#include <G4ParameterisationPolycone.hh>

Inheritance diagram for G4ParameterisationPolyconeZ:

Public Member Functions
void	CheckParametersValidity ()

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

virtual G4Material *	ComputeMaterial (const G4int repNo, G4VPhysicalVolume currentVol, const G4VTouchable parentTouch=nullptr)

virtual G4VSolid *	ComputeSolid (const G4int, G4VPhysicalVolume *)

void	ComputeTransformation (const G4int copyNo, G4VPhysicalVolume *physVol) const

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

EAxis	GetAxis () const

G4double	GetHalfGap () const

virtual G4VVolumeMaterialScanner *	GetMaterialScanner ()

G4double	GetMaxParameter () const

G4VSolid *	GetMotherSolid () const

G4int	GetNoDiv () const

G4double	GetOffset () const

const G4String &	GetType () const

G4double	GetWidth () const

virtual G4bool	IsNested () const

void	SetHalfGap (G4double hg)

void	SetType (const G4String &type)

G4int	VolumeFirstCopyNo () const

	~G4ParameterisationPolyconeZ ()

Protected Member Functions
G4int	CalculateNDiv (G4double motherDim, G4double width, G4double offset) const

G4double	CalculateWidth (G4double motherDim, G4int nDiv, G4double offset) const

void	ChangeRotMatrix (G4VPhysicalVolume *physVol, G4double rotZ=0.0) const

void	CheckNDivAndWidth (G4double maxPar)

void	CheckOffset (G4double maxPar)

G4double	OffsetZ () const

Protected Attributes
EAxis	faxis

G4bool	fDeleteSolid = false

DivisionType	fDivisionType

G4double	fhgap = 0.0

G4VSolid *	fmotherSolid = nullptr

G4int	fnDiv = 0

G4double	foffset = 0.0

G4bool	fReflectedSolid = false

G4String	ftype

G4double	fwidth = 0.0

G4double	kCarTolerance

G4int	theVoluFirstCopyNo = 1

Static Protected Attributes
static G4ThreadLocal G4RotationMatrix *	fRot = nullptr

static const G4int	verbose = 5

Private Member Functions
void	ComputeDimensions (G4Box &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Cons &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Ellipsoid &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Hype &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Orb &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Para &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Polyhedra &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Sphere &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Torus &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Trap &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Trd &, const G4int, const G4VPhysicalVolume *) const

void	ComputeDimensions (G4Tubs &, const G4int, const G4VPhysicalVolume *) const

G4double	GetR (G4double z, G4double z1, G4double r1, G4double z2, G4double r2) const

G4double	GetRmax (G4double z, G4int nsegment) const

G4double	GetRmin (G4double z, G4int nsegment) const

Private Attributes
G4int	fNSegment = 0

G4PolyconeHistorical *	fOrigParamMother = nullptr

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.

  : G4VParameterisationPolycone( axis, nDiv, width, offset, msolid, divType ),
    fOrigParamMother(((G4Polycone*)fmotherSolid)->GetOriginalParameters())
{
 
  CheckParametersValidity();
  SetType( "DivisionPolyconeZ" );
 
  if( divType == DivWIDTH )
  {
    fnDiv =
      CalculateNDiv( fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
                     - fOrigParamMother->Z_values[0] , width, offset );
  }
  else if( divType == DivNDIV )
  {
    fwidth =
      CalculateNDiv( fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
                     - fOrigParamMother->Z_values[0] , nDiv, offset );
  }
  
#ifdef G4DIVDEBUG
  if( verbose >= 1 )
  {
    G4cout << " G4ParameterisationPolyconeZ - # divisions " << fnDiv << " = "
           << nDiv << G4endl
           << " Offset " << foffset << " = " << offset << G4endl
           << " Width " << fwidth << " = " << width << G4endl;
  }
#endif
}

