G4ReplicatedSlice Class Reference

#include <G4ReplicatedSlice.hh>

Inheritance diagram for G4ReplicatedSlice:

Public Member Functions
virtual G4bool	CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int errMax=1)
EVolume	DeduceVolumeType () const
	G4ReplicatedSlice (const G4ReplicatedSlice &)=delete
	G4ReplicatedSlice (const G4String &pName, G4LogicalVolume *pLogical, G4LogicalVolume *pMotherLogical, const EAxis pAxis, const G4double width, const G4double half_gap, const G4double offset)
	G4ReplicatedSlice (const G4String &pName, G4LogicalVolume *pLogical, G4LogicalVolume *pMotherLogical, const EAxis pAxis, const G4int nReplicas, const G4double half_gap, const G4double offset)
	G4ReplicatedSlice (const G4String &pName, G4LogicalVolume *pLogical, G4LogicalVolume *pMotherLogical, const EAxis pAxis, const G4int nReplicas, const G4double width, const G4double half_gap, const G4double offset)
	G4ReplicatedSlice (const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMotherPhysical, const EAxis pAxis, const G4double width, const G4double half_gap, const G4double offset)
	G4ReplicatedSlice (const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMotherPhysical, const EAxis pAxis, const G4int nReplicas, const G4double half_gap, const G4double offset)
	G4ReplicatedSlice (const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMotherPhysical, const EAxis pAxis, const G4int nReplicas, const G4double width, const G4double half_gap, const G4double offset)
virtual G4int	GetCopyNo () const
EAxis	GetDivisionAxis () const
const G4RotationMatrix *	GetFrameRotation () const
G4ThreeVector	GetFrameTranslation () const
G4int	GetInstanceID () const
G4LogicalVolume *	GetLogicalVolume () const
G4LogicalVolume *	GetMotherLogical () const
virtual G4int	GetMultiplicity () const
const G4String &	GetName () const
G4RotationMatrix *	GetObjectRotation () const
G4RotationMatrix	GetObjectRotationValue () const
G4ThreeVector	GetObjectTranslation () const
virtual G4VPVParameterisation *	GetParameterisation () const
G4int	GetRegularStructureId () const
virtual void	GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const
G4RotationMatrix *	GetRotation ()
const G4RotationMatrix *	GetRotation () const
const G4ThreeVector	GetTranslation () const
void	InitialiseWorker (G4PVReplica *pMasterObject)
virtual G4bool	IsMany () const
G4bool	IsParameterised () const
G4bool	IsRegularStructure () const
virtual G4bool	IsReplicated () const
G4ReplicatedSlice &	operator= (const G4ReplicatedSlice &)=delete
G4bool	operator== (const G4VPhysicalVolume &p) const
virtual void	SetCopyNo (G4int CopyNo)
void	SetLogicalVolume (G4LogicalVolume *pLogical)
void	SetMotherLogical (G4LogicalVolume *pMother)
void	SetName (const G4String &pName)
virtual void	SetRegularStructureId (G4int code)
void	SetRotation (G4RotationMatrix *)
void	SetTranslation (const G4ThreeVector &v)
void	TerminateWorker (G4PVReplica *pMasterObject)
EVolume	VolumeType () const final
virtual	~G4ReplicatedSlice ()

Static Public Member Functions
static void	Clean ()
static const G4PVRManager &	GetSubInstanceManager ()

Protected Member Functions
void	InitialiseWorker (G4VPhysicalVolume *pMasterObject, G4RotationMatrix *pRot, const G4ThreeVector &tlate)
void	TerminateWorker (G4VPhysicalVolume *pMasterObject)

Protected Attributes
EAxis	faxis
EAxis	fdivAxis
G4int	fnReplicas = 0
G4double	foffset = 0.0
G4VDivisionParameterisation *	fparam = nullptr
G4double	fwidth = 0.0

Private Member Functions
void	CheckAndSetParameters (const EAxis pAxis, const G4int nDivs, const G4double width, const G4double half_gap, const G4double offset, DivisionType divType, G4LogicalVolume *pMotherLogical, const G4LogicalVolume *pLogical)
void	CheckOnlyDaughter (G4LogicalVolume *pMotherLogical)
void	ErrorInAxis (EAxis axis, G4VSolid *solid)
void	SetParameterisation (G4LogicalVolume *motherLogical, const EAxis pAxis, const G4int nReplicas, const G4double width, const G4double half_gap, const G4double offset, DivisionType divType)

Private Attributes
G4LogicalVolume *	flmother = nullptr
G4LogicalVolume *	flogical = nullptr
G4String	fname
G4int	fRegularVolsId = 0
G4int	instanceID
G4PVData *	pvdata = nullptr

Static Private Attributes
static G4GEOM_DLL G4PVRManager	subInstanceManager

Detailed Description

Definition at line 66 of file G4ReplicatedSlice.hh.

Constructor & Destructor Documentation

G4ReplicatedSlice() [1/7]

G4ReplicatedSlice::G4ReplicatedSlice	(	const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4LogicalVolume *	pMotherLogical,
		const EAxis	pAxis,
		const G4int	nReplicas,
		const G4double	width,
		const G4double	half_gap,
		const G4double	offset
	)

Definition at line 44 of file G4ReplicatedSlice.cc.

  : G4PVReplica(pName, nDivs, pAxis, pLogical, pMotherLogical)
{
  CheckAndSetParameters(pAxis, nDivs, width, half_gap, offset,
                        DivNDIVandWIDTH, pMotherLogical, pLogical);
}

References CheckAndSetParameters(), and DivNDIVandWIDTH.

G4ReplicatedSlice() [2/7]

G4ReplicatedSlice::G4ReplicatedSlice	(	const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4LogicalVolume *	pMotherLogical,
		const EAxis	pAxis,
		const G4int	nReplicas,
		const G4double	half_gap,
		const G4double	offset
	)

Definition at line 59 of file G4ReplicatedSlice.cc.

  : G4PVReplica(pName, nDivs, pAxis, pLogical, pMotherLogical)
{
  CheckAndSetParameters(pAxis, nDivs, 0., half_gap, offset,
                        DivNDIV, pMotherLogical, pLogical);
}

References CheckAndSetParameters(), and DivNDIV.

G4ReplicatedSlice() [3/7]

G4ReplicatedSlice::G4ReplicatedSlice	(	const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4LogicalVolume *	pMotherLogical,
		const EAxis	pAxis,
		const G4double	width,
		const G4double	half_gap,
		const G4double	offset
	)

Definition at line 73 of file G4ReplicatedSlice.cc.

  : G4PVReplica(pName, 0, pAxis, pLogical, pMotherLogical)
{
  CheckAndSetParameters(pAxis, 0, width, half_gap, offset,
                        DivWIDTH, pMotherLogical, pLogical);
}

References CheckAndSetParameters(), and DivWIDTH.

G4ReplicatedSlice() [4/7]

G4ReplicatedSlice::G4ReplicatedSlice	(	const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4VPhysicalVolume *	pMotherPhysical,
		const EAxis	pAxis,
		const G4int	nReplicas,
		const G4double	width,
		const G4double	half_gap,
		const G4double	offset
	)

Definition at line 87 of file G4ReplicatedSlice.cc.

  : G4PVReplica(pName, nDivs, pAxis, pLogical,
                pMotherPhysical ? pMotherPhysical->GetLogicalVolume() : nullptr)
{
  if (pMotherPhysical == nullptr)
  {
    std::ostringstream message;
    message << "Invalid setup." << G4endl
            << "NULL pointer specified as mother for volume: " << pName;
    G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "GeomDiv0002",
                FatalException, message);
    return;
  }
  CheckAndSetParameters(pAxis, nDivs, width, half_gap, offset,
      DivNDIVandWIDTH, pMotherPhysical->GetLogicalVolume(), pLogical);
}

