G4LogicalVolume Class Reference

#include <G4LogicalVolume.hh>

Public Member Functions
	G4LogicalVolume (G4VSolid *pSolid, G4Material *pMaterial, const G4String &name, G4FieldManager *pFieldMgr=0, G4VSensitiveDetector *pSDetector=0, G4UserLimits *pULimits=0, G4bool optimise=true)
	~G4LogicalVolume ()
G4String	GetName () const
void	SetName (const G4String &pName)
G4int	GetNoDaughters () const
G4VPhysicalVolume *	GetDaughter (const G4int 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
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=0)
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__ &)
void	Lock ()

Detailed Description

Definition at line 133 of file G4LogicalVolume.hh.

Constructor & Destructor Documentation

G4LogicalVolume() [1/2]

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

Definition at line 56 of file G4LogicalVolume.cc.

 : fDaughters(0,(G4VPhysicalVolume*)0), fFieldManager(pFieldMgr),
   fVoxel(0), fOptimise(optimise), fRootRegion(false), fLock(false),
   fSmartless(2.), fMass(0.), fVisAttributes(0), fRegion(0), fCutsCouple(0)
{
  SetSolid(pSolid);
  SetMaterial(pMaterial);
  SetName(name);
  SetSensitiveDetector(pSDetector);
  SetUserLimits(pULimits);    
  //
  // Add to store
  //
  G4LogicalVolumeStore::Register(this);
}

~G4LogicalVolume()

G4LogicalVolume::~G4LogicalVolume

(

)

Definition at line 99 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);
  }
  G4LogicalVolumeStore::DeRegister(this);
}

G4LogicalVolume() [2/2]

G4LogicalVolume::G4LogicalVolume

(

__void__ &

)

Definition at line 83 of file G4LogicalVolume.cc.

 : fDaughters(0,(G4VPhysicalVolume*)0), fFieldManager(0),
   fMaterial(0), fName(""), fSensitiveDetector(0), fSolid(0), fUserLimits(0),
   fVoxel(0), fOptimise(true), fRootRegion(false), fLock(false), fSmartless(2.),
   fMass(0.), fVisAttributes(0), fRegion(0), fCutsCouple(0), fBiasWeight(0.)
{
  // Add to store
  //
  G4LogicalVolumeStore::Register(this);
}

Member Function Documentation

AddDaughter()

void G4LogicalVolume::AddDaughter ( G4VPhysicalVolume *  p )

inline

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

ClearDaughters()

void G4LogicalVolume::ClearDaughters ( )

inline

GetBiasWeight()

G4double G4LogicalVolume::GetBiasWeight ( ) const

inline

GetDaughter()

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

inline

Referenced by 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(), G4SmartVoxelHeader::G4SmartVoxelHeader(), G4GeomTestOvershootList::GetDaughter(), G4GeomTestOverlapList::GetDaughter1(), G4GeomTestOverlapList::GetDaughter2(), G4ParameterisedNavigation::LevelLocate(), G4RegularNavigation::LevelLocate(), G4VoxelSafety::SafetyForVoxelNode(), G4Region::ScanVolumeTree(), SetFieldManager(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4GeomTestVolume::TestOneLine(), G4GeomTestVolume::TestRecursiveCartGrid(), G4GeomTestVolume::TestRecursiveCylinder(), G4GeomTestVolume::TestRecursiveLine(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetFastSimulationManager()

G4FastSimulationManager * G4LogicalVolume::GetFastSimulationManager ( ) const

inline

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

GetFieldManager()

G4FieldManager * G4LogicalVolume::GetFieldManager ( ) const

inline

Referenced by G4PropagatorInField::FindAndSetFieldManager(), and SetFieldManager().

GetMass()

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

Definition at line 193 of file G4LogicalVolume.cc.

{
  // Return the cached non-zero value, if not forced
  //
  if ( (fMass) && (!forced) ) return fMass;
 
  // Global density and computed mass associated to the logical
  // volume without considering its daughters
  //
  G4Material* logMaterial = parMaterial ? parMaterial : fMaterial;
  if (!logMaterial)
  {
    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;
  }
  if (!fSolid)
  {
    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;
  }
  G4double globalDensity = logMaterial->GetDensity();
  fMass = fSolid->GetCubicVolume() * globalDensity;
 
  // 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 (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
       itDau != fDaughters.end(); itDau++)
  {
    G4VPhysicalVolume* physDaughter = (*itDau);
    G4LogicalVolume* logDaughter = physDaughter->GetLogicalVolume();
    G4double subMass=0.;
    G4VSolid* daughterSolid = 0;
    G4Material* daughterMaterial = 0;
 
    // 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 (G4int 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
      //
      fMass -= subMass;
      if (propagate)
      {
        fMass += logDaughter->GetMass(true, true, daughterMaterial);
      }
    }
  }
 
  return fMass;
}

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