References G4VDivisionParameterisation::CalculateNDiv(), CheckParametersValidity(), DivNDIV, DivWIDTH, G4VDivisionParameterisation::fnDiv, G4VDivisionParameterisation::foffset, fOrigParamMother, G4VDivisionParameterisation::fwidth, G4cout, G4endl, G4PolyconeHistorical::Num_z_planes, G4VDivisionParameterisation::SetType(), G4VDivisionParameterisation::verbose, and G4PolyconeHistorical::Z_values.

◆ ~G4ParameterisationPolyconeZ()

G4ParameterisationPolyconeZ::~G4ParameterisationPolyconeZ ( )

Definition at line 387 of file G4ParameterisationPolycone.cc.

388{

389}

Member Function Documentation

◆ CalculateNDiv()

G4int G4VDivisionParameterisation::CalculateNDiv	(	G4double	motherDim,
		G4double	width,
		G4double	offset
	)		const

protectedinherited

Definition at line 99 of file G4VDivisionParameterisation.cc.

{
#ifdef G4DIVDEBUG
  G4cout << " G4VDivisionParameterisation::CalculateNDiv: "
         << ( motherDim - offset ) / width 
         << " Motherdim: " <<  motherDim << ", Offset: " << offset
         << ", Width: " << width << G4endl;
#endif
 
  return G4int( ( motherDim - offset ) / width );
}

References G4cout, and G4endl.

◆ CalculateWidth()

G4double G4VDivisionParameterisation::CalculateWidth	(	G4double	motherDim,
		G4int	nDiv,
		G4double	offset
	)		const

protectedinherited

Definition at line 114 of file G4VDivisionParameterisation.cc.

{ 
#ifdef G4DIVDEBUG
  G4cout << " G4VDivisionParameterisation::CalculateWidth: "
         << ( motherDim - offset ) / nDiv
         << ", Motherdim: " << motherDim << ", Offset: " << offset
         << ", Number of divisions: " << nDiv << G4endl;
#endif
 
  return ( motherDim - offset ) / nDiv;
}

References G4cout, and G4endl.

◆ ChangeRotMatrix()

void G4VDivisionParameterisation::ChangeRotMatrix	(	G4VPhysicalVolume *	physVol,
		G4double	rotZ = `0.0`
	)		const

protectedinherited

Definition at line 85 of file G4VDivisionParameterisation.cc.

{
  if (fRot == nullptr)
  {
    fRot = new G4RotationMatrix();
    G4AutoDelete::Register(fRot);
  }
  fRot->rotateZ( rotZ );
  physVol->SetRotation(fRot);
}

References G4VDivisionParameterisation::fRot, G4AutoDelete::Register(), CLHEP::HepRotation::rotateZ(), and G4VPhysicalVolume::SetRotation().

◆ CheckNDivAndWidth()

void G4VDivisionParameterisation::CheckNDivAndWidth ( G4double maxPar )

protectedinherited

Definition at line 151 of file G4VDivisionParameterisation.cc.

{
  if( (fDivisionType == DivNDIVandWIDTH)
      && (foffset + fwidth*fnDiv - maxPar > kCarTolerance ) )
  {
    std::ostringstream message;
    message << "Configuration not supported." << G4endl
            << "Division of solid " << fmotherSolid->GetName()
           << " has too big offset + width*nDiv = " << G4endl
           << "        " << foffset + fwidth*fnDiv << " > "
           << foffset << ". Width = "
           << G4endl
           << "        " << fwidth << ". nDiv = " << fnDiv << " !";
    G4Exception("G4VDivisionParameterisation::CheckNDivAndWidth()",
                "GeomDiv0001", FatalException, message);
  }
}

References DivNDIVandWIDTH, FatalException, G4VDivisionParameterisation::fDivisionType, G4VDivisionParameterisation::fmotherSolid, G4VDivisionParameterisation::fnDiv, G4VDivisionParameterisation::foffset, G4VDivisionParameterisation::fwidth, G4endl, G4Exception(), G4VSolid::GetName(), and G4VDivisionParameterisation::kCarTolerance.

Referenced by G4VDivisionParameterisation::CheckParametersValidity().

◆ CheckOffset()

void G4VDivisionParameterisation::CheckOffset ( G4double maxPar )

