G4Region Class Reference

G4Region defines a region or a group of regions in the detector geometry setup, sharing properties associated to materials or production cuts which may affect or bias specific physics processes. More...

#include <G4Region.hh>

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

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

Detailed Description

G4Region defines a region or a group of regions in the detector geometry setup, sharing properties associated to materials or production cuts which may affect or bias specific physics processes.

Definition at line 89 of file G4Region.hh.

Constructor & Destructor Documentation

G4Region() [1/3]

G4Region::G4Region

(

const G4String &

name

)

Constructor for G4Region.

Parameters

[in]

name

The name of the region.

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) != nullptr)
  {
    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);
  }
}

Referenced by ClearFastSimulationManager(), G4Region(), GetParentRegion(), GetWorldPhysical(), operator=(), operator==(), and ScanVolumeTree().

~G4Region()

G4Region::~G4Region

(

)

Destructor.

Definition at line 110 of file G4Region.cc.

{
  G4RegionStore::GetInstance()->DeRegister(this);
  delete fUserInfo; 
}

G4Region() [2/3]

G4Region::G4Region ( const G4Region & )

delete

Copy constructor and assignment operator not allowed.

G4Region() [3/3]

G4Region::G4Region

(

__void__ &

)

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 93 of file G4Region.cc.

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

Member Function Documentation

AddRootLogicalVolume()

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

Adds a root logical volume and sets its daughters flags as regions. It also recompute the materials list for the region. Search in the tree can be turned off, assuming the user guarantees the logical volume is NOT already inserted, in which case significant speedup can be achieved in complex flat geometry setups.

Parameters

[in]	lv	Pointer to the logical volume to act as root region.
[in]	search	To enable/disable search in the tree (default true).

Definition at line 292 of file G4Region.cc.

{
  // Check if logical volume is already belonging to another region
  //
  if ((lv->IsRootRegion()) && (lv->GetRegion() != this))
  {
    std::ostringstream message;
    message << "Logical volume <" << lv->GetName() << "> is already set as" << G4endl
            << "root for region <" << lv->GetRegion()->GetName() << ">." << G4endl
            << "It cannot be root logical volume for another region <" << GetName()
            << ">" << G4endl;
    G4Exception("G4Region::AddRootLogicalVolume()", "GeomMgt0002", FatalException,
                message, "A logical volume cannot belong to more than one region!");
    return;
  }
 
  // 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;
}

BelongsTo()

G4bool G4Region::BelongsTo

(

G4VPhysicalVolume *

pv

)

const

Returns whether the region belongs to the given physical volume 'pv' (recursively scanned to the bottom of the hierarchy).

Definition at line 431 of file G4Region.cc.

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

Referenced by BelongsTo(), and SetWorld().

Clean()

void G4Region::Clean ( )

static

Clears the memory allocated by the MT sub-instance manager.

Definition at line 369 of file G4Region.cc.

{
  subInstanceManager.FreeSlave();
}

Referenced by G4RegionStore::~G4RegionStore().

ClearFastSimulationManager()

void G4Region::ClearFastSimulationManager

(

)

Sets the G4FastSimulationManager pointer to the one for the parent region if it exists, otherwise it sets it to null.

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

ClearMap()

void G4Region::ClearMap ( )

inline

Resets the material-cuts-couples map.

ClearMaterialList()

void G4Region::ClearMaterialList

(

)

Clears the material list.

Definition at line 379 of file G4Region.cc.

{
  fMaterials.clear();
}

Referenced by UpdateMaterialList().

FindCouple()

G4MaterialCutsCouple * G4Region::FindCouple ( G4Material * mat )

inline

Finds a G4MaterialCutsCouple which corresponds to the material 'mat' in the region.

Referenced by G4EmUtility::FillFluctFlags().

GetFastSimulationManager()

G4FastSimulationManager * G4Region::GetFastSimulationManager

(

)

const

Definition at line 139 of file G4Region.cc.

{
  return G4MT_fsmanager;
}

Referenced by ClearFastSimulationManager(), G4CoherentPairProductionPhysics::ConstructProcess(), G4RunManagerKernel::DumpRegion(), and G4VFastSimulationModel::G4VFastSimulationModel().

GetFieldManager()

G4FieldManager * G4Region::GetFieldManager ( ) const

inline

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

GetInstanceID()

G4int G4Region::GetInstanceID ( ) const

inline

Returns the instance ID for multi-threading.

GetMaterialIterator()

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

inline