References CheckAndSetParameters(), DivNDIVandWIDTH, FatalException, G4endl, G4Exception(), and G4VPhysicalVolume::GetLogicalVolume().

G4ReplicatedSlice() [5/7]

G4ReplicatedSlice::G4ReplicatedSlice	(	const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4VPhysicalVolume *	pMotherPhysical,
		const EAxis	pAxis,
		const G4int	nReplicas,
		const G4double	half_gap,
		const G4double	offset
	)

Definition at line 112 of file G4ReplicatedSlice.cc.

  : G4PVReplica(pName, nDivs, pAxis, pLogical,
                pMotherPhysical ? pMotherPhysical->GetLogicalVolume() : nullptr)
{
  if (pMotherPhysical == nullptr)
  {
    std::ostringstream message;
    message << "Invalid setup." << G4endl
            << "NULL pointer specified as mother for volume: " << pName;
    G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "GeomDiv0002",
                FatalException, message);
    return;
  }
  CheckAndSetParameters(pAxis, nDivs, 0., half_gap, offset,
      DivNDIV, pMotherPhysical->GetLogicalVolume(), pLogical);
}

References CheckAndSetParameters(), DivNDIV, FatalException, G4endl, G4Exception(), and G4VPhysicalVolume::GetLogicalVolume().

G4ReplicatedSlice() [6/7]

G4ReplicatedSlice::G4ReplicatedSlice	(	const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4VPhysicalVolume *	pMotherPhysical,
		const EAxis	pAxis,
		const G4double	width,
		const G4double	half_gap,
		const G4double	offset
	)

Definition at line 136 of file G4ReplicatedSlice.cc.

  : G4PVReplica(pName, 0, pAxis, pLogical,
                pMotherPhysical ? pMotherPhysical->GetLogicalVolume() : nullptr)
{
  if (pMotherPhysical == nullptr)
  {
    std::ostringstream message;
    message << "Invalid setup." << G4endl
            << "NULL pointer specified as mother for volume: " << pName;
    G4Exception("G4ReplicatedSlice::G4ReplicatedSlice()", "GeomDiv0002",
                FatalException, message);
    return;
  }
  CheckAndSetParameters(pAxis, 0, width, half_gap, offset,
      DivWIDTH, pMotherPhysical->GetLogicalVolume(), pLogical);
}

References CheckAndSetParameters(), DivWIDTH, FatalException, G4endl, G4Exception(), and G4VPhysicalVolume::GetLogicalVolume().

~G4ReplicatedSlice()

G4ReplicatedSlice::~G4ReplicatedSlice ( )

virtual

Definition at line 279 of file G4ReplicatedSlice.cc.

{
  delete GetRotation();
}

References G4VPhysicalVolume::GetRotation().

G4ReplicatedSlice() [7/7]

G4ReplicatedSlice::G4ReplicatedSlice ( const G4ReplicatedSlice &  )

delete

Member Function Documentation

CheckAndSetParameters()

void G4ReplicatedSlice::CheckAndSetParameters ( const EAxis  pAxis, const G4int  nDivs, const G4double  width, const G4double  half_gap, const G4double  offset, DivisionType  divType, G4LogicalVolume *  pMotherLogical, const G4LogicalVolume *  pLogical  )

private

!!!! axis has to be x/y/z in G4VoxelLimits::GetMinExtent

Definition at line 161 of file G4ReplicatedSlice.cc.

{
  if(pMotherLogical == nullptr)
  {
    std::ostringstream message;
    message << "Invalid setup." << G4endl
            << "NULL pointer specified as mother! Volume: " << GetName();
    G4Exception("G4ReplicatedSlice::CheckAndSetParameters()", "GeomDiv0002",
                FatalException, message);
  }
  if(pLogical == pMotherLogical)
  {
    std::ostringstream message;
    message << "Invalid setup." << G4endl
            << "Cannot place a volume inside itself! Volume: " << GetName();
    G4Exception("G4ReplicatedSlice::CheckAndSetParameters()", "GeomDiv0002",
                FatalException, message);
  }
 
  //----- Check that mother solid is of the same type as
  //      daughter solid (otherwise, the corresponding
  //      Parameterisation::ComputeDimension() will not be called)
  //
  G4String msolType = pMotherLogical->GetSolid()->GetEntityType();
  G4String dsolType = pLogical->GetSolid()->GetEntityType();
  if( msolType != dsolType && ( msolType != "G4Trd" || dsolType != "G4Trap" ) )
  {
    std::ostringstream message;
    message << "Invalid setup." << G4endl
            << "Incorrect solid type for division of volume: "
            << GetName() << G4endl
            << "    It is: " << msolType
            << ", while it should be: " << dsolType;
    G4Exception("G4ReplicatedSlice::CheckAndSetParameters()",
                "GeomDiv0002", FatalException, message);
  }
 
  pMotherLogical->AddDaughter(this);
  SetMotherLogical(pMotherLogical);
  SetParameterisation(pMotherLogical, pAxis, nDivs,
                      width, half_gap, offset, divType);
 
  if( divType == DivWIDTH )
  {
    fnReplicas = fparam->GetNoDiv();
  }
  else
  {
    fnReplicas = nDivs;
  }
  if (fnReplicas < 1 )
  {
    G4Exception("G4ReplicatedSlice::CheckAndSetParameters()", "GeomDiv0002",
                FatalException, "Illegal number of replicas!");
  }
  if( divType != DivNDIV)
  {
    fwidth = fparam->GetWidth();
  }
  else
  {
    fwidth = width;
  }
  if( fwidth < 0 )
  {
    G4Exception("G4ReplicatedSlice::CheckAndSetParameters()", "GeomDiv0002",
                FatalException, "Width must be positive!");
  }
  if( fwidth < 2.*half_gap )
  {
    G4Exception("G4ReplicatedSlice::CheckAndSetParameters()", "GeomDiv0002",
                FatalException, "Half_gap is too large!");
  }
  
  foffset = offset;
  fdivAxis = pAxis;
 
  //
  if( pAxis == kRho || pAxis == kRadial3D || pAxis == kPhi )
  {
    faxis = kZAxis;
  }
  else
  {
    faxis = pAxis;
  }
  
  switch (faxis)
  {
    case kPhi:
    case kRho:
    case kXAxis:
    case kYAxis:
    case kZAxis:
      break;
    default:
      G4Exception("G4ReplicatedSlice::CheckAndSetParameters()", "GeomDiv0002",
                  FatalException, "Unknown axis of replication.");
      break;
  }
 
  // Create rotation matrix: for phi axis it will be changed
  // in G4VPVParameterisation::ComputeTransformation, for others
  // it will stay the unity
  //
  G4RotationMatrix* pRMat = new G4RotationMatrix();
  SetRotation(pRMat);
}

References G4LogicalVolume::AddDaughter(), DivNDIV, DivWIDTH, FatalException, faxis, fdivAxis, fnReplicas, foffset, fparam, fwidth, G4endl, G4Exception(), G4VSolid::GetEntityType(), G4VPhysicalVolume::GetName(), G4VDivisionParameterisation::GetNoDiv(), G4LogicalVolume::GetSolid(), G4VDivisionParameterisation::GetWidth(), kPhi, kRadial3D, kRho, kXAxis, kYAxis, kZAxis, G4VPhysicalVolume::SetMotherLogical(), SetParameterisation(), and G4VPhysicalVolume::SetRotation().

