G4LogicalVolume Class Reference

#include <G4LogicalVolume.hh>

Inheritance diagram for G4LogicalVolume:

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

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

Private Types
using	G4PhysicalVolumeList = std::vector< G4VPhysicalVolume * >

Private Attributes
G4double	fBiasWeight = 1.0
G4PhysicalVolumeList	fDaughters
EVolume	fDaughtersVolumeType
G4FieldManager *	fFieldManager = nullptr
G4bool	fLock = false
G4String	fName
G4bool	fOptimise = true
G4Region *	fRegion = nullptr
G4bool	fRootRegion = false
G4VSensitiveDetector *	fSensitiveDetector = nullptr
G4double	fSmartless = 2.0
G4VSolid *	fSolid = nullptr
G4UserLimits *	fUserLimits = nullptr
const G4VisAttributes *	fVisAttributes = nullptr
G4SmartVoxelHeader *	fVoxel = nullptr
G4int	instanceID
G4LVData *	lvdata = nullptr

Static Private Attributes
static G4GEOM_DLL G4LVManager	subInstanceManager

Detailed Description

Definition at line 181 of file G4LogicalVolume.hh.

Member Typedef Documentation

G4PhysicalVolumeList

using G4LogicalVolume::G4PhysicalVolumeList = std::vector<G4VPhysicalVolume *>

private

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

References AssignFieldManager(), G4GeomSplitter< T >::CreateSubInstance(), fFieldManager, G4LVData::fMaterial, fSensitiveDetector, G4LVData::fSolid, fSolid, G4MT_ccouple, G4MT_mass, instanceID, lvdata, G4InuclParticleNames::name(), G4LogicalVolumeStore::Register(), SetMaterial(), SetName(), SetSensitiveDetector(), SetSolid(), SetUserLimits(), and subInstanceManager.

~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);
}

References G4LogicalVolumeStore::DeRegister(), fLock, fRegion, fRootRegion, lvdata, and G4Region::RemoveRootLogicalVolume().

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);
}

References G4GeomSplitter< T >::CreateSubInstance(), G4MT_ccouple, G4MT_mass, instanceID, G4LogicalVolumeStore::Register(), SetFieldManager(), SetSensitiveDetector(), and subInstanceManager.

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);
  }
}

References FatalException, fDaughters, fDaughtersVolumeType, fRegion, G4endl, G4Exception(), G4MT_fmanager, G4MT_mass, GetFieldManager(), G4VPhysicalVolume::GetLogicalVolume(), GetName(), G4VPhysicalVolume::GetName(), PropagateRegion(), G4Region::RegionModified(), SetFieldManager(), and G4VPhysicalVolume::VolumeType().

Referenced by G4ReplicatedSlice::CheckAndSetParameters(), export_G4LogicalVolume(), 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; }
}

References fFieldManager, G4MT_fmanager, and G4Threading::IsMasterThread().

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

ChangeDaughtersType()

G4bool G4LogicalVolume::ChangeDaughtersType

(

EVolume

atype

)

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

References DeduceDaughtersType(), fDaughtersVolumeType, and kExternal.

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();
}

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

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.;
}

References fDaughters, fRegion, G4MT_mass, and G4Region::RegionModified().

Referenced by export_G4LogicalVolume().

DeduceDaughtersType()

EVolume G4LogicalVolume::DeduceDaughtersType ( ) const

inline

Referenced by ChangeDaughtersType().

GetBiasWeight()

G4double G4LogicalVolume::GetBiasWeight ( ) const

inline

Referenced by G4ReflectionFactory::CreateReflectedLV(), and export_G4LogicalVolume().

GetDaughter()

G4VPhysicalVolume * G4LogicalVolume::GetDaughter ( const G4int  i ) const

inline

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

GetFastSimulationManager()

G4FastSimulationManager * G4LogicalVolume::GetFastSimulationManager ( ) const

inline

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

GetFieldManager()

G4FieldManager * G4LogicalVolume::GetFieldManager

