G4Region Class Reference

#include <G4Region.hh>

Public Member Functions
void	AddRootLogicalVolume (G4LogicalVolume *lv, G4bool search=true)
G4bool	BelongsTo (G4VPhysicalVolume *thePhys) const
void	ClearFastSimulationManager ()
void	ClearMap ()
void	ClearMaterialList ()
G4MaterialCutsCouple *	FindCouple (G4Material *mat)
	G4Region (__void__ &)
	G4Region (const G4Region &)=delete
	G4Region (const G4String &name)
G4FastSimulationManager *	GetFastSimulationManager () const
G4FieldManager *	GetFieldManager () const
G4int	GetInstanceID () const
std::vector< G4Material * >::const_iterator	GetMaterialIterator () const
const G4String &	GetName () const
size_t	GetNumberOfMaterials () const
size_t	GetNumberOfRootVolumes () const
G4Region *	GetParentRegion (G4bool &unique) const
G4ProductionCuts *	GetProductionCuts () const
G4UserSteppingAction *	GetRegionalSteppingAction () const
std::vector< G4LogicalVolume * >::iterator	GetRootLogicalVolumeIterator ()
G4VUserRegionInformation *	GetUserInformation () const
G4UserLimits *	GetUserLimits () const
G4VPhysicalVolume *	GetWorldPhysical () const
G4bool	IsInMassGeometry () const
G4bool	IsInParallelGeometry () const
G4bool	IsModified () const
G4Region &	operator= (const G4Region &)=delete
G4bool	operator== (const G4Region &rg) const
void	RegionModified (G4bool flag)
void	RegisterMaterialCouplePair (G4Material *mat, G4MaterialCutsCouple *couple)
void	RemoveRootLogicalVolume (G4LogicalVolume *lv, G4bool scan=true)
void	ScanVolumeTree (G4LogicalVolume *lv, G4bool region)
void	SetFastSimulationManager (G4FastSimulationManager *fsm)
void	SetFieldManager (G4FieldManager *fm)
void	SetName (const G4String &name)
void	SetProductionCuts (G4ProductionCuts *cut)
void	SetRegionalSteppingAction (G4UserSteppingAction *rusa)
void	SetUserInformation (G4VUserRegionInformation *ui)
void	SetUserLimits (G4UserLimits *ul)
void	SetWorld (G4VPhysicalVolume *wp)
void	UpdateMaterialList ()
void	UsedInMassGeometry (G4bool val=true)
void	UsedInParallelGeometry (G4bool val=true)
virtual	~G4Region ()

Static Public Member Functions
static void	Clean ()
static const G4RegionManager &	GetSubInstanceManager ()

Private Types
using	G4MaterialCoupleMap = std::map< G4Material *, G4MaterialCutsCouple * >
using	G4MaterialCouplePair = std::pair< G4Material *, G4MaterialCutsCouple * >
using	G4MaterialList = std::vector< G4Material * >
using	G4RootLVList = std::vector< G4LogicalVolume * >

Private Member Functions
void	AddMaterial (G4Material *aMaterial)

Private Attributes
G4ProductionCuts *	fCut = nullptr
G4FieldManager *	fFieldManager = nullptr
G4bool	fInMassGeometry = false
G4bool	fInParallelGeometry = false
G4MaterialCoupleMap	fMaterialCoupleMap
G4MaterialList	fMaterials
G4String	fName
G4bool	fRegionMod = true
G4RootLVList	fRootVolumes
G4VUserRegionInformation *	fUserInfo = nullptr
G4UserLimits *	fUserLimits = nullptr
G4VPhysicalVolume *	fWorldPhys = nullptr
G4int	instanceID

Static Private Attributes
static G4GEOM_DLL G4RegionManager	subInstanceManager

Detailed Description

Definition at line 95 of file G4Region.hh.

Member Typedef Documentation

G4MaterialCoupleMap

using G4Region::G4MaterialCoupleMap = std::map<G4Material*, G4MaterialCutsCouple*>

private

Definition at line 249 of file G4Region.hh.

G4MaterialCouplePair

using G4Region::G4MaterialCouplePair = std::pair<G4Material*, G4MaterialCutsCouple*>

private

Definition at line 248 of file G4Region.hh.

G4MaterialList

using G4Region::G4MaterialList = std::vector<G4Material*>

private

Definition at line 247 of file G4Region.hh.

G4RootLVList

using G4Region::G4RootLVList = std::vector<G4LogicalVolume*>

private

Definition at line 246 of file G4Region.hh.

Constructor & Destructor Documentation

G4Region() [1/3]

G4Region::G4Region

(

const G4String &

name

)

Definition at line 65 of file G4Region.cc.

  : fName(pName)
{
 
  instanceID = subInstanceManager.CreateSubInstance();
  G4MT_fsmanager = nullptr;
  G4MT_rsaction = nullptr;
 
  G4RegionStore* rStore = G4RegionStore::GetInstance();
  if (rStore->GetRegion(pName, false))
  {
    std::ostringstream message;
    message << "The region has NOT been registered !" << G4endl
            << "          Region " << pName << " already existing in store !"
            << G4endl;
    G4Exception("G4Region::G4Region()", "GeomMgt1001",
                JustWarning, message);
  }
  else
  {
    rStore->Register(this);
  }
}

References G4GeomSplitter< T >::CreateSubInstance(), G4endl, G4Exception(), G4MT_fsmanager, G4MT_rsaction, G4RegionStore::GetInstance(), G4RegionStore::GetRegion(), instanceID, JustWarning, G4RegionStore::Register(), and subInstanceManager.

~G4Region()

G4Region::~G4Region ( )

virtual

Definition at line 111 of file G4Region.cc.

{
  G4RegionStore::GetInstance()->DeRegister(this);
  if(fUserInfo != nullptr)  { delete fUserInfo; }
}

References G4RegionStore::DeRegister(), fUserInfo, and G4RegionStore::GetInstance().

G4Region() [2/3]

G4Region::G4Region ( const G4Region &  )

delete

G4Region() [3/3]

G4Region::G4Region

(

__void__ &

)

Definition at line 94 of file G4Region.cc.

  : fName("")
{
  instanceID = subInstanceManager.CreateSubInstance();
  G4MT_fsmanager = nullptr;
  G4MT_rsaction = nullptr;
 
  // Register to store
  //
  G4RegionStore::GetInstance()->Register(this);
}

References G4GeomSplitter< T >::CreateSubInstance(), G4MT_fsmanager, G4MT_rsaction, G4RegionStore::GetInstance(), instanceID, G4RegionStore::Register(), and subInstanceManager.

Member Function Documentation

AddMaterial()

void G4Region::AddMaterial ( G4Material *  aMaterial )

inlineprivate

Referenced by ScanVolumeTree().

AddRootLogicalVolume()

void G4Region::AddRootLogicalVolume	(	G4LogicalVolume *	lv,
		G4bool	search = true
	)

Definition at line 293 of file G4Region.cc.

{
  // Check the logical volume is not already in the list
  //
  if (search) 
  {
    auto pos = std::find(fRootVolumes.cbegin(),fRootVolumes.cend(),lv);
    if (pos == fRootVolumes.cend())
    {
      // Insert the root volume in the list and set it as root region
      //
      fRootVolumes.push_back(lv);
      lv->SetRegionRootFlag(true);
    }
  }
  else  // WARNING: user *MUST* guarantee lv is not already inserted.
  {     // Providing speedup for very complex flat geometries
    fRootVolumes.push_back(lv);
    lv->SetRegionRootFlag(true);
  }
  // Scan recursively the tree of daugther volumes and set regions
  //
  ScanVolumeTree(lv, true);
 
  // Set region as modified
  //
  fRegionMod = true;
}

References fRegionMod, fRootVolumes, pos, ScanVolumeTree(), and G4LogicalVolume::SetRegionRootFlag().

Referenced by G4RunManagerKernel::CheckRegions(), G4RunManagerKernel::DefineWorldVolume(), export_G4Region(), G4GDMLParser::ImportRegions(), and G4ReflectionFactory::ReflectLV().

BelongsTo()

G4bool G4Region::BelongsTo

(

G4VPhysicalVolume *

thePhys

)

const

Definition at line 414 of file G4Region.cc.

{
  G4LogicalVolume* currLog = thePhys->GetLogicalVolume();
  if (currLog->GetRegion()==this) {return true;}
 
  G4int nDaughters = currLog->GetNoDaughters();
  while (nDaughters--)  // Loop checking, 06.08.2015, G.Cosmo
  {
    if (BelongsTo(currLog->GetDaughter(nDaughters))) {return true;}
  }
 
  return false;
}

References BelongsTo(), G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetNoDaughters(), and G4LogicalVolume::GetRegion().

Referenced by BelongsTo(), G4RunManagerKernel::CheckRegions(), export_G4Region(), and SetWorld().

Clean()

void G4Region::Clean ( )

static

Definition at line 356 of file G4Region.cc.

{
  subInstanceManager.FreeSlave();
}

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

Referenced by G4RegionStore::~G4RegionStore().

ClearFastSimulationManager()

void G4Region::ClearFastSimulationManager

(

)

Definition at line 434 of file G4Region.cc.

{
  G4bool isUnique;
  G4Region* parent = GetParentRegion(isUnique);
  if(parent != nullptr)
  {
    if (isUnique)
    {
      G4MT_fsmanager = parent->GetFastSimulationManager();
    }
    else
    {
      std::ostringstream message;
      message << "Region <" << fName << "> belongs to more than"
              << " one parent region !" << G4endl
              << "A region cannot belong to more than one direct parent region,"
              << G4endl
              << "to have fast-simulation assigned.";
      G4Exception("G4Region::ClearFastSimulationManager()",
                  "GeomMgt1002", JustWarning, message);
      G4MT_fsmanager = nullptr;
    }
  }
  else
  {
    G4MT_fsmanager = nullptr;
  }
}

References fName, G4endl, G4Exception(), G4MT_fsmanager, GetFastSimulationManager(), GetParentRegion(), and JustWarning.

Referenced by export_G4Region(), and G4FastSimulationManager::~G4FastSimulationManager().

ClearMap()

void G4Region::ClearMap ( )

inline

Referenced by export_G4Region().

ClearMaterialList()

void G4Region::ClearMaterialList

(

)

Definition at line 366 of file G4Region.cc.

{
  fMaterials.clear();
}

References fMaterials.

Referenced by export_G4Region(), and UpdateMaterialList().

FindCouple()

G4MaterialCutsCouple * G4Region::FindCouple ( G4Material *  mat )

inline

Referenced by export_G4Region(), and G4LogicalVolume::UpdateMaterial().

GetFastSimulationManager()

G4FastSimulationManager * G4Region::GetFastSimulationManager

(

)

const

Definition at line 140 of file G4Region.cc.

{
  return G4MT_fsmanager;
}

References G4MT_fsmanager.

Referenced by ClearFastSimulationManager(), G4GlobalFastSimulationManager::DisplayRegion(), G4RunManagerKernel::DumpRegion(), export_G4Region(), G4VFastSimulationModel::G4VFastSimulationModel(), and G4FastSimulationManager::~G4FastSimulationManager().

GetFieldManager()

G4FieldManager * G4Region::GetFieldManager ( ) const

inline

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

GetInstanceID()

G4int G4Region::GetInstanceID ( ) const

inline

GetMaterialIterator()

std::vector< G4Material * >::const_iterator G4Region::GetMaterialIterator ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion(), and G4ProductionCutsTable::IsCoupleUsedInTheRegion().

GetName()

const G4String & G4Region::GetName ( ) const

inline

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4RunManagerKernel::CheckRegions(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4RunManagerKernel::DefineWorldVolume(), G4RegionStore::DeRegister(), G4GlobalFastSimulationManager::DisplayRegion(), G4RunManagerKernel::DumpRegion(), export_G4Region(), G4EmCalculator::FindCouple(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4ElNeutrinoNucleusProcess::GetMeanFreePath(), G4MuNeutrinoNucleusProcess::GetMeanFreePath(), G4EmBiasingManager::Initialise(), G4PAIModel::Initialise(), G4PAIPhotModel::Initialise(), G4EmModelManager::Initialise(), G4FastSimulationManager::ListTitle(), G4NeutrinoElectronProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4VEnergyLossProcess::PreparePhysicsTable(), G4RegionStore::Register(), and G4GlobalFastSimulationManager::ShowSetup().

GetNumberOfMaterials()

size_t G4Region::GetNumberOfMaterials ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion(), export_G4Region(), and G4ProductionCutsTable::IsCoupleUsedInTheRegion().

GetNumberOfRootVolumes()

size_t G4Region::GetNumberOfRootVolumes ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion(), export_G4Region(), and G4RunManagerKernel::SetupDefaultRegion().

GetParentRegion()

G4Region * G4Region::GetParentRegion

(

G4bool &

unique

)

const

Definition at line 469 of file G4Region.cc.

{
  G4Region* parent = nullptr; unique = true;
  G4LogicalVolumeStore* lvStore = G4LogicalVolumeStore::GetInstance();
 
  // Loop over all logical volumes in the store
  //
  for(auto lvItr=lvStore->cbegin(); lvItr!=lvStore->cend(); ++lvItr)
  {
    G4int nD = (*lvItr)->GetNoDaughters();
    G4Region* aR = (*lvItr)->GetRegion();
 
    // Loop over all daughters of each logical volume
    //
    for(auto iD=0; iD<nD; ++iD)
    {
      if((*lvItr)->GetDaughter(iD)->GetLogicalVolume()->GetRegion()==this)
      { 
        if(parent)
        {
          if(parent!=aR) { unique = false; }
        }
        else  // Cache LV parent region which includes a daughter volume
              // with the same associated region as the current one
        {
          parent = aR;
        }
      }
    }
  }
  return parent;
}

References G4LogicalVolumeStore::GetInstance().

Referenced by ClearFastSimulationManager(), and export_G4Region().

GetProductionCuts()

G4ProductionCuts * G4Region::GetProductionCuts ( ) const

inline

Referenced by G4RunManagerKernel::CheckRegions(), G4RunManagerKernel::DumpRegion(), export_G4Region(), G4GDMLWriteStructure::ExportEnergyCuts(), G4EmCalculator::FindCouple(), G4VUserPhysicsList::GetCutValue(), G4ProductionCutsTable::IsCoupleUsedInTheRegion(), G4VUserPhysicsList::SetParticleCuts(), and G4ParallelWorldProcess::SwitchMaterial().

GetRegionalSteppingAction()

G4UserSteppingAction * G4Region::GetRegionalSteppingAction

(

)

const

Definition at line 158 of file G4Region.cc.

{
  return G4MT_rsaction;
}

References G4MT_rsaction.

Referenced by G4RunManagerKernel::DumpRegion(), and G4SteppingManager::Stepping().

GetRootLogicalVolumeIterator()

std::vector< G4LogicalVolume * >::iterator G4Region::GetRootLogicalVolumeIterator ( )

inline

Referenced by G4RunManagerKernel::DumpRegion(), and G4RunManagerKernel::SetupDefaultRegion().

GetSubInstanceManager()

const G4RegionManager & G4Region::GetSubInstanceManager ( )

static

Definition at line 55 of file G4Region.cc.

{
  return subInstanceManager;
}

References subInstanceManager.

Referenced by G4GeometryWorkspace::G4GeometryWorkspace().

GetUserInformation()

G4VUserRegionInformation * G4Region::GetUserInformation ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion(), and export_G4Region().

GetUserLimits()

G4UserLimits * G4Region::GetUserLimits ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion(), and export_G4Region().

GetWorldPhysical()

G4VPhysicalVolume * G4Region::GetWorldPhysical ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion(), export_G4Region(), and G4FastSimulationManager::ListTitle().

IsInMassGeometry()

G4bool G4Region::IsInMassGeometry ( ) const

inline

Referenced by G4RunManagerKernel::CheckRegions(), and G4RunManagerKernel::DumpRegion().

IsInParallelGeometry()

G4bool G4Region::IsInParallelGeometry ( ) const

inline

Referenced by G4RunManagerKernel::CheckRegions(), and G4RunManagerKernel::DumpRegion().

IsModified()

G4bool G4Region::IsModified ( ) const

inline

Referenced by export_G4Region().

operator=()

G4Region & G4Region::operator= ( const G4Region &  )

delete

operator==()

G4bool G4Region::operator== ( const G4Region &  rg ) const

inline

RegionModified()

void G4Region::RegionModified ( G4bool  flag )

inline

Referenced by G4LogicalVolume::AddDaughter(), G4LogicalVolume::ClearDaughters(), export_G4Region(), and G4LogicalVolume::RemoveDaughter().

RegisterMaterialCouplePair()

void G4Region::RegisterMaterialCouplePair ( G4Material *  mat, G4MaterialCutsCouple *  couple  )

inline

Referenced by export_G4Region().

RemoveRootLogicalVolume()

void G4Region::RemoveRootLogicalVolume	(	G4LogicalVolume *	lv,
		G4bool	scan = true
	)

Definition at line 328 of file G4Region.cc.

{
  // Find and remove logical volume from the list
  //
  auto pos = std::find(fRootVolumes.cbegin(),fRootVolumes.cend(),lv);
  if (pos != fRootVolumes.cend())
  {
    if (fRootVolumes.size() != 1)  // Avoid resetting flag for world since
    {                              // volume may be already deleted !
      lv->SetRegionRootFlag(false);
    }
    fRootVolumes.erase(pos);
  }
 
  if (scan)  // Update the materials list
  {
    UpdateMaterialList();
  }
 
  // Set region as modified
  //
  fRegionMod = true;
}

References fRegionMod, fRootVolumes, pos, G4LogicalVolume::SetRegionRootFlag(), and UpdateMaterialList().

Referenced by export_G4Region(), G4RunManagerKernel::SetupDefaultRegion(), and G4LogicalVolume::~G4LogicalVolume().

ScanVolumeTree()

void G4Region::ScanVolumeTree	(	G4LogicalVolume *	lv,
		G4bool	region
	)

Definition at line 172 of file G4Region.cc.

{
  // If logical volume is going to become a region, add 
  // its material to the list if not already present
  //
  G4Region* currentRegion = nullptr;
  size_t noDaughters = lv->GetNoDaughters();
  G4Material* volMat = lv->GetMaterial();
  if((volMat == nullptr) && fInMassGeometry)
  {
    std::ostringstream message;
    message << "Logical volume <" << lv->GetName() << ">" << G4endl
            << "does not have a valid material pointer." << G4endl
            << "A logical volume belonging to the (tracking) world volume "
            << "must have a valid material.";
    G4Exception("G4Region::ScanVolumeTree()", "GeomMgt0002",
                FatalException, message, "Check your geometry construction.");
  }
  if (region)
  {
    currentRegion = this;
    if (volMat != nullptr)
    { 
      AddMaterial(volMat); 
      G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial());
      if (baseMat != nullptr) { AddMaterial(baseMat); }
    }
  }
 
  // Set the LV region to be either the current region or NULL,
  // according to the boolean selector
  //
  lv->SetRegion(currentRegion);
 
  // Stop recursion here if no further daughters are involved
  //
  if(noDaughters==0) return;
 
  G4VPhysicalVolume* daughterPVol = lv->GetDaughter(0);
  if (daughterPVol->IsParameterised())
  {
    // Adopt special treatment in case of parameterised volumes,
    // where parameterisation involves a new material scan
    //
    G4VPVParameterisation* pParam = daughterPVol->GetParameterisation();
 
    if (pParam->GetMaterialScanner() != nullptr)
    {
      size_t matNo = pParam->GetMaterialScanner()->GetNumberOfMaterials();
      for (size_t mat=0; mat<matNo; ++mat)
      {
        volMat = pParam->GetMaterialScanner()->GetMaterial(mat);
        if(!volMat && fInMassGeometry)
        {
          std::ostringstream message;
          message << "The parameterisation for the physical volume <"
                  << daughterPVol->GetName() << ">" << G4endl
                  << "does not return a valid material pointer." << G4endl
                  << "A volume belonging to the (tracking) world volume must "
                  << "have a valid material.";
          G4Exception("G4Region::ScanVolumeTree()", "GeomMgt0002",
                      FatalException, message, "Check your parameterisation.");
        }
        if (volMat != nullptr)
        { 
          AddMaterial(volMat); 
          G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial());
          if (baseMat != nullptr) { AddMaterial(baseMat); }
        }
      }
    }
    else
    {
      size_t repNo = daughterPVol->GetMultiplicity();
      for (size_t rep=0; rep<repNo; ++rep)
      {
        volMat = pParam->ComputeMaterial(rep, daughterPVol);
        if((volMat == nullptr) && fInMassGeometry)
        {
          std::ostringstream message;
          message << "The parameterisation for the physical volume <"
                  << daughterPVol->GetName() << ">" << G4endl
                  << "does not return a valid material pointer." << G4endl
                  << "A volume belonging to the (tracking) world volume must "
                  << "have a valid material.";
          G4Exception("G4Region::ScanVolumeTree()", "GeomMgt0002",
                      FatalException, message, "Check your parameterisation.");
        }
        if(volMat != nullptr)
        { 
          AddMaterial(volMat);
          G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial());
          if (baseMat != nullptr) { AddMaterial(baseMat); }
        }
      }
    }
    G4LogicalVolume* daughterLVol = daughterPVol->GetLogicalVolume();
    ScanVolumeTree(daughterLVol, region);
  }
  else
  {
    for (size_t i=0; i<noDaughters; ++i)
    {
      G4LogicalVolume* daughterLVol = lv->GetDaughter(i)->GetLogicalVolume();
      if (!daughterLVol->IsRootRegion())
      {
        // Set daughter's LV to be a region and store materials in
        // the materials list, if the LV is not already a root region
        //
        ScanVolumeTree(daughterLVol, region);
      }
    }
  }
}

References AddMaterial(), G4VPVParameterisation::ComputeMaterial(), FatalException, fInMassGeometry, G4endl, G4Exception(), G4Material::GetBaseMaterial(), G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMaterial(), G4VVolumeMaterialScanner::GetMaterial(), G4VPVParameterisation::GetMaterialScanner(), G4VPhysicalVolume::GetMultiplicity(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4LogicalVolume::GetNoDaughters(), G4VVolumeMaterialScanner::GetNumberOfMaterials(), G4VPhysicalVolume::GetParameterisation(), G4VPhysicalVolume::IsParameterised(), G4LogicalVolume::IsRootRegion(), ScanVolumeTree(), and G4LogicalVolume::SetRegion().

Referenced by AddRootLogicalVolume(), export_G4Region(), ScanVolumeTree(), and UpdateMaterialList().

SetFastSimulationManager()

void G4Region::SetFastSimulationManager

(

G4FastSimulationManager *

fsm

)

Definition at line 131 of file G4Region.cc.

{
  G4MT_fsmanager = fsm;
}

References G4MT_fsmanager.

Referenced by export_G4Region(), and G4FastSimulationManager::G4FastSimulationManager().

SetFieldManager()

void G4Region::SetFieldManager ( G4FieldManager *  fm )

inline

SetName()

void G4Region::SetName

(

const G4String &

name

)

Definition at line 121 of file G4Region.cc.

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

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

Referenced by export_G4Region().

SetProductionCuts()

void G4Region::SetProductionCuts ( G4ProductionCuts *  cut )

inline

Referenced by G4RunManagerKernel::CheckRegions(), G4RunManagerKernel::DumpRegion(), export_G4Region(), G4RunManagerKernel::G4RunManagerKernel(), G4GDMLParser::ImportRegions(), and G4VUserPhysicsList::SetParticleCuts().

SetRegionalSteppingAction()

void G4Region::SetRegionalSteppingAction

(

G4UserSteppingAction *

rusa

)

Definition at line 149 of file G4Region.cc.

{
  G4MT_rsaction = rusa;
}

References G4MT_rsaction.

SetUserInformation()

void G4Region::SetUserInformation ( G4VUserRegionInformation *  ui )

inline

Referenced by export_G4Region().

SetUserLimits()

void G4Region::SetUserLimits ( G4UserLimits *  ul )

inline

Referenced by export_G4Region(), and G4GDMLParser::ImportRegions().

SetWorld()

void G4Region::SetWorld

(

G4VPhysicalVolume *

wp

)

Definition at line 398 of file G4Region.cc.

{
  if(!wp)
  { fWorldPhys = nullptr; }
  else
  { if(BelongsTo(wp)) fWorldPhys = wp; }
 
  return;
}

References BelongsTo(), fWorldPhys, and G4InuclParticleNames::wp.

Referenced by G4RunManagerKernel::CheckRegions(), and export_G4Region().

UpdateMaterialList()

void G4Region::UpdateMaterialList

(

)

Definition at line 377 of file G4Region.cc.

{
  // Reset the materials list
  //
  ClearMaterialList();
 
  // Loop over the root logical volumes and rebuild the list
  // of materials from scratch
  //
  for (auto pLV=fRootVolumes.cbegin(); pLV!=fRootVolumes.cend(); ++pLV)
  {
    ScanVolumeTree(*pLV, true);
  }
}

References ClearMaterialList(), fRootVolumes, and ScanVolumeTree().

Referenced by export_G4Region(), and RemoveRootLogicalVolume().

UsedInMassGeometry()

void G4Region::UsedInMassGeometry ( G4bool  val = true )

inline

Referenced by G4RunManagerKernel::CheckRegions().

UsedInParallelGeometry()

void G4Region::UsedInParallelGeometry ( G4bool  val = true )

inline

Referenced by G4RunManagerKernel::CheckRegions().

Field Documentation

fCut

G4ProductionCuts* G4Region::fCut = nullptr

private

Definition at line 258 of file G4Region.hh.

fFieldManager

G4FieldManager* G4Region::fFieldManager = nullptr

private

Definition at line 262 of file G4Region.hh.

fInMassGeometry

G4bool G4Region::fInMassGeometry = false

private

Definition at line 266 of file G4Region.hh.

Referenced by ScanVolumeTree().

fInParallelGeometry

G4bool G4Region::fInParallelGeometry = false

private

Definition at line 267 of file G4Region.hh.

fMaterialCoupleMap

G4MaterialCoupleMap G4Region::fMaterialCoupleMap

private

Definition at line 255 of file G4Region.hh.

fMaterials

G4MaterialList G4Region::fMaterials

private

Definition at line 254 of file G4Region.hh.

Referenced by ClearMaterialList().

fName

G4String G4Region::fName

private

Definition at line 251 of file G4Region.hh.

Referenced by ClearFastSimulationManager(), and SetName().

fRegionMod

G4bool G4Region::fRegionMod = true

private

Definition at line 257 of file G4Region.hh.

Referenced by AddRootLogicalVolume(), and RemoveRootLogicalVolume().

fRootVolumes

G4RootLVList G4Region::fRootVolumes

private

Definition at line 253 of file G4Region.hh.

Referenced by AddRootLogicalVolume(), RemoveRootLogicalVolume(), and UpdateMaterialList().

fUserInfo

G4VUserRegionInformation* G4Region::fUserInfo = nullptr

private

Definition at line 260 of file G4Region.hh.

Referenced by ~G4Region().

fUserLimits

G4UserLimits* G4Region::fUserLimits = nullptr

private

Definition at line 261 of file G4Region.hh.

fWorldPhys

G4VPhysicalVolume* G4Region::fWorldPhys = nullptr

private

Definition at line 264 of file G4Region.hh.

Referenced by SetWorld().

instanceID

G4int G4Region::instanceID

private

Definition at line 269 of file G4Region.hh.

Referenced by G4Region().

subInstanceManager

G4RegionManager G4Region::subInstanceManager

staticprivate

Definition at line 271 of file G4Region.hh.

Referenced by Clean(), G4Region(), and GetSubInstanceManager().

---

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

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