GetMaterial()

G4Material * G4LogicalVolume::GetMaterial ( ) const

inline

Referenced by G4Track::CalculateVelocityForOpticalPhoton(), G4VPVParameterisation::ComputeMaterial(), G4tgbGeometryDumper::DumpLogVol(), GetMass(), G4VXTRenergyLoss::PostStepDoIt(), G4ITTransportation::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4Transportation::PostStepDoIt(), G4Region::ScanVolumeTree(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetMaterialCutsCouple()

const G4MaterialCutsCouple * G4LogicalVolume::GetMaterialCutsCouple ( ) const

inline

Referenced by G4ITTransportation::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), and G4Transportation::PostStepDoIt().

GetName()

G4String G4LogicalVolume::GetName ( ) const

inline

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), G4HepRepSceneHandler::AddSolid(), G4SmartVoxelHeader::BuildNodes(), G4SmartVoxelHeader::BuildReplicaVoxels(), G4SmartVoxelHeader::BuildVoxelsWithinLimits(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), checkVol(), G4tgbVolume::ConstructG4LogVol(), G4tgbVolume::ConstructG4PhysVol(), G4tgbVolume::ConstructG4Volumes(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G3Division::CreatePVReplica(), G4AdjointCrossSurfChecker::CrossingAnInterfaceBetweenTwoVolumes(), G4RadioactiveDecay::DecayIt(), G4RunManagerKernel::DefineWorldVolume(), G4RadioactiveDecay::DeselectAVolume(), 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(), G4Navigator::GetLocalExitNormal(), G4ITNavigator::GetLocalExitNormal(), G4PolarizedCompton::GetMeanFreePath(), G4eplusPolarizedAnnihilation::GetMeanFreePath(), G4tgbVolumeMgr::GetTopLogVol(), G4tgbVolumeMgr::GetTopPhysVol(), G4GDMLReadStructure::GetWorldVolume(), G4AdjointCrossSurfChecker::GoingInOrOutOfaVolumeByExtSurface(), G4GDMLWriteParamvol::ParamvolAlgorithmWrite(), G4GDMLReadParamvol::ParamvolRead(), G4GDMLWriteParamvol::ParamvolWrite(), G4GDMLReadStructure::PhysvolRead(), G4GDMLWriteStructure::PhysvolWrite(), G4ReflectionFactory::Place(), G4eplusPolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4tgbVolumeMgr::RegisterMe(), G4GDMLReadStructure::ReplicaRead(), G4ReflectionFactory::Replicate(), G4GDMLWriteStructure::ReplicavolWrite(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VoxelSafety::SafetyForVoxelHeader(), G4PolarizedComptonModel::SampleSecondaries(), G4Region::ScanVolumeTree(), G4RadioactiveDecay::SelectAllVolumes(), G4RadioactiveDecay::SelectAVolume(), G4VVisCommandGeometrySet::Set(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4VisCommandGeometryList::SetNewValue(), G4VisCommandGeometryRestore::SetNewValue(), G4GDMLWriteSetup::SetupWrite(), G4PolarizationManager::SetVolumePolarization(), G4GDMLWriteStructure::SkinSurfaceCache(), G4GDMLRead::StripNames(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetNoDaughters()

G4int 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(), G4DrawVoxels::DrawVoxels(), G4PVReplica::G4PVReplica(), G4SmartVoxelHeader::G4SmartVoxelHeader(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4Region::ScanVolumeTree(), SetFieldManager(), G4VVisCommandGeometrySet::SetLVVisAtts(), G4GeomTestVolume::TestOneLine(), G4GeomTestVolume::TestRecursiveCartGrid(), G4GeomTestVolume::TestRecursiveCylinder(), G4GeomTestVolume::TestRecursiveLine(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetRegion()

G4Region * G4LogicalVolume::GetRegion ( ) const

inline

Referenced by G4Region::BelongsTo(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4RunManagerKernel::DefineWorldVolume(), G4PropagatorInField::FindAndSetFieldManager(), G4VTransitionRadiation::GetMeanFreePath(), G4VTransitionRadiation::PostStepDoIt(), G4GlobalFastSimulationManager::ShowSetup(), G4SteppingManager::Stepping(), and G4MSSteppingAction::UserSteppingAction().

GetSensitiveDetector()

G4VSensitiveDetector * G4LogicalVolume::GetSensitiveDetector ( ) const

inline

Referenced by G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4LogicalVolumeModel::DescribeYourselfTo(), GFlashHitMaker::make(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4ITTransportation::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4Transportation::PostStepDoIt(), and G4ASCIITreeSceneHandler::RequestPrimitives().

GetSmartless()

G4double G4LogicalVolume::GetSmartless ( ) const

inline

Referenced by G4SmartVoxelHeader::BuildNodes().

GetSolid()

G4VSolid * G4LogicalVolume::GetSolid ( ) const

inline

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), G4GMocrenFileSceneHandler::AddPrimitive(), G4ReplicaNavigation::BackLocate(), G4PhantomParameterisation::BuildContainerSolid(), G4SmartVoxelHeader::BuildNodes(), G4SmartVoxelHeader::BuildReplicaVoxels(), G4SmartVoxelHeader::BuildVoxelsWithinLimits(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), 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(), G4ITNavigator::ComputeStep(), G4RegularNavigation::ComputeStepSkippingEqualMaterials(), G4PSCellFlux::ComputeVolume(), G4PSDoseDeposit::ComputeVolume(), G4PSPassageCellFlux::ComputeVolume(), G4tgbVolume::ConstructG4PhysVol(), G4TheRayTracer::CreateBitMap(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G3Division::CreatePVReplica(), G4AdjointPosOnPhysVolGenerator::DefinePhysicalVolume(), G4VisManager::Draw(), G4tgbGeometryDumper::DumpLogVol(), G4Navigator::GetLocalExitNormal(), G4ITNavigator::GetLocalExitNormal(), GetMass(), G4TransportationManager::GetParallelWorld(), G4Navigator::LocateGlobalPointAndSetup(), G4ITNavigator::LocateGlobalPointAndSetup(), G4GDMLWriteParamvol::ParametersWrite(), G4VXTRenergyLoss::PostStepDoIt(), G4NavigationLogger::PreComputeStepLog(), G4PSCylinderSurfaceCurrent::ProcessHits(), G4PSCylinderSurfaceFlux::ProcessHits(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), G4PSSphereSurfaceCurrent::ProcessHits(), G4PSSphereSurfaceFlux::ProcessHits(), G4VoxelSafety::SafetyForVoxelHeader(), G4VoxelSafety::SafetyForVoxelNode(), G4GeomTestVolume::TestOneLine(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetUserLimits()

G4UserLimits * G4LogicalVolume::GetUserLimits ( ) const

inline

Referenced by MaxTimeCuts::PostStepGetPhysicalInteractionLength(), MinEkineCuts::PostStepGetPhysicalInteractionLength(), G4StepLimiter::PostStepGetPhysicalInteractionLength(), and G4UserSpecialCuts::PostStepGetPhysicalInteractionLength().

GetVisAttributes()

const G4VisAttributes * G4LogicalVolume::GetVisAttributes ( ) const

inline

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

GetVoxelHeader()

G4SmartVoxelHeader * G4LogicalVolume::GetVoxelHeader ( ) const

inline

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

IsAncestor()

G4bool G4LogicalVolume::IsAncestor

(

const G4VPhysicalVolume *

p

)

const

Definition at line 139 of file G4LogicalVolume.cc.

{
  G4bool isDaughter = IsDaughter(aVolume);
  if (!isDaughter)
  {
    for (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
         itDau != fDaughters.end(); itDau++)
    {
      isDaughter = (*itDau)->GetLogicalVolume()->IsAncestor(aVolume);
      if (isDaughter)  break;
    }
  }
  return isDaughter;
}

IsDaughter()

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

inline

Referenced by IsAncestor().

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

G4bool G4LogicalVolume::operator==

(

const G4LogicalVolume &

lv

)

const

PropagateRegion()

void G4LogicalVolume::PropagateRegion ( )

inline

RemoveDaughter()

void G4LogicalVolume::RemoveDaughter ( const G4VPhysicalVolume *  p )

inline

Referenced by G4PhysicalVolumeStore::DeRegister().

SetBiasWeight()

void G4LogicalVolume::SetBiasWeight ( G4double  w )

inline

SetFieldManager()

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

Definition at line 113 of file G4LogicalVolume.cc.

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

Referenced by SetFieldManager().

SetMaterial()

void G4LogicalVolume::SetMaterial ( G4Material *  pMaterial )

inline

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

SetMaterialCutsCouple()

void G4LogicalVolume::SetMaterialCutsCouple ( G4MaterialCutsCouple *  cuts )

inline

SetName()

void G4LogicalVolume::SetName ( const G4String &  pName )

inline

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

SetOptimisation()

void G4LogicalVolume::SetOptimisation ( G4bool  optim )

inline

SetRegion()

void G4LogicalVolume::SetRegion ( G4Region *  reg )

inline

Referenced by 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 )

inline

Referenced by G4LogicalVolume().

SetSmartless()

void G4LogicalVolume::SetSmartless ( G4double  s )

inline

SetSolid()

void G4LogicalVolume::SetSolid ( G4VSolid *  pSolid )

inline

Referenced by G4LogicalVolume(), G4Navigator::GetMotherToDaughterTransform(), G4ITNavigator::GetMotherToDaughterTransform(), G4ParameterisedNavigation::LevelLocate(), G4Navigator::LocateGlobalPointAndSetup(), G4ITNavigator::LocateGlobalPointAndSetup(), G4Navigator::SetupHierarchy(), and G4ITNavigator::SetupHierarchy().

SetUserLimits()

void G4LogicalVolume::SetUserLimits ( G4UserLimits *  pULimits )

inline

Referenced by G4LogicalVolume().

SetVisAttributes() [1/2]

void G4LogicalVolume::SetVisAttributes

(

const G4VisAttributes &

VA

)

Definition at line 276 of file G4LogicalVolume.cc.

{
  fVisAttributes = new G4VisAttributes(VA);
}

SetVisAttributes() [2/2]

void G4LogicalVolume::SetVisAttributes ( const G4VisAttributes *  pVA )

inline

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

SetVoxelHeader()

void G4LogicalVolume::SetVoxelHeader ( G4SmartVoxelHeader *  pVoxel )

inline

Referenced by G4RunManager::ReOptimize().

TotalVolumeEntities()

G4int G4LogicalVolume::TotalVolumeEntities

(

)

const

Definition at line 161 of file G4LogicalVolume.cc.

{
  G4int vols = 1;
  for (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
       itDau != fDaughters.end(); itDau++)
  {
    G4VPhysicalVolume* physDaughter = (*itDau);
    vols += physDaughter->GetMultiplicity()
           *physDaughter->GetLogicalVolume()->TotalVolumeEntities();
  }
  return vols;
}

Referenced by TotalVolumeEntities().

UpdateMaterial()

void G4LogicalVolume::UpdateMaterial ( G4Material *  pMaterial )

inline

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

---

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

• G4LogicalVolume.hh
• G4LogicalVolume.cc