Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
G4ParameterisationPolycone.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// G4ParameterisationPolycone[Rho/Phi/Z] implementation
27//
28// 26.05.03 - P.Arce, Initial version
29// 08.04.04 - I.Hrivnacova, Implemented reflection
30//---------------------------------------------------------------------
31
32#include "G4ParameterisationPolycone.hh"
33
34#include <iomanip>
35#include "G4ThreeVector.hh"
36#include "G4RotationMatrix.hh"
37#include "G4VPhysicalVolume.hh"
38#include "G4LogicalVolume.hh"
39#include "G4ReflectedSolid.hh"
40
41//-----------------------------------------------------------------------
42G4VParameterisationPolycone::
43G4VParameterisationPolycone( EAxis axis, G4int nDiv, G4double width,
44 G4double offset, G4VSolid* msolid,
45 DivisionType divType )
46 : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
47{
48 /*#ifdef G4MULTITHREADED
49 std::ostringstream message;
50 message << "Divisions for G4Polycone currently NOT supported in MT-mode."
51 << G4endl
52 << "Sorry! Solid: " << msolid->GetName();
53 G4Exception("G4VParameterisationPolycone::G4VParameterisationPolycone()",
54 "GeomDiv0001", FatalException, message);
55 #endif */
56 G4Polycone* msol = (G4Polycone*)(msolid);
57 if (msolid->GetEntityType() == "G4ReflectedSolid")
58 {
59 // Get constituent solid
60 //
61 G4VSolid* mConstituentSolid
62 = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
63 msol = (G4Polycone*)(mConstituentSolid);
64
65 // Get parameters
66 //
67 G4int nofZplanes = msol->GetOriginalParameters()->Num_z_planes;
68 G4double* zValues = msol->GetOriginalParameters()->Z_values;
69 G4double* rminValues = msol->GetOriginalParameters()->Rmin;
70 G4double* rmaxValues = msol->GetOriginalParameters()->Rmax;
71
72 // Invert z values
73 //
74 G4double* zValuesRefl = new G4double[nofZplanes];
75 for (G4int i=0; i<nofZplanes; ++i) { zValuesRefl[i] = - zValues[i]; }
76
77 G4Polycone* newSolid
78 = new G4Polycone(msol->GetName(),
79 msol->GetStartPhi(),
80 msol->GetEndPhi() - msol->GetStartPhi(),
81 nofZplanes, zValuesRefl, rminValues, rmaxValues);
82
83 delete [] zValuesRefl;
84
85 msol = newSolid;
86 fmotherSolid = newSolid;
87 fReflectedSolid = true;
88 fDeleteSolid = true;
89 }
90}
91
92//---------------------------------------------------------------------
93G4VParameterisationPolycone::~G4VParameterisationPolycone()
94{
95}
96
97//---------------------------------------------------------------------
98G4ParameterisationPolyconeRho::
99G4ParameterisationPolyconeRho( EAxis axis, G4int nDiv,
100 G4double width, G4double offset,
101 G4VSolid* msolid, DivisionType divType )
102 : G4VParameterisationPolycone( axis, nDiv, width, offset, msolid, divType )
103{
104 CheckParametersValidity();
105 SetType( "DivisionPolyconeRho" );
106
107 G4Polycone* msol = (G4Polycone*)(fmotherSolid);
108 G4PolyconeHistorical* origparamMother = msol->GetOriginalParameters();
109
110 if( divType == DivWIDTH )
111 {
112 fnDiv = CalculateNDiv( origparamMother->Rmax[0]
113 - origparamMother->Rmin[0], width, offset );
114 }
115 else if( divType == DivNDIV )
116 {
117 fwidth = CalculateWidth( origparamMother->Rmax[0]
118 - origparamMother->Rmin[0], nDiv, offset );
119 }
120
121#ifdef G4DIVDEBUG
122 if( verbose >= -1 )
123 {
124 G4cout << " G4ParameterisationPolyconeRho - # divisions " << fnDiv
125 << " = " << nDiv << G4endl
126 << " Offset " << foffset << " = " << offset << G4endl
127 << " Width " << fwidth << " = " << width << G4endl;
128 }
129#endif
130}
131
132//---------------------------------------------------------------------
133G4ParameterisationPolyconeRho::~G4ParameterisationPolyconeRho()
134{
135}
136
137//---------------------------------------------------------------------
138void G4ParameterisationPolyconeRho::CheckParametersValidity()
139{
140 G4VDivisionParameterisation::CheckParametersValidity();
141
142 G4Polycone* msol = (G4Polycone*)(fmotherSolid);
143
144 if( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
145 {
146 std::ostringstream message;
147 message << "In solid " << msol->GetName() << G4endl
148 << "Division along R will be done with a width "
149 << "different for each solid section." << G4endl
150 << "WIDTH will not be used !";
151 G4Exception("G4VParameterisationPolycone::CheckParametersValidity()",
152 "GeomDiv1001", JustWarning, message);
153 }
154 if( foffset != 0. )
155 {
156 std::ostringstream message;
157 message << "In solid " << msol->GetName() << G4endl
158 << "Division along R will be done with a width "
159 << "different for each solid section." << G4endl
160 << "OFFSET will not be used !";
161 G4Exception("G4VParameterisationPolycone::CheckParametersValidity()",
162 "GeomDiv1001", JustWarning, message);
163 }
164}
165
166//------------------------------------------------------------------------
167G4double G4ParameterisationPolyconeRho::GetMaxParameter() const
168{
169 G4Polycone* msol = (G4Polycone*)(fmotherSolid);
170 G4PolyconeHistorical* original_pars = msol->GetOriginalParameters();
171 return original_pars->Rmax[0] - original_pars->Rmin[0];
172}
173
174
175//---------------------------------------------------------------------
176void
177G4ParameterisationPolyconeRho::
178ComputeTransformation( const G4int, G4VPhysicalVolume* physVol ) const
179{
180 //----- translation
181 G4ThreeVector origin(0.,0.,0.);
182 //----- set translation
183 physVol->SetTranslation( origin );
184
185 //----- calculate rotation matrix: unit
186
187#ifdef G4DIVDEBUG
188 if( verbose >= 2 )
189 {
190 G4cout << " G4ParameterisationPolyconeRho " << G4endl
191 << " foffset: " << foffset
192 << " - fwidth: " << fwidth << G4endl;
193 }
194#endif
195
196 ChangeRotMatrix( physVol );
197
198#ifdef G4DIVDEBUG
199 if( verbose >= 2 )
200 {
201 G4cout << std::setprecision(8) << " G4ParameterisationPolyconeRho "
202 << G4endl
203 << " Position: (0,0,0)"
204 << " - Width: " << fwidth/CLHEP::deg
205 << " - Axis: " << faxis << G4endl;
206 }
207#endif
208}
209
210//---------------------------------------------------------------------
211void
212G4ParameterisationPolyconeRho::
213ComputeDimensions( G4Polycone& pcone, const G4int copyNo,
214 const G4VPhysicalVolume* ) const
215{
216 G4Polycone* msol = (G4Polycone*)(fmotherSolid);
217
218 G4PolyconeHistorical* origparamMother = msol->GetOriginalParameters();
219 G4PolyconeHistorical origparam( *origparamMother );
220 G4int nZplanes = origparamMother->Num_z_planes;
221
222 G4double width = 0.;
223 for( G4int ii = 0; ii < nZplanes; ++ii )
224 {
225 width = CalculateWidth( origparamMother->Rmax[ii]
226 - origparamMother->Rmin[ii], fnDiv, foffset );
227 origparam.Rmin[ii] = origparamMother->Rmin[ii]+foffset+width*copyNo;
228 origparam.Rmax[ii] = origparamMother->Rmin[ii]+foffset+width*(copyNo+1);
229 }
230
231 pcone.SetOriginalParameters(&origparam); // copy values & transfer pointers
232 pcone.Reset(); // reset to new solid parameters
233
234#ifdef G4DIVDEBUG
235 if( verbose >= -2 )
236 {
237 G4cout << "G4ParameterisationPolyconeRho::ComputeDimensions()" << G4endl
238 << "-- Parametrised pcone copy-number: " << copyNo << G4endl;
239 pcone.DumpInfo();
240 }
241#endif
242}
243
244//---------------------------------------------------------------------
245G4ParameterisationPolyconePhi::
246G4ParameterisationPolyconePhi( EAxis axis, G4int nDiv,
247 G4double width, G4double offset,
248 G4VSolid* msolid, DivisionType divType )
249 : G4VParameterisationPolycone( axis, nDiv, width, offset, msolid, divType )
250{
251 CheckParametersValidity();
252 SetType( "DivisionPolyconePhi" );
253
254 G4Polycone* msol = (G4Polycone*)(fmotherSolid);
255 G4double deltaPhi = msol->GetEndPhi() - msol->GetStartPhi();
256
257 if( divType == DivWIDTH )
258 {
259 fnDiv = CalculateNDiv( deltaPhi, width, offset );
260 }
261 else if( divType == DivNDIV )
262 {
263 fwidth = CalculateWidth( deltaPhi, nDiv, offset );
264 }
265
266#ifdef G4DIVDEBUG
267 if( verbose >= 1 )
268 {
269 G4cout << " G4ParameterisationPolyconePhi - # divisions " << fnDiv
270 << " = " << nDiv << G4endl
271 << " Offset " << foffset/CLHEP::deg << " = " << offset/CLHEP::deg << G4endl
272 << " Width " << fwidth/CLHEP::deg << " = " << width/CLHEP::deg << G4endl;
273 }
274#endif
275}
276
277//---------------------------------------------------------------------
278G4ParameterisationPolyconePhi::~G4ParameterisationPolyconePhi()
279{
280}
281
282//------------------------------------------------------------------------
283G4double G4ParameterisationPolyconePhi::GetMaxParameter() const
284{
285 G4Polycone* msol = (G4Polycone*)(fmotherSolid);
286 return msol->GetEndPhi() - msol->GetStartPhi();
287}
288
289//---------------------------------------------------------------------
290void
291G4ParameterisationPolyconePhi::
292ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
293{
294 //----- translation
295 G4ThreeVector origin(0.,0.,0.);
296 //----- set translation
297 physVol->SetTranslation( origin );
298
299 //----- calculate rotation matrix (so that all volumes point to the centre)
300 G4double posi = foffset + copyNo*fwidth;
301
302#ifdef G4DIVDEBUG
303 if( verbose >= 2 )
304 {
305 G4cout << " G4ParameterisationPolyconePhi - position: " << posi/CLHEP::deg
306 << G4endl
307 << " copyNo: " << copyNo << " - foffset: " << foffset/CLHEP::deg
308 << " - fwidth: " << fwidth/CLHEP::deg << G4endl;
309 }
310#endif
311
312 ChangeRotMatrix( physVol, -posi );
313
314#ifdef G4DIVDEBUG
315 if( verbose >= 2 )
316 {
317 G4cout << std::setprecision(8) << " G4ParameterisationPolyconePhi "
318 << copyNo << G4endl
319 << " Position: (0,0,0) - Width: " << fwidth
320 << " - Axis: " << faxis << G4endl;
321 }
322#endif
323}
324
325//---------------------------------------------------------------------
326void
327G4ParameterisationPolyconePhi::
328ComputeDimensions( G4Polycone& pcone, const G4int,
329 const G4VPhysicalVolume* ) const
330{
331 G4Polycone* msol = (G4Polycone*)(fmotherSolid);
332
333 G4PolyconeHistorical* origparamMother = msol->GetOriginalParameters();
334 G4PolyconeHistorical origparam( *origparamMother );
335 origparam.Start_angle = origparamMother->Start_angle;
336 origparam.Opening_angle = fwidth;
337
338 pcone.SetOriginalParameters(&origparam); // copy values & transfer pointers
339 pcone.Reset(); // reset to new solid parameters
340
341#ifdef G4DIVDEBUG
342 if( verbose >= 2 )
343 {
344 G4cout << "G4ParameterisationPolyconePhi::ComputeDimensions():" << G4endl;
345 pcone.DumpInfo();
346 }
347#endif
348}
349
350//---------------------------------------------------------------------
351G4ParameterisationPolyconeZ::
352G4ParameterisationPolyconeZ( EAxis axis, G4int nDiv,
353 G4double width, G4double offset,
354 G4VSolid* msolid, DivisionType divType)
355 : G4VParameterisationPolycone( axis, nDiv, width, offset, msolid, divType ),
356 fOrigParamMother(((G4Polycone*)fmotherSolid)->GetOriginalParameters())
357{
358
359 CheckParametersValidity();
360 SetType( "DivisionPolyconeZ" );
361
362 if( divType == DivWIDTH )
363 {
364 fnDiv =
365 CalculateNDiv( fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
366 - fOrigParamMother->Z_values[0] , width, offset );
367 }
368 else if( divType == DivNDIV )
369 {
370 fwidth =
371 CalculateNDiv( fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
372 - fOrigParamMother->Z_values[0] , nDiv, offset );
373 }
374
375#ifdef G4DIVDEBUG
376 if( verbose >= 1 )
377 {
378 G4cout << " G4ParameterisationPolyconeZ - # divisions " << fnDiv << " = "
379 << nDiv << G4endl
380 << " Offset " << foffset << " = " << offset << G4endl
381 << " Width " << fwidth << " = " << width << G4endl;
382 }
383#endif
384}
385
386//---------------------------------------------------------------------
387G4ParameterisationPolyconeZ::~G4ParameterisationPolyconeZ()
388{
389}
390
391//------------------------------------------------------------------------
392G4double G4ParameterisationPolyconeZ::GetR(G4double z,
393 G4double z1, G4double r1,
394 G4double z2, G4double r2) const
395{
396 // Linear parameterisation:
397 // r = az + b
398 // a = (r1 - r2)/(z1-z2)
399 // b = r1 - a*z1
400
401 return (r1-r2)/(z1-z2)*z + ( r1 - (r1-r2)/(z1-z2)*z1 ) ;
402}
403
404//------------------------------------------------------------------------
405G4double G4ParameterisationPolyconeZ::GetRmin(G4double z, G4int nseg) const
406{
407// Get Rmin in the given z position for the given polycone segment
408
409 return GetR(z,
410 fOrigParamMother->Z_values[nseg],
411 fOrigParamMother->Rmin[nseg],
412 fOrigParamMother->Z_values[nseg+1],
413 fOrigParamMother->Rmin[nseg+1]);
414}
415
416//------------------------------------------------------------------------
417G4double G4ParameterisationPolyconeZ::GetRmax(G4double z, G4int nseg) const
418{
419// Get Rmax in the given z position for the given polycone segment
420
421 return GetR(z,
422 fOrigParamMother->Z_values[nseg],
423 fOrigParamMother->Rmax[nseg],
424 fOrigParamMother->Z_values[nseg+1],
425 fOrigParamMother->Rmax[nseg+1]);
426}
427
428//------------------------------------------------------------------------
429G4double G4ParameterisationPolyconeZ::GetMaxParameter() const
430{
431 return std::abs (fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
432 -fOrigParamMother->Z_values[0]);
433}
434
435//---------------------------------------------------------------------
436void G4ParameterisationPolyconeZ::CheckParametersValidity()
437{
438 G4VDivisionParameterisation::CheckParametersValidity();
439
440 // Division will be following the mother polycone segments
441 //
442 if( fDivisionType == DivNDIV )
443 {
444 if( fnDiv > fOrigParamMother->Num_z_planes-1 )
445 {
446 std::ostringstream error;
447 error << "Configuration not supported." << G4endl
448 << "Division along Z will be done by splitting in the defined"
449 << G4endl
450 << "Z planes, i.e, the number of division would be: "
451 << fOrigParamMother->Num_z_planes-1
452 << ", instead of: " << fnDiv << " !";
453 G4Exception("G4ParameterisationPolyconeZ::CheckParametersValidity()",
454 "GeomDiv0001", FatalException, error);
455 }
456 }
457
458 // Division will be done within one polycone segment
459 // with applying given width and offset
460 //
461 if( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
462 {
463 // Check if divided region does not span over more
464 // than one z segment
465
466 G4int isegstart = -1; // number of the segment containing start position
467 G4int isegend = -1; // number of the segment containing end position
468
469 if ( !fReflectedSolid )
470 {
471 // The start/end position of the divided region
472 //
473 G4double zstart
474 = fOrigParamMother->Z_values[0] + foffset;
475 G4double zend
476 = fOrigParamMother->Z_values[0] + foffset + fnDiv* fwidth;
477
478 G4int counter = 0;
479 while ( isegend < 0 && counter < fOrigParamMother->Num_z_planes-1 )
480 {
481 // first segment
482 if ( zstart >= fOrigParamMother->Z_values[counter] &&
483 zstart < fOrigParamMother->Z_values[counter+1] )
484 {
485 isegstart = counter;
486 }
487 // last segment
488 if ( zend > fOrigParamMother->Z_values[counter] &&
489 zend <= fOrigParamMother->Z_values[counter+1] )
490 {
491 isegend = counter;
492 }
493 ++counter;
494 } // Loop checking, 06.08.2015, G.Cosmo
495 }
496 else
497 {
498 // The start/end position of the divided region
499 //
500 G4double zstart
501 = fOrigParamMother->Z_values[0] - foffset;
502 G4double zend
503 = fOrigParamMother->Z_values[0] - ( foffset + fnDiv* fwidth);
504
505 G4int counter = 0;
506 while ( isegend < 0 && counter < fOrigParamMother->Num_z_planes-1 )
507 {
508 // first segment
509 if ( zstart <= fOrigParamMother->Z_values[counter] &&
510 zstart > fOrigParamMother->Z_values[counter+1] )
511 {
512 isegstart = counter;
513 }
514 // last segment
515 if ( zend < fOrigParamMother->Z_values[counter] &&
516 zend >= fOrigParamMother->Z_values[counter+1] )
517 {
518 isegend = counter;
519 }
520 ++counter;
521 } // Loop checking, 06.08.2015, G.Cosmo
522 }
523
524
525 if ( isegstart != isegend )
526 {
527 std::ostringstream message;
528 message << "Condiguration not supported." << G4endl
529 << "Division with user defined width." << G4endl
530 << "Solid " << fmotherSolid->GetName() << G4endl
531 << "Divided region is not between two z planes.";
532 G4Exception("G4ParameterisationPolyconeZ::CheckParametersValidity()",
533 "GeomDiv0001", FatalException, message);
534 }
535
536 fNSegment = isegstart;
537 }
538}
539
540//---------------------------------------------------------------------
541void
542G4ParameterisationPolyconeZ::
543ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol) const
544{
545 G4double posi = 0.;
546 if ( fDivisionType == DivNDIV )
547 {
548 // The position of the centre of copyNo-th mother polycone segment
549 //
550 posi = ( fOrigParamMother->Z_values[copyNo]
551 + fOrigParamMother->Z_values[copyNo+1])/2;
552 physVol->SetTranslation( G4ThreeVector(0, 0, posi) );
553 }
554
555 if ( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
556 {
557 // The position of the centre of copyNo-th division
558 //
559 posi = fOrigParamMother->Z_values[0];
560
561 if ( !fReflectedSolid )
562 posi += foffset + (2*copyNo + 1) * fwidth/2.;
563 else
564 posi -= foffset + (2*copyNo + 1) * fwidth/2.;
565
566 physVol->SetTranslation( G4ThreeVector(0, 0, posi) );
567 }
568
569 //----- calculate rotation matrix: unit
570
571#ifdef G4DIVDEBUG
572 if( verbose >= 2 )
573 {
574 G4cout << " G4ParameterisationPolyconeZ - position: " << posi << G4endl
575 << " copyNo: " << copyNo << " - foffset: " << foffset/CLHEP::deg
576 << " - fwidth: " << fwidth/CLHEP::deg << G4endl;
577 }
578#endif
579
580 ChangeRotMatrix( physVol );
581
582#ifdef G4DIVDEBUG
583 if( verbose >= 2 )
584 {
585 G4cout << std::setprecision(8) << " G4ParameterisationPolyconeZ "
586 << copyNo << G4endl
587 << " Position: (0,0,0) - Width: " << fwidth
588 << " - Axis: " << faxis << G4endl;
589 }
590#endif
591}
592
593//---------------------------------------------------------------------
594void
595G4ParameterisationPolyconeZ::
596ComputeDimensions( G4Polycone& pcone, const G4int copyNo,
597 const G4VPhysicalVolume* ) const
598{
599
600 // Define division solid
601 //
602 G4PolyconeHistorical origparam;
603 G4int nz = 2;
604 origparam.Num_z_planes = nz;
605 origparam.Start_angle = fOrigParamMother->Start_angle;
606 origparam.Opening_angle = fOrigParamMother->Opening_angle;
607
608 // Define division solid z sections
609 //
610 origparam.Z_values = new G4double[nz];
611 origparam.Rmin = new G4double[nz];
612 origparam.Rmax = new G4double[nz];
613
614 if ( fDivisionType == DivNDIV )
615 {
616 // The position of the centre of copyNo-th mother polycone segment
617 G4double posi = (fOrigParamMother->Z_values[copyNo]
618 + fOrigParamMother->Z_values[copyNo+1])/2;
619
620 origparam.Z_values[0] = fOrigParamMother->Z_values[copyNo] - posi;
621 origparam.Z_values[1] = fOrigParamMother->Z_values[copyNo+1] - posi;
622 origparam.Rmin[0] = fOrigParamMother->Rmin[copyNo];
623 origparam.Rmin[1] = fOrigParamMother->Rmin[copyNo+1];
624 origparam.Rmax[0] = fOrigParamMother->Rmax[copyNo];
625 origparam.Rmax[1] = fOrigParamMother->Rmax[copyNo+1];
626 }
627
628 if ( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
629 {
630 if ( !fReflectedSolid )
631 {
632 origparam.Z_values[0] = - fwidth/2.;
633 origparam.Z_values[1] = fwidth/2.;
634
635 // The position of the centre of copyNo-th division
636 //
637 G4double posi = fOrigParamMother->Z_values[0]
638 + foffset + (2*copyNo + 1) * fwidth/2.;
639
640 // The first and last z sides z values
641 //
642 G4double zstart = posi - fwidth/2.;
643 G4double zend = posi + fwidth/2.;
644 origparam.Rmin[0] = GetRmin(zstart, fNSegment);
645 origparam.Rmax[0] = GetRmax(zstart, fNSegment);
646 origparam.Rmin[1] = GetRmin(zend, fNSegment);
647 origparam.Rmax[1] = GetRmax(zend, fNSegment);
648 }
649 else
650 {
651 origparam.Z_values[0] = fwidth/2.;
652 origparam.Z_values[1] = - fwidth/2.;
653
654 // The position of the centre of copyNo-th division
655 //
656 G4double posi = fOrigParamMother->Z_values[0]
657 - ( foffset + (2*copyNo + 1) * fwidth/2.);
658
659 // The first and last z sides z values
660 //
661 G4double zstart = posi + fwidth/2.;
662 G4double zend = posi - fwidth/2.;
663 origparam.Rmin[0] = GetRmin(zstart, fNSegment);
664 origparam.Rmax[0] = GetRmax(zstart, fNSegment);
665 origparam.Rmin[1] = GetRmin(zend, fNSegment);
666 origparam.Rmax[1] = GetRmax(zend, fNSegment);
667 }
668
669 // It can happen due to rounding errors
670 //
671 if ( origparam.Rmin[0] < 0.0 ) origparam.Rmin[0] = 0.0;
672 if ( origparam.Rmin[nz-1] < 0.0 ) origparam.Rmin[1] = 0.0;
673 }
674
675 pcone.SetOriginalParameters(&origparam); // copy values & transfer pointers
676 pcone.Reset(); // reset to new solid parameters
677
678#ifdef G4DIVDEBUG
679 if( verbose >= 2 )
680 {
681 G4cout << "G4ParameterisationPolyconeZ::ComputeDimensions()" << G4endl
682 << "-- Parametrised pcone copy-number: " << copyNo << G4endl;
683 pcone.DumpInfo();
684 }
685#endif
686}
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:65
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:36
G4double
double G4double
Definition: G4Types.hh:83
G4int
int G4int
Definition: G4Types.hh:85
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4ParameterisationPolyconePhi::ComputeTransformation
void ComputeTransformation(const G4int copyNo, G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolycone.cc:292
G4ParameterisationPolyconePhi::ComputeDimensions
void ComputeDimensions(G4Polycone &pcone, const G4int copyNo, const G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolycone.cc:328
G4ParameterisationPolyconePhi::G4ParameterisationPolyconePhi
G4ParameterisationPolyconePhi(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *motherSolid, DivisionType divType)
Definition: G4ParameterisationPolycone.cc:246
G4ParameterisationPolyconeRho::ComputeDimensions
void ComputeDimensions(G4Polycone &pcone, const G4int copyNo, const G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolycone.cc:213
G4ParameterisationPolyconeRho::G4ParameterisationPolyconeRho
G4ParameterisationPolyconeRho(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *motherSolid, DivisionType divType)
Definition: G4ParameterisationPolycone.cc:99
G4ParameterisationPolyconeRho::ComputeTransformation
void ComputeTransformation(const G4int copyNo, G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolycone.cc:178
G4ParameterisationPolyconeZ::G4ParameterisationPolyconeZ
G4ParameterisationPolyconeZ(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *motherSolid, DivisionType divType)
Definition: G4ParameterisationPolycone.cc:352
G4ParameterisationPolyconeZ::ComputeTransformation
void ComputeTransformation(const G4int copyNo, G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolycone.cc:543
G4ParameterisationPolyconeZ::ComputeDimensions
void ComputeDimensions(G4Polycone &pcone, const G4int copyNo, const G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolycone.cc:596
G4Polycone::GetEndPhi
G4double GetEndPhi() const
G4Polycone::SetOriginalParameters
void SetOriginalParameters(G4PolyconeHistorical *pars)
G4Polycone::GetStartPhi
G4double GetStartPhi() const
G4Polycone::GetOriginalParameters
G4PolyconeHistorical * GetOriginalParameters() const
G4Polycone::Reset
G4bool Reset()
Definition: G4Polycone.cc:436
G4VDivisionParameterisation::SetType
void SetType(const G4String &type)
G4VDivisionParameterisation::CalculateWidth
G4double CalculateWidth(G4double motherDim, G4int nDiv, G4double offset) const
Definition: G4VDivisionParameterisation.cc:115
G4VDivisionParameterisation::CalculateNDiv
G4int CalculateNDiv(G4double motherDim, G4double width, G4double offset) const
Definition: G4VDivisionParameterisation.cc:100
G4VDivisionParameterisation::ChangeRotMatrix
void ChangeRotMatrix(G4VPhysicalVolume *physVol, G4double rotZ=0.0) const
Definition: G4VDivisionParameterisation.cc:86
G4VParameterisationPolycone::G4VParameterisationPolycone
G4VParameterisationPolycone(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *msolid, DivisionType divType)
Definition: G4ParameterisationPolycone.cc:43
G4VPhysicalVolume::SetTranslation
void SetTranslation(const G4ThreeVector &v)
Definition: G4VPhysicalVolume.cc:155
G4VSolid::GetName
G4String GetName() const
G4VSolid::DumpInfo
void DumpInfo() const
G4VSolid::GetEntityType
virtual G4GeometryType GetEntityType() const =0
EAxis
EAxis
Definition: geomdefs.hh:54