Referenced by G4ReplicatedSlice().

CheckOnlyDaughter()

void G4PVReplica::CheckOnlyDaughter ( G4LogicalVolume *  pMotherLogical )

privateinherited

Definition at line 182 of file G4PVReplica.cc.

{
  if (pMotherLogical->GetNoDaughters() != 0)
  {
    std::ostringstream message;
    message << "Replica or parameterised volume must be the only daughter !"
            << G4endl
            << "     Mother logical volume: " << pMotherLogical->GetName()
            << G4endl
            << "     Replicated volume: " << this->GetName() << G4endl
            << "     Existing 'sister': " << pMotherLogical->GetDaughter(0)
                                              ->GetName(); 
    G4Exception("G4PVReplica::G4PVReplica()", "GeomVol0002",
                FatalException, message);
    return;
  }
}

References FatalException, G4endl, G4Exception(), G4LogicalVolume::GetDaughter(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), and G4LogicalVolume::GetNoDaughters().

Referenced by G4PVReplica::G4PVReplica().

CheckOverlaps()

G4bool G4VPhysicalVolume::CheckOverlaps ( G4int  res = 1000, G4double  tol = 0., G4bool  verbose = true, G4int  errMax = 1  )

virtualinherited

Reimplemented in G4PVParameterised, G4PVPlacement, and G4VExternalPhysicalVolume.

Definition at line 221 of file G4VPhysicalVolume.cc.

{
  return false;
}

Referenced by G4Navigator::CheckOverlapsIterative(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4LogicalVolumeModel::DescribeYourselfTo(), G4GeomTestVolume::TestOverlapInTree(), and G4GeomTestVolume::TestRecursiveOverlap().

Clean()

void G4VPhysicalVolume::Clean ( )

staticinherited

Definition at line 125 of file G4VPhysicalVolume.cc.

{
  subInstanceManager.FreeSlave();
}

References G4GeomSplitter< T >::FreeSlave(), and G4VPhysicalVolume::subInstanceManager.

Referenced by G4PhysicalVolumeStore::~G4PhysicalVolumeStore().

DeduceVolumeType()

EVolume G4VPhysicalVolume::DeduceVolumeType ( ) const

inlineinherited

ErrorInAxis()

void G4ReplicatedSlice::ErrorInAxis ( EAxis  axis, G4VSolid *  solid  )

private

Definition at line 528 of file G4ReplicatedSlice.cc.

{
  G4String error = "Trying to divide solid " + solid->GetName()
                 + " of type " + solid->GetEntityType() + " along axis ";
  switch( axis )
  {
    case kXAxis:
      error += "X.";
      break;
    case kYAxis:
      error += "Y.";
      break;
    case kZAxis:
      error += "Z.";
      break;
    case kRho:
      error += "Rho.";
      break;
    case kRadial3D:
      error += "Radial3D.";
      break;
    case kPhi:
      error += "Phi.";
      break;
    default:
      break;
  }
  G4Exception("G4ReplicatedSlice::ErrorInAxis()", "GeomDiv0002",
              FatalException, error);
}

References error, FatalException, G4Exception(), G4VSolid::GetEntityType(), G4VSolid::GetName(), kPhi, kRadial3D, kRho, kXAxis, kYAxis, and kZAxis.

Referenced by SetParameterisation().

GetCopyNo()

G4int G4PVReplica::GetCopyNo ( ) const

virtualinherited

Implements G4VPhysicalVolume.

Definition at line 267 of file G4PVReplica.cc.

{
  return G4MT_copyNo;
}

References G4MT_copyNo.

GetDivisionAxis()

EAxis G4ReplicatedSlice::GetDivisionAxis

(

)

const

Definition at line 285 of file G4ReplicatedSlice.cc.

{
  return fdivAxis;
}

References fdivAxis.

GetFrameRotation()

const G4RotationMatrix * G4VPhysicalVolume::GetFrameRotation ( ) const

inherited

Definition at line 208 of file G4VPhysicalVolume.cc.

{
  return G4MT_rot;
}

References G4MT_rot.

Referenced by G4AdjointCrossSurfChecker::AddaSphericalSurfaceWithCenterAtTheCenterOfAVolume(), G4AdjointPosOnPhysVolGenerator::ComputeTransformationFromPhysVolToWorld(), export_G4VPhysicalVolume(), G4LatticeManager::LoadLattice(), G4LatticeManager::RegisterLattice(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetFrameTranslation()

G4ThreeVector G4VPhysicalVolume::GetFrameTranslation ( ) const

inherited

Definition at line 213 of file G4VPhysicalVolume.cc.

{
  return -G4ThreeVector(G4MT_tx, G4MT_ty, G4MT_tz);
}

References G4MT_tx, G4MT_ty, and G4MT_tz.

GetInstanceID()

G4int G4PVReplica::GetInstanceID ( ) const

inlineinherited

Definition at line 149 of file G4PVReplica.hh.

{ return instanceID; }

References G4PVReplica::instanceID.

GetLogicalVolume()

G4LogicalVolume * G4VPhysicalVolume::GetLogicalVolume ( ) const

inlineinherited

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), G4VSceneHandler::AddCompound(), G4VtkSceneHandler::AddCompound(), G4LogicalVolume::AddDaughter(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4FastSimulationManagerProcess::AtRestGetPhysicalInteractionLength(), G4ReplicaNavigation::BackLocate(), G4Region::BelongsTo(), G4PhantomParameterisation::BuildContainerSolid(), G4SmartVoxelHeader::BuildNodes(), G4GeometryManager::BuildOptimisations(), G4Track::CalculateVelocityForOpticalPhoton(), G4PVDivision::CheckAndSetParameters(), G4PVPlacement::CheckOverlaps(), G4GeometryWorkspace::CloneReplicaSolid(), G4AdjointPrimaryGenerator::ComputeAccumulatedDepthVectorAlongBackRay(), G4VPVParameterisation::ComputeMaterial(), G4Navigator::ComputeSafety(), G4ITNavigator1::ComputeSafety(), G4ITNavigator2::ComputeSafety(), G4NormalNavigation::ComputeSafety(), G4VoxelNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4PolarizedAnnihilation::ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4VNestedParameterisation::ComputeSolid(), G4VPVParameterisation::ComputeSolid(), G4PhantomParameterisation::ComputeSolid(), G4ParameterisedNavigation::ComputeStep(), G4RegularNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4NormalNavigation::ComputeStep(), G4Navigator::ComputeStep(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4PropagatorInField::ComputeStep(), G4RegularNavigation::ComputeStepSkippingEqualMaterials(), G4tgbVolume::ConstructG4Volumes(), G4TheRayTracer::CreateBitMap(), G4AdjointCrossSurfChecker::CrossingAnInterfaceBetweenTwoVolumes(), G4Radioactivation::DecayIt(), G4RadioactiveDecay::DecayIt(), G4AdjointPosOnPhysVolGenerator::DefinePhysicalVolume(), G4RunManagerKernel::DefineWorldVolume(), G4GeometryManager::DeleteOptimisations(), G4LogicalVolumeModel::DescribeYourselfTo(), G4PhysicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4GeometryWorkspace::DestroyWorkspace(), G4GlobalFastSimulationManager::DisplayRegion(), G4GDMLWriteStructure::DivisionvolWrite(), G4VisManager::Draw(), G4TrajectoryDrawByOriginVolume::Draw(), G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVParameterised(), G4tgbGeometryDumper::DumpPVPlacement(), G4TrajectoryOriginVolumeFilter::Evaluate(), export_G4VPhysicalVolume(), G4PropagatorInField::FindAndSetFieldManager(), G4VReadOutGeometry::FindROTouchable(), G4FastTrack::FRecordsAffineTransformation(), G4Mesh::G4Mesh(), G4PVDivision::G4PVDivision(), G4PVParameterised::G4PVParameterised(), G4PVPlacement::G4PVPlacement(), G4PVReplica::G4PVReplica(), G4ReplicatedSlice(), G4VExternalPhysicalVolume::G4VExternalPhysicalVolume(), G4GDMLRead::GeneratePhysvolName(), G4RTPrimaryGeneratorAction::GeneratePrimaries(), G4Navigator::GetGlobalExitNormal(), G4Navigator::GetLocalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4VIntersectionLocator::GetLocalSurfaceNormal(), G4LogicalVolume::GetMass(), G4Channeling::GetMatData(), G4Channeling::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4ElNeutrinoNucleusProcess::GetMeanFreePath(), G4MuNeutrinoNucleusProcess::GetMeanFreePath(), G4VTransitionRadiation::GetMeanFreePath(), G4Navigator::GetMotherToDaughterTransform(), G4ITNavigator1::GetMotherToDaughterTransform(), G4ITNavigator2::GetMotherToDaughterTransform(), G4TransportationManager::GetParallelWorld(), G4ITTransportationManager::GetParallelWorld(), G4tgbGeometryDumper::GetTopPhysVol(), G4AdjointCrossSurfChecker::GoingInOrOutOfaVolumeByExtSurface(), G4GeometryWorkspace::InitialisePhysicalVolumes(), G4BOptnForceCommonTruncatedExp::Initialize(), G4IStore::IsInWorld(), G4WeightWindowStore::IsInWorld(), G4VEnergyLossProcess::IsRegionForCubcutProcessor(), G4ParameterisedNavigation::LevelLocate(), G4RegularNavigation::LevelLocate(), G4LatticeManager::LoadLattice(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointWithinVolume(), G4ITNavigator1::LocateGlobalPointWithinVolume(), G4ITNavigator2::LocateGlobalPointWithinVolume(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4GDMLWriteParamvol::ParametersWrite(), G4GDMLWriteParamvol::ParamvolAlgorithmWrite(), G4GDMLWriteParamvol::ParamvolWrite(), G4GDMLWriteStructure::PhysvolWrite(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4Channeling::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4ForwardXrayTR::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4ITTransportation::PostStepDoIt(), G4VTransitionRadiation::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4Transportation::PostStepDoIt(), G4MaxTimeCuts::PostStepGetPhysicalInteractionLength(), G4MinEkineCuts::PostStepGetPhysicalInteractionLength(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4FastSimulationManagerProcess::PostStepGetPhysicalInteractionLength(), G4StepLimiter::PostStepGetPhysicalInteractionLength(), G4UserSpecialCuts::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4LowECapture::PostStepGetPhysicalInteractionLength(), G4NavigationLogger::PreComputeStepLog(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), G4PSSphereSurfaceFlux::ProcessHits(), G4PSVolumeFlux::ProcessHits(), G4ErrorFreeTrajState::PropagateErrorIoni(), G4ErrorFreeTrajState::PropagateErrorMSC(), G4ITNavigator2::RecheckDistanceToCurrentBoundary(), G4ReflectionFactory::ReflectPVDivision(), G4ReflectionFactory::ReflectPVPlacement(), G4ReflectionFactory::ReflectPVReplica(), G4LatticeManager::RegisterLattice(), G4GDMLWriteStructure::ReplicavolWrite(), G4PropagatorInField::ReportLoopingParticle(), G4NavigationLogger::ReportOutsideMother(), G4NavigationLogger::ReportVolumeAndIntersection(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VoxelSafety::SafetyForVoxelHeader(), G4VoxelSafety::SafetyForVoxelNode(), G4PolarizedAnnihilationModel::SampleSecondaries(), G4PolarizedComptonModel::SampleSecondaries(), G4PolarizedIonisationModel::SampleSecondaries(), G4DNAIRT_geometries::Sampling(), G4ProductionCutsTable::ScanAndSetCouple(), G4Region::ScanVolumeTree(), G4LogicalVolume::SetFieldManager(), G4ITStepProcessor::SetInitialStep(), G4SteppingManager::SetInitialStep(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4VisCommandsTouchable::SetNewValue(), G4RTPrimaryGeneratorAction::SetUp(), G4ScoringProbe::SetupGeometry(), G4ScoringBox::SetupGeometry(), G4ScoringCylinder::SetupGeometry(), G4Navigator::SetupHierarchy(), G4ITNavigator1::SetupHierarchy(), G4ITNavigator2::SetupHierarchy(), G4GlobalFastSimulationManager::ShowSetup(), G4SteppingManager::Stepping(), G4ParallelWorldProcess::SwitchMaterial(), G4GeomTestVolume::TestOverlapInTree(), G4GeomTestVolume::TestRecursiveOverlap(), G4LogicalVolume::TotalVolumeEntities(), G4GDMLWriteStructure::TraverseVolumeTree(), G4Channeling::UpdateParameters(), and G4MSSteppingAction::UserSteppingAction().

GetMotherLogical()

G4LogicalVolume * G4VPhysicalVolume::GetMotherLogical ( ) const

inlineinherited

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), G4AdjointCrossSurfChecker::AddaSphericalSurfaceWithCenterAtTheCenterOfAVolume(), G4GeometryManager::BuildOptimisations(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4AdjointPosOnPhysVolGenerator::ComputeTransformationFromPhysVolToWorld(), G4GeometryManager::DeleteOptimisations(), G4PhysicalVolumeStore::DeRegister(), G4GlobalFastSimulationManager::DisplayRegion(), G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVParameterised(), G4tgbGeometryDumper::DumpPVPlacement(), G4tgbGeometryDumper::DumpPVReplica(), export_G4VPhysicalVolume(), G4tgbGeometryDumper::GetTopPhysVol(), G4MicroElecSurface::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4RunManager::ReOptimizeMotherOf(), and G4RegionStore::SetWorldVolume().

GetMultiplicity()

G4int G4ReplicatedSlice::GetMultiplicity ( ) const

virtual

Reimplemented from G4PVReplica.

Definition at line 309 of file G4ReplicatedSlice.cc.

{
  return fnReplicas;
}

References fnReplicas.

GetName()

const G4String & G4VPhysicalVolume::GetName ( ) const

inlineinherited

Referenced by G4TransportationManager::ActivateNavigator(), G4VSceneHandler::AddCompound(), G4LogicalVolume::AddDaughter(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4GDMLWrite::AddModule(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4DNABrownianTransportation::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4GDMLWriteStructure::BorderSurfaceCache(), G4SmartVoxelHeader::BuildNodes(), CheckAndSetParameters(), G4PVDivision::CheckAndSetParameters(), G4PVReplica::CheckOnlyDaughter(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4Navigator::CheckOverlapsIterative(), G4Navigator::ComputeSafety(), G4ITNavigator1::ComputeSafety(), G4ITNavigator2::ComputeSafety(), G4VoxelNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4PolarizedAnnihilation::ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4Navigator::ComputeStep(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4PropagatorInField::ComputeStep(), G4tgbPlaceParamCircle::ComputeTransformation(), G4tgbPlaceParamLinear::ComputeTransformation(), G4tgbPlaceParamSquare::ComputeTransformation(), G4ImportanceConfigurator::Configure(), G4WeightCutOffConfigurator::Configure(), G4WeightWindowConfigurator::Configure(), G4tgbDetectorConstruction::Construct(), G4tgbDetectorBuilder::ConstructDetector(), G4tgbVolume::ConstructG4PhysVol(), G4FastSimulationPhysics::ConstructProcess(), G4Qt3DSceneHandler::CreateNewNode(), G4PathFinder::CreateTouchableHandle(), G4ITPathFinder::CreateTouchableHandle(), G4AdjointCrossSurfChecker::CrossingAnInterfaceBetweenTwoVolumes(), G4TransportationManager::DeActivateNavigator(), G4DNAMolecularDissociation::DecayIt(), G4PhysicalVolumeStore::DeRegister(), G4TransportationManager::DeRegisterNavigator(), G4TransportationManager::DeRegisterWorld(), G4ITTransportationManager::DeRegisterWorld(), G4PhysicalVolumeModel::DescribeAndDescend(), G4LogicalVolumeModel::DescribeYourselfTo(), G4GDMLWriteStructure::DivisionvolWrite(), G4TrajectoryDrawByOriginVolume::Draw(), G4tgbVolumeMgr::DumpG4PhysVolLeaf(), G4LogicalBorderSurface::DumpInfo(), G4tgbGeometryDumper::DumpPVParameterised(), G4tgbGeometryDumper::DumpPVPlacement(), G4tgbGeometryDumper::DumpPVReplica(), G4RunManagerKernel::DumpRegion(), G4HadronicProcess::DumpState(), G4MuonicAtomDecay::DumpState(), G4tgbVolumeMgr::DumpSummary(), G4ExceptionHandler::DumpTrackInfo(), G4ASCIITreeSceneHandler::EndModeling(), G4TrajectoryOriginVolumeFilter::Evaluate(), export_G4VPhysicalVolume(), G4FastTrack::FRecordsAffineTransformation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4IStore::G4IStore(), G4PhysicalVolumeModel::G4PhysicalVolumeModel(), G4PVParameterised::G4PVParameterised(), G4PVReplica::G4PVReplica(), G4Navigator::GetGlobalExitNormal(), G4PSDoseDeposit3D::GetIndex(), G4PSEnergyDeposit3D::GetIndex(), G4LatticeManager::GetLattice(), G4Navigator::GetLocalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ModelingParameters::PVPointerCopyNo::GetName(), G4TransportationManager::GetNavigator(), G4ITTransportationManager::GetNavigator(), G4tgbVolumeMgr::GetTopPhysVol(), G4AdjointCrossSurfChecker::GoingInOrOutOfaVolume(), G4AdjointCrossSurfChecker::GoingInOrOutOfaVolumeByExtSurface(), G4SPSPosDistribution::IsSourceConfined(), G4LatticeManager::LoadLattice(), G4ITMultiNavigator::LocateGlobalPointAndSetup(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4MultiNavigator::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), operator<<(), G4GDMLWriteParamvol::ParametersWrite(), Path(), G4GDMLWriteStructure::PhysvolWrite(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4ITSteppingVerbose::PostStepVerbose(), G4NavigationLogger::PreComputeStepLog(), G4MultiNavigator::PrepareNavigators(), G4ITMultiNavigator::PrepareNavigators(), G4ITSteppingVerbose::PreStepVerbose(), G4MultiNavigator::PrintLimited(), G4PathFinder::PrintLimited(), G4ITMultiNavigator::PrintLimited(), G4ITPathFinder::PrintLimited(), G4Navigator::PrintState(), G4ITNavigator1::PrintState(), G4PropagatorInField::printStatus(), G4PhysicalVolumeMassScene::ProcessVolume(), G4PhysicalVolumesSearchScene::ProcessVolume(), G4ReflectionFactory::ReflectPVDivision(), G4ReflectionFactory::ReflectPVParameterised(), G4ReflectionFactory::ReflectPVPlacement(), G4ReflectionFactory::ReflectPVReplica(), G4PhysicalVolumeStore::Register(), G4tgbVolumeMgr::RegisterMe(), G4PropagatorInField::ReportLoopingParticle(), G4PropagatorInField::ReportStuckParticle(), G4NavigationLogger::ReportVolumeAndIntersection(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VoxelSafety::SafetyForVoxelHeader(), G4Region::ScanVolumeTree(), G4VisCommandsTouchable::SetNewValue(), G4WeightCutOffProcess::SetParallelWorld(), G4WeightWindowProcess::SetParallelWorld(), G4ParallelWorldProcess::SetParallelWorld(), G4ParallelWorldScoringProcess::SetParallelWorld(), G4IStore::SetParallelWorldVolume(), G4IStore::SetWorldVolume(), G4WeightWindowStore::SetWorldVolume(), G4FastSimulationManagerProcess::SetWorldVolume(), G4GlobalFastSimulationManager::ShowSetup(), G4ITSteppingVerbose::ShowStep(), G4SteppingVerbose::ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), G4ITSteppingVerbose::StepInfo(), G4SteppingVerbose::StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), G4ITSteppingVerbose::StepInfoForLeadingTrack(), G4GDMLRead::StripNames(), G4ErrorGeomVolumeTarget::TargetReached(), G4GeomTestVolume::TestOverlapInTree(), G4ITSteppingVerbose::TrackingEnded(), G4SteppingVerbose::TrackingStarted(), G4SteppingVerboseWithUnits::TrackingStarted(), G4ITSteppingVerbose::TrackingStarted(), G4ParallelWorldScoringProcess::Verbose(), G4ScoreSplittingProcess::Verbose(), G4ITSteppingVerbose::VerboseTrack(), G4SteppingVerbose::VerboseTrack(), G4SteppingVerboseWithUnits::VerboseTrack(), G4VScoringMesh::WorkerConstruct(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

GetObjectRotation()

G4RotationMatrix * G4VPhysicalVolume::GetObjectRotation ( ) const

inherited

Definition at line 175 of file G4VPhysicalVolume.cc.

{
  static G4RotationMatrix aRotM;
  static G4RotationMatrix IdentityRM;
 
  G4RotationMatrix* retval = &IdentityRM;
 
  // Insure against frot being a null pointer
  if(this->GetRotation())
  {
     aRotM = GetRotation()->inverse();
     retval= &aRotM;
  }
  return retval;
}

References G4VPhysicalVolume::GetRotation(), and CLHEP::HepRotation::inverse().

GetObjectRotationValue()

G4RotationMatrix G4VPhysicalVolume::GetObjectRotationValue ( ) const

inherited

Definition at line 191 of file G4VPhysicalVolume.cc.

{
  G4RotationMatrix aRotM;   // Initialised to identity
 
  // Insure against G4MT_rot being a null pointer
  if(G4MT_rot)
  {
     aRotM = G4MT_rot->inverse();
  }
  return aRotM;
}

References G4MT_rot.

Referenced by G4PhysicalVolumeModel::CreateCurrentAttValues(), export_G4VPhysicalVolume(), G4GDMLWriteParamvol::ParametersWrite(), and G4ReflectionFactory::ReflectPVPlacement().

GetObjectTranslation()

G4ThreeVector G4VPhysicalVolume::GetObjectTranslation ( ) const

inherited

Definition at line 203 of file G4VPhysicalVolume.cc.

{
  return G4ThreeVector(G4MT_tx, G4MT_ty, G4MT_tz);
}

References G4MT_tx, G4MT_ty, and G4MT_tz.

Referenced by G4AdjointCrossSurfChecker::AddaSphericalSurfaceWithCenterAtTheCenterOfAVolume(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4AdjointPosOnPhysVolGenerator::ComputeTransformationFromPhysVolToWorld(), export_G4VPhysicalVolume(), G4GDMLWriteParamvol::ParametersWrite(), G4ReflectionFactory::ReflectPVPlacement(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetParameterisation()

G4VPVParameterisation * G4ReplicatedSlice::GetParameterisation ( ) const

virtual

Reimplemented from G4PVReplica.

Definition at line 315 of file G4ReplicatedSlice.cc.

{
  return fparam;
}

References fparam.

GetRegularStructureId()

G4int G4ReplicatedSlice::GetRegularStructureId ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 574 of file G4ReplicatedSlice.cc.

{
  return 0;  
}           

GetReplicationData()

void G4ReplicatedSlice::GetReplicationData ( EAxis &  axis, G4int &  nReplicas, G4double &  width, G4double &  offset, G4bool &  consuming  ) const

virtual

Reimplemented from G4PVReplica.

Definition at line 327 of file G4ReplicatedSlice.cc.

{
  axis = faxis;
  nDivs = fnReplicas;
  width = fwidth;
  offset = foffset;
  consuming = false;
}

References faxis, fnReplicas, foffset, and fwidth.

GetRotation() [1/2]

G4RotationMatrix * G4VPhysicalVolume::GetRotation ( )

inherited

Definition at line 165 of file G4VPhysicalVolume.cc.

{
  return G4MT_rot;
}

References G4MT_rot.

GetRotation() [2/2]

const G4RotationMatrix * G4VPhysicalVolume::GetRotation ( ) const

inherited

Definition at line 160 of file G4VPhysicalVolume.cc.

{
  return G4MT_rot;
}

References G4MT_rot.

Referenced by G4SmartVoxelHeader::BuildNodes(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4NormalNavigation::ComputeSafety(), G4VoxelNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4NormalNavigation::ComputeStep(), G4Navigator::ComputeStep(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4tgbPlaceParamCircle::ComputeTransformation(), G4LogicalVolumeModel::DescribeYourselfTo(), G4tgbGeometryDumper::DumpPVPlacement(), G4PVPlacement::G4PVPlacement(), G4Navigator::GetMotherToDaughterTransform(), G4ITNavigator1::GetMotherToDaughterTransform(), G4ITNavigator2::GetMotherToDaughterTransform(), G4VPhysicalVolume::GetObjectRotation(), G4TransportationManager::GetParallelWorld(), G4ITTransportationManager::GetParallelWorld(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4ITNavigator2::RecheckDistanceToCurrentBoundary(), G4VoxelSafety::SafetyForVoxelNode(), G4PVReplica::TerminateWorker(), G4PVPlacement::~G4PVPlacement(), and ~G4ReplicatedSlice().

GetSubInstanceManager()

const G4PVRManager & G4PVReplica::GetSubInstanceManager ( )

staticinherited

Definition at line 343 of file G4PVReplica.cc.

{
  return subInstanceManager;
}

References G4PVReplica::subInstanceManager.

Referenced by G4GeometryWorkspace::G4GeometryWorkspace().

GetTranslation()

const G4ThreeVector G4VPhysicalVolume::GetTranslation ( ) const

inherited

Definition at line 150 of file G4VPhysicalVolume.cc.

{
  return G4ThreeVector(G4MT_tx, G4MT_ty, G4MT_tz);
}

References G4MT_tx, G4MT_ty, and G4MT_tz.

Referenced by G4SmartVoxelHeader::BuildNodes(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4NormalNavigation::ComputeSafety(), G4VoxelNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4NormalNavigation::ComputeStep(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4LogicalVolumeModel::DescribeYourselfTo(), G4tgbGeometryDumper::DumpPVPlacement(), export_G4VPhysicalVolume(), G4Navigator::GetMotherToDaughterTransform(), G4ITNavigator1::GetMotherToDaughterTransform(), G4ITNavigator2::GetMotherToDaughterTransform(), G4TransportationManager::GetParallelWorld(), G4ITTransportationManager::GetParallelWorld(), G4ITNavigator2::RecheckDistanceToCurrentBoundary(), and G4VoxelSafety::SafetyForVoxelNode().

InitialiseWorker() [1/2]

void G4PVReplica::InitialiseWorker ( G4PVReplica *  pMasterObject )

inherited

Definition at line 355 of file G4PVReplica.cc.

{
  
  G4VPhysicalVolume::InitialiseWorker( pMasterObject, nullptr, G4ThreeVector());
  subInstanceManager.SlaveCopySubInstanceArray();
  G4MT_copyNo = -1;
 
  // This call causes "self-assignment" of the input parameters
  // Issue reported by DRD since TerminateWorker() below can be called
  // at the same time by another thread.
  // What we need here is the split-class component of CheckAndSetParameters()
  // funciton copied here.
 
  // Create rotation matrix for phi axis case & check axis is valid
  //
  G4RotationMatrix* pRMat = nullptr;
  switch (faxis)
  {
    case kPhi:
      pRMat = new G4RotationMatrix();
      if (pRMat == nullptr)
      {
        G4Exception("G4PVReplica::InitialiseWorker(...)", "GeomVol0003",
                    FatalException, "Rotation matrix allocation failed.");
      }
      SetRotation(pRMat);
      break;
    case kRho:
    case kXAxis:
    case kYAxis:
    case kZAxis:
    case kUndefined:
      break;
    default:
      G4Exception("G4PVReplica::InitialiseWorker(...)", "GeomVol0002",
                  FatalException, "Unknown axis of replication.");
      break;
  }
}

References FatalException, G4PVReplica::faxis, G4Exception(), G4MT_copyNo, G4VPhysicalVolume::InitialiseWorker(), kPhi, kRho, kUndefined, kXAxis, kYAxis, kZAxis, G4VPhysicalVolume::SetRotation(), G4GeomSplitter< T >::SlaveCopySubInstanceArray(), and G4PVReplica::subInstanceManager.

Referenced by G4GeometryWorkspace::InitialisePhysicalVolumes().

InitialiseWorker() [2/2]

void G4VPhysicalVolume::InitialiseWorker ( G4VPhysicalVolume *  pMasterObject, G4RotationMatrix *  pRot, const G4ThreeVector &  tlate  )

protectedinherited

Definition at line 111 of file G4VPhysicalVolume.cc.

{
  subInstanceManager.SlaveCopySubInstanceArray();
 
  this->SetRotation( pRot );      // G4MT_rot   = pRot;
  this->SetTranslation( tlate );  // G4MT_trans = tlate;
  //  G4PhysicalVolumeStore::Register(this);
}

References G4VPhysicalVolume::SetRotation(), G4VPhysicalVolume::SetTranslation(), G4GeomSplitter< T >::SlaveCopySubInstanceArray(), and G4VPhysicalVolume::subInstanceManager.

Referenced by G4PVReplica::InitialiseWorker().

IsMany()

G4bool G4ReplicatedSlice::IsMany ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 297 of file G4ReplicatedSlice.cc.

{
  return false; 
}

IsParameterised()

G4bool G4ReplicatedSlice::IsParameterised ( ) const

virtual

Reimplemented from G4PVReplica.

Definition at line 291 of file G4ReplicatedSlice.cc.

{ 
  return true;
}

IsRegularStructure()

G4bool G4ReplicatedSlice::IsRegularStructure ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 566 of file G4ReplicatedSlice.cc.

{
  return false;
}           

IsReplicated()

G4bool G4ReplicatedSlice::IsReplicated ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 303 of file G4ReplicatedSlice.cc.

{
  return true;
}

operator=()

G4ReplicatedSlice & G4ReplicatedSlice::operator= ( const G4ReplicatedSlice &  )

delete

operator==()

G4bool G4VPhysicalVolume::operator== ( const G4VPhysicalVolume &  p ) const

inlineinherited

SetCopyNo()

void G4PVReplica::SetCopyNo ( G4int  CopyNo )

virtualinherited

Implements G4VPhysicalVolume.

Definition at line 273 of file G4PVReplica.cc.

{
  G4MT_copyNo = newCopyNo;
}

References G4MT_copyNo.

SetLogicalVolume()

void G4VPhysicalVolume::SetLogicalVolume ( G4LogicalVolume *  pLogical )

inlineinherited

Referenced by export_G4VPhysicalVolume().

SetMotherLogical()

void G4VPhysicalVolume::SetMotherLogical ( G4LogicalVolume *  pMother )

inlineinherited

Referenced by CheckAndSetParameters(), export_G4VPhysicalVolume(), G4PVDivision::G4PVDivision(), G4PVParameterised::G4PVParameterised(), G4PVPlacement::G4PVPlacement(), G4PVReplica::G4PVReplica(), and G4VExternalPhysicalVolume::G4VExternalPhysicalVolume().

SetName()

void G4VPhysicalVolume::SetName ( const G4String &  pName )

inherited

Definition at line 99 of file G4VPhysicalVolume.cc.

{
  fname = pName;
  G4PhysicalVolumeStore::GetInstance()->SetMapValid(false);
}

References G4VPhysicalVolume::fname, G4PhysicalVolumeStore::GetInstance(), and G4PhysicalVolumeStore::SetMapValid().

Referenced by G4RunManager::ConstructScoringWorlds(), export_G4VPhysicalVolume(), G4GDMLRead::GeneratePhysvolName(), G4VUserParallelWorld::GetWorld(), and G4GDMLRead::StripNames().

SetParameterisation()

void G4ReplicatedSlice::SetParameterisation ( G4LogicalVolume *  motherLogical, const EAxis  pAxis, const G4int  nReplicas, const G4double  width, const G4double  half_gap, const G4double  offset, DivisionType  divType  )

private

Definition at line 342 of file G4ReplicatedSlice.cc.

{
  G4VSolid* mSolid = motherLogical->GetSolid();
  G4String mSolidType = mSolid->GetEntityType();
  fparam = nullptr;
 
  // If the solid is a reflected one, update type to its
  // real constituent solid.
  // 
  if (mSolidType == "G4ReflectedSolid")
  {
      mSolidType = ((G4ReflectedSolid*)mSolid)->GetConstituentMovedSolid()
                 ->GetEntityType(); 
  }    
 
  // Parameterisation type depend of mother solid type and axis of division
  //
  if( mSolidType == "G4Box" )
  {
    switch( axis )
    {
      case kXAxis:
        fparam = new G4ParameterisationBoxX( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      case kYAxis:
        fparam = new G4ParameterisationBoxY( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      case kZAxis:
        fparam = new G4ParameterisationBoxZ( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      default:
        ErrorInAxis( axis, mSolid );
        break;
    }
  }
  else if( mSolidType == "G4Tubs" )
  {
    switch( axis )
    {
      case kRho:
        fparam = new G4ParameterisationTubsRho( axis, nDivs, width,
                                                offset, mSolid, divType );
        break;
      case kPhi:
        fparam = new G4ParameterisationTubsPhi( axis, nDivs, width,
                                                offset, mSolid, divType );
        break;
      case kZAxis:
        fparam = new G4ParameterisationTubsZ( axis, nDivs, width,
                                              offset, mSolid, divType );
        break;
      default:
        ErrorInAxis( axis, mSolid );
        break;
    }
  }
  else if( mSolidType == "G4Cons" )
  {
    switch( axis )
    {
      case kRho:
        fparam = new G4ParameterisationConsRho( axis, nDivs, width,
                                                offset, mSolid, divType );
        break;
      case kPhi:
        fparam = new G4ParameterisationConsPhi( axis, nDivs, width,
                                                offset, mSolid, divType );
        break;
      case kZAxis:
        fparam = new G4ParameterisationConsZ( axis, nDivs, width,
                                              offset, mSolid, divType );
        break;
      default:
        ErrorInAxis( axis, mSolid );
        break;
    }
  }
  else if( mSolidType == "G4Trd" )
  { 
    switch( axis )
    {
      case kXAxis:
        fparam = new G4ParameterisationTrdX( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      case kYAxis:
        fparam = new G4ParameterisationTrdY( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      case kZAxis:
        fparam = new G4ParameterisationTrdZ( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      default:
        ErrorInAxis( axis, mSolid );
        break;
    }
  }
  else if( mSolidType == "G4Para" )
  { 
    switch( axis )
    {
      case kXAxis:
        fparam = new G4ParameterisationParaX( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      case kYAxis:
        fparam = new G4ParameterisationParaY( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      case kZAxis:
        fparam = new G4ParameterisationParaZ( axis, nDivs, width,
                                             offset, mSolid, divType );
        break;
      default:
        ErrorInAxis( axis, mSolid );
        break;
    }
  }
//  else if( mSolidType == "G4Trap" )
//  {
//  }
//  else if( mSolidType == "G4Polycone" )
//  {
//    switch( axis )
//    {
//      case kRho:
//        fparam = new G4ParameterisationPolyconeRho( axis, nDivs, width,
//                                                    offset, mSolid, divType );
//        break;
//      case kPhi:
//        fparam = new G4ParameterisationPolyconePhi( axis, nDivs, width,
//                                                    offset, mSolid, divType );
//        break;
//      case kZAxis:
//        fparam = new G4ParameterisationPolyconeZ( axis, nDivs, width,
//                                                  offset, mSolid, divType );
//        break;
//      default:
//        ErrorInAxis( axis, mSolid );
//      break;
//    }
//  }
//  else if( mSolidType == "G4Polyhedra" )
//  {
//    switch( axis )
//    {
//      case kRho:
//        fparam = new G4ParameterisationPolyhedraRho( axis, nDivs, width,
//                                                    offset, mSolid, divType );
//        break;
//      case kPhi:
//        fparam = new G4ParameterisationPolyhedraPhi( axis, nDivs, width,
//                                                    offset, mSolid, divType );
//        break;
//      case kZAxis:
//        fparam = new G4ParameterisationPolyhedraZ( axis, nDivs, width,
//                                                  offset, mSolid, divType );
//        break;
//      default:
//        ErrorInAxis( axis, mSolid );
//      break;
//    }
//  }
  else
  {
    std::ostringstream message;
    message << "Solid type not supported: " << mSolidType << "." << G4endl
            << "Divisions for " << mSolidType << " not implemented.";
    G4Exception("G4ReplicatedSlice::SetParameterisation()", "GeomDiv0001",
                FatalException, message);
  }
 
  fparam->SetHalfGap(half_gap);
}

References ErrorInAxis(), FatalException, fparam, G4endl, G4Exception(), G4VSolid::GetEntityType(), G4LogicalVolume::GetSolid(), kPhi, kRho, kXAxis, kYAxis, kZAxis, and G4VDivisionParameterisation::SetHalfGap().

Referenced by CheckAndSetParameters().

SetRegularStructureId()

void G4PVReplica::SetRegularStructureId ( G4int  code )

virtualinherited

Reimplemented in G4PVParameterised.

Definition at line 335 of file G4PVReplica.cc.

{
  fRegularVolsId = code; 
} 

References G4PVReplica::fRegularVolsId.

Referenced by G4PVParameterised::SetRegularStructureId().

SetRotation()

void G4VPhysicalVolume::SetRotation ( G4RotationMatrix *  pRot )

inherited

Definition at line 170 of file G4VPhysicalVolume.cc.

{
  G4MT_rot = pRot;
}

References G4MT_rot.

Referenced by G4VDivisionParameterisation::ChangeRotMatrix(), CheckAndSetParameters(), G4PVDivision::CheckAndSetParameters(), G4PVReplica::CheckAndSetParameters(), G4tgbPlaceParamCircle::ComputeTransformation(), G4tgbPlaceParamLinear::ComputeTransformation(), G4tgbPlaceParamSquare::ComputeTransformation(), G4GDMLParameterisation::ComputeTransformation(), export_G4VPhysicalVolume(), G4PVPlacement::G4PVPlacement(), G4VPhysicalVolume::G4VPhysicalVolume(), G4PVReplica::InitialiseWorker(), and G4VPhysicalVolume::InitialiseWorker().

SetTranslation()

void G4VPhysicalVolume::SetTranslation ( const G4ThreeVector &  v )

inherited

Definition at line 155 of file G4VPhysicalVolume.cc.

{
  G4MT_tx=vec.x(); G4MT_ty=vec.y(); G4MT_tz=vec.z();
}

References G4MT_tx, G4MT_ty, G4MT_tz, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4ParameterisationBoxX::ComputeTransformation(), G4ParameterisationBoxY::ComputeTransformation(), G4ParameterisationBoxZ::ComputeTransformation(), G4ParameterisationConsRho::ComputeTransformation(), G4ParameterisationConsPhi::ComputeTransformation(), G4ParameterisationConsZ::ComputeTransformation(), G4ParameterisationParaX::ComputeTransformation(), G4ParameterisationParaY::ComputeTransformation(), G4ParameterisationParaZ::ComputeTransformation(), G4ParameterisationPolyconeRho::ComputeTransformation(), G4ParameterisationPolyconePhi::ComputeTransformation(), G4ParameterisationPolyconeZ::ComputeTransformation(), G4ParameterisationPolyhedraRho::ComputeTransformation(), G4ParameterisationPolyhedraPhi::ComputeTransformation(), G4ParameterisationPolyhedraZ::ComputeTransformation(), G4ParameterisationTrdX::ComputeTransformation(), G4ParameterisationTrdY::ComputeTransformation(), G4ParameterisationTrdZ::ComputeTransformation(), G4ParameterisationTubsRho::ComputeTransformation(), G4ParameterisationTubsPhi::ComputeTransformation(), G4ParameterisationTubsZ::ComputeTransformation(), G4tgbPlaceParamCircle::ComputeTransformation(), G4tgbPlaceParamLinear::ComputeTransformation(), G4tgbPlaceParamSquare::ComputeTransformation(), G4ReplicaNavigation::ComputeTransformation(), G4PartialPhantomParameterisation::ComputeTransformation(), G4PhantomParameterisation::ComputeTransformation(), G4GDMLParameterisation::ComputeTransformation(), export_G4VPhysicalVolume(), G4VPhysicalVolume::G4VPhysicalVolume(), and G4VPhysicalVolume::InitialiseWorker().

TerminateWorker() [1/2]

void G4PVReplica::TerminateWorker ( G4PVReplica *  pMasterObject )

inherited

Definition at line 400 of file G4PVReplica.cc.

{
  if ( faxis==kPhi )
  {
    delete GetRotation();
  }
}

References G4PVReplica::faxis, G4VPhysicalVolume::GetRotation(), and kPhi.

Referenced by G4GeometryWorkspace::DestroyWorkspace().

TerminateWorker() [2/2]

void G4VPhysicalVolume::TerminateWorker ( G4VPhysicalVolume *  pMasterObject )

protectedinherited

Definition at line 134 of file G4VPhysicalVolume.cc.

{
}

VolumeType()

EVolume G4ReplicatedSlice::VolumeType ( ) const

finalvirtual

Reimplemented from G4PVReplica.

Definition at line 321 of file G4ReplicatedSlice.cc.

{
  return kParameterised;
}

References kParameterised.

Field Documentation

faxis

EAxis G4ReplicatedSlice::faxis

protected

Definition at line 174 of file G4ReplicatedSlice.hh.

Referenced by CheckAndSetParameters(), and GetReplicationData().

fdivAxis

EAxis G4ReplicatedSlice::fdivAxis

protected

Definition at line 175 of file G4ReplicatedSlice.hh.

Referenced by CheckAndSetParameters(), and GetDivisionAxis().

flmother

G4LogicalVolume* G4VPhysicalVolume::flmother = nullptr

privateinherited

Definition at line 246 of file G4VPhysicalVolume.hh.

flogical

G4LogicalVolume* G4VPhysicalVolume::flogical = nullptr

privateinherited

Definition at line 242 of file G4VPhysicalVolume.hh.

fname

G4String G4VPhysicalVolume::fname

privateinherited

Definition at line 245 of file G4VPhysicalVolume.hh.

Referenced by G4VPhysicalVolume::SetName().

fnReplicas

G4int G4ReplicatedSlice::fnReplicas = 0

protected

Definition at line 176 of file G4ReplicatedSlice.hh.

Referenced by CheckAndSetParameters(), GetMultiplicity(), and GetReplicationData().

foffset

G4double G4ReplicatedSlice::foffset = 0.0

protected

Definition at line 177 of file G4ReplicatedSlice.hh.

Referenced by CheckAndSetParameters(), and GetReplicationData().

fparam

G4VDivisionParameterisation* G4ReplicatedSlice::fparam = nullptr

protected

Definition at line 178 of file G4ReplicatedSlice.hh.

Referenced by CheckAndSetParameters(), GetParameterisation(), and SetParameterisation().

fRegularVolsId

G4int G4PVReplica::fRegularVolsId = 0

privateinherited

Definition at line 191 of file G4PVReplica.hh.

Referenced by G4PVReplica::GetRegularStructureId(), G4PVReplica::IsRegularStructure(), and G4PVReplica::SetRegularStructureId().

fwidth

G4double G4ReplicatedSlice::fwidth = 0.0

protected

Definition at line 177 of file G4ReplicatedSlice.hh.

Referenced by CheckAndSetParameters(), and GetReplicationData().

instanceID

G4int G4PVReplica::instanceID

privateinherited

Definition at line 193 of file G4PVReplica.hh.

Referenced by G4PVReplica::G4PVReplica(), and G4PVReplica::GetInstanceID().

pvdata

G4PVData* G4VPhysicalVolume::pvdata = nullptr

privateinherited

Definition at line 248 of file G4VPhysicalVolume.hh.

Referenced by G4VPhysicalVolume::G4VPhysicalVolume(), and G4VPhysicalVolume::~G4VPhysicalVolume().

subInstanceManager

G4PVRManager G4PVReplica::subInstanceManager

staticprivateinherited

Definition at line 195 of file G4PVReplica.hh.

Referenced by G4PVReplica::G4PVReplica(), G4PVReplica::GetSubInstanceManager(), and G4PVReplica::InitialiseWorker().

---

The documentation for this class was generated from the following files:

• source/geometry/divisions/include/G4ReplicatedSlice.hh
• source/geometry/divisions/src/G4ReplicatedSlice.cc