Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
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//
27// $Id$
28//
29// class G4ParameterisationPolycone Implementation file
30//
31// 26.05.03 - P.Arce, Initial version
32// 08.04.04 - I.Hrivnacova, Implemented reflection
33//---------------------------------------------------------------------
34
35#include "G4ParameterisationPolycone.hh"
36
37#include <iomanip>
38#include "G4ThreeVector.hh"
39#include "G4RotationMatrix.hh"
40#include "G4VPhysicalVolume.hh"
41#include "G4LogicalVolume.hh"
42#include "G4ReflectedSolid.hh"
43
44//-----------------------------------------------------------------------
45G4VParameterisationPolycone::
46G4VParameterisationPolycone( EAxis axis, G4int nDiv, G4double width,
47 G4double offset, G4VSolid* msolid,
48 DivisionType divType )
49 : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
50{
51 G4Polycone* msol = (G4Polycone*)(msolid);
52 if ((msolid->GetEntityType() != "G4ReflectedSolid") && (msol->IsGeneric()))
53 {
54 std::ostringstream message;
55 message << "Generic construct for G4Polycone NOT supported." << G4endl
56 << "Sorry! Solid: " << msol->GetName() << ".";
57 G4Exception("G4VParameterisationPolycone::G4VParameterisationPolycone()",
58 "GeomDiv0001", FatalException, message);
59 }
60 if (msolid->GetEntityType() == "G4ReflectedSolid")
61 {
62 // Get constituent solid
63 G4VSolid* mConstituentSolid
64 = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
65 msol = (G4Polycone*)(mConstituentSolid);
66
67 // Get parameters
68 G4int nofZplanes = msol->GetOriginalParameters()->Num_z_planes;
69 G4double* zValues = msol->GetOriginalParameters()->Z_values;
70 G4double* rminValues = msol->GetOriginalParameters()->Rmin;
71 G4double* rmaxValues = msol->GetOriginalParameters()->Rmax;
72
73 // Invert z values
74 G4double* zValuesRefl = new double[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: " << origin/mm
204 << " - Width: " << fwidth/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/deg << " = " << offset/deg << G4endl
272 << " Width " << fwidth/deg << " = " << width/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/deg
306 << G4endl
307 << " copyNo: " << copyNo << " - foffset: " << foffset/deg
308 << " - fwidth: " << fwidth/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: " << origin << " - 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 fNSegment(0),
357 fOrigParamMother(((G4Polycone*)fmotherSolid)->GetOriginalParameters())
358{
359
360 CheckParametersValidity();
361 SetType( "DivisionPolyconeZ" );
362
363 if( divType == DivWIDTH )
364 {
365 fnDiv =
366 CalculateNDiv( fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
367 - fOrigParamMother->Z_values[0] , width, offset );
368 }
369 else if( divType == DivNDIV )
370 {
371 fwidth =
372 CalculateNDiv( fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
373 - fOrigParamMother->Z_values[0] , nDiv, offset );
374 }
375
376#ifdef G4DIVDEBUG
377 if( verbose >= 1 )
378 {
379 G4cout << " G4ParameterisationPolyconeZ - # divisions " << fnDiv << " = "
380 << nDiv << G4endl
381 << " Offset " << foffset << " = " << offset << G4endl
382 << " Width " << fwidth << " = " << width << G4endl;
383 }
384#endif
385}
386
387//---------------------------------------------------------------------
388G4ParameterisationPolyconeZ::~G4ParameterisationPolyconeZ()
389{
390}
391
392//------------------------------------------------------------------------
393G4double G4ParameterisationPolyconeZ::GetR(G4double z,
394 G4double z1, G4double r1,
395 G4double z2, G4double r2) const
396{
397 // Linear parameterisation:
398 // r = az + b
399 // a = (r1 - r2)/(z1-z2)
400 // b = r1 - a*z1
401
402 return (r1-r2)/(z1-z2)*z + ( r1 - (r1-r2)/(z1-z2)*z1 ) ;
403}
404
405//------------------------------------------------------------------------
406G4double G4ParameterisationPolyconeZ::GetRmin(G4double z, G4int nseg) const
407{
408// Get Rmin in the given z position for the given polycone segment
409
410 return GetR(z,
411 fOrigParamMother->Z_values[nseg],
412 fOrigParamMother->Rmin[nseg],
413 fOrigParamMother->Z_values[nseg+1],
414 fOrigParamMother->Rmin[nseg+1]);
415}
416
417//------------------------------------------------------------------------
418G4double G4ParameterisationPolyconeZ::GetRmax(G4double z, G4int nseg) const
419{
420// Get Rmax in the given z position for the given polycone segment
421
422 return GetR(z,
423 fOrigParamMother->Z_values[nseg],
424 fOrigParamMother->Rmax[nseg],
425 fOrigParamMother->Z_values[nseg+1],
426 fOrigParamMother->Rmax[nseg+1]);
427}
428
429//------------------------------------------------------------------------
430G4double G4ParameterisationPolyconeZ::GetMaxParameter() const
431{
432 return std::abs (fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
433 -fOrigParamMother->Z_values[0]);
434}
435
436//---------------------------------------------------------------------
437void G4ParameterisationPolyconeZ::CheckParametersValidity()
438{
439 G4VDivisionParameterisation::CheckParametersValidity();
440
441 // Division will be following the mother polycone segments
442 if( fDivisionType == DivNDIV ) {
443 if( fnDiv > fOrigParamMother->Num_z_planes-1 ) {
444 std::ostringstream error;
445 error << "Configuration not supported." << G4endl
446 << "Division along Z will be done by splitting in the defined"
447 << G4endl
448 << "Z planes, i.e, the number of division would be: "
449 << fOrigParamMother->Num_z_planes-1
450 << ", instead of: " << fnDiv << " !";
451 G4Exception("G4ParameterisationPolyconeZ::CheckParametersValidity()",
452 "GeomDiv0001", FatalException, error);
453 }
454 }
455
456 // Division will be done within one polycone segment
457 // with applying given width and offset
458 if( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH ) {
459 // Check if divided region does not span over more
460 // than one z segment
461
462 G4int isegstart = -1; // number of the segment containing start position
463 G4int isegend = -1; // number of the segment containing end position
464
465 if ( ! fReflectedSolid ) {
466 // The start/end position of the divided region
467 G4double zstart
468 = fOrigParamMother->Z_values[0] + foffset;
469 G4double zend
470 = fOrigParamMother->Z_values[0] + foffset + fnDiv* fwidth;
471
472 G4int counter = 0;
473 while ( isegend < 0 && counter < fOrigParamMother->Num_z_planes-1 ) {
474 // first segment
475 if ( zstart >= fOrigParamMother->Z_values[counter] &&
476 zstart < fOrigParamMother->Z_values[counter+1] ) {
477 isegstart = counter;
478 }
479 // last segment
480 if ( zend > fOrigParamMother->Z_values[counter] &&
481 zend <= fOrigParamMother->Z_values[counter+1] ) {
482 isegend = counter;
483 }
484 ++counter;
485 }
486 }
487 else {
488 // The start/end position of the divided region
489 G4double zstart
490 = fOrigParamMother->Z_values[0] - foffset;
491 G4double zend
492 = fOrigParamMother->Z_values[0] - ( foffset + fnDiv* fwidth);
493
494 G4int counter = 0;
495 while ( isegend < 0 && counter < fOrigParamMother->Num_z_planes-1 ) {
496 // first segment
497 if ( zstart <= fOrigParamMother->Z_values[counter] &&
498 zstart > fOrigParamMother->Z_values[counter+1] ) {
499 isegstart = counter;
500 }
501 // last segment
502 if ( zend < fOrigParamMother->Z_values[counter] &&
503 zend >= fOrigParamMother->Z_values[counter+1] ) {
504 isegend = counter;
505 }
506 ++counter;
507 }
508 }
509
510
511 if ( isegstart != isegend ) {
512 std::ostringstream message;
513 message << "Condiguration not supported." << G4endl
514 << "Division with user defined width." << G4endl
515 << "Solid " << fmotherSolid->GetName() << G4endl
516 << "Divided region is not between two z planes.";
517 G4Exception("G4ParameterisationPolyconeZ::CheckParametersValidity()",
518 "GeomDiv0001", FatalException, message);
519 }
520
521 fNSegment = isegstart;
522 }
523}
524
525//---------------------------------------------------------------------
526void
527G4ParameterisationPolyconeZ::
528ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol) const
529{
530 if ( fDivisionType == DivNDIV ) {
531 // The position of the centre of copyNo-th mother polycone segment
532 G4double posi
533 = ( fOrigParamMother->Z_values[copyNo]
534 + fOrigParamMother->Z_values[copyNo+1])/2;
535 physVol->SetTranslation( G4ThreeVector(0, 0, posi) );
536 }
537
538 if ( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH ) {
539 // The position of the centre of copyNo-th division
540 G4double posi = fOrigParamMother->Z_values[0];
541
542 if ( ! fReflectedSolid )
543 posi += foffset + (2*copyNo + 1) * fwidth/2.;
544 else
545 posi -= foffset + (2*copyNo + 1) * fwidth/2.;
546
547 physVol->SetTranslation( G4ThreeVector(0, 0, posi) );
548 }
549
550 //----- calculate rotation matrix: unit
551
552#ifdef G4DIVDEBUG
553 if( verbose >= 2 )
554 {
555 G4cout << " G4ParameterisationPolyconeZ - position: " << posi << G4endl
556 << " copyNo: " << copyNo << " - foffset: " << foffset/deg
557 << " - fwidth: " << fwidth/deg << G4endl;
558 }
559#endif
560
561 ChangeRotMatrix( physVol );
562
563#ifdef G4DIVDEBUG
564 if( verbose >= 2 )
565 {
566 G4cout << std::setprecision(8) << " G4ParameterisationPolyconeZ "
567 << copyNo << G4endl
568 << " Position: " << origin << " - Width: " << fwidth
569 << " - Axis: " << faxis << G4endl;
570 }
571#endif
572}
573
574//---------------------------------------------------------------------
575void
576G4ParameterisationPolyconeZ::
577ComputeDimensions( G4Polycone& pcone, const G4int copyNo,
578 const G4VPhysicalVolume* ) const
579{
580
581 // Define division solid
582 G4PolyconeHistorical origparam;
583 G4int nz = 2;
584 origparam.Num_z_planes = nz;
585 origparam.Start_angle = fOrigParamMother->Start_angle;
586 origparam.Opening_angle = fOrigParamMother->Opening_angle;
587
588 // Define division solid z sections
589 origparam.Z_values = new G4double[nz];
590 origparam.Rmin = new G4double[nz];
591 origparam.Rmax = new G4double[nz];
592
593 if ( fDivisionType == DivNDIV ) {
594 // The position of the centre of copyNo-th mother polycone segment
595 G4double posi = (fOrigParamMother->Z_values[copyNo]
596 + fOrigParamMother->Z_values[copyNo+1])/2;
597
598 origparam.Z_values[0] = fOrigParamMother->Z_values[copyNo] - posi;
599 origparam.Z_values[1] = fOrigParamMother->Z_values[copyNo+1] - posi;
600 origparam.Rmin[0] = fOrigParamMother->Rmin[copyNo];
601 origparam.Rmin[1] = fOrigParamMother->Rmin[copyNo+1];
602 origparam.Rmax[0] = fOrigParamMother->Rmax[copyNo];
603 origparam.Rmax[1] = fOrigParamMother->Rmax[copyNo+1];
604 }
605
606 if ( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH ) {
607 if ( ! fReflectedSolid ) {
608 origparam.Z_values[0] = - fwidth/2.;
609 origparam.Z_values[1] = fwidth/2.;
610
611 // The position of the centre of copyNo-th division
612 G4double posi
613 = fOrigParamMother->Z_values[0] + foffset + (2*copyNo + 1) * fwidth/2.;
614
615 // The first and last z sides z values
616 G4double zstart = posi - fwidth/2.;
617 G4double zend = posi + fwidth/2.;
618 origparam.Rmin[0] = GetRmin(zstart, fNSegment);
619 origparam.Rmax[0] = GetRmax(zstart, fNSegment);
620 origparam.Rmin[1] = GetRmin(zend, fNSegment);
621 origparam.Rmax[1] = GetRmax(zend, fNSegment);
622 }
623 else {
624 origparam.Z_values[0] = fwidth/2.;
625 origparam.Z_values[1] = - fwidth/2.;
626
627 // The position of the centre of copyNo-th division
628 G4double posi
629 = fOrigParamMother->Z_values[0] - ( foffset + (2*copyNo + 1) * fwidth/2.);
630
631 // The first and last z sides z values
632 G4double zstart = posi + fwidth/2.;
633 G4double zend = posi - fwidth/2.;
634 origparam.Rmin[0] = GetRmin(zstart, fNSegment);
635 origparam.Rmax[0] = GetRmax(zstart, fNSegment);
636 origparam.Rmin[1] = GetRmin(zend, fNSegment);
637 origparam.Rmax[1] = GetRmax(zend, fNSegment);
638 }
639
640 // It can happen due to rounding errors
641 if ( origparam.Rmin[0] < 0.0 ) origparam.Rmin[0] = 0.0;
642 if ( origparam.Rmin[nz-1] < 0.0 ) origparam.Rmin[1] = 0.0;
643 }
644
645 pcone.SetOriginalParameters(&origparam); // copy values & transfer pointers
646 pcone.Reset(); // reset to new solid parameters
647
648#ifdef G4DIVDEBUG
649 if( verbose >= 2 )
650 {
651 G4cout << "G4ParameterisationPolyconeZ::ComputeDimensions()" << G4endl
652 << "-- Parametrised pcone copy-number: " << copyNo << G4endl;
653 pcone.DumpInfo();
654 }
655#endif
656}
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:64
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:60
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:42
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT 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:528
G4ParameterisationPolyconeZ::ComputeDimensions
void ComputeDimensions(G4Polycone &pcone, const G4int copyNo, const G4VPhysicalVolume *physVol) const
Definition: G4ParameterisationPolycone.cc:577
G4PolyconeHistorical::Opening_angle
G4double Opening_angle
Definition: G4Polycone.hh:78
G4PolyconeHistorical::Z_values
G4double * Z_values
Definition: G4Polycone.hh:80
G4Polycone::GetEndPhi
G4double GetEndPhi() const
G4Polycone::SetOriginalParameters
void SetOriginalParameters(G4PolyconeHistorical *pars)
G4Polycone::GetStartPhi
G4double GetStartPhi() const
G4Polycone::IsGeneric
G4bool IsGeneric() const
G4Polycone::GetOriginalParameters
G4PolyconeHistorical * GetOriginalParameters() const
G4Polycone::Reset
G4bool Reset()
Definition: G4Polycone.cc:409
G4VDivisionParameterisation::ChangeRotMatrix
void ChangeRotMatrix(G4VPhysicalVolume *physVol, G4double rotZ=0.) const
Definition: G4VDivisionParameterisation.cc:88
G4VDivisionParameterisation::SetType
void SetType(const G4String &type)
G4VDivisionParameterisation::CalculateWidth
G4double CalculateWidth(G4double motherDim, G4int nDiv, G4double offset) const
Definition: G4VDivisionParameterisation.cc:117
G4VDivisionParameterisation::CalculateNDiv
G4int CalculateNDiv(G4double motherDim, G4double width, G4double offset) const
Definition: G4VDivisionParameterisation.cc:102
G4VParameterisationPolycone::G4VParameterisationPolycone
G4VParameterisationPolycone(EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *msolid, DivisionType divType)
Definition: G4ParameterisationPolycone.cc:46
G4VPhysicalVolume::SetTranslation
void SetTranslation(const G4ThreeVector &v)
G4VSolid::GetName
G4String GetName() const
G4VSolid::DumpInfo
void DumpInfo() const
G4VSolid::GetEntityType
virtual G4GeometryType GetEntityType() const =0
EAxis
EAxis
Definition: geomdefs.hh:54
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41