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
G4ParameterisationPolyhedra.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// G4ParameterisationPolyhedra[Rho/Phi/Z] implementation
27//
28// 14.10.03 - P.Arce, Initial version
29// 08.04.04 - I.Hrivnacova, Implemented reflection
30// --------------------------------------------------------------------
31
32#include "G4ParameterisationPolyhedra.hh"
33
34#include <iomanip>
35#include "G4PhysicalConstants.hh"
36#include "G4ThreeVector.hh"
37#include "G4GeometryTolerance.hh"
38#include "G4RotationMatrix.hh"
39#include "G4VPhysicalVolume.hh"
40#include "G4LogicalVolume.hh"
41#include "G4ReflectedSolid.hh"
42#include "G4Polyhedra.hh"
43
44//--------------------------------------------------------------------------
45G4VParameterisationPolyhedra::
46G4VParameterisationPolyhedra( EAxis axis, G4int nDiv, G4double width,
47 G4double offset, G4VSolid* msolid,
48 DivisionType divType )
49 : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
50{
51 std::ostringstream message;
52 /* #ifdef G4MULTITHREADED
53 message << "Divisions for G4Polyhedra currently NOT supported in MT-mode."
54 << G4endl
55 << "Sorry! Solid: " << msolid->GetName();
56 G4Exception("G4VParameterisationPolyhedra::G4VParameterisationPolyhedra()",
57 "GeomDiv0001", FatalException, message);
58 #endif */
59
60 G4Polyhedra* msol = (G4Polyhedra*)(msolid);
61 if ((msolid->GetEntityType() != "G4ReflectedSolid") && (msol->IsGeneric()))
62 {
63 message << "Generic construct for G4Polyhedra NOT supported." << G4endl
64 << "Sorry! Solid: " << msol->GetName();
65 G4Exception("G4VParameterisationPolyhedra::G4VParameterisationPolyhedra()",
66 "GeomDiv0001", FatalException, message);
67 }
68 if (msolid->GetEntityType() == "G4ReflectedSolid")
69 {
70 // Get constituent solid
71 //
72 G4VSolid* mConstituentSolid
73 = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
74 msol = (G4Polyhedra*)(mConstituentSolid);
75
76 // Get parameters
77 //
78 G4int nofSides = msol->GetOriginalParameters()->numSide;
79 G4int nofZplanes = msol->GetOriginalParameters()->Num_z_planes;
80 G4double* zValues = msol->GetOriginalParameters()->Z_values;
81 G4double* rminValues = msol->GetOriginalParameters()->Rmin;
82 G4double* rmaxValues = msol->GetOriginalParameters()->Rmax;
83
84 // Invert z values, convert radius parameters
85 //
86 G4double* rminValues2 = new G4double[nofZplanes];
87 G4double* rmaxValues2 = new G4double[nofZplanes];
88 G4double* zValuesRefl = new G4double[nofZplanes];
89 for (G4int i=0; i<nofZplanes; ++i)
90 {
91 rminValues2[i] = rminValues[i] * ConvertRadiusFactor(*msol);
92 rmaxValues2[i] = rmaxValues[i] * ConvertRadiusFactor(*msol);
93 zValuesRefl[i] = - zValues[i];
94 }
95
96 G4Polyhedra* newSolid
97 = new G4Polyhedra(msol->GetName(),
98 msol->GetStartPhi(),
99 msol->GetEndPhi() - msol->GetStartPhi(),
100 nofSides,
101 nofZplanes, zValuesRefl, rminValues2, rmaxValues2);
102
103 delete [] rminValues2;
104 delete [] rmaxValues2;
105 delete [] zValuesRefl;
106
107 msol = newSolid;
108 fmotherSolid = newSolid;
109 fReflectedSolid = true;
110 fDeleteSolid = true;
111 }
112}
113
114//------------------------------------------------------------------------
115G4VParameterisationPolyhedra::~G4VParameterisationPolyhedra()
116{
117}
118
119//--------------------------------------------------------------------------
120G4double
121G4VParameterisationPolyhedra::
122ConvertRadiusFactor(const G4Polyhedra& phedra) const
123{
124 G4double phiTotal = phedra.GetEndPhi() - phedra.GetStartPhi();
125 G4int nofSides = phedra.GetOriginalParameters()->numSide;
126
127 if ( (phiTotal <=0) || (phiTotal >
128 2*pi+G4GeometryTolerance::GetInstance()->GetAngularTolerance()) )
129 { phiTotal = 2*pi; }
130
131 return std::cos(0.5*phiTotal/nofSides);
132}
133
134//--------------------------------------------------------------------------
135G4ParameterisationPolyhedraRho::
136G4ParameterisationPolyhedraRho( EAxis axis, G4int nDiv,
137 G4double width, G4double offset,
138 G4VSolid* msolid, DivisionType divType )
139 : G4VParameterisationPolyhedra( axis, nDiv, width, offset, msolid, divType )
140{
141
142 CheckParametersValidity();
143 SetType( "DivisionPolyhedraRho" );
144
145 G4Polyhedra* msol = (G4Polyhedra*)(fmotherSolid);
146 G4PolyhedraHistorical* original_pars = msol->GetOriginalParameters();
147
148 if( divType == DivWIDTH )
149 {
150 fnDiv = CalculateNDiv( original_pars->Rmax[0]
151 - original_pars->Rmin[0], width, offset );
152 }
153 else if( divType == DivNDIV )
154 {
155 fwidth = CalculateWidth( original_pars->Rmax[0]
156 - original_pars->Rmin[0], nDiv, offset );
157 }
158
159#ifdef G4DIVDEBUG
160 if( verbose >= 1 )
161 {
162 G4cout << " G4ParameterisationPolyhedraRho - # divisions " << fnDiv
163 << " = " << nDiv << G4endl
164 << " Offset " << foffset << " = " << offset << G4endl
165 << " Width " << fwidth << " = " << width << G4endl;
166 }
167#endif
168}
169
170//------------------------------------------------------------------------
171G4ParameterisationPolyhedraRho::~G4ParameterisationPolyhedraRho()
172{
173}
174
175//---------------------------------------------------------------------
176void G4ParameterisationPolyhedraRho::CheckParametersValidity()
177{
178 G4VDivisionParameterisation::CheckParametersValidity();
179
180 G4Polyhedra* msol = (G4Polyhedra*)(fmotherSolid);
181
182 if( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
183 {
184 std::ostringstream message;
185 message << "In solid " << msol->GetName() << G4endl
186 << "Division along R will be done with a width "
187 << "different for each solid section." << G4endl
188 << "WIDTH will not be used !";
189 G4Exception("G4ParameterisationPolyhedraRho::CheckParametersValidity()",
190 "GeomDiv1001", JustWarning, message);
191 }
192 if( foffset != 0. )
193 {
194 std::ostringstream message;
195 message << "In solid " << msol->GetName() << G4endl
196 << "Division along R will be done with a width "
197 << "different for each solid section." << G4endl
198 << "OFFSET will not be used !";
199 G4Exception("G4ParameterisationPolyhedraRho::CheckParametersValidity()",
200 "GeomDiv1001", JustWarning, message);
201 }
202}
203
204//------------------------------------------------------------------------
205G4double G4ParameterisationPolyhedraRho::GetMaxParameter() const
206{
207 G4Polyhedra* msol = (G4Polyhedra*)(fmotherSolid);
208 G4PolyhedraHistorical* original_pars = msol->GetOriginalParameters();
209 return original_pars->Rmax[0] - original_pars->Rmin[0];
210}
211
212//--------------------------------------------------------------------------
213void
214G4ParameterisationPolyhedraRho::
215ComputeTransformation( const G4int, G4VPhysicalVolume* physVol ) const
216{
217 //----- translation
218 G4ThreeVector origin(0.,0.,0.);
219
220 //----- set translation
221 physVol->SetTranslation( origin );
222
223 //----- calculate rotation matrix: unit
224
225#ifdef G4DIVDEBUG
226 if( verbose >= 2 )
227 {
228 G4cout << " G4ParameterisationPolyhedraRho " << G4endl
229 << " foffset: " << foffset/CLHEP::deg
230 << " - fwidth: " << fwidth/CLHEP::deg << G4endl;
231 }
232#endif
233
234 ChangeRotMatrix( physVol );
235
236#ifdef G4DIVDEBUG
237 if( verbose >= 2 )
238 {
239 G4cout << std::setprecision(8) << " G4ParameterisationPolyhedraRho "
240 << G4endl
241 << " Position: " << origin
242 << " - Width: " << fwidth
243 << " - Axis: " << faxis << G4endl;
244 }
245#endif
246}
247
248//--------------------------------------------------------------------------
249void
250G4ParameterisationPolyhedraRho::
251ComputeDimensions( G4Polyhedra& phedra, const G4int copyNo,
252 const G4VPhysicalVolume* ) const
253{
254 G4Polyhedra* msol = (G4Polyhedra*)(fmotherSolid);
255
256 G4PolyhedraHistorical* origparamMother = msol->GetOriginalParameters();
257 G4PolyhedraHistorical origparam( *origparamMother );
258 G4int nZplanes = origparamMother->Num_z_planes;
259
260 G4double width = 0.;
261 for( G4int ii = 0; ii < nZplanes; ++ii )
262 {
263 width = CalculateWidth( origparamMother->Rmax[ii]
264 - origparamMother->Rmin[ii], fnDiv, foffset );
265 origparam.Rmin[ii] = origparamMother->Rmin[ii]+foffset+width*copyNo;
266 origparam.Rmax[ii] = origparamMother->Rmin[ii]+foffset+width*(copyNo+1);
267 }
268
269 phedra.SetOriginalParameters(&origparam); // copy values & transfer pointers
270 phedra.Reset(); // reset to new solid parameters
271
272#ifdef G4DIVDEBUG
273 if( verbose >= -2 )
274 {
275 G4cout << "G4ParameterisationPolyhedraRho::ComputeDimensions()" << G4endl
276 << "-- Parametrised phedra copy-number: " << copyNo << G4endl;
277 phedra.DumpInfo();
278 }
279#endif
280}
281
282//--------------------------------------------------------------------------
283G4ParameterisationPolyhedraPhi::
284G4ParameterisationPolyhedraPhi( EAxis axis, G4int nDiv,
285 G4double width, G4double offset,
286 G4VSolid* msolid, DivisionType divType )
287 : G4VParameterisationPolyhedra( axis, nDiv, width, offset, msolid, divType )
288{
289 CheckParametersValidity();
290 SetType( "DivisionPolyhedraPhi" );
291
292 G4Polyhedra* msol = (G4Polyhedra*)(fmotherSolid);
293 G4double deltaPhi = msol->GetEndPhi() - msol->GetStartPhi();
294
295 if( divType == DivWIDTH )
296 {
297 fnDiv = msol->GetNumSide();
298 }
299
300 fwidth = CalculateWidth( deltaPhi, fnDiv, 0.0 );
301
302#ifdef G4DIVDEBUG
303 if( verbose >= 1 )
304 {
305 G4cout << " G4ParameterisationPolyhedraPhi - # divisions " << fnDiv
306 << " = " << nDiv << G4endl
307 << " Offset " << foffset << " = " << offset << G4endl
308 << " Width " << fwidth << " = " << width << G4endl;
309 }
310#endif
311}
312
313//------------------------------------------------------------------------
314G4ParameterisationPolyhedraPhi::~G4ParameterisationPolyhedraPhi()
315{
316}
317
318//------------------------------------------------------------------------
319G4double G4ParameterisationPolyhedraPhi::GetMaxParameter() const
320{
321 G4Polyhedra* msol = (G4Polyhedra*)(fmotherSolid);
322 return msol->GetEndPhi() - msol->GetStartPhi();
323}
324
325//---------------------------------------------------------------------
326void G4ParameterisationPolyhedraPhi::CheckParametersValidity()
327{
328 G4VDivisionParameterisation::CheckParametersValidity();
329
330 G4Polyhedra* msol = (G4Polyhedra*)(fmotherSolid);
331
332 if( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
333 {
334 std::ostringstream message;
335 message << "In solid " << msol->GetName() << G4endl
336 << " Division along PHI will be done splitting "
337 << "in the defined numSide." << G4endl
338 << "WIDTH will not be used !";
339 G4Exception("G4ParameterisationPolyhedraPhi::CheckParametersValidity()",
340 "GeomDiv1001", JustWarning, message);
341 }
342 if( foffset != 0. )
343 {
344 std::ostringstream message;
345 message << "In solid " << msol->GetName() << G4endl
346 << "Division along PHI will be done splitting "
347 << "in the defined numSide." << G4endl
348 << "OFFSET will not be used !";
349 G4Exception("G4ParameterisationPolyhedraPhi::CheckParametersValidity()",
350 "GeomDiv1001", JustWarning, message);
351 }
352
353 G4PolyhedraHistorical* origparamMother = msol->GetOriginalParameters();
354
355 if( origparamMother->numSide != fnDiv && fDivisionType != DivWIDTH)
356 {
357 std::ostringstream message;
358 message << "Configuration not supported." << G4endl
359 << "Division along PHI will be done splitting in the defined"
360 << G4endl
361 << "numSide, i.e, the number of division would be :"
362 << origparamMother->numSide << " instead of " << fnDiv << " !";
363 G4Exception("G4ParameterisationPolyhedraPhi::CheckParametersValidity()",
364 "GeomDiv0001", FatalException, message);
365 }
366}
367
368//--------------------------------------------------------------------------
369void
370G4ParameterisationPolyhedraPhi::
371ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
372{
373 //----- translation
374 G4ThreeVector origin(0.,0.,0.);
375 //----- set translation
376 physVol->SetTranslation( origin );
377
378 //----- calculate rotation matrix (so that all volumes point to the centre)
379 G4double posi = copyNo*fwidth;
380
381#ifdef G4DIVDEBUG
382 if( verbose >= 2 )
383 {
384 G4cout << " G4ParameterisationPolyhedraPhi - position: " << posi/CLHEP::deg
385 << G4endl
386 << " copyNo: " << copyNo
387 << " - fwidth: " << fwidth/CLHEP::deg << G4endl;
388 }
389#endif
390
391 ChangeRotMatrix( physVol, -posi );
392
393#ifdef G4DIVDEBUG
394 if( verbose >= 2 )
395 {
396 G4cout << std::setprecision(8) << " G4ParameterisationPolyhedraPhi "
397 << copyNo << G4endl
398 << " Position: " << origin << " - Width: " << fwidth
399 << " - Axis: " << faxis << G4endl;
400 }
401#endif
402}
403
404//--------------------------------------------------------------------------
405void
406G4ParameterisationPolyhedraPhi::
407ComputeDimensions( G4Polyhedra& phedra, const G4int,
408 const G4VPhysicalVolume* ) const
409{
410 G4Polyhedra* msol = (G4Polyhedra*)(fmotherSolid);
411
412 G4PolyhedraHistorical* origparamMother = msol->GetOriginalParameters();
413 G4PolyhedraHistorical origparam( *origparamMother );
414
415 origparam.numSide = 1;
416 origparam.Start_angle = origparamMother->Start_angle;
417 origparam.Opening_angle = fwidth;
418
419 phedra.SetOriginalParameters(&origparam); // copy values & transfer pointers
420 phedra.Reset(); // reset to new solid parameters
421
422#ifdef G4DIVDEBUG
423 if( verbose >= 2 )
424 {
425 G4cout << "G4ParameterisationPolyhedraPhi::ComputeDimensions():" << G4endl;
426 phedra.DumpInfo();
427 }
428#endif
429}
430
431//--------------------------------------------------------------------------
432G4ParameterisationPolyhedraZ::
433G4ParameterisationPolyhedraZ( EAxis axis, G4int nDiv,
434 G4double width, G4double offset,
435 G4VSolid* msolid, DivisionType divType )
436 : G4VParameterisationPolyhedra( axis, nDiv, width, offset, msolid, divType ),
437 fOrigParamMother(((G4Polyhedra*)fmotherSolid)->GetOriginalParameters())
438{
439 CheckParametersValidity();
440 SetType( "DivisionPolyhedraZ" );
441
442 if( divType == DivWIDTH )
443 {
444 fnDiv =
445 CalculateNDiv(fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
446 - fOrigParamMother->Z_values[0] , width, offset);
447 }
448 else if( divType == DivNDIV )
449 {
450 fwidth =
451 CalculateNDiv(fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
452 - fOrigParamMother->Z_values[0] , nDiv, offset);
453 }
454
455#ifdef G4DIVDEBUG
456 if( verbose >= 1 )
457 {
458 G4cout << " G4ParameterisationPolyhedraZ - # divisions " << fnDiv << " = "
459 << nDiv << G4endl
460 << " Offset " << foffset << " = " << offset << G4endl
461 << " Width " << fwidth << " = " << width << G4endl;
462 }
463#endif
464}
465
466//---------------------------------------------------------------------
467G4ParameterisationPolyhedraZ::~G4ParameterisationPolyhedraZ()
468{
469}
470
471//------------------------------------------------------------------------
472G4double G4ParameterisationPolyhedraZ::GetR(G4double z,
473 G4double z1, G4double r1,
474 G4double z2, G4double r2) const
475{
476 // Linear parameterisation:
477 // r = az + b
478 // a = (r1 - r2)/(z1-z2)
479 // b = r1 - a*z1
480
481 return (r1-r2)/(z1-z2)*z + ( r1 - (r1-r2)/(z1-z2)*z1 ) ;
482}
483
484//------------------------------------------------------------------------
485G4double G4ParameterisationPolyhedraZ::GetRmin(G4double z, G4int nseg) const
486{
487// Get Rmin in the given z position for the given polyhedra segment
488
489 return GetR(z,
490 fOrigParamMother->Z_values[nseg],
491 fOrigParamMother->Rmin[nseg],
492 fOrigParamMother->Z_values[nseg+1],
493 fOrigParamMother->Rmin[nseg+1]);
494}
495
496//------------------------------------------------------------------------
497G4double G4ParameterisationPolyhedraZ::GetRmax(G4double z, G4int nseg) const
498{
499// Get Rmax in the given z position for the given polyhedra segment
500
501 return GetR(z,
502 fOrigParamMother->Z_values[nseg],
503 fOrigParamMother->Rmax[nseg],
504 fOrigParamMother->Z_values[nseg+1],
505 fOrigParamMother->Rmax[nseg+1]);
506}
507
508//------------------------------------------------------------------------
509G4double G4ParameterisationPolyhedraZ::GetMaxParameter() const
510{
511 return std::abs(fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
512 -fOrigParamMother->Z_values[0]);
513}
514
515//---------------------------------------------------------------------
516void G4ParameterisationPolyhedraZ::CheckParametersValidity()
517{
518 G4VDivisionParameterisation::CheckParametersValidity();
519
520 // Division will be following the mother polyhedra segments
521 //
522 if( fDivisionType == DivNDIV )
523 {
524 if( fOrigParamMother->Num_z_planes-1 != fnDiv )
525 {
526 std::ostringstream message;
527 message << "Configuration not supported." << G4endl
528 << "Division along Z will be done splitting in the defined"
529 << G4endl
530 << "Z planes, i.e, the number of division would be :"
531 << fOrigParamMother->Num_z_planes-1 << " instead of "
532 << fnDiv << " !";
533 G4Exception("G4ParameterisationPolyhedraZ::CheckParametersValidity()",
534 "GeomDiv0001", FatalException, message);
535 }
536 }
537
538 // Division will be done within one polyhedra segment
539 // with applying given width and offset
540 //
541 if( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
542 {
543 // Check if divided region does not span over more
544 // than one z segment
545
546 G4int isegstart = -1; // number of the segment containing start position
547 G4int isegend = -1; // number of the segment containing end position
548
549 if ( !fReflectedSolid )
550 {
551 // The start/end position of the divided region
552 //
553 G4double zstart = fOrigParamMother->Z_values[0] + foffset;
554 G4double zend = fOrigParamMother->Z_values[0]
555 + foffset + fnDiv*fwidth;
556
557 G4int counter = 0;
558 while ( isegend < 0 && counter < fOrigParamMother->Num_z_planes-1 )
559 {
560 // first segment
561 if ( zstart >= fOrigParamMother->Z_values[counter] &&
562 zstart < fOrigParamMother->Z_values[counter+1] )
563 {
564 isegstart = counter;
565 }
566 // last segment
567 if ( zend > fOrigParamMother->Z_values[counter] &&
568 zend <= fOrigParamMother->Z_values[counter+1] )
569 {
570 isegend = counter;
571 }
572 ++counter;
573 } // Loop checking, 06.08.2015, G.Cosmo
574 }
575 else
576 {
577 // The start/end position of the divided region
578 //
579 G4double zstart = fOrigParamMother->Z_values[0] - foffset;
580 G4double zend = fOrigParamMother->Z_values[0]
581 - (foffset + fnDiv* fwidth);
582
583 G4int counter = 0;
584 while ( isegend < 0 && counter < fOrigParamMother->Num_z_planes-1 )
585 {
586 // first segment
587 if ( zstart <= fOrigParamMother->Z_values[counter] &&
588 zstart > fOrigParamMother->Z_values[counter+1] )
589 {
590 isegstart = counter;
591 }
592 // last segment
593 if ( zend < fOrigParamMother->Z_values[counter] &&
594 zend >= fOrigParamMother->Z_values[counter+1] )
595 {
596 isegend = counter;
597 }
598 ++counter;
599 } // Loop checking, 06.08.2015, G.Cosmo
600 }
601
602 if ( isegstart != isegend )
603 {
604 std::ostringstream message;
605 message << "Configuration not supported." << G4endl
606 << "Division with user defined width." << G4endl
607 << "Solid " << fmotherSolid->GetName() << G4endl
608 << "Divided region is not between two Z planes.";
609 G4Exception("G4ParameterisationPolyhedraZ::CheckParametersValidity()",
610 "GeomDiv0001", FatalException, message);
611 }
612
613 fNSegment = isegstart;
614 }
615}
616
617//---------------------------------------------------------------------
618void
619G4ParameterisationPolyhedraZ::
620ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol) const
621{
622 G4double posi;
623 if ( fDivisionType == DivNDIV )
624 {
625 // The position of the centre of copyNo-th mother polycone segment
626
627 posi = ( fOrigParamMother->Z_values[copyNo]
628 + fOrigParamMother->Z_values[copyNo+1])/2;
629 physVol->SetTranslation( G4ThreeVector(0, 0, posi) );
630 }
631
632 if ( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
633 {
634 // The position of the centre of copyNo-th division
635
636 posi = fOrigParamMother->Z_values[0];
637
638 if ( !fReflectedSolid )
639 posi += foffset + (2*copyNo + 1) * fwidth/2.;
640 else
641 posi -= foffset + (2*copyNo + 1) * fwidth/2.;
642
643 physVol->SetTranslation( G4ThreeVector(0, 0, posi) );
644 }
645
646 //----- calculate rotation matrix: unit
647
648#ifdef G4DIVDEBUG
649 if( verbose >= 2 )
650 {
651 G4cout << " G4ParameterisationPolyhedraZ - position: " << posi << G4endl
652 << " copyNo: " << copyNo << " - foffset: " << foffset/CLHEP::deg
653 << " - fwidth: " << fwidth/CLHEP::deg << G4endl;
654 }
655#endif
656
657 ChangeRotMatrix( physVol );
658
659#ifdef G4DIVDEBUG
660 if( verbose >= 2 )
661 {
662 G4cout << std::setprecision(8) << " G4ParameterisationPolyhedraZ "
663 << copyNo << G4endl
664 << " Position: (0,0,0) - Width: " << fwidth
665 << " - Axis: " << faxis << G4endl;
666 }
667#endif
668}
669
670//---------------------------------------------------------------------
671void
672G4ParameterisationPolyhedraZ::
673ComputeDimensions( G4Polyhedra& phedra, const G4int copyNo,
674 const G4VPhysicalVolume* ) const
675{
676 // Define division solid
677 //
678 G4PolyhedraHistorical origparam;
679 G4int nz = 2;
680 origparam.Num_z_planes = nz;
681 origparam.numSide = fOrigParamMother->numSide;
682 origparam.Start_angle = fOrigParamMother->Start_angle;
683 origparam.Opening_angle = fOrigParamMother->Opening_angle;
684
685 // Define division solid z sections
686 //
687 origparam.Z_values = new G4double[nz];
688 origparam.Rmin = new G4double[nz];
689 origparam.Rmax = new G4double[nz];
690 origparam.Z_values[0] = - fwidth/2.;
691 origparam.Z_values[1] = fwidth/2.;
692
693 if ( fDivisionType == DivNDIV )
694 {
695 // The position of the centre of copyNo-th mother polycone segment
696 //
697 G4double posi = ( fOrigParamMother->Z_values[copyNo]
698 + fOrigParamMother->Z_values[copyNo+1])/2;
699
700 origparam.Z_values[0] = fOrigParamMother->Z_values[copyNo] - posi;
701 origparam.Z_values[1] = fOrigParamMother->Z_values[copyNo+1] - posi;
702 origparam.Rmin[0] = fOrigParamMother->Rmin[copyNo];
703 origparam.Rmin[1] = fOrigParamMother->Rmin[copyNo+1];
704 origparam.Rmax[0] = fOrigParamMother->Rmax[copyNo];
705 origparam.Rmax[1] = fOrigParamMother->Rmax[copyNo+1];
706 }
707
708 if ( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
709 {
710 if ( !fReflectedSolid )
711 {
712 origparam.Z_values[0] = -fwidth/2.;
713 origparam.Z_values[1] = fwidth/2.;
714
715 // The position of the centre of copyNo-th division
716 //
717 G4double posi = fOrigParamMother->Z_values[0]
718 + foffset + (2*copyNo + 1) * fwidth/2.;
719
720 // The first and last z sides z values
721 G4double zstart = posi - fwidth/2.;
722 G4double zend = posi + fwidth/2.;
723 origparam.Rmin[0] = GetRmin(zstart, fNSegment);
724 origparam.Rmax[0] = GetRmax(zstart, fNSegment);
725 origparam.Rmin[1] = GetRmin(zend, fNSegment);
726 origparam.Rmax[1] = GetRmax(zend, fNSegment);
727 }
728 else
729 {
730 origparam.Z_values[0] = fwidth/2.;
731 origparam.Z_values[1] = -fwidth/2.;
732
733 // The position of the centre of copyNo-th division
734 //
735 G4double posi = fOrigParamMother->Z_values[0]
736 - ( foffset + (2*copyNo + 1) * fwidth/2.);
737
738 // The first and last z sides z values
739 //
740 G4double zstart = posi + fwidth/2.;
741 G4double zend = posi - fwidth/2.;
742 origparam.Rmin[0] = GetRmin(zstart, fNSegment);
743 origparam.Rmax[0] = GetRmax(zstart, fNSegment);
744 origparam.Rmin[1] = GetRmin(zend, fNSegment);
745 origparam.Rmax[1] = GetRmax(zend, fNSegment);
746 }
747
748 // It can happen due to rounding errors
749 //
750 if ( origparam.Rmin[0] < 0.0 ) origparam.Rmin[0] = 0.0;
751 if ( origparam.Rmin[nz-1] < 0.0 ) origparam.Rmin[1] = 0.0;
752 }
753
754 phedra.SetOriginalParameters(&origparam); // copy values & transfer pointers
755 phedra.Reset(); // reset to new solid parameters
756
757#ifdef G4DIVDEBUG
758 if( verbose >= 2 )
759 {
760 G4cout << "G4ParameterisationPolyhedraZ::ComputeDimensions()" << G4endl
761 << "-- Parametrised phedra copy-number: " << copyNo << G4endl;
762 phedra.DumpInfo();
763 }
764#endif
765}
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
G4GeometryTolerance::GetInstance
static G4GeometryTolerance * GetInstance()
Definition: G4GeometryTolerance.cc:58
G4ParameterisationPolyhedraPhi::G4ParameterisationPolyhedraPhi
G4ParameterisationPolyhedraPhi(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *motherSolid, DivisionType divType)
Definition: G4ParameterisationPolyhedra.cc:284
G4ParameterisationPolyhedraPhi::ComputeDimensions
void ComputeDimensions(G4Polyhedra &phedra, const G4int copyNo, const G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolyhedra.cc:407
G4ParameterisationPolyhedraPhi::ComputeTransformation
void ComputeTransformation(const G4int copyNo, G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolyhedra.cc:371
G4ParameterisationPolyhedraRho::ComputeDimensions
void ComputeDimensions(G4Polyhedra &phedra, const G4int copyNo, const G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolyhedra.cc:251
G4ParameterisationPolyhedraRho::G4ParameterisationPolyhedraRho
G4ParameterisationPolyhedraRho(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *motherSolid, DivisionType divType)
Definition: G4ParameterisationPolyhedra.cc:136
G4ParameterisationPolyhedraRho::ComputeTransformation
void ComputeTransformation(const G4int copyNo, G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolyhedra.cc:215
G4ParameterisationPolyhedraZ::ComputeTransformation
void ComputeTransformation(const G4int copyNo, G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolyhedra.cc:620
G4ParameterisationPolyhedraZ::G4ParameterisationPolyhedraZ
G4ParameterisationPolyhedraZ(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *motherSolid, DivisionType divType)
Definition: G4ParameterisationPolyhedra.cc:433
G4ParameterisationPolyhedraZ::ComputeDimensions
void ComputeDimensions(G4Polyhedra &phedra, const G4int copyNo, const G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolyhedra.cc:673
G4Polyhedra::GetEndPhi
G4double GetEndPhi() const
G4Polyhedra::SetOriginalParameters
void SetOriginalParameters(G4PolyhedraHistorical *pars)
G4Polyhedra::GetNumSide
G4int GetNumSide() const
G4Polyhedra::GetOriginalParameters
G4PolyhedraHistorical * GetOriginalParameters() const
G4Polyhedra::Reset
G4bool Reset()
Definition: G4Polyhedra.cc:463
G4Polyhedra::GetStartPhi
G4double GetStartPhi() const
G4Polyhedra::IsGeneric
G4bool IsGeneric() const
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
G4VParameterisationPolyhedra::G4VParameterisationPolyhedra
G4VParameterisationPolyhedra(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *msolid, DivisionType divType)
Definition: G4ParameterisationPolyhedra.cc:46
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