(

)

const

Definition at line 231 of file G4LogicalVolume.cc.

{
  return G4MT_fmanager;
}

References G4MT_fmanager.

Referenced by AddDaughter(), G4ReflectionFactory::CreateReflectedLV(), G4VFieldModel::DescribeYourselfTo(), export_G4LogicalVolume(), 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;
}

References G4VSolid::ComputeDimensions(), G4VPVParameterisation::ComputeMaterial(), G4VPVParameterisation::ComputeSolid(), FatalException, fDaughters, fName, G4endl, G4Exception(), G4MT_mass, G4VSolid::GetCubicVolume(), G4Material::GetDensity(), G4VPhysicalVolume::GetLogicalVolume(), GetMass(), GetMaterial(), G4VPhysicalVolume::GetMultiplicity(), G4VPhysicalVolume::GetParameterisation(), and GetSolid().

Referenced by export_G4LogicalVolume(), 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;
}

References G4MT_material.

Referenced by G4Track::CalculateVelocityForOpticalPhoton(), G4AdjointPrimaryGenerator::ComputeAccumulatedDepthVectorAlongBackRay(), G4VPVParameterisation::ComputeMaterial(), G4ReflectionFactory::CreateReflectedLV(), G4PhysicalVolumeModel::DescribeYourselfTo(), G4tgbGeometryDumper::DumpLogVol(), export_G4LogicalVolume(), G4GDMLWriteStructure::ExportEnergyCuts(), G4LogicalCrystalVolume::GetCrystal(), GetMass(), G4Channeling::GetMatData(), G4LatticeManager::LoadLattice(), G4MicroElecSurface::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ITTransportation::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4Transportation::PostStepDoIt(), G4ErrorFreeTrajState::PropagateErrorIoni(), G4ErrorFreeTrajState::PropagateErrorMSC(), G4LatticeManager::RegisterLattice(), G4PropagatorInField::ReportLoopingParticle(), G4ProductionCutsTable::ScanAndSetCouple(), G4Region::ScanVolumeTree(), G4ParallelWorldProcess::SwitchMaterial(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetMaterialCutsCouple()

const G4MaterialCutsCouple * G4LogicalVolume::GetMaterialCutsCouple

(

)

const

Definition at line 488 of file G4LogicalVolume.cc.

{
  return G4MT_ccouple;
}

References G4MT_ccouple.

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

GetName()

const G4String & G4LogicalVolume::GetName ( ) const

inline

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), AddDaughter(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4OpenInventorSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddSolid(), G4VBiasingOperator::AttachTo(), G4SmartVoxelHeader::BuildNodes(), G4GeometryManager::BuildOptimisations(), G4SmartVoxelHeader::BuildReplicaVoxels(), G4SmartVoxelHeader::BuildVoxelsWithinLimits(), G4PVReplica::CheckOnlyDaughter(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), checkVol(), G4PolarizedAnnihilation::ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4tgbVolume::ConstructG4LogVol(), G4tgbVolume::ConstructG4PhysVol(), G4tgbVolume::ConstructG4Volumes(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G3Division::CreatePVReplica(), G4ReflectionFactory::CreateReflectedLV(), 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(), export_G4LogicalVolume(), G4GDMLParser::ExportRegions(), G4BuildGeom(), G4PVReplica::G4PVReplica(), G4GDMLRead::GeneratePhysvolName(), G4Navigator::GetLocalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4tgbGeometryDumper::GetPVChildren(), G4tgbVolumeMgr::GetTopLogVol(), G4tgbVolumeMgr::GetTopPhysVol(), G4GDMLReadStructure::GetWorldVolume(), G4AdjointCrossSurfChecker::GoingInOrOutOfaVolumeByExtSurface(), G4GDMLWriteParamvol::ParamvolAlgorithmWrite(), G4GDMLReadParamvol::ParamvolRead(), G4GDMLWriteParamvol::ParamvolWrite(), G4GDMLReadStructure::PhysvolRead(), G4GDMLWriteStructure::PhysvolWrite(), G4ReflectionFactory::Place(), G4ReflectionFactory::ReflectDaughters(), G4ReflectionFactory::ReflectPVDivision(), G4ReflectionFactory::ReflectPVPlacement(), G4ReflectionFactory::ReflectPVReplica(), 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()

size_t G4LogicalVolume::GetNoDaughters ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4Region::BelongsTo(), G4SmartVoxelHeader::BuildNodes(), G4GeometryManager::BuildOptimisations(), G4SmartVoxelHeader::BuildReplicaVoxels(), G4SmartVoxelHeader::BuildVoxels(), G4PVReplica::CheckOnlyDaughter(), G4PVPlacement::CheckOverlaps(), G4NormalNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4VoxelNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4NormalNavigation::ComputeStep(), G4DrawVoxels::ComputeVoxelPolyhedra(), G4GeometryManager::DeleteOptimisations(), G4PhysicalVolumeModel::DescribeAndDescend(), G4LogicalVolumeModel::DescribeYourselfTo(), G4DrawVoxels::DrawVoxels(), export_G4LogicalVolume(), G4Mesh::G4Mesh(), G4PVReplica::G4PVReplica(), G4SmartVoxelHeader::G4SmartVoxelHeader(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4AssemblyVolume::MakeImprint(), G4ReflectionFactory::ReflectDaughters(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4ProductionCutsTable::ScanAndSetCouple(), G4Region::ScanVolumeTree(), SetFieldManager(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4GeomTestVolume::TestOverlapInTree(), G4GeomTestVolume::TestRecursiveOverlap(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetRegion()

G4Region * G4LogicalVolume::GetRegion ( ) const

inline

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4Region::BelongsTo(), G4RunManagerKernel::CheckRegions(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4ReflectionFactory::CreateReflectedLV(), G4RunManagerKernel::DefineWorldVolume(), G4VFieldModel::DescribeYourselfTo(), G4GlobalFastSimulationManager::DisplayRegion(), export_G4LogicalVolume(), G4GDMLWriteStructure::ExportEnergyCuts(), G4PropagatorInField::FindAndSetFieldManager(), G4FastTrack::FRecordsAffineTransformation(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4ElNeutrinoNucleusProcess::GetMeanFreePath(), G4MuNeutrinoNucleusProcess::GetMeanFreePath(), G4VTransitionRadiation::GetMeanFreePath(), G4VEnergyLossProcess::IsRegionForCubcutProcessor(), G4NeutrinoElectronProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4VTransitionRadiation::PostStepDoIt(), G4LowECapture::PostStepGetPhysicalInteractionLength(), G4ReflectionFactory::ReflectLV(), G4ProductionCutsTable::ScanAndSetCouple(), 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;
}

References G4MT_sdetector.

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

GetSmartless()

G4double G4LogicalVolume::GetSmartless ( ) const

inline

Referenced by G4SmartVoxelHeader::BuildNodes(), and export_G4LogicalVolume().

GetSolid() [1/2]

G4VSolid * G4LogicalVolume::GetSolid

(

)

const

Definition at line 413 of file G4LogicalVolume.cc.

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

References GetSolid(), instanceID, G4GeomSplitter< T >::offset, and subInstanceManager.

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), G4VSceneHandler::AddCompound(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4GMocrenFileSceneHandler::AddSolid(), G4ReplicaNavigation::BackLocate(), G4PhantomParameterisation::BuildContainerSolid(), G4SmartVoxelHeader::BuildNodes(), G4SmartVoxelHeader::BuildReplicaVoxels(), G4SmartVoxelHeader::BuildVoxelsWithinLimits(), G4ReplicatedSlice::CheckAndSetParameters(), G4PVDivision::CheckAndSetParameters(), 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(), G4DrawVoxels::ComputeVoxelPolyhedra(), G4tgbVolume::ConstructG4PhysVol(), G4TheRayTracer::CreateBitMap(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G3Division::CreatePVReplica(), G4ReflectionFactory::CreateReflectedLV(), G4AdjointPosOnPhysVolGenerator::DefinePhysicalVolume(), G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4VisManager::Draw(), G4tgbGeometryDumper::DumpLogVol(), G4FastTrack::FRecordsAffineTransformation(), G4RTPrimaryGeneratorAction::GeneratePrimaries(), G4Navigator::GetGlobalExitNormal(), G4Navigator::GetLocalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4VIntersectionLocator::GetLocalSurfaceNormal(), GetMass(), G4TransportationManager::GetParallelWorld(), G4ITTransportationManager::GetParallelWorld(), GetSolid(), G4BOptnForceCommonTruncatedExp::Initialize(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4GDMLWriteParamvol::ParametersWrite(), G4NeutrinoElectronProcess::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NavigationLogger::PreComputeStepLog(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), G4PSSphereSurfaceFlux::ProcessHits(), G4PSVolumeFlux::ProcessHits(), G4ITNavigator2::RecheckDistanceToCurrentBoundary(), G4NavigationLogger::ReportOutsideMother(), G4NavigationLogger::ReportVolumeAndIntersection(), G4VoxelSafety::SafetyForVoxelHeader(), G4VoxelSafety::SafetyForVoxelNode(), G4VisCommandsTouchable::SetNewValue(), G4ReplicatedSlice::SetParameterisation(), G4PVDivision::SetParameterisation(), 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;
}

References G4LVData::fSolid.

GetSubInstanceManager()

const G4LVManager & G4LogicalVolume::GetSubInstanceManager ( )

static

Definition at line 222 of file G4LogicalVolume.cc.

{
  return subInstanceManager;
}

References subInstanceManager.

Referenced by G4GeometryWorkspace::G4GeometryWorkspace().

GetUserLimits()

G4UserLimits * G4LogicalVolume::GetUserLimits ( ) const

inline

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

GetVisAttributes()

const G4VisAttributes * G4LogicalVolume::GetVisAttributes ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddDetector(), G4ReflectionFactory::CreateReflectedLV(), G4PhysicalVolumeModel::DescribeAndDescend(), export_G4LogicalVolume(), G4BuildGeom(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4VisCommandGeometryList::SetNewValue(), and G4VisCommandGeometryRestore::SetNewValue().

GetVoxelHeader()

G4SmartVoxelHeader * G4LogicalVolume::GetVoxelHeader ( ) const

inline

Referenced by G4GeometryManager::BuildOptimisations(), G4Navigator::ComputeSafety(), G4ITNavigator1::ComputeSafety(), G4ITNavigator2::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4Navigator::ComputeStep(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4DrawVoxels::CreatePlacedPolyhedra(), G4GeometryManager::DeleteOptimisations(), G4LogicalVolumeModel::DescribeYourselfTo(), export_G4LogicalVolume(), 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
}

References AssignFieldManager(), fFieldManager, GetFieldManager(), SetFieldManager(), SetSensitiveDetector(), SetSolid(), G4GeomSplitter< T >::SlaveCopySubInstanceArray(), and subInstanceManager.

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;
}

References fDaughters, and IsDaughter().

Referenced by export_G4LogicalVolume(), G4IStore::IsInWorld(), and G4WeightWindowStore::IsInWorld().

IsDaughter()

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

inline

Referenced by export_G4LogicalVolume(), and IsAncestor().

IsExtended()

G4bool G4LogicalVolume::IsExtended ( ) const

virtual

Reimplemented in G4LogicalCrystalVolume.

Definition at line 250 of file G4LogicalVolume.cc.

{
  return false;
}

Referenced by G4Channeling::GetMatData().

IsRegion()

G4bool G4LogicalVolume::IsRegion ( ) const

inline

Referenced by G4ReflectionFactory::CreateReflectedLV(), and export_G4LogicalVolume().

IsRootRegion()

G4bool G4LogicalVolume::IsRootRegion ( ) const

inline

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4GlobalFastSimulationManager::DisplayRegion(), export_G4LogicalVolume(), G4FastTrack::FRecordsAffineTransformation(), G4ReflectionFactory::ReflectLV(), and G4Region::ScanVolumeTree().

IsToOptimise()

G4bool G4LogicalVolume::IsToOptimise ( ) const

inline

Referenced by G4GeometryManager::BuildOptimisations(), and export_G4LogicalVolume().

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

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.;
}

References fDaughters, fRegion, G4MT_mass, and G4Region::RegionModified().

Referenced by G4PhysicalVolumeStore::DeRegister(), and export_G4LogicalVolume().

ResetMass()

void G4LogicalVolume::ResetMass

(

)

Definition at line 399 of file G4LogicalVolume.cc.

{
  G4MT_mass= 0.0;
}

References G4MT_mass.

Referenced by SetSolid().

SetBiasWeight()

void G4LogicalVolume::SetBiasWeight ( G4double  w )

inline

Referenced by G4ReflectionFactory::CreateReflectedLV(), and export_G4LogicalVolume().

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);
    }
  }
}

References AssignFieldManager(), GetDaughter(), GetFieldManager(), G4VPhysicalVolume::GetLogicalVolume(), GetNoDaughters(), and SetFieldManager().

Referenced by AddDaughter(), G4VUserDetectorConstruction::CloneF(), export_G4LogicalVolume(), 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;
}

References G4MT_mass, and G4MT_material.

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

SetMaterialCutsCouple()

void G4LogicalVolume::SetMaterialCutsCouple

(

G4MaterialCutsCouple *

cuts

)

Definition at line 497 of file G4LogicalVolume.cc.

{
  G4MT_ccouple = cuts;
}

References G4MT_ccouple.

Referenced by export_G4LogicalVolume(), and G4ProductionCutsTable::ScanAndSetCouple().

SetName()

void G4LogicalVolume::SetName

(

const G4String &

pName

)

Definition at line 148 of file G4LogicalVolume.cc.

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

References fName, G4LogicalVolumeStore::GetInstance(), and G4LogicalVolumeStore::SetMapValid().

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

SetOptimisation()

void G4LogicalVolume::SetOptimisation ( G4bool  optim )

inline

Referenced by export_G4LogicalVolume().

SetRegion()

void G4LogicalVolume::SetRegion ( G4Region *  reg )

inline

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

SetRegionRootFlag()

void G4LogicalVolume::SetRegionRootFlag ( G4bool  rreg )

inline

Referenced by G4Region::AddRootLogicalVolume(), export_G4LogicalVolume(), 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; }
}

