#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 != nullptr)
  {
    PropagateRegion();
    fRegion->RegionModified(true);
  }
}

Referenced by G4PVDivision::G4PVDivision(), G4PVDivision::G4PVDivision(), G4PVDivision::G4PVDivision(), G4PVDivision::G4PVDivision(), G4PVParameterised::G4PVParameterised(), G4PVParameterised::G4PVParameterised(), G4PVPlacement::G4PVPlacement(), G4PVPlacement::G4PVPlacement(), G4PVPlacement::G4PVPlacement(), 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 G4SafetyCalculator::CharacteriseDaughters(), and 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

◆ 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(), and SetFieldManager().

◆ GetInstanceID()

G4int G4LogicalVolume::GetInstanceID ( ) const

inline

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

◆ 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) != 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 (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 != 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

◆ GetMasterSensitiveDetector()

G4VSensitiveDetector * G4LogicalVolume::GetMasterSensitiveDetector ( ) const

inline

Referenced by G4GDMLWriteStructure::ExportSD().

◆ 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(), G4XrayReflection::GetMeanFreePath(), G4LatticeManager::LoadLattice(), G4ITTransportation::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4VXTRenergyLoss::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(), G4Region::AddRootLogicalVolume(), 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(), G4ReflectionFactory::Divide(), G4ReflectionFactory::Divide(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLWriteStructure::DivisionvolWrite(), G4TrajectoryDrawByOriginVolume::Draw(), G4tgbVolumeMgr::DumpG4LogVolLeaf(), G4LogicalSkinSurface::DumpInfo(), G4tgbGeometryDumper::DumpLogVol(), G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVParameterised(), G4tgbGeometryDumper::DumpPVPlacement(), G4tgbGeometryDumper::DumpPVReplica(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4BuildGeom(), G4PVReplica::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(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VoxelSafety::SafetyForVoxelHeader(), G4PolarizedAnnihilationModel::SampleSecondaries(), G4PolarizedComptonModel::SampleSecondaries(), G4Region::ScanVolumeTree(), G4RadioactiveDecay::SelectAllVolumes(), G4VVisCommandGeometrySet::Set(), G4VChannelingFastSimCrystalData::SetBendingAngle(), G4VChannelingFastSimCrystalData::SetCrystallineUndulatorParameters(), G4VChannelingFastSimCrystalData::SetCUParameters(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4VChannelingFastSimCrystalData::SetMiscutAngle(), 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(), G4NormalNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4PhysicalVolumeModel::DescribeAndDescend(), G4LogicalVolumeModel::DescribeYourselfTo(), G4DrawVoxels::DrawVoxels(), G4Mesh::G4Mesh(), G4PVReplica::G4PVReplica(), G4SmartVoxelHeader::G4SmartVoxelHeader(), G4SafetyCalculator::GetDaughtersRegularStructureId(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4Region::ScanVolumeTree(), SetFieldManager(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4GeomTestVolume::TestOverlapInTree(), G4GeomTestVolume::TestRecursiveOverlap(), and G4GDMLWriteStructure::TraverseVolumeTree().

◆ GetRegion()

G4Region * G4LogicalVolume::GetRegion ( ) const

inline

Referenced by G4Region::AddRootLogicalVolume(), G4Region::BelongsTo(), G4RunManagerKernel::CheckRegions(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4RunManagerKernel::DefineWorldVolume(), G4VFieldModel::DescribeYourselfTo(), G4GDMLWriteStructure::ExportEnergyCuts(), G4PropagatorInField::FindAndSetFieldManager(), 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(), 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(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4ITTransportation::PostStepDoIt(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VUserDetectorConstruction::SetSensitiveDetector(), and G4Transportation::SetTouchableInformation().

◆ 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(), G4PseudoScene::AddCompound(), G4VSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddSolid(), G4ReplicaNavigation::BackLocate(), G4PhantomParameterisation::BuildContainerSolid(), G4SmartVoxelHeader::BuildNodes(), G4SmartVoxelHeader::BuildReplicaVoxels(), G4SmartVoxelHeader::BuildVoxelsWithinLimits(), 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(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G3Division::CreatePVReplica(), G4AdjointPosOnPhysVolGenerator::DefinePhysicalVolume(), G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4ChannelingFastSimModel::DoIt(), G4VisManager::Draw(), G4tgbGeometryDumper::DumpLogVol(), G4RTPrimaryGeneratorAction::GeneratePrimaries(), G4Navigator::GetGlobalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), GetMass(), G4XrayReflection::GetMeanFreePath(), G4ITTransportationManager::GetParallelWorld(), G4TransportationManager::GetParallelWorld(), GetSolid(), G4BOptnForceCommonTruncatedExp::Initialize(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4ChannelingFastSimModel::ModelTrigger(), G4GDMLWriteParamvol::ParametersWrite(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4VXTRenergyLoss::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(), 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(), G4StepLimiter::PostStepGetPhysicalInteractionLength(), and G4UserSpecialCuts::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 G4ITNavigator1::ComputeSafety(), G4ITNavigator2::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4Navigator::ComputeStep(), G4DrawVoxels::CreatePlacedPolyhedra(), G4LogicalVolumeModel::DescribeYourselfTo(), G4ParameterisedNavigation::LevelLocate(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4ITNavigator1::LocateGlobalPointWithinVolume(), G4ITNavigator2::LocateGlobalPointWithinVolume(), G4SafetyCalculator::QuickLocateWithinVolume(), G4RunManager::ReOptimize(), and G4SafetyCalculator::SafetyInCurrentVolume().

◆ 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 G4Region::AddRootLogicalVolume(), 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 != nullptr)
  {
    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(), 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 G4LogicalVolume(), G4LogicalVolume(), InitialiseWorker(), G4VUserDetectorConstruction::SetSensitiveDetector(), G4VUserParallelWorld::SetSensitiveDetector(), G4ScoringBox::SetupGeometry(), G4ScoringCylinder::SetupGeometry(), G4ScoringProbe::SetupGeometry(), G4ScoringRealWorld::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(), 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 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(), G4ScoringBox::SetupGeometry(), G4ScoringCylinder::SetupGeometry(), and G4ScoringProbe::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.

213{

214}

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

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ G4LogicalVolume() [1/3]

◆ ~G4LogicalVolume()

◆ G4LogicalVolume() [2/3]

◆ G4LogicalVolume() [3/3]

Member Function Documentation

◆ AddDaughter()

◆ AssignFieldManager()

◆ ChangeDaughtersType()

◆ CharacteriseDaughters()

◆ Clean()

◆ ClearDaughters()

◆ DeduceDaughtersType()

◆ GetBiasWeight()

◆ GetDaughter()

◆ GetFastSimulationManager()

◆ GetFieldManager()

◆ GetInstanceID()

◆ GetMass()

◆ GetMasterFieldManager()

◆ GetMasterSensitiveDetector()

◆ GetMasterSolid()

◆ GetMaterial()

◆ GetMaterialCutsCouple()

◆ GetName()

◆ GetNoDaughters()

◆ GetRegion()

◆ GetSensitiveDetector()

◆ GetSmartless()

◆ GetSolid() [1/2]

◆ GetSolid() [2/2]

◆ GetSubInstanceManager()

◆ GetUserLimits()

◆ GetVisAttributes()

◆ GetVoxelHeader()

◆ InitialiseWorker()

◆ IsAncestor()

◆ IsDaughter()

◆ IsExtended()

◆ IsRegion()

◆ IsRootRegion()

◆ IsToOptimise()

◆ Lock()

◆ operator=()

◆ operator==()

◆ PropagateRegion()

◆ RemoveDaughter()

◆ ResetMass()

◆ SetBiasWeight()

◆ SetFieldManager()

◆ SetMaterial()

◆ SetMaterialCutsCouple()

◆ SetName()

◆ SetOptimisation()

◆ SetRegion()

◆ SetRegionRootFlag()

◆ SetSensitiveDetector()

◆ SetSmartless()

◆ SetSolid() [1/2]

◆ SetSolid() [2/2]

◆ SetUserLimits()

◆ SetVisAttributes() [1/2]

◆ SetVisAttributes() [2/2]

◆ SetVoxelHeader()

◆ TerminateWorker()

◆ TotalVolumeEntities()

◆ UpdateMaterial()