G4LogicalVolume Class Reference

G4LogicalVolume represents a leaf node or unpositioned subtree in the geometry hierarchy. Logical volumes are named, and may have daughters ascribed to them. They are responsible for retrieval of the physical and tracking attributes of the physical volume that it represents: solid, material, magnetic field, and optionally, user limits, sensitive detectors, regions, biasing weights. More...

#include <G4LogicalVolume.hh>

Inheritance diagram for G4LogicalVolume:

Public Member Functions
	G4LogicalVolume (G4VSolid *pSolid, G4Material *pMaterial, const G4String &name, G4FieldManager *pFieldMgr=nullptr, G4VSensitiveDetector *pSDetector=nullptr, G4UserLimits *pULimits=nullptr, G4bool optimise=true)
virtual	~G4LogicalVolume ()
	G4LogicalVolume (const G4LogicalVolume &)=delete
G4LogicalVolume &	operator= (const G4LogicalVolume &)=delete
const G4String &	GetName () const
void	SetName (const G4String &pName)
std::size_t	GetNoDaughters () const
G4VPhysicalVolume *	GetDaughter (const std::size_t i) const
void	AddDaughter (G4VPhysicalVolume *p)
G4bool	IsDaughter (const G4VPhysicalVolume *p) const
G4bool	IsAncestor (const G4VPhysicalVolume *p) const
void	RemoveDaughter (const G4VPhysicalVolume *p)
void	ClearDaughters ()
G4int	TotalVolumeEntities () const
EVolume	CharacteriseDaughters () const
EVolume	DeduceDaughtersType () const
G4VSolid *	GetSolid () const
void	SetSolid (G4VSolid *pSolid)
G4Material *	GetMaterial () const
void	SetMaterial (G4Material *pMaterial)
void	UpdateMaterial (G4Material *pMaterial)
G4double	GetMass (G4bool forced=false, G4bool propagate=true, G4Material *parMaterial=nullptr)
void	ResetMass ()
G4FieldManager *	GetFieldManager () const
void	SetFieldManager (G4FieldManager *pFieldMgr, G4bool forceToAllDaughters)
G4VSensitiveDetector *	GetSensitiveDetector () const
void	SetSensitiveDetector (G4VSensitiveDetector *pSDetector)
G4UserLimits *	GetUserLimits () const
void	SetUserLimits (G4UserLimits *pULimits)
G4SmartVoxelHeader *	GetVoxelHeader () const
void	SetVoxelHeader (G4SmartVoxelHeader *pVoxel)
G4double	GetSmartless () const
void	SetSmartless (G4double s)
G4bool	IsToOptimise () const
void	SetOptimisation (G4bool optim)
G4bool	IsRootRegion () const
void	SetRegionRootFlag (G4bool rreg)
G4bool	IsRegion () const
void	SetRegion (G4Region *reg)
G4Region *	GetRegion () const
void	PropagateRegion ()
const G4MaterialCutsCouple *	GetMaterialCutsCouple () const
void	SetMaterialCutsCouple (G4MaterialCutsCouple *cuts)
G4bool	operator== (const G4LogicalVolume &lv) const
const G4VisAttributes *	GetVisAttributes () const
void	SetVisAttributes (const G4VisAttributes *pVA)
void	SetVisAttributes (const G4VisAttributes &VA)
G4FastSimulationManager *	GetFastSimulationManager () const
void	SetBiasWeight (G4double w)
G4double	GetBiasWeight () const
virtual G4bool	IsExtended () const
G4FieldManager *	GetMasterFieldManager () const
G4VSensitiveDetector *	GetMasterSensitiveDetector () const
G4VSolid *	GetMasterSolid () const
G4int	GetInstanceID () const
void	Lock ()
void	InitialiseWorker (G4LogicalVolume *ptrMasterObject, G4VSolid *pSolid, G4VSensitiveDetector *pSDetector)
void	TerminateWorker (G4LogicalVolume *ptrMasterObject)
void	AssignFieldManager (G4FieldManager *fldMgr)
G4bool	ChangeDaughtersType (EVolume atype)
	G4LogicalVolume (__void__ &)

Static Public Member Functions
static const G4LVManager &	GetSubInstanceManager ()
static void	Clean ()
static G4VSolid *	GetSolid (G4LVData &instLVdata)
static void	SetSolid (G4LVData &instLVdata, G4VSolid *pSolid)

Detailed Description

G4LogicalVolume represents a leaf node or unpositioned subtree in the geometry hierarchy. Logical volumes are named, and may have daughters ascribed to them. They are responsible for retrieval of the physical and tracking attributes of the physical volume that it represents: solid, material, magnetic field, and optionally, user limits, sensitive detectors, regions, biasing weights.

Definition at line 170 of file G4LogicalVolume.hh.

Constructor & Destructor Documentation

G4LogicalVolume() [1/3]

G4LogicalVolume::G4LogicalVolume	(	G4VSolid *	pSolid,
		G4Material *	pMaterial,
		const G4String &	name,
		G4FieldManager *	pFieldMgr = nullptr,
		G4VSensitiveDetector *	pSDetector = nullptr,
		G4UserLimits *	pULimits = nullptr,
		G4bool	optimise = true )

Constructor for G4LogicalVolume. The solid and material pointer must be non null. The parameters for field, detector and user limits are optional. The volume also enters itself into the logical volume Store. Optimisation of the geometry (voxelisation) for the volume hierarchy is applied by default. For parameterised volumes in the hierarchy, optimisation is -always- applied.

Parameters

[in]	pSolid	Pointer to the associated solid primitive.
[in]	pMaterial	Pointer to the associated material.
[in]	name	The volume name.
[in]	pFieldMgr	Pointer to optional magnetic field manager.
[in]	pSDetector	Pointer to optional associated sensitive detector.
[in]	pULimits	Pointer to optional user limits.
[in]	optimise	Flag to enable/disable optimisation structure.

Definition at line 72 of file G4LogicalVolume.cc.

 : fDaughters(0,(G4VPhysicalVolume*)nullptr), fDaughtersVolumeType(kNormal),
   fOptimise(optimise)
{
  // Initialize 'Shadow'/master pointers - for use in copying to workers
  //
  fSolid = pSolid;
  fSensitiveDetector = pSDetector;
  fFieldManager = pFieldMgr;
 
  instanceID = subInstanceManager.CreateSubInstance();
  AssignFieldManager(pFieldMgr);
  
  G4MT_mass = 0.;
  G4MT_ccouple = nullptr;
 
  SetSolid(pSolid);
  SetMaterial(pMaterial);
  SetName(name);
  SetSensitiveDetector(pSDetector);
  SetUserLimits(pULimits);    
 
  // Initialize 'Shadow' data structure - for use by object persistency
  //
  lvdata = new G4LVData();
  lvdata->fSolid = pSolid;
  lvdata->fMaterial = pMaterial;
 
  //
  // Add to store
  //
  G4LogicalVolumeStore::Register(this);
}

Referenced by AddDaughter(), G4LogicalCrystalVolume::G4LogicalCrystalVolume(), G4LogicalVolume(), GetMass(), InitialiseWorker(), G4LogicalCrystalVolume::IsLattice(), Lock(), operator=(), operator==(), SetFieldManager(), and TerminateWorker().

~G4LogicalVolume()

G4LogicalVolume::~G4LogicalVolume ( )

virtual

Destructor. Removes the logical volume from the logical volume Store. This class is NOT meant to act as base class, except for exceptional circumstances of extended types used in the kernel.

Definition at line 138 of file G4LogicalVolume.cc.

{
  if (!fLock && fRootRegion)  // De-register root region first if not locked
  {                           // and flagged as root logical-volume
    fRegion->RemoveRootLogicalVolume(this, true);
  }
  delete lvdata;
  G4LogicalVolumeStore::DeRegister(this);
}

G4LogicalVolume() [2/3]

G4LogicalVolume::G4LogicalVolume ( const G4LogicalVolume & )

delete

Copy-constructor and assignment operator not allowed.

G4LogicalVolume() [3/3]

G4LogicalVolume::G4LogicalVolume

(

__void__ &

)

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 117 of file G4LogicalVolume.cc.

 : fDaughters(0,(G4VPhysicalVolume*)nullptr), fName("")
{
  instanceID = subInstanceManager.CreateSubInstance();
  
  SetSensitiveDetector(nullptr);    // G4MT_sdetector = nullptr;
  SetFieldManager(nullptr, false);  // G4MT_fmanager = nullptr;
 
  G4MT_mass = 0.;
  G4MT_ccouple = nullptr;
  
  // Add to store
  //
  G4LogicalVolumeStore::Register(this);
}

Member Function Documentation

AddDaughter()

void G4LogicalVolume::AddDaughter

(

G4VPhysicalVolume *

p

)

Adds the volume 'p' as a daughter of the current logical volume.

Definition at line 285 of file G4LogicalVolume.cc.

{
  EVolume daughterType = pNewDaughter->VolumeType();
 
  // The type of the navigation needed is determined by the first daughter
  //
  if( fDaughters.empty() )
  {
    fDaughtersVolumeType = daughterType;
  }
  else
  {
    // Check consistency of detector description
 
    // 1. A replica or parameterised volume can have only one daughter
    //
    if( fDaughters[0]->IsReplicated() )
    {
      std::ostringstream message;
      message << "ERROR - Attempt to place a volume in a mother volume"
        << G4endl
        << "        already containing a replicated volume." << G4endl
        << "        A volume can either contain several placements" << G4endl
        << "        or a unique replica or parameterised volume !" << G4endl
        << "           Mother logical volume: " << GetName() << G4endl
        << "           Placing volume: " << pNewDaughter->GetName()
        << G4endl;
      G4Exception("G4LogicalVolume::AddDaughter()", "GeomMgt0002",
                  FatalException, message,
                  "Replica or parameterised volume must be the only daughter!");
    }
    else
    {
      // 2. Ensure that Placement and External physical volumes do not mix
      //
      if(  daughterType != fDaughtersVolumeType )
      {
        std::ostringstream message;
        message << "ERROR - Attempt to place a volume in a mother volume"
          << G4endl
          << "        already containing a different type of volume." << G4endl
          << "        A volume can either contain" << G4endl
          << "        - one or more placements, OR" << G4endl
          << "        - one or more 'external' type physical volumes." << G4endl
          << "          Mother logical volume: " << GetName() << G4endl
          << "          Volume being placed: " << pNewDaughter->GetName()
          << G4endl;
        G4Exception("G4LogicalVolume::AddDaughter()", "GeomMgt0002",
                    FatalException, message,
                    "Cannot mix placements and external physical volumes !");
      }
    }
  }
 
  // Invalidate previous calculation of mass - if any - for all threads
  //
  G4MT_mass = 0.;
  fDaughters.push_back(pNewDaughter);
 
  G4LogicalVolume* pDaughterLogical = pNewDaughter->GetLogicalVolume();
 
  // Propagate the Field Manager, if the daughter has no field Manager
  //
  G4FieldManager* pDaughterFieldManager = pDaughterLogical->GetFieldManager();
 
  // Avoid propagating the fieldManager pointer if null
  // and daughter's one is null as well...
  // 
  if( (G4MT_fmanager != nullptr ) && (pDaughterFieldManager == nullptr) )
  {
    pDaughterLogical->SetFieldManager(G4MT_fmanager, false);
  }
  if (fRegion != nullptr)
  {
    PropagateRegion();
    fRegion->RegionModified(true);
  }
}

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

AssignFieldManager()

void G4LogicalVolume::AssignFieldManager

(

G4FieldManager *

fldMgr

)

Sets the Field Manager only at this level (does not push down hierarchy)

Definition at line 244 of file G4LogicalVolume.cc.

{
  G4MT_fmanager= fldMgr;
  if(G4Threading::IsMasterThread())  { fFieldManager = fldMgr; }
}

Referenced by G4LogicalVolume(), InitialiseWorker(), and SetFieldManager().

ChangeDaughtersType()

G4bool G4LogicalVolume::ChangeDaughtersType

(

EVolume

atype

)

Changes the type of the daughters volume to be of type 'atype'. Meant for the user adopting an external navigator for the contents of a volume.

Returns

Success (true) or failure (false).

Definition at line 656 of file G4LogicalVolume.cc.

{
  G4bool works = false;
  if( aType == kExternal )
  {
    // It is the responsibility of External Navigator to handle types selected
    //
    fDaughtersVolumeType = aType;
    works = true;
  }
  else
  {
    EVolume expectedVType = DeduceDaughtersType();
    works = (expectedVType == aType);
    if ( works )
    {
      fDaughtersVolumeType = aType;
    }
  }
  return works;
}

CharacteriseDaughters()

EVolume G4LogicalVolume::CharacteriseDaughters ( ) const

inline

Characterises the daughters of this logical volume.

Referenced by G4ITNavigator2::RecheckDistanceToCurrentBoundary().

Clean()

void G4LogicalVolume::Clean ( )

static

Clears memory allocated by sub-instance manager.

Definition at line 202 of file G4LogicalVolume.cc.

{
  subInstanceManager.FreeSlave();
}

Referenced by G4LogicalVolumeStore::~G4LogicalVolumeStore().

ClearDaughters()

void G4LogicalVolume::ClearDaughters

(

)

Clears the list of daughters. Used by the physical volume store when the geometry tree is cleared, since modified at run-time.

Definition at line 389 of file G4LogicalVolume.cc.

{
  fDaughters.erase(fDaughters.cbegin(), fDaughters.cend());
  if (fRegion != nullptr)
  {
    fRegion->RegionModified(true);
  }
  G4MT_mass = 0.;
}

DeduceDaughtersType()

EVolume G4LogicalVolume::DeduceDaughtersType ( ) const

inline

Utility method used by CharacteriseDaughters().

Referenced by ChangeDaughtersType().

GetBiasWeight()

G4double G4LogicalVolume::GetBiasWeight ( ) const

inline

GetDaughter()

G4VPhysicalVolume * G4LogicalVolume::GetDaughter ( const std::size_t i ) const

inline

Returns the ith daughter. Note numbering starts from 0, and no bounds checking is performed.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4Region::BelongsTo(), G4PVPlacement::CheckOverlaps(), G4NormalNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4VoxelNavigation::ComputeSafety(), G4NormalNavigation::ComputeStep(), G4ParameterisedNavigation::ComputeStep(), G4RegularNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4LogicalVolumeModel::DescribeYourselfTo(), G4SmartVoxelHeader::G4SmartVoxelHeader(), G4ParameterisedNavigation::LevelLocate(), G4RegularNavigation::LevelLocate(), G4Region::ScanVolumeTree(), SetFieldManager(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4GeomTestVolume::TestOverlapInTree(), G4GeomTestVolume::TestRecursiveOverlap(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetFastSimulationManager()

G4FastSimulationManager * G4LogicalVolume::GetFastSimulationManager ( ) const

inline

Gets the current FastSimulationManager pointer if existing, otherwise null.

Referenced by G4FastSimulationManagerProcess::AtRestGetPhysicalInteractionLength(), G4FastSimHitMaker::make(), and G4FastSimulationManagerProcess::PostStepGetPhysicalInteractionLength().

GetFieldManager()

G4FieldManager * G4LogicalVolume::GetFieldManager

(

)

const

Gets current Field Manager pointer.

Definition at line 235 of file G4LogicalVolume.cc.

{
  return G4MT_fmanager;
}

Referenced by AddDaughter(), G4VFieldModel::DescribeYourselfTo(), G4PropagatorInField::FindAndSetFieldManager(), InitialiseWorker(), and SetFieldManager().

GetInstanceID()

G4int G4LogicalVolume::GetInstanceID ( ) const

inline

Returns the instance ID.

Referenced by G4VChannelingFastSimCrystalData::SetBendingAngle(), G4VChannelingFastSimCrystalData::SetCrystallineUndulatorParameters(), G4VChannelingFastSimCrystalData::SetCUParameters(), G4VChannelingFastSimCrystalData::SetGeometryParameters(), and G4VChannelingFastSimCrystalData::SetMiscutAngle().

GetMass()

G4double G4LogicalVolume::GetMass	(	G4bool	forced = false,
		G4bool	propagate = true,
		G4Material *	parMaterial = nullptr )

Returns the mass of the logical volume tree computed from the estimated geometrical volume of each solid and material associated to the logical volume and (by default) to its daughters.

Note

The computation may require a considerable amount of time, depending from the complexity of the geometry tree. The returned value is cached and can be used for successive calls (default), unless recomputation is forced by providing 'true' for the Boolean argument in input. Computation should be forced if the geometry setup has changed after the previous call. By setting the 'propagate' Boolean flag to 'false' the method returns the mass of the present logical volume only (subtracted for the volume occupied by the daughter volumes). An optional argument to specify a material is also provided.

Parameters

[in]	forced	Flag to force recomputation or use cached value.
[in]	propagate	Flag to limit or not computation to daughters.
[in]	parMaterial	Optional pointer to a custom material, usually used in parameterisations.

Definition at line 565 of file G4LogicalVolume.cc.

{
  // Return the cached non-zero value, if not forced
  //
  if ( ((G4MT_mass) != 0.0) && (!forced) )  { return G4MT_mass; }
 
  // Global density and computed mass associated to the logical
  // volume without considering its daughters
  //
  G4Material* logMaterial = parMaterial != nullptr ? parMaterial : GetMaterial();
  if (logMaterial == nullptr)
  {
    std::ostringstream message;
    message << "No material associated to the logical volume: "
            << fName << " !" << G4endl
            << "Sorry, cannot compute the mass ...";
    G4Exception("G4LogicalVolume::GetMass()", "GeomMgt0002",
                FatalException, message);
    return 0.0;
  }
  if ( GetSolid() == nullptr )
  {
    std::ostringstream message;
    message << "No solid is associated to the logical volume: "
            << fName << " !" << G4endl
            << "Sorry, cannot compute the mass ...";
    G4Exception("G4LogicalVolume::GetMass()", "GeomMgt0002",
                FatalException, message);
    return 0.0;
  }
  G4double globalDensity = logMaterial->GetDensity();
  G4double motherMass = GetSolid()->GetCubicVolume() * globalDensity;
  G4double massSum = motherMass;
  
  // For each daughter in the tree, subtract the mass occupied
  // and if required by the propagate flag, add the real daughter's
  // one computed recursively
 
  for (const auto & physDaughter : fDaughters)
  {
    G4LogicalVolume* logDaughter = physDaughter->GetLogicalVolume();
    G4double subMass = 0.0;
    G4VSolid* daughterSolid = nullptr;
    G4Material* daughterMaterial = nullptr;
 
    // Compute the mass to subtract and to add for each daughter
    // considering its multiplicity (i.e. replicated or not) and
    // eventually its parameterisation (by solid and/or by material)
    //
    for (auto i=0; i<physDaughter->GetMultiplicity(); ++i)
    {
      G4VPVParameterisation* physParam = physDaughter->GetParameterisation();
      if (physParam != nullptr)
      {
        daughterSolid = physParam->ComputeSolid(i, physDaughter);
        daughterSolid->ComputeDimensions(physParam, i, physDaughter);
        daughterMaterial = physParam->ComputeMaterial(i, physDaughter);
      }
      else
      {
        daughterSolid = logDaughter->GetSolid();
        daughterMaterial = logDaughter->GetMaterial();
      }
      subMass = daughterSolid->GetCubicVolume() * globalDensity;
 
      // Subtract the daughter's portion for the mass and, if required,
      // add the real daughter's mass computed recursively
      //
      massSum -= subMass;
      if (propagate)
      {
        massSum += logDaughter->GetMass(true, true, daughterMaterial);
      }
    }
  }
  G4MT_mass = massSum;
  return massSum;
}

Referenced by GetMass(), and G4ASCIITreeSceneHandler::RequestPrimitives().

GetMasterFieldManager()

G4FieldManager * G4LogicalVolume::GetMasterFieldManager ( ) const

inline

Returns current Field Manager for the master thread.

GetMasterSensitiveDetector()

G4VSensitiveDetector * G4LogicalVolume::GetMasterSensitiveDetector ( ) const

inline

Returns current Sensitive Detector for the master thread.

Referenced by G4GDMLWriteStructure::ExportSD().

GetMasterSolid()

G4VSolid * G4LogicalVolume::GetMasterSolid ( ) const

inline

Returns current Solid for the master thread.

Referenced by G4GeometryWorkspace::InitialisePhysicalVolumes().

GetMaterial()

G4Material * G4LogicalVolume::GetMaterial

(

)

const

Gets and sets the current material.

Definition at line 443 of file G4LogicalVolume.cc.

{
  return G4MT_material;
}

Referenced by G4AdjointPrimaryGenerator::ComputeAccumulatedDepthVectorAlongBackRay(), G4VPVParameterisation::ComputeMaterial(), G4tgbGeometryDumper::DumpLogVol(), G4GDMLWriteStructure::ExportEnergyCuts(), G4LogicalCrystalVolume::GetCrystal(), GetMass(), G4XrayReflection::GetMeanFreePath(), G4LatticeManager::LoadLattice(), G4ITTransportation::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4GeneralCerenkov::PostStepGetPhysicalInteractionLength(), G4LatticeManager::RegisterLattice(), G4PropagatorInField::ReportLoopingParticle(), G4TransportationLogger::ReportLoopingTrack(), G4Region::ScanVolumeTree(), G4Transportation::SetTouchableInformation(), G4ParallelWorldProcess::SwitchMaterial(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetMaterialCutsCouple()

const G4MaterialCutsCouple * G4LogicalVolume::GetMaterialCutsCouple

(

)

const

Accessor and modifier for production cuts.

Definition at line 492 of file G4LogicalVolume.cc.

{
  return G4MT_ccouple;
}

Referenced by G4ForwardXrayTR::PostStepDoIt(), G4ITTransportation::PostStepDoIt(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), and G4Transportation::SetTouchableInformation().

GetName()

const G4String & G4LogicalVolume::GetName ( ) const

inline

Returns and sets the name of the logical volume.

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), AddDaughter(), G4OpenInventorSceneHandler::AddPrimitive(), G4Region::AddRootLogicalVolume(), G4VtkSceneHandler::AddSolid(), G4VBiasingOperator::AttachTo(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), checkVol(), G4tgbVolume::ConstructG4LogVol(), G4tgbVolume::ConstructG4PhysVol(), G4tgbVolume::ConstructG4Volumes(), G3Division::CreatePVReplica(), G4AdjointCrossSurfChecker::CrossingAnInterfaceBetweenTwoVolumes(), G4RadioactiveDecay::DecayIt(), G4VRadioactiveDecay::DecayIt(), G4RunManagerKernel::DefineWorldVolume(), G4LogicalVolumeStore::DeRegister(), G4ReflectionFactory::Divide(), G4ReflectionFactory::Divide(), G4ReflectionFactory::Divide(), G4GDMLReadStructure::DivisionvolRead(), G4TrajectoryDrawByOriginVolume::Draw(), G4tgbVolumeMgr::DumpG4LogVolLeaf(), G4LogicalSkinSurface::DumpInfo(), G4tgbGeometryDumper::DumpLogVol(), G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVPlacement(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4BuildGeom(), G4PVReplica(), G4GDMLRead::GeneratePhysvolName(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), G4XrayReflection::GetMeanFreePath(), G4tgbVolumeMgr::GetTopLogVol(), G4tgbVolumeMgr::GetTopPhysVol(), G4GDMLReadStructure::GetWorldVolume(), G4AdjointCrossSurfChecker::GoingInOrOutOfaVolumeByExtSurface(), G4GDMLWriteParamvol::ParamvolAlgorithmWrite(), G4GDMLReadParamvol::ParamvolRead(), G4GDMLWriteParamvol::ParamvolWrite(), G4GDMLReadStructure::PhysvolRead(), G4GDMLWriteStructure::PhysvolWrite(), G4ReflectionFactory::Place(), G4LogicalVolumeStore::Register(), G4tgbVolumeMgr::RegisterMe(), G4RunManager::ReOptimize(), G4GDMLReadStructure::ReplicaRead(), G4ReflectionFactory::Replicate(), G4GDMLWriteStructure::ReplicavolWrite(), G4VoxelisationHelper::ReportVoxelInfo(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VoxelSafety::SafetyForVoxelHeader(), G4PolarizedAnnihilationModel::SampleSecondaries(), G4PolarizedComptonModel::SampleSecondaries(), G4Region::ScanVolumeTree(), G4VRadioactiveDecay::SelectAllVolumes(), G4VChannelingFastSimCrystalData::SetBendingAngle(), G4VChannelingFastSimCrystalData::SetCrystallineUndulatorParameters(), G4VChannelingFastSimCrystalData::SetCUParameters(), G4FieldBuilder::SetLocalField(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4VChannelingFastSimCrystalData::SetMiscutAngle(), G4VisCommandGeometryRestore::SetNewValue(), G4VUserDetectorConstruction::SetSensitiveDetector(), G4GDMLWriteSetup::SetupWrite(), G4PolarizationManager::SetVolumePolarization(), G4GDMLWriteStructure::SkinSurfaceCache(), G4GDMLRead::StripNames(), G4GDMLWriteStructure::TraverseVolumeTree(), and G4VoxelisationHelper::UndertakeOptimisation().

GetNoDaughters()

std::size_t G4LogicalVolume::GetNoDaughters ( ) const

inline

Returns the number of daughters (0 to n).

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4Region::BelongsTo(), G4PVPlacement::CheckOverlaps(), G4NormalNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4NormalNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4PhysicalVolumeModel::DescribeAndDescend(), G4LogicalVolumeModel::DescribeYourselfTo(), G4DrawVoxels::DrawVoxels(), G4Mesh::G4Mesh(), G4PVReplica(), G4SmartVoxelHeader::G4SmartVoxelHeader(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4Region::ScanVolumeTree(), SetFieldManager(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4GeomTestVolume::TestOverlapInTree(), G4GeomTestVolume::TestRecursiveOverlap(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetRegion()

G4Region * G4LogicalVolume::GetRegion ( ) const

inline

Returns the region to which the volume belongs, if any.

Referenced by G4Region::AddRootLogicalVolume(), G4Region::BelongsTo(), G4RunManagerKernel::CheckRegions(), G4RunManagerKernel::DefineWorldVolume(), G4VFieldModel::DescribeYourselfTo(), G4GDMLWriteStructure::ExportEnergyCuts(), G4PropagatorInField::FindAndSetFieldManager(), G4CoherentPairProduction::GetMeanFreePath(), G4ElNeutrinoNucleusProcess::GetMeanFreePath(), G4MuNeutrinoNucleusProcess::GetMeanFreePath(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4NuVacOscProcess::GetMeanFreePath(), G4TauNeutrinoNucleusProcess::GetMeanFreePath(), G4VTransitionRadiation::GetMeanFreePath(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4NuVacOscProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4VTransitionRadiation::PostStepDoIt(), G4LowECapture::PostStepGetPhysicalInteractionLength(), G4GlobalFastSimulationManager::ShowSetup(), G4ParallelWorldProcess::SwitchMaterial(), and G4MSSteppingAction::UserSteppingAction().

GetSensitiveDetector()

G4VSensitiveDetector * G4LogicalVolume::GetSensitiveDetector

(

)

const

Gets and sets the current sensitive detector (can be a null pointer).

Definition at line 473 of file G4LogicalVolume.cc.

{
  return G4MT_sdetector;
}

Referenced by G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4ITTransportation::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VUserDetectorConstruction::SetSensitiveDetector(), and G4Transportation::SetTouchableInformation().

GetSmartless()

G4double G4LogicalVolume::GetSmartless ( ) const

inline

Gets and sets the user defined optimisation quality associated to the volume.

GetSolid() [1/2]

G4VSolid * G4LogicalVolume::GetSolid

(

)

const

Gets and sets the current solid.

Definition at line 417 of file G4LogicalVolume.cc.

{
  return this->GetSolid( subInstanceManager.offset[instanceID] ); 
}

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), G4PseudoScene::AddCompound(), G4VSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddSolid(), G4ReplicaNavigation::BackLocate(), G4PhantomParameterisation::BuildContainerSolid(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4GeometryWorkspace::CloneReplicaSolid(), G4NormalNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4VoxelNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4PhantomParameterisation::ComputeSolid(), G4VNestedParameterisation::ComputeSolid(), G4VPVParameterisation::ComputeSolid(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4Navigator::ComputeStep(), G4NormalNavigation::ComputeStep(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4RegularNavigation::ComputeStepSkippingEqualMaterials(), G4tgbVolume::ConstructG4PhysVol(), G4TheRayTracer::CreateBitMap(), G3Division::CreatePVReplica(), G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4ChannelingFastSimModel::DoIt(), G4VisManager::Draw(), G4tgbGeometryDumper::DumpLogVol(), G4Navigator::GetGlobalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), GetMass(), G4ITTransportationManager::GetParallelWorld(), G4TransportationManager::GetParallelWorld(), GetSolid(), G4BOptnForceCommonTruncatedExp::Initialize(), G4ChannelingFastSimModel::ModelTrigger(), G4GDMLWriteParamvol::ParametersWrite(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4NavigationLogger::PreComputeStepLog(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), G4PSSphereSurfaceFlux::ProcessHits(), G4PSVolumeFlux::ProcessHits(), G4ITNavigator2::RecheckDistanceToCurrentBoundary(), G4NavigationLogger::ReportOutsideMother(), G4NavigationLogger::ReportVolumeAndIntersection(), G4VoxelSafety::SafetyForVoxelHeader(), G4VoxelSafety::SafetyForVoxelNode(), G4VChannelingFastSimCrystalData::SetBendingAngle(), G4VisCommandsTouchable::SetNewValue(), G4GeomTestVolume::TestOverlapInTree(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetSolid() [2/2]

G4VSolid * G4LogicalVolume::GetSolid ( G4LVData & instLVdata )

static

Optimised methods, passing thread instance of worker data.

Definition at line 412 of file G4LogicalVolume.cc.

{
  return instLVdata.fSolid;
}

GetSubInstanceManager()

const G4LVManager & G4LogicalVolume::GetSubInstanceManager ( )

static

Returns the private data instance manager.

Definition at line 226 of file G4LogicalVolume.cc.

{
  return subInstanceManager;
}

Referenced by G4GeometryWorkspace::G4GeometryWorkspace().

GetUserLimits()

G4UserLimits * G4LogicalVolume::GetUserLimits ( ) const

inline

Gets and sets the current User Limits.

Referenced by G4MaxTimeCuts::PostStepGetPhysicalInteractionLength(), G4MinEkineCuts::PostStepGetPhysicalInteractionLength(), G4StepLimiter::PostStepGetPhysicalInteractionLength(), and G4UserSpecialCuts::PostStepGetPhysicalInteractionLength().

GetVisAttributes()

const G4VisAttributes * G4LogicalVolume::GetVisAttributes

(

)

const

Accessor and modifiers for visualization attributes. Arguments are converted to shared_ptr.

Referenced by G4PhysicalVolumeModel::DescribeAndDescend(), G4BuildGeom(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4VisCommandGeometryRestore::SetNewValue(), and G4VSceneHandler::StandardSpecialMeshRendering().

GetVoxelHeader()

G4SmartVoxelHeader * G4LogicalVolume::GetVoxelHeader ( ) const

inline

Gets and sets the current Voxel Header.

Referenced by G4ITNavigator1::ComputeSafety(), G4ITNavigator2::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4Navigator::ComputeStep(), G4DrawVoxels::CreatePlacedPolyhedra(), G4ParameterisedNavigation::LevelLocate(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4ITNavigator1::LocateGlobalPointWithinVolume(), G4ITNavigator2::LocateGlobalPointWithinVolume(), G4SafetyCalculator::QuickLocateWithinVolume(), G4RunManager::ReOptimize(), G4VoxelisationHelper::ReportVoxelInfo(), G4SafetyCalculator::SafetyInCurrentVolume(), and G4VoxelisationHelper::UndertakeOptimisation().

InitialiseWorker()

void G4LogicalVolume::InitialiseWorker	(	G4LogicalVolume *	ptrMasterObject,
		G4VSolid *	pSolid,
		G4VSensitiveDetector *	pSDetector )

This method is similar to the constructor. It is used by each worker thread to achieve the partial effect as that of the master thread.

Definition at line 168 of file G4LogicalVolume.cc.

{
  subInstanceManager.SlaveCopySubInstanceArray();
 
  SetSolid(pSolid);
  SetSensitiveDetector(pSDetector); //  How this object is available now ?
  AssignFieldManager(fFieldManager);
   // Should be set - but a per-thread copy is not available yet
   // Must not call SetFieldManager(), which propagates FieldMgr
 
#ifdef CLONE_FIELD_MGR
  // Create a field FieldManager by cloning
  //
  G4FieldManager workerFldMgr = fFieldManager->GetWorkerClone(G4bool* created);
  if( created || (GetFieldManager() != workerFldMgr) )
  {
    SetFieldManager(fFieldManager, false); // which propagates FieldMgr
  }
  else
  {
    // Field manager existed and is equal to current one
    //
    AssignFieldManager(workerFldMgr);
  }
#endif
}

Referenced by G4GeometryWorkspace::CloneReplicaSolid(), and G4GeometryWorkspace::InitialisePhysicalVolumes().

IsAncestor()

G4bool G4LogicalVolume::IsAncestor

(

const G4VPhysicalVolume *

p

)

const

Returns true if the volume 'p' is part of the hierarchy of volumes established by the current logical volume. Scans recursively the volume tree.

Definition at line 514 of file G4LogicalVolume.cc.

{
  G4bool isDaughter = IsDaughter(aVolume);
  if (!isDaughter)
  {
    for (const auto & daughter : fDaughters)
    {
      isDaughter = daughter->GetLogicalVolume()->IsAncestor(aVolume);
      if (isDaughter) { break; }
    }
  }
  return isDaughter;
}

IsDaughter()

G4bool G4LogicalVolume::IsDaughter ( const G4VPhysicalVolume * p ) const

inline

Returns true if the volume 'p' is a daughter of the current logical volume.

Referenced by IsAncestor().

IsExtended()

G4bool G4LogicalVolume::IsExtended ( ) const

virtual

Returns true if it is not a base-class object.

Reimplemented in G4LogicalCrystalVolume.

Definition at line 254 of file G4LogicalVolume.cc.

{
  return false;
}

IsRegion()

G4bool G4LogicalVolume::IsRegion ( ) const

inline

Replies if the logical volume is part of a cuts region or not.

IsRootRegion()

G4bool G4LogicalVolume::IsRootRegion ( ) const

inline

Replies if the logical volume represents a root region or not.

Referenced by G4Region::AddRootLogicalVolume(), and G4Region::ScanVolumeTree().

IsToOptimise()

G4bool G4LogicalVolume::IsToOptimise ( ) const

inline

Replies if the geometry optimisation (voxelisation) is to be applied for this volume hierarchy.

Lock()

void G4LogicalVolume::Lock ( )

inline

Sets lock identifier for final deletion of entity.

operator=()

G4LogicalVolume & G4LogicalVolume::operator= ( const G4LogicalVolume & )

delete

operator==()

G4bool G4LogicalVolume::operator==

(

const G4LogicalVolume &

lv

)

const

Equality defined by address only. Returns true if objects are at same address, else false.

PropagateRegion()

void G4LogicalVolume::PropagateRegion ( )

inline

Propagates region pointer to daughters.

Referenced by AddDaughter().

RemoveDaughter()

void G4LogicalVolume::RemoveDaughter

(

const G4VPhysicalVolume *

p

)

Removes the volume 'p' from the list of daughters of the current logical volume.

Definition at line 368 of file G4LogicalVolume.cc.

{
  for (auto i=fDaughters.cbegin(); i!=fDaughters.cend(); ++i )
  {
    if (**i==*p)
    {
      fDaughters.erase(i);
      break;
    }
  }
  if (fRegion != nullptr)
  {
    fRegion->RegionModified(true);
  }
  G4MT_mass = 0.;
}

Referenced by G4PhysicalVolumeStore::DeRegister().

ResetMass()

void G4LogicalVolume::ResetMass

(

)

Resets the cached value of mass. Ensures that cached value of mass is invalidated due to change in state, e.g. change of the size of the solid, change of the type of solid, or the addition/deletion of a daughter volume.

Definition at line 403 of file G4LogicalVolume.cc.

{
  G4MT_mass= 0.0;
}

Referenced by SetSolid().

SetBiasWeight()

void G4LogicalVolume::SetBiasWeight ( G4double w )

inline

Sets and gets the bias weight.

SetFieldManager()

void G4LogicalVolume::SetFieldManager	(	G4FieldManager *	pFieldMgr,
		G4bool	forceToAllDaughters )

Sets the Field Manager and propagates it.

Parameters

[in]	pFieldMgr	Pointer to the field manager.
[in]	forceToAllDaughters	Flag to force propagation to all daughters (true), or only to daughters having null pointer to the field manager (false).

Definition at line 264 of file G4LogicalVolume.cc.

{
  AssignFieldManager(pNewFieldMgr);
 
  auto NoDaughters = GetNoDaughters();
  while ( (NoDaughters--)>0 )
  {
    G4LogicalVolume* DaughterLogVol; 
    DaughterLogVol = GetDaughter(NoDaughters)->GetLogicalVolume();
    if ( forceAllDaughters || (DaughterLogVol->GetFieldManager() == nullptr) )
    {
      DaughterLogVol->SetFieldManager(pNewFieldMgr, forceAllDaughters);
    }
  }
}

Referenced by AddDaughter(), G4LogicalVolume(), InitialiseWorker(), SetFieldManager(), and G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster().

SetMaterial()

void G4LogicalVolume::SetMaterial

(

G4Material *

pMaterial

)

Definition at line 452 of file G4LogicalVolume.cc.

{
  G4MT_material = pMaterial;
  G4MT_mass = 0.0;
}

Referenced by G4LogicalVolume(), and G4ScoreSplittingProcess::PostStepDoIt().

SetMaterialCutsCouple()

void G4LogicalVolume::SetMaterialCutsCouple

(

G4MaterialCutsCouple *

cuts

)

Definition at line 501 of file G4LogicalVolume.cc.

{
  G4MT_ccouple = cuts;
}

SetName()

void G4LogicalVolume::SetName

(

const G4String &

pName

)

Definition at line 152 of file G4LogicalVolume.cc.

{
  fName = pName;
  G4LogicalVolumeStore::GetInstance()->SetMapValid(false);
}

Referenced by G4LogicalVolume(), and G4GDMLRead::StripNames().

SetOptimisation()

void G4LogicalVolume::SetOptimisation ( G4bool optim )

inline

Specifies if to apply or not geometry optimisation to the volume hierarchy. For parameterised volumes in the hierarchy, optimisation is always applied.

SetRegion()

void G4LogicalVolume::SetRegion ( G4Region * reg )

inline

Sets/unsets the volume as cuts region.

Referenced by G4RunManagerKernel::CheckRegions(), G4RunManagerKernel::DefineWorldVolume(), and G4Region::ScanVolumeTree().

SetRegionRootFlag()

void G4LogicalVolume::SetRegionRootFlag ( G4bool rreg )

inline

Sets/unsets the volume as a root region for cuts.

Referenced by G4Region::AddRootLogicalVolume(), and G4Region::RemoveRootLogicalVolume().

SetSensitiveDetector()

void G4LogicalVolume::SetSensitiveDetector

(

G4VSensitiveDetector *

pSDetector

)

Definition at line 482 of file G4LogicalVolume.cc.

{
  G4MT_sdetector = pSDetector;
  if (G4Threading::IsMasterThread())  { fSensitiveDetector = pSDetector; }
}

Referenced by G4LogicalVolume(), G4LogicalVolume(), InitialiseWorker(), G4VUserDetectorConstruction::SetSensitiveDetector(), G4VUserParallelWorld::SetSensitiveDetector(), and G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster().

SetSmartless()

void G4LogicalVolume::SetSmartless ( G4double s )

inline

SetSolid() [1/2]

void G4LogicalVolume::SetSolid ( G4LVData & instLVdata, G4VSolid * pSolid )

static

Definition at line 433 of file G4LogicalVolume.cc.

{  
  instLVdata.fSolid = pSolid;
  instLVdata.fMass = 0.0;
}

SetSolid() [2/2]

void G4LogicalVolume::SetSolid

(

G4VSolid *

pSolid

)

Definition at line 426 of file G4LogicalVolume.cc.

{
 
  G4MT_solid = pSolid;
  this->ResetMass(); 
}

Referenced by G4LogicalVolume(), G4ITNavigator1::GetMotherToDaughterTransform(), G4ITNavigator2::GetMotherToDaughterTransform(), G4Navigator::GetMotherToDaughterTransform(), InitialiseWorker(), G4ParameterisedNavigation::LevelLocate(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4ITNavigator1::SetupHierarchy(), G4ITNavigator2::SetupHierarchy(), and G4Navigator::SetupHierarchy().

SetUserLimits()

void G4LogicalVolume::SetUserLimits ( G4UserLimits * pULimits )

inline

Referenced by G4LogicalVolume().

SetVisAttributes() [1/2]

void G4LogicalVolume::SetVisAttributes

(

const G4VisAttributes &

VA

)

Definition at line 682 of file G4LogicalVolume.cc.

{
  if (G4Threading::IsWorkerThread()) { return; }
  fVisAttributes = std::make_shared<const G4VisAttributes>(VA);
}

SetVisAttributes() [2/2]

void G4LogicalVolume::SetVisAttributes

(

const G4VisAttributes *

pVA

)

Definition at line 692 of file G4LogicalVolume.cc.

{
  if (G4Threading::IsWorkerThread()) { return; }
  fVisAttributes = std::shared_ptr<const G4VisAttributes>(pVA,[](const G4VisAttributes*){});
}

Referenced by G4tgbVolume::ConstructG4LogVol(), G4BuildGeom(), G4GDMLReadStructure::GetWorldVolume(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4VisCommandGeometryRestore::SetNewValue(), G4ScoringBox::SetupGeometry(), and G4ScoringCylinder::SetupGeometry().

SetVoxelHeader()

void G4LogicalVolume::SetVoxelHeader ( G4SmartVoxelHeader * pVoxel )

inline

Referenced by G4RunManager::ReOptimize(), and G4VoxelisationHelper::UndertakeOptimisation().

TerminateWorker()

void G4LogicalVolume::TerminateWorker

(

G4LogicalVolume *

ptrMasterObject

)

This method is similar to the destructor. It is used by each worker thread to achieve the partial effect as that of the master thread.

Definition at line 215 of file G4LogicalVolume.cc.

{
}

Referenced by G4GeometryWorkspace::DestroyWorkspace().

TotalVolumeEntities()

G4int G4LogicalVolume::TotalVolumeEntities

(

)

const

Returns the total number of physical volumes (replicated or placed) in the tree represented by the current logical volume.

Definition at line 535 of file G4LogicalVolume.cc.

{
  G4int vols = 1;
  for (auto physDaughter : fDaughters)
  {
    vols += physDaughter->GetMultiplicity()
           *physDaughter->GetLogicalVolume()->TotalVolumeEntities();
  }
  return vols;
}

UpdateMaterial()

void G4LogicalVolume::UpdateMaterial

(

G4Material *

pMaterial

)

Sets the material and corresponding Material-Cuts-Couple. This method is invoked by G4Navigator while it is navigating through material parameterisation.

Definition at line 462 of file G4LogicalVolume.cc.

{
  G4MT_material=pMaterial;
  if (fRegion != nullptr) { G4MT_ccouple = fRegion->FindCouple(pMaterial); }
  G4MT_mass = 0.0;
}

Referenced by G4ParameterisedNavigation::LevelLocate(), G4RegularNavigation::LevelLocate(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4ITNavigator1::SetupHierarchy(), G4ITNavigator2::SetupHierarchy(), and G4Navigator::SetupHierarchy().

---

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

• G4LogicalVolume.hh
• G4LogicalVolume.cc