References fSensitiveDetector, G4MT_sdetector, and G4Threading::IsMasterThread().

Referenced by G4VUserDetectorConstruction::CloneSD(), export_G4LogicalVolume(), 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

Referenced by export_G4LogicalVolume().

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;
}

References G4LVData::fMass, and G4LVData::fSolid.

SetSolid() [2/2]

void G4LogicalVolume::SetSolid

(

G4VSolid *

pSolid

)

Definition at line 422 of file G4LogicalVolume.cc.

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

References G4MT_solid, and 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 export_G4LogicalVolume(), and G4LogicalVolume().

SetVisAttributes() [1/2]

void G4LogicalVolume::SetVisAttributes

(

const G4VisAttributes &

VA

)

Definition at line 644 of file G4LogicalVolume.cc.

{
  fVisAttributes = new G4VisAttributes(VA);
}

References fVisAttributes.

SetVisAttributes() [2/2]

void G4LogicalVolume::SetVisAttributes ( const G4VisAttributes *  pVA )

inline

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

SetVoxelHeader()

void G4LogicalVolume::SetVoxelHeader ( G4SmartVoxelHeader *  pVoxel )

inline

Referenced by G4GeometryManager::BuildOptimisations(), G4GeometryManager::DeleteOptimisations(), export_G4LogicalVolume(), and 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;
}