protectedinherited

Definition at line 136 of file G4VDivisionParameterisation.cc.

{
  if( foffset >= maxPar )
  {
    std::ostringstream message;
    message << "Configuration not supported." << G4endl
            << "Division of solid " << fmotherSolid->GetName()
            << " has too big offset = " << G4endl
            << "        " << foffset << " > " << maxPar << " !";
    G4Exception("G4VDivisionParameterisation::CheckOffset()",
                "GeomDiv0001", FatalException, message);
  }
}

References FatalException, G4VDivisionParameterisation::fmotherSolid, G4VDivisionParameterisation::foffset, G4endl, G4Exception(), and G4VSolid::GetName().

Referenced by G4VDivisionParameterisation::CheckParametersValidity().

◆ CheckParametersValidity()

void G4ParameterisationPolyconeZ::CheckParametersValidity ( )

virtual

Reimplemented from G4VDivisionParameterisation.

Definition at line 436 of file G4ParameterisationPolycone.cc.

{
  G4VDivisionParameterisation::CheckParametersValidity();
  
  // Division will be following the mother polycone segments
  //
  if( fDivisionType == DivNDIV )
  {
    if( fnDiv > fOrigParamMother->Num_z_planes-1 )
    { 
      std::ostringstream error;
      error  << "Configuration not supported." << G4endl
             << "Division along Z will be done by splitting in the defined"
             << G4endl
             << "Z planes, i.e, the number of division would be: "
             << fOrigParamMother->Num_z_planes-1
             << ", instead of: " << fnDiv << " !"; 
      G4Exception("G4ParameterisationPolyconeZ::CheckParametersValidity()",
                  "GeomDiv0001", FatalException, error);
    }
  }  
     
  // Division will be done within one polycone segment
  // with applying given width and offset
  //
  if( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
  {
    // Check if divided region does not span over more
    // than one z segment
  
    G4int isegstart = -1;  // number of the segment containing start position
    G4int isegend = -1;    // number of the segment containing end position
 
    if ( !fReflectedSolid )
    {
      // The start/end position of the divided region
      //
      G4double zstart 
        = fOrigParamMother->Z_values[0] + foffset;
      G4double zend 
        = fOrigParamMother->Z_values[0] + foffset + fnDiv* fwidth;
   
      G4int counter = 0;
      while ( isegend < 0 && counter < fOrigParamMother->Num_z_planes-1 )
      {
        // first segment
        if ( zstart >= fOrigParamMother->Z_values[counter]  &&
             zstart  < fOrigParamMother->Z_values[counter+1] )
        {
           isegstart = counter;
        }     
        // last segment
        if ( zend  > fOrigParamMother->Z_values[counter] &&
             zend <= fOrigParamMother->Z_values[counter+1] )
        {
          isegend = counter;
        }   
        ++counter;   
      }  // Loop checking, 06.08.2015, G.Cosmo
    }
    else
    {
      // The start/end position of the divided region
      //
      G4double zstart 
        = fOrigParamMother->Z_values[0] - foffset;
      G4double zend 
        = fOrigParamMother->Z_values[0] - ( foffset + fnDiv* fwidth);
   
      G4int counter = 0;
      while ( isegend < 0 && counter < fOrigParamMother->Num_z_planes-1 )
      {
        // first segment
        if ( zstart <= fOrigParamMother->Z_values[counter]  &&
             zstart  > fOrigParamMother->Z_values[counter+1] )
        {
           isegstart = counter;
        }     
        // last segment
        if ( zend  < fOrigParamMother->Z_values[counter] &&
             zend >= fOrigParamMother->Z_values[counter+1] )
        {
           isegend = counter;
        }   
        ++counter;   
      }  // Loop checking, 06.08.2015, G.Cosmo
    }
      
  
    if ( isegstart != isegend )
    {
      std::ostringstream message;
      message << "Condiguration not supported." << G4endl
              << "Division with user defined width." << G4endl
              << "Solid " << fmotherSolid->GetName() << G4endl
              << "Divided region is not between two z planes.";
      G4Exception("G4ParameterisationPolyconeZ::CheckParametersValidity()",
                  "GeomDiv0001", FatalException, message);
    }
  
    fNSegment = isegstart;
  }  
}

References G4VDivisionParameterisation::CheckParametersValidity(), DivNDIV, DivNDIVandWIDTH, DivWIDTH, error, FatalException, G4VDivisionParameterisation::fDivisionType, G4VDivisionParameterisation::fmotherSolid, G4VDivisionParameterisation::fnDiv, fNSegment, G4VDivisionParameterisation::foffset, fOrigParamMother, G4VDivisionParameterisation::fReflectedSolid, G4VDivisionParameterisation::fwidth, G4endl, G4Exception(), G4VSolid::GetName(), G4PolyconeHistorical::Num_z_planes, and G4PolyconeHistorical::Z_values.

Referenced by G4ParameterisationPolyconeZ().

◆ ComputeDimensions() [1/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Box &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 205 of file G4ParameterisationPolycone.hh.

206 {}

◆ ComputeDimensions() [2/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Cons &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 221 of file G4ParameterisationPolycone.hh.

222 {}

◆ ComputeDimensions() [3/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Ellipsoid &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 211 of file G4ParameterisationPolycone.hh.

212 {}

◆ ComputeDimensions() [4/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Hype &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 217 of file G4ParameterisationPolycone.hh.

218 {}

◆ ComputeDimensions() [5/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Orb &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 207 of file G4ParameterisationPolycone.hh.

208 {}

◆ ComputeDimensions() [6/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Para &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 215 of file G4ParameterisationPolycone.hh.

216 {}

◆ ComputeDimensions() [7/13]

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

virtual

Reimplemented from G4VPVParameterisation.

Definition at line 595 of file G4ParameterisationPolycone.cc.

{
 
  // Define division solid
  //
  G4PolyconeHistorical origparam;
  G4int nz = 2; 
  origparam.Num_z_planes = nz;
  origparam.Start_angle = fOrigParamMother->Start_angle;
  origparam.Opening_angle = fOrigParamMother->Opening_angle;
 
  // Define division solid z sections
  //
  origparam.Z_values = new G4double[nz];
  origparam.Rmin = new G4double[nz];
  origparam.Rmax = new G4double[nz];
 
  if ( fDivisionType == DivNDIV )
  {
    // The position of the centre of copyNo-th mother polycone segment
    G4double posi = (fOrigParamMother->Z_values[copyNo]
                   + fOrigParamMother->Z_values[copyNo+1])/2;
 
    origparam.Z_values[0] = fOrigParamMother->Z_values[copyNo] - posi;
    origparam.Z_values[1] = fOrigParamMother->Z_values[copyNo+1] - posi;
    origparam.Rmin[0] = fOrigParamMother->Rmin[copyNo];
    origparam.Rmin[1] = fOrigParamMother->Rmin[copyNo+1];
    origparam.Rmax[0] = fOrigParamMother->Rmax[copyNo];
    origparam.Rmax[1] = fOrigParamMother->Rmax[copyNo+1];
  }
  
  if ( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
  {
    if ( !fReflectedSolid )
    {
      origparam.Z_values[0] = - fwidth/2.;
      origparam.Z_values[1] = fwidth/2.;
 
      // The position of the centre of copyNo-th division
      //
      G4double posi = fOrigParamMother->Z_values[0]
                    + foffset + (2*copyNo + 1) * fwidth/2.;
    
      // The first and last z sides z values
      //
      G4double zstart = posi - fwidth/2.;
      G4double zend = posi + fwidth/2.;
      origparam.Rmin[0] = GetRmin(zstart, fNSegment); 
      origparam.Rmax[0] = GetRmax(zstart, fNSegment);  
      origparam.Rmin[1] = GetRmin(zend, fNSegment); 
      origparam.Rmax[1] = GetRmax(zend, fNSegment);  
    }
    else
    {
      origparam.Z_values[0] = fwidth/2.;
      origparam.Z_values[1] = - fwidth/2.;
 
      // The position of the centre of copyNo-th division
      //
      G4double posi = fOrigParamMother->Z_values[0]
                    - ( foffset + (2*copyNo + 1) * fwidth/2.);
    
      // The first and last z sides z values
      //
      G4double zstart = posi + fwidth/2.;
      G4double zend = posi - fwidth/2.;
      origparam.Rmin[0] = GetRmin(zstart, fNSegment); 
      origparam.Rmax[0] = GetRmax(zstart, fNSegment);  
      origparam.Rmin[1] = GetRmin(zend, fNSegment); 
      origparam.Rmax[1] = GetRmax(zend, fNSegment);  
    }
 
    // It can happen due to rounding errors
    //
    if ( origparam.Rmin[0]    < 0.0 ) origparam.Rmin[0] = 0.0;
    if ( origparam.Rmin[nz-1] < 0.0 ) origparam.Rmin[1] = 0.0;
  }  
 
  pcone.SetOriginalParameters(&origparam);  // copy values & transfer pointers
  pcone.Reset();                            // reset to new solid parameters
 
#ifdef G4DIVDEBUG
  if( verbose >= 2 )
  {
    G4cout << "G4ParameterisationPolyconeZ::ComputeDimensions()" << G4endl
           << "-- Parametrised pcone copy-number: " << copyNo << G4endl;
    pcone.DumpInfo();
  }
#endif
}

References DivNDIV, DivNDIVandWIDTH, DivWIDTH, G4VSolid::DumpInfo(), G4VDivisionParameterisation::fDivisionType, fNSegment, G4VDivisionParameterisation::foffset, fOrigParamMother, G4VDivisionParameterisation::fReflectedSolid, G4VDivisionParameterisation::fwidth, G4cout, G4endl, GetRmax(), GetRmin(), G4PolyconeHistorical::Num_z_planes, G4PolyconeHistorical::Opening_angle, G4Polycone::Reset(), G4PolyconeHistorical::Rmax, G4PolyconeHistorical::Rmin, G4Polycone::SetOriginalParameters(), G4PolyconeHistorical::Start_angle, G4VDivisionParameterisation::verbose, and G4PolyconeHistorical::Z_values.

◆ ComputeDimensions() [8/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Polyhedra &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 223 of file G4ParameterisationPolycone.hh.

224 {}

◆ ComputeDimensions() [9/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Sphere &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 209 of file G4ParameterisationPolycone.hh.

210 {}

◆ ComputeDimensions() [10/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Torus &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 213 of file G4ParameterisationPolycone.hh.

214 {}

◆ ComputeDimensions() [11/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Trap &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 203 of file G4ParameterisationPolycone.hh.

204 {}

◆ ComputeDimensions() [12/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Trd &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 201 of file G4ParameterisationPolycone.hh.

202 {}

◆ ComputeDimensions() [13/13]

void G4ParameterisationPolyconeZ::ComputeDimensions	(	G4Tubs &	,
		const	G4int,
		const G4VPhysicalVolume *
	)		const

inlineprivatevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 219 of file G4ParameterisationPolycone.hh.

220 {}

◆ ComputeMaterial()

G4Material * G4VPVParameterisation::ComputeMaterial	(	const G4int	repNo,
		G4VPhysicalVolume *	currentVol,
		const G4VTouchable *	parentTouch = `nullptr`
	)

virtualinherited

Reimplemented in G4VNestedParameterisation, G4PartialPhantomParameterisation, and G4PhantomParameterisation.

Definition at line 47 of file G4VPVParameterisation.cc.

{
  return pPhysicalVol->GetLogicalVolume()->GetMaterial();
}

References G4VPhysicalVolume::GetLogicalVolume(), and G4LogicalVolume::GetMaterial().

Referenced by G4tgbGeometryDumper::DumpPVParameterised(), G4LogicalVolume::GetMass(), G4ParameterisedNavigation::LevelLocate(), and G4Region::ScanVolumeTree().

◆ ComputeSolid()

G4VSolid * G4VDivisionParameterisation::ComputeSolid	(	const G4int	i,
		G4VPhysicalVolume *	pv
	)

virtualinherited

Reimplemented from G4VPVParameterisation.

Definition at line 72 of file G4VDivisionParameterisation.cc.

{
  G4VSolid* solid = G4VPVParameterisation::ComputeSolid(i, pv);
  if (solid->GetEntityType() == "G4ReflectedSolid")
  {
    solid = ((G4ReflectedSolid*)solid)->GetConstituentMovedSolid();
  }
  return solid;
}      

References G4VPVParameterisation::ComputeSolid(), and G4VSolid::GetEntityType().

◆ ComputeTransformation()

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

virtual

Implements G4VDivisionParameterisation.

Definition at line 542 of file G4ParameterisationPolycone.cc.

{
  G4double posi = 0.;
  if ( fDivisionType == DivNDIV )
  {
    // The position of the centre of copyNo-th mother polycone segment
    //
    posi = ( fOrigParamMother->Z_values[copyNo]
                    + fOrigParamMother->Z_values[copyNo+1])/2;
    physVol->SetTranslation( G4ThreeVector(0, 0, posi) );
  }
  
  if ( fDivisionType == DivNDIVandWIDTH || fDivisionType == DivWIDTH )
  {
    // The position of the centre of copyNo-th division
    //
    posi = fOrigParamMother->Z_values[0];
      
    if ( !fReflectedSolid )  
      posi += foffset + (2*copyNo + 1) * fwidth/2.;
    else
      posi -= foffset + (2*copyNo + 1) * fwidth/2.;
    
    physVol->SetTranslation( G4ThreeVector(0, 0, posi) );
  }   
 
  //----- calculate rotation matrix: unit
 
#ifdef G4DIVDEBUG
  if( verbose >= 2 )
  {
    G4cout << " G4ParameterisationPolyconeZ - position: " << posi << G4endl
           << " copyNo: " << copyNo << " - foffset: " << foffset/CLHEP::deg
           << " - fwidth: " << fwidth/CLHEP::deg << G4endl;
  }
#endif
 
  ChangeRotMatrix( physVol );
 
#ifdef G4DIVDEBUG
  if( verbose >= 2 )
  {
    G4cout << std::setprecision(8) << " G4ParameterisationPolyconeZ "
           << copyNo << G4endl
           << " Position: (0,0,0) - Width: " << fwidth
           << " - Axis: " << faxis  << G4endl;
  }
#endif
}

References G4VDivisionParameterisation::ChangeRotMatrix(), CLHEP::deg, DivNDIV, DivNDIVandWIDTH, DivWIDTH, G4VDivisionParameterisation::faxis, G4VDivisionParameterisation::fDivisionType, G4VDivisionParameterisation::foffset, fOrigParamMother, G4VDivisionParameterisation::fReflectedSolid, G4VDivisionParameterisation::fwidth, G4cout, G4endl, G4VPhysicalVolume::SetTranslation(), G4VDivisionParameterisation::verbose, and G4PolyconeHistorical::Z_values.

◆ GetAxis()

EAxis G4VDivisionParameterisation::GetAxis ( ) const

inlineinherited

Referenced by G4PVDivisionFactory::CreatePVDivision().

◆ GetHalfGap()

G4double G4VDivisionParameterisation::GetHalfGap ( ) const

inlineinherited

◆ GetMaterialScanner()

G4VVolumeMaterialScanner * G4VPVParameterisation::GetMaterialScanner ( )

virtualinherited

Reimplemented in G4VNestedParameterisation.

Definition at line 62 of file G4VPVParameterisation.cc.

{
  return nullptr;
}

Referenced by G4Region::ScanVolumeTree().

◆ GetMaxParameter()

G4double G4ParameterisationPolyconeZ::GetMaxParameter ( ) const

virtual

Implements G4VDivisionParameterisation.

Definition at line 429 of file G4ParameterisationPolycone.cc.

{
  return std::abs (fOrigParamMother->Z_values[fOrigParamMother->Num_z_planes-1]
                  -fOrigParamMother->Z_values[0]);
}

References fOrigParamMother, G4PolyconeHistorical::Num_z_planes, and G4PolyconeHistorical::Z_values.

◆ GetMotherSolid()

G4VSolid * G4VDivisionParameterisation::GetMotherSolid ( ) const

inlineinherited

Referenced by G4ParameterisationConsZ::ComputeTransformation().

◆ GetNoDiv()

G4int G4VDivisionParameterisation::GetNoDiv ( ) const

inlineinherited

Referenced by G4ReplicatedSlice::CheckAndSetParameters(), G4PVDivision::CheckAndSetParameters(), and G4PVDivisionFactory::CreatePVDivision().

◆ GetOffset()

G4double G4VDivisionParameterisation::GetOffset ( ) const

inlineinherited

Referenced by G4PVDivisionFactory::CreatePVDivision().

◆ GetR()

G4double G4ParameterisationPolyconeZ::GetR	(	G4double	z,
		G4double	z1,
		G4double	r1,
		G4double	z2,
		G4double	r2
	)		const

private

Definition at line 392 of file G4ParameterisationPolycone.cc.

{
  // Linear parameterisation: 
  // r = az + b
  // a = (r1 - r2)/(z1-z2)
  // b = r1 - a*z1
 
  return (r1-r2)/(z1-z2)*z + ( r1 - (r1-r2)/(z1-z2)*z1 ) ;
}  

Referenced by GetRmax(), and GetRmin().

◆ GetRmax()

G4double G4ParameterisationPolyconeZ::GetRmax	(	G4double	z,
		G4int	nsegment
	)		const

private

Definition at line 417 of file G4ParameterisationPolycone.cc.

{
// Get Rmax in the given z position for the given polycone segment 
 
  return GetR(z, 
              fOrigParamMother->Z_values[nseg], 
              fOrigParamMother->Rmax[nseg],
              fOrigParamMother->Z_values[nseg+1], 
              fOrigParamMother->Rmax[nseg+1]);
}  

References fOrigParamMother, GetR(), G4PolyconeHistorical::Rmax, and G4PolyconeHistorical::Z_values.

Referenced by ComputeDimensions().

◆ GetRmin()

G4double G4ParameterisationPolyconeZ::GetRmin	(	G4double	z,
		G4int	nsegment
	)		const

private

Definition at line 405 of file G4ParameterisationPolycone.cc.

{
// Get Rmin in the given z position for the given polycone segment 
 
  return GetR(z, 
              fOrigParamMother->Z_values[nseg], 
              fOrigParamMother->Rmin[nseg],
              fOrigParamMother->Z_values[nseg+1], 
              fOrigParamMother->Rmin[nseg+1]);
}  

References fOrigParamMother, GetR(), G4PolyconeHistorical::Rmin, and G4PolyconeHistorical::Z_values.

Referenced by ComputeDimensions().

◆ GetType()

const G4String & G4VDivisionParameterisation::GetType ( ) const

inlineinherited

◆ GetWidth()

G4double G4VDivisionParameterisation::GetWidth ( ) const

inlineinherited

Referenced by G4ReplicatedSlice::CheckAndSetParameters(), G4PVDivision::CheckAndSetParameters(), and G4PVDivisionFactory::CreatePVDivision().

◆ IsNested()

G4bool G4VPVParameterisation::IsNested ( ) const

virtualinherited

Reimplemented in G4VNestedParameterisation.

Definition at line 55 of file G4VPVParameterisation.cc.

{
  return false;
}

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4Navigator::SetupHierarchy(), and G4ITNavigator2::SetupHierarchy().

◆ OffsetZ()

G4double G4VDivisionParameterisation::OffsetZ ( ) const

protectedinherited

Definition at line 170 of file G4VDivisionParameterisation.cc.

{
  // take into account reflection in the offset
 
  G4double offset = foffset;
  if (fReflectedSolid)
  {
    offset = GetMaxParameter() - fwidth*fnDiv - foffset;
  }
 
  return offset;
}  