Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
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