References fDaughters, G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMultiplicity(), and TotalVolumeEntities().

Referenced by export_G4LogicalVolume(), and 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;
}

References G4Region::FindCouple(), fRegion, G4MT_ccouple, G4MT_mass, and G4MT_material.

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

Field Documentation

fBiasWeight

G4double G4LogicalVolume::fBiasWeight = 1.0

private

Definition at line 412 of file G4LogicalVolume.hh.

fDaughters

G4PhysicalVolumeList G4LogicalVolume::fDaughters

private

Definition at line 397 of file G4LogicalVolume.hh.

Referenced by AddDaughter(), ClearDaughters(), GetMass(), IsAncestor(), RemoveDaughter(), and TotalVolumeEntities().

fDaughtersVolumeType

EVolume G4LogicalVolume::fDaughtersVolumeType

private

Definition at line 426 of file G4LogicalVolume.hh.

Referenced by AddDaughter(), and ChangeDaughtersType().

fFieldManager

G4FieldManager* G4LogicalVolume::fFieldManager = nullptr

private

Definition at line 421 of file G4LogicalVolume.hh.

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

fLock

G4bool G4LogicalVolume::fLock = false

private

Definition at line 432 of file G4LogicalVolume.hh.

Referenced by ~G4LogicalVolume().

fName

G4String G4LogicalVolume::fName

private

Definition at line 399 of file G4LogicalVolume.hh.

Referenced by GetMass(), and SetName().

fOptimise

G4bool G4LogicalVolume::fOptimise = true

private

Definition at line 428 of file G4LogicalVolume.hh.

fRegion

G4Region* G4LogicalVolume::fRegion = nullptr

private

Definition at line 410 of file G4LogicalVolume.hh.

Referenced by AddDaughter(), ClearDaughters(), RemoveDaughter(), UpdateMaterial(), and ~G4LogicalVolume().

fRootRegion

G4bool G4LogicalVolume::fRootRegion = false

private

Definition at line 430 of file G4LogicalVolume.hh.

Referenced by ~G4LogicalVolume().

fSensitiveDetector

G4VSensitiveDetector* G4LogicalVolume::fSensitiveDetector = nullptr

private

Definition at line 420 of file G4LogicalVolume.hh.

Referenced by G4LogicalVolume(), and SetSensitiveDetector().

fSmartless

G4double G4LogicalVolume::fSmartless = 2.0

private

Definition at line 405 of file G4LogicalVolume.hh.

fSolid

G4VSolid* G4LogicalVolume::fSolid = nullptr

private

Definition at line 419 of file G4LogicalVolume.hh.

Referenced by G4LogicalVolume().

fUserLimits

G4UserLimits* G4LogicalVolume::fUserLimits = nullptr

private

Definition at line 401 of file G4LogicalVolume.hh.

fVisAttributes

const G4VisAttributes* G4LogicalVolume::fVisAttributes = nullptr

private

Definition at line 408 of file G4LogicalVolume.hh.

Referenced by SetVisAttributes().

fVoxel

G4SmartVoxelHeader* G4LogicalVolume::fVoxel = nullptr

private

Definition at line 403 of file G4LogicalVolume.hh.

instanceID

G4int G4LogicalVolume::instanceID

private

Definition at line 424 of file G4LogicalVolume.hh.

Referenced by G4LogicalVolume(), and GetSolid().

lvdata

G4LVData* G4LogicalVolume::lvdata = nullptr

private

Definition at line 422 of file G4LogicalVolume.hh.

Referenced by G4LogicalVolume(), and ~G4LogicalVolume().

subInstanceManager

G4LVManager G4LogicalVolume::subInstanceManager

staticprivate

Definition at line 394 of file G4LogicalVolume.hh.

Referenced by Clean(), G4LogicalVolume(), GetSolid(), GetSubInstanceManager(), and InitialiseWorker().

---

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

• source/geometry/management/include/G4LogicalVolume.hh
• source/geometry/management/src/G4LogicalVolume.cc