Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4ParameterisationPolyconeZ Class Reference

#include <G4ParameterisationPolycone.hh>

+ Inheritance diagram for G4ParameterisationPolyconeZ:

Public Member Functions

 G4ParameterisationPolyconeZ (EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *motherSolid, DivisionType divType)
 
 ~G4ParameterisationPolyconeZ ()
 
void CheckParametersValidity ()
 
G4double GetMaxParameter () const
 
void ComputeTransformation (const G4int copyNo, G4VPhysicalVolume *physVol) const
 
void ComputeDimensions (G4Polycone &pcone, const G4int copyNo, const G4VPhysicalVolume *physVol) const
 
- Public Member Functions inherited from G4VParameterisationPolycone
 G4VParameterisationPolycone (EAxis axis, G4int nCopies, G4double offset, G4double step, G4VSolid *msolid, DivisionType divType)
 
virtual ~G4VParameterisationPolycone ()
 
- Public Member Functions inherited from G4VDivisionParameterisation
 G4VDivisionParameterisation (EAxis axis, G4int nDiv, G4double width, G4double offset, DivisionType divType, G4VSolid *motherSolid=nullptr)
 
virtual ~G4VDivisionParameterisation ()
 
virtual G4VSolid * ComputeSolid (const G4int, G4VPhysicalVolume *)
 
virtual void ComputeTransformation (const G4int copyNo, G4VPhysicalVolume *physVol) const =0
 
const G4String & GetType () const
 
EAxis GetAxis () const
 
G4int GetNoDiv () const
 
G4double GetWidth () const
 
G4double GetOffset () const
 
G4VSolid * GetMotherSolid () const
 
void SetType (const G4String &type)
 
G4int VolumeFirstCopyNo () const
 
void SetHalfGap (G4double hg)
 
G4double GetHalfGap () const
 
- Public Member Functions inherited from G4VPVParameterisation
 G4VPVParameterisation ()=default
 
virtual ~G4VPVParameterisation ()=default
 
virtual void ComputeTransformation (const G4int, G4VPhysicalVolume *) const =0
 
virtual G4VSolid * ComputeSolid (const G4int, G4VPhysicalVolume *)
 
virtual G4Material * ComputeMaterial (const G4int repNo, G4VPhysicalVolume *currentVol, const G4VTouchable *parentTouch=nullptr)
 
virtual G4bool IsNested () const
 
virtual G4VVolumeMaterialScanner * GetMaterialScanner ()
 
virtual void ComputeDimensions (G4Box &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Tubs &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Trd &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Trap &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Cons &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Sphere &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Orb &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Ellipsoid &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Torus &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Para &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Polycone &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Polyhedra &, const G4int, const G4VPhysicalVolume *) const
 
virtual void ComputeDimensions (G4Hype &, const G4int, const G4VPhysicalVolume *) const
 

Additional Inherited Members

- Protected Member Functions inherited from G4VDivisionParameterisation
void ChangeRotMatrix (G4VPhysicalVolume *physVol, G4double rotZ=0.0) const
 
G4int CalculateNDiv (G4double motherDim, G4double width, G4double offset) const
 
G4double CalculateWidth (G4double motherDim, G4int nDiv, G4double offset) const
 
virtual void CheckParametersValidity ()
 
void CheckOffset (G4double maxPar)
 
void CheckNDivAndWidth (G4double maxPar)
 
virtual G4double GetMaxParameter () const =0
 
G4double OffsetZ () const
 
- Protected Attributes inherited from G4VDivisionParameterisation
G4String ftype
 
EAxis faxis
 
G4int fnDiv = 0
 
G4double fwidth = 0.0
 
G4double foffset = 0.0
 
DivisionType fDivisionType
 
G4VSolid * fmotherSolid = nullptr
 
G4bool fReflectedSolid = false
 
G4bool fDeleteSolid = false
 
G4int theVoluFirstCopyNo = 1
 
G4double kCarTolerance
 
G4double fhgap = 0.0
 
- Static Protected Attributes inherited from G4VDivisionParameterisation
static G4ThreadLocal G4RotationMatrix * fRot = nullptr
 
static const G4int verbose = 5
 

Detailed Description

Definition at line 173 of file G4ParameterisationPolycone.hh.

Constructor & Destructor Documentation

◆ G4ParameterisationPolyconeZ()

G4ParameterisationPolyconeZ::G4ParameterisationPolyconeZ ( EAxis  axis,
G4int  nCopies,
G4double  offset,
G4double  step,
G4VSolid *  motherSolid,
DivisionType  divType 
)

Definition at line 351 of file G4ParameterisationPolycone.cc.

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}
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4VDivisionParameterisation::SetType
void SetType(const G4String &type)
G4VDivisionParameterisation::CalculateNDiv
G4int CalculateNDiv(G4double motherDim, G4double width, G4double offset) const
Definition: G4VDivisionParameterisation.cc:100

◆ ~G4ParameterisationPolyconeZ()

G4ParameterisationPolyconeZ::~G4ParameterisationPolyconeZ ( )

Definition at line 387 of file G4ParameterisationPolycone.cc.

388{
389}

Member Function Documentation

◆ CheckParametersValidity()

void G4ParameterisationPolyconeZ::CheckParametersValidity ( )
virtual

Reimplemented from G4VDivisionParameterisation.

Definition at line 436 of file G4ParameterisationPolycone.cc.

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}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
G4double
double G4double
Definition: G4Types.hh:83
G4int
int G4int
Definition: G4Types.hh:85
G4VSolid::GetName
G4String GetName() const

Referenced by G4ParameterisationPolyconeZ().

◆ ComputeDimensions()

void G4ParameterisationPolyconeZ::ComputeDimensions ( G4Polycone &  pcone,
const G4int  copyNo,
const G4VPhysicalVolume *  physVol 
) const
virtual

Reimplemented from G4VPVParameterisation.

Definition at line 595 of file G4ParameterisationPolycone.cc.

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}
G4Polycone::SetOriginalParameters
void SetOriginalParameters(G4PolyconeHistorical *pars)
G4Polycone::Reset
G4bool Reset()
Definition: G4Polycone.cc:436
G4VSolid::DumpInfo
void DumpInfo() const

◆ ComputeTransformation()

void G4ParameterisationPolyconeZ::ComputeTransformation ( const G4int  copyNo,
G4VPhysicalVolume *  physVol 
) const
virtual

Implements G4VDivisionParameterisation.

Definition at line 542 of file G4ParameterisationPolycone.cc.

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}
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:36
G4VDivisionParameterisation::ChangeRotMatrix
void ChangeRotMatrix(G4VPhysicalVolume *physVol, G4double rotZ=0.0) const
Definition: G4VDivisionParameterisation.cc:86
G4VPhysicalVolume::SetTranslation
void SetTranslation(const G4ThreeVector &v)
Definition: G4VPhysicalVolume.cc:155

◆ GetMaxParameter()

G4double G4ParameterisationPolyconeZ::GetMaxParameter ( ) const
virtual

Implements G4VDivisionParameterisation.

Definition at line 429 of file G4ParameterisationPolycone.cc.

430{
431 return std::abs (fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
432 -fOrigParamMother->Z_values[0]);
433}
The documentation for this class was generated from the following files: