G4LogicalVolume Class Reference

#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
	G4LogicalVolume (__void__ &)
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)

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

Definition at line 182 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
	)

Definition at line 68 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);
}

~G4LogicalVolume()

G4LogicalVolume::~G4LogicalVolume ( )

virtual

Definition at line 134 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

G4LogicalVolume() [3/3]

G4LogicalVolume::G4LogicalVolume

(

__void__ &

)

Definition at line 113 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

)

Definition at line 281 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)
  {
    PropagateRegion();
    fRegion->RegionModified(true);
  }
}

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

AssignFieldManager()

void G4LogicalVolume::AssignFieldManager

(

G4FieldManager *

fldMgr

)

Definition at line 240 of file G4LogicalVolume.cc.

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

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

ChangeDaughtersType()

G4bool G4LogicalVolume::ChangeDaughtersType

(

EVolume

atype

)

Definition at line 654 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

Referenced by G4ITNavigator2::RecheckDistanceToCurrentBoundary().

Clean()

void G4LogicalVolume::Clean ( )

static

Definition at line 198 of file G4LogicalVolume.cc.

{
  subInstanceManager.FreeSlave();
}

Referenced by G4LogicalVolumeStore::~G4LogicalVolumeStore().

ClearDaughters()

void G4LogicalVolume::ClearDaughters

(

)

Definition at line 385 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

Referenced by ChangeDaughtersType().

GetBiasWeight()

G4double G4LogicalVolume::GetBiasWeight ( ) const

inline

GetDaughter()

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

inline

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

GetFastSimulationManager()

G4FastSimulationManager * G4LogicalVolume::GetFastSimulationManager ( ) const

inline

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

GetFieldManager()

G4FieldManager * G4LogicalVolume::GetFieldManager

(

)

const

Definition at line 231 of file G4LogicalVolume.cc.

{
  return G4MT_fmanager;
}

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

GetInstanceID()

G4int G4LogicalVolume::GetInstanceID ( ) const

inline

GetMass()

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

Definition at line 562 of file G4LogicalVolume.cc.

{
  // Return the cached non-zero value, if not forced
  //
  if ( (G4MT_mass) && (!forced) )  { return G4MT_mass; }
 
  // Global density and computed mass associated to the logical
  // volume without considering its daughters
  //
  G4Material* logMaterial = parMaterial ? 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 (auto itDau = fDaughters.cbegin(); itDau != fDaughters.cend(); ++itDau)
  {
    G4VPhysicalVolume* physDaughter = (*itDau);
    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)
      {
        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

Referenced by G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster().

GetMasterSensitiveDetector()

G4VSensitiveDetector * G4LogicalVolume::GetMasterSensitiveDetector ( ) const

inline

Referenced by G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster().

GetMasterSolid()

G4VSolid * G4LogicalVolume::GetMasterSolid ( ) const

inline

Referenced by G4GeometryWorkspace::InitialisePhysicalVolumes().

GetMaterial()

G4Material * G4LogicalVolume::GetMaterial

(

)

const

Definition at line 439 of file G4LogicalVolume.cc.

{
  return G4MT_material;
}

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

GetMaterialCutsCouple()

const G4MaterialCutsCouple * G4LogicalVolume::GetMaterialCutsCouple

(

)

const

Definition at line 488 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

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), AddDaughter(), G4OpenInventorSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddSolid(), G4VBiasingOperator::AttachTo(), G4SmartVoxelHeader::BuildNodes(), G4SmartVoxelHeader::BuildReplicaVoxels(), G4SmartVoxelHeader::BuildVoxelsWithinLimits(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), checkVol(), G4tgbVolume::ConstructG4LogVol(), G4tgbVolume::ConstructG4PhysVol(), G4tgbVolume::ConstructG4Volumes(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G3Division::CreatePVReplica(), G4AdjointCrossSurfChecker::CrossingAnInterfaceBetweenTwoVolumes(), G4Radioactivation::DecayIt(), G4RadioactiveDecay::DecayIt(), G4RunManagerKernel::DefineWorldVolume(), G4LogicalVolumeStore::DeRegister(), G4ReflectionFactory::Divide(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLWriteStructure::DivisionvolWrite(), G4TrajectoryDrawByOriginVolume::Draw(), G4tgbVolumeMgr::DumpG4LogVolLeaf(), G4tgbGeometryDumper::DumpLogVol(), G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVParameterised(), G4tgbGeometryDumper::DumpPVPlacement(), G4tgbGeometryDumper::DumpPVReplica(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4BuildGeom(), G4PVReplica::G4PVReplica(), G4GDMLRead::GeneratePhysvolName(), G4Navigator::GetLocalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), 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(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VoxelSafety::SafetyForVoxelHeader(), G4PolarizedAnnihilationModel::SampleSecondaries(), G4PolarizedComptonModel::SampleSecondaries(), G4Region::ScanVolumeTree(), G4RadioactiveDecay::SelectAllVolumes(), G4VVisCommandGeometrySet::Set(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4VisCommandGeometryList::SetNewValue(), G4VisCommandGeometryRestore::SetNewValue(), G4VUserDetectorConstruction::SetSensitiveDetector(), G4GDMLWriteSetup::SetupWrite(), G4PolarizationManager::SetVolumePolarization(), G4GDMLWriteStructure::SkinSurfaceCache(), G4GDMLRead::StripNames(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetNoDaughters()

std::size_t G4LogicalVolume::GetNoDaughters ( ) const

inline

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

GetRegion()

G4Region * G4LogicalVolume::GetRegion ( ) const

inline

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

GetSensitiveDetector()

G4VSensitiveDetector * G4LogicalVolume::GetSensitiveDetector

(

)

const

Definition at line 469 of file G4LogicalVolume.cc.

{
  return G4MT_sdetector;
}

Referenced by G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4LogicalVolumeModel::DescribeYourselfTo(), G4GDMLWriteStructure::ExportSD(), G4VReadOutGeometry::FindROTouchable(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4ITTransportation::PostStepDoIt(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VUserDetectorConstruction::SetSensitiveDetector(), G4Transportation::SetTouchableInformation(), and G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster().

GetSmartless()

G4double G4LogicalVolume::GetSmartless ( ) const

inline

Referenced by G4SmartVoxelHeader::BuildNodes().

GetSolid() [1/2]

G4VSolid * G4LogicalVolume::GetSolid

(

)

const

Definition at line 413 of file G4LogicalVolume.cc.

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

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

GetSolid() [2/2]

G4VSolid * G4LogicalVolume::GetSolid ( G4LVData &  instLVdata )

static

Definition at line 408 of file G4LogicalVolume.cc.

{
  return instLVdata.fSolid;
}

GetSubInstanceManager()

const G4LVManager & G4LogicalVolume::GetSubInstanceManager ( )

static

Definition at line 222 of file G4LogicalVolume.cc.

{
  return subInstanceManager;
}

Referenced by G4GeometryWorkspace::G4GeometryWorkspace().

GetUserLimits()

G4UserLimits * G4LogicalVolume::GetUserLimits ( ) const

inline

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

GetVisAttributes()

const G4VisAttributes * G4LogicalVolume::GetVisAttributes

(

)

const

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

GetVoxelHeader()

G4SmartVoxelHeader * G4LogicalVolume::GetVoxelHeader ( ) const

inline

Referenced by G4Navigator::ComputeSafety(), G4ITNavigator1::ComputeSafety(), G4ITNavigator2::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4Navigator::ComputeStep(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4DrawVoxels::CreatePlacedPolyhedra(), G4LogicalVolumeModel::DescribeYourselfTo(), G4ParameterisedNavigation::LevelLocate(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointWithinVolume(), G4ITNavigator1::LocateGlobalPointWithinVolume(), G4ITNavigator2::LocateGlobalPointWithinVolume(), and G4RunManager::ReOptimize().

InitialiseWorker()

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

Definition at line 164 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

Definition at line 510 of file G4LogicalVolume.cc.

{
  G4bool isDaughter = IsDaughter(aVolume);
  if (!isDaughter)
  {
    for (auto itDau = fDaughters.cbegin(); itDau != fDaughters.cend(); ++itDau)
    {
      isDaughter = (*itDau)->GetLogicalVolume()->IsAncestor(aVolume);
      if (isDaughter)  break;
    }
  }
  return isDaughter;
}

IsDaughter()

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

inline

Referenced by IsAncestor().

IsExtended()

G4bool G4LogicalVolume::IsExtended ( ) const

virtual

Reimplemented in G4LogicalCrystalVolume.

Definition at line 250 of file G4LogicalVolume.cc.

{
  return false;
}

IsRegion()

G4bool G4LogicalVolume::IsRegion ( ) const

inline

IsRootRegion()

G4bool G4LogicalVolume::IsRootRegion ( ) const

inline

Referenced by G4PhysicalVolumeModel::CreateCurrentAttValues(), and G4Region::ScanVolumeTree().

IsToOptimise()

G4bool G4LogicalVolume::IsToOptimise ( ) const

inline

Lock()

void G4LogicalVolume::Lock ( )

inline

operator=()

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

delete

operator==()

G4bool G4LogicalVolume::operator==

(

const G4LogicalVolume &

lv

)

const

PropagateRegion()

void G4LogicalVolume::PropagateRegion ( )

inline

Referenced by AddDaughter().

RemoveDaughter()

void G4LogicalVolume::RemoveDaughter

(

const G4VPhysicalVolume *

p

)

Definition at line 364 of file G4LogicalVolume.cc.

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

Referenced by G4PhysicalVolumeStore::DeRegister().

ResetMass()

void G4LogicalVolume::ResetMass

(

)

Definition at line 399 of file G4LogicalVolume.cc.

{
  G4MT_mass= 0.0;
}

Referenced by SetSolid().

SetBiasWeight()

void G4LogicalVolume::SetBiasWeight ( G4double  w )

inline

SetFieldManager()

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

Definition at line 260 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(), G4VUserDetectorConstruction::CloneF(), G4LogicalVolume(), InitialiseWorker(), SetFieldManager(), and G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster().

SetMaterial()

void G4LogicalVolume::SetMaterial

(

G4Material *

pMaterial

)

Definition at line 448 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 497 of file G4LogicalVolume.cc.

{
  G4MT_ccouple = cuts;
}

SetName()

void G4LogicalVolume::SetName

(

const G4String &

pName

)

Definition at line 148 of file G4LogicalVolume.cc.

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

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

SetOptimisation()

void G4LogicalVolume::SetOptimisation ( G4bool  optim )

inline

SetRegion()

void G4LogicalVolume::SetRegion ( G4Region *  reg )

inline

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

SetRegionRootFlag()

void G4LogicalVolume::SetRegionRootFlag ( G4bool  rreg )

inline

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

SetSensitiveDetector()

void G4LogicalVolume::SetSensitiveDetector

(

G4VSensitiveDetector *

pSDetector

)

Definition at line 478 of file G4LogicalVolume.cc.

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

Referenced by G4VUserDetectorConstruction::CloneSD(), G4LogicalVolume(), InitialiseWorker(), G4VUserDetectorConstruction::SetSensitiveDetector(), G4VUserParallelWorld::SetSensitiveDetector(), G4ScoringProbe::SetupGeometry(), G4ScoringRealWorld::SetupGeometry(), G4ScoringBox::SetupGeometry(), G4ScoringCylinder::SetupGeometry(), G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster(), and G4VScoringMesh::WorkerConstruct().

SetSmartless()

void G4LogicalVolume::SetSmartless ( G4double  s )

inline

SetSolid() [1/2]

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

static

Definition at line 429 of file G4LogicalVolume.cc.

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

SetSolid() [2/2]

void G4LogicalVolume::SetSolid

(

G4VSolid *

pSolid

)

Definition at line 422 of file G4LogicalVolume.cc.

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

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

SetUserLimits()

void G4LogicalVolume::SetUserLimits ( G4UserLimits *  pULimits )

inline

Referenced by G4LogicalVolume().

SetVisAttributes() [1/2]

void G4LogicalVolume::SetVisAttributes

(

const G4VisAttributes &

VA

)

Definition at line 680 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 690 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(), G4ScoringProbe::SetupGeometry(), G4ScoringBox::SetupGeometry(), and G4ScoringCylinder::SetupGeometry().

SetVoxelHeader()

void G4LogicalVolume::SetVoxelHeader ( G4SmartVoxelHeader *  pVoxel )

inline

Referenced by G4RunManager::ReOptimize().

TerminateWorker()

void G4LogicalVolume::TerminateWorker

(

G4LogicalVolume *

ptrMasterObject

)

Definition at line 211 of file G4LogicalVolume.cc.

{
}

Referenced by G4GeometryWorkspace::DestroyWorkspace().

TotalVolumeEntities()

G4int G4LogicalVolume::TotalVolumeEntities

(

)

const

Definition at line 531 of file G4LogicalVolume.cc.

{
  G4int vols = 1;
  for (auto itDau = fDaughters.cbegin(); itDau != fDaughters.cend(); ++itDau)
  {
    G4VPhysicalVolume* physDaughter = (*itDau);
    vols += physDaughter->GetMultiplicity()
           *physDaughter->GetLogicalVolume()->TotalVolumeEntities();
  }
  return vols;
}

Referenced by TotalVolumeEntities().

UpdateMaterial()

void G4LogicalVolume::UpdateMaterial

(

G4Material *

pMaterial

)

Definition at line 458 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(), G4Navigator::SetupHierarchy(), G4ITNavigator1::SetupHierarchy(), and G4ITNavigator2::SetupHierarchy().

---

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

• G4LogicalVolume.hh
• G4LogicalVolume.cc