Referenced by G4RunManagerKernel::DumpRegion().

GetName()

const G4String & G4Region::GetName ( ) const

inline

Referenced by AddRootLogicalVolume(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4RunManagerKernel::DefineWorldVolume(), G4RegionStore::DeRegister(), G4RunManagerKernel::DumpRegion(), G4EmCalculator::FindCouple(), G4CoherentPairProduction::GetMeanFreePath(), G4ElNeutrinoNucleusProcess::GetMeanFreePath(), G4MuNeutrinoNucleusProcess::GetMeanFreePath(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4NuVacOscProcess::GetMeanFreePath(), G4TauNeutrinoNucleusProcess::GetMeanFreePath(), G4EmBiasingManager::Initialise(), G4EmModelManager::Initialise(), G4PAIModel::Initialise(), G4PAIPhotModel::Initialise(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4NuVacOscProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4VEnergyLossProcess::PreparePhysicsTable(), G4RegionStore::Register(), and G4GlobalFastSimulationManager::ShowSetup().

GetNumberOfMaterials()

std::size_t G4Region::GetNumberOfMaterials ( ) const

inline

Methods to return the number of elements in the lists of materials and root logical volumes.

Referenced by G4RunManagerKernel::DumpRegion().

GetNumberOfRootVolumes()

std::size_t G4Region::GetNumberOfRootVolumes ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion().

GetParentRegion()

G4Region * G4Region::GetParentRegion

(

G4bool &

unique

)

const

Returns a region that contains this region. Otherwise null returned.

Parameters

[out]

unique

Returns true if there is only one parent region containing the current region.

Returns

A pointer to the mother region.

Definition at line 486 of file G4Region.cc.

{
  G4Region* parent = nullptr; unique = true;
  G4LogicalVolumeStore* lvStore = G4LogicalVolumeStore::GetInstance();
 
  // Loop over all logical volumes in the store
  //
  for(const auto & lvol : *lvStore)
  {
    std::size_t nD = lvol->GetNoDaughters();
    G4Region* aR = lvol->GetRegion();
 
    // Loop over all daughters of each logical volume
    //
    for(std::size_t iD=0; iD<nD; ++iD)
    {
      if(lvol->GetDaughter(iD)->GetLogicalVolume()->GetRegion()==this)
      { 
        if(parent != nullptr)
        {
          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;
}

Referenced by ClearFastSimulationManager().

GetProductionCuts()

G4ProductionCuts * G4Region::GetProductionCuts ( ) const

inline

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

GetRegionalSteppingAction()

G4UserSteppingAction * G4Region::GetRegionalSteppingAction

(

)

const

Definition at line 157 of file G4Region.cc.

{
  return G4MT_rsaction;
}

Referenced by G4RunManagerKernel::DumpRegion().

GetRootLogicalVolumeIterator()

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

inline

Methods to return iterators to the lists of root logical volumes and materials.

Referenced by G4RunManagerKernel::DumpRegion().

GetSubInstanceManager()

const G4RegionManager & G4Region::GetSubInstanceManager ( )

static

Returns the private data instance manager for multi-threading.

Definition at line 55 of file G4Region.cc.

{
  return subInstanceManager;
}

Referenced by G4GeometryWorkspace::G4GeometryWorkspace().

GetUserInformation()

G4VUserRegionInformation * G4Region::GetUserInformation ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion().

GetUserLimits()

G4UserLimits * G4Region::GetUserLimits ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion().

GetWorldPhysical()

G4VPhysicalVolume * G4Region::GetWorldPhysical ( ) const

inline

Get method for the world physical volume which the region belongs to. A valid pointer will be assigned by G4RunManagerKernel through the G4RegionStore when the geometry is to be closed. Thus, this pointer may be incorrect at the PreInit and Idle state. If the pointer is null at the proper state, this particular region does not belong to any world (maybe not assigned to any volume, etc.).

Referenced by G4RunManagerKernel::DumpRegion().

IsInMassGeometry()

G4bool G4Region::IsInMassGeometry ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion().

IsInParallelGeometry()

G4bool G4Region::IsInParallelGeometry ( ) const

inline

Referenced by G4RunManagerKernel::DumpRegion().

IsModified()

G4bool G4Region::IsModified ( ) const

inline

operator=()

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

delete

operator==()

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

inline

Equality operator, defined by address only.

RegionModified()

void G4Region::RegionModified ( G4bool flag )

inline

Accessors to flag identifying if a region has been modified (and still cuts needs to be computed) or not.

RegisterMaterialCouplePair()

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

inline

Method invoked by G4ProductionCutsTable to register the material-cuts couple pair.

RemoveRootLogicalVolume()

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

Removes a root logical volume and resets its daughters flags as regions. It also recompute the materials list for the region. The flag for scanning the subtree is always enabled by default.

Parameters

[in]	lv	Pointer to the logical volume to remove as root region.
[in]	scan	To enable/disable scanning the tree (default true).

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

ScanVolumeTree()

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

Scans recursively the 'lv' logical volume tree, retrieves and places all materials in the list if becoming a region.

Definition at line 171 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;
  std::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); 
      auto  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)
    {
      std::size_t matNo = pParam->GetMaterialScanner()->GetNumberOfMaterials();
      for (std::size_t mat=0; mat<matNo; ++mat)
      {
        volMat = pParam->GetMaterialScanner()->GetMaterial((G4int)mat);
        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); 
          auto  baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial());
          if (baseMat != nullptr) { AddMaterial(baseMat); }
        }
      }
    }
    else
    {
      std::size_t repNo = daughterPVol->GetMultiplicity();
      for (std::size_t rep=0; rep<repNo; ++rep)
      {
        volMat = pParam->ComputeMaterial((G4int)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);
          auto  baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial());
          if (baseMat != nullptr) { AddMaterial(baseMat); }
        }
      }
    }
    G4LogicalVolume* daughterLVol = daughterPVol->GetLogicalVolume();
    ScanVolumeTree(daughterLVol, region);
  }
  else
  {
    for (std::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);
      }
    }
  }
}

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

SetFastSimulationManager()

void G4Region::SetFastSimulationManager

(

G4FastSimulationManager *

fsm

)

Setter/getter for the fast-simulation manager. The root logical volume that has the region with G4FastSimulationManager becomes an envelope of fast simulation.

Definition at line 130 of file G4Region.cc.

{
  G4MT_fsmanager = fsm;
}

Referenced by G4FastSimulationManager::G4FastSimulationManager().

SetFieldManager()

void G4Region::SetFieldManager ( G4FieldManager * fm )

inline

Setter/getter for the field manager. The region with assigned field-manager sets the field to the geometrical area associated with it; priority is anyhow given to local fields eventually set to logical volumes.

SetName()

void G4Region::SetName

(

const G4String &

name

)

Setter/getter for the region's name.

Definition at line 120 of file G4Region.cc.

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

SetProductionCuts()

void G4Region::SetProductionCuts ( G4ProductionCuts * cut )

inline

Setter/getter for the production cuts values.

Referenced by G4RunManagerKernel::DumpRegion(), and G4VUserPhysicsList::SetParticleCuts().

SetRegionalSteppingAction()

void G4Region::SetRegionalSteppingAction

(

G4UserSteppingAction *

rusa

)

Setter/getter methods for the regional user stepping action.

Definition at line 148 of file G4Region.cc.

{
  G4MT_rsaction = rusa;
}

SetUserInformation()

void G4Region::SetUserInformation ( G4VUserRegionInformation * ui )

inline

Setter/getter for the user information data.

SetUserLimits()

void G4Region::SetUserLimits ( G4UserLimits * ul )

inline

Setter/getter for the user-limits associated to a region. Once user-limits are set, it will propagate to the daughter volumes.

SetWorld()

void G4Region::SetWorld

(

G4VPhysicalVolume *

wp

)

Sets the world physical volume if the region belongs to this world. If 'wp' pointer is null, resets the pointer.

Definition at line 411 of file G4Region.cc.

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

UpdateMaterialList()

void G4Region::UpdateMaterialList

(

)

Clears the material list and recomputes it, looping through each root logical volume in the region.

Definition at line 390 of file G4Region.cc.

{
  // Reset the materials list
  //
  ClearMaterialList();
 
  // Loop over the root logical volumes and rebuild the list
  // of materials from scratch
  //
  for (const auto & rootVolume : fRootVolumes)
  {
    ScanVolumeTree(rootVolume, true);
  }
}

Referenced by RemoveRootLogicalVolume().

UsedInMassGeometry()

void G4Region::UsedInMassGeometry ( G4bool val = true )

inline

Utility methods to identify if the region is part of the main mass geometry for tracking or part of a parallel geometry.

UsedInParallelGeometry()

void G4Region::UsedInParallelGeometry ( G4bool val = true )

inline

---

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

• G4Region.hh
• G4Region.cc