G4Region Class Reference

#include <G4Region.hh>

Public Member Functions
	G4Region (const G4String &name)
virtual	~G4Region ()
G4bool	operator== (const G4Region &rg) const
void	AddRootLogicalVolume (G4LogicalVolume *lv)
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
size_t	GetNumberOfMaterials () const
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 *thePhys) const
G4Region *	GetParentRegion (G4bool &unique) const
void	SetRegionalSteppingAction (G4UserSteppingAction *rusa)
G4UserSteppingAction *	GetRegionalSteppingAction () const
	G4Region (__void__ &)
void	UsedInMassGeometry (G4bool val=true)
void	UsedInParallelGeometry (G4bool val=true)
G4bool	IsInMassGeometry () const
G4bool	IsInParallelGeometry () const

---

Detailed Description

Definition at line 61 of file G4Region.hh.

---

Constructor & Destructor Documentation

G4Region::G4Region

(

const G4String &

name

)

Definition at line 48 of file G4Region.cc.

References G4endl, G4Exception(), G4RegionStore::GetInstance(), G4RegionStore::GetRegion(), JustWarning, and G4RegionStore::Register().

  : fName(pName), fRegionMod(true), fCut(0), fUserInfo(0), fUserLimits(0),
    fFieldManager(0), fFastSimulationManager(0), fWorldPhys(0),
    fRegionalSteppingAction(0),
    fInMassGeometry(false), fInParallelGeometry(false)
{
  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);
  }
}

G4Region::~G4Region

(

)

[virtual]

Definition at line 91 of file G4Region.cc.

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

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

G4Region::G4Region

(

__void__ &

)

Definition at line 75 of file G4Region.cc.

References G4RegionStore::GetInstance(), and G4RegionStore::Register().

  : fName(""), fRegionMod(true), fCut(0), fUserInfo(0), fUserLimits(0),
    fFieldManager(0), fFastSimulationManager(0), fWorldPhys(0),
    fRegionalSteppingAction(0),
    fInMassGeometry(false), fInParallelGeometry(false)
{
  // Register to store
  //
  G4RegionStore::GetInstance()->Register(this);
}

---

Member Function Documentation

void G4Region::AddRootLogicalVolume

(

G4LogicalVolume *

lv

)

Definition at line 227 of file G4Region.cc.

References ScanVolumeTree(), and G4LogicalVolume::SetRegionRootFlag().

Referenced by G4RunManagerKernel::DefineWorldVolume().

{
  // Check the logical volume is not already in the list
  //
  G4RootLVList::iterator pos;
  pos = std::find(fRootVolumes.begin(),fRootVolumes.end(),lv);
  if (pos == fRootVolumes.end())
  {
    // Insert the root volume in the list and set it as root region
    //
    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;
}

G4bool G4Region::BelongsTo

(

G4VPhysicalVolume *

thePhys

)

const

Definition at line 335 of file G4Region.cc.

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

Referenced by SetWorld().

{
  G4LogicalVolume* currLog = thePhys->GetLogicalVolume();
  if (currLog->GetRegion()==this) {return true;}

  G4int nDaughters = currLog->GetNoDaughters();
  while (nDaughters--)
  {
    if (BelongsTo(currLog->GetDaughter(nDaughters))) {return true;}
  }

  return false;
}

void G4Region::ClearFastSimulationManager

(

)

Definition at line 355 of file G4Region.cc.

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

Referenced by G4FastSimulationManager::~G4FastSimulationManager().

{
  G4bool isUnique;
  G4Region* parent = GetParentRegion(isUnique);
  if(parent)
  {
    if (isUnique)
    {
      fFastSimulationManager = 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);
      fFastSimulationManager = 0;
    }
  }
  else
  {
    fFastSimulationManager = 0;
  }
}

void G4Region::ClearMap

(

)

[inline]

Definition at line 196 of file G4Region.icc.

{
  if(!(fMaterialCoupleMap.empty()))
  {
    G4MaterialCoupleMap::iterator b = fMaterialCoupleMap.begin();
    G4MaterialCoupleMap::iterator e = fMaterialCoupleMap.end();
    fMaterialCoupleMap.erase(b,e);
  }
}

void G4Region::ClearMaterialList

(

)

Definition at line 286 of file G4Region.cc.

Referenced by UpdateMaterialList().

{
  fMaterials.clear();
}

G4MaterialCutsCouple * G4Region::FindCouple

(

G4Material *

mat

)

[inline]

Definition at line 222 of file G4Region.icc.

Referenced by G4LogicalVolume::UpdateMaterial().

{
  G4MaterialCoupleMap::iterator c = fMaterialCoupleMap.find(mat);
  G4MaterialCutsCouple* couple = 0;
  if(c!=fMaterialCoupleMap.end()) couple = (*c).second;
  return couple;
}

G4FastSimulationManager * G4Region::GetFastSimulationManager

(

)

const [inline]

Definition at line 245 of file G4Region.icc.

Referenced by ClearFastSimulationManager(), G4RunManagerKernel::DumpRegion(), G4VFastSimulationModel::G4VFastSimulationModel(), G4LogicalVolume::GetFastSimulationManager(), and G4FastSimulationManager::~G4FastSimulationManager().

{
  return fFastSimulationManager;
}

G4FieldManager * G4Region::GetFieldManager

(

)

const [inline]

Definition at line 255 of file G4Region.icc.

Referenced by G4PropagatorInField::FindAndSetFieldManager().

{
  return fFieldManager;
}

std::vector< G4Material * >::const_iterator G4Region::GetMaterialIterator

(

)

const [inline]

Definition at line 125 of file G4Region.icc.

Referenced by G4RunManagerKernel::DumpRegion().

{
  G4MaterialList::const_iterator iterator = fMaterials.begin();
  return iterator;
}

const G4String & G4Region::GetName

(

)

const [inline]

Definition at line 50 of file G4Region.icc.

Referenced by G4PhysicalVolumeModel::CreateCurrentAttValues(), G4RunManagerKernel::DefineWorldVolume(), G4EmModelManager::DumpModelList(), G4RunManagerKernel::DumpRegion(), G4FastSimulationManager::ListTitle(), and G4GlobalFastSimulationManager::ShowSetup().

{
  return fName;
}

size_t G4Region::GetNumberOfMaterials

(

)

const [inline]

Definition at line 136 of file G4Region.icc.

Referenced by G4RunManagerKernel::DumpRegion().

{
  return fMaterials.size();
}

size_t G4Region::GetNumberOfRootVolumes

(

)

const [inline]

Definition at line 146 of file G4Region.icc.

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

{
  return fRootVolumes.size();
}

G4Region * G4Region::GetParentRegion

(

G4bool &

unique

)

const

Definition at line 390 of file G4Region.cc.

References G4LogicalVolumeStore::GetInstance().

Referenced by ClearFastSimulationManager().

{
  G4Region* parent = 0; unique = true;
  G4LogicalVolumeStore* lvStore = G4LogicalVolumeStore::GetInstance();
  G4LogicalVolumeStore::iterator lvItr;

  // Loop over all logical volumes in the store
  //
  for(lvItr=lvStore->begin(); lvItr!=lvStore->end(); lvItr++)
  {
    G4int nD = (*lvItr)->GetNoDaughters();
    G4Region* aR = (*lvItr)->GetRegion();

    // Loop over all daughters of each logical volume
    //
    for(G4int 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;
}

G4ProductionCuts * G4Region::GetProductionCuts

(

)

const [inline]

Definition at line 101 of file G4Region.icc.

Referenced by G4RunManagerKernel::DumpRegion(), G4EmCalculator::FindCouple(), G4VUserPhysicsList::GetCutValue(), G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), and G4VUserPhysicsList::SetParticleCuts().

{
  return fCut;
}

G4UserSteppingAction * G4Region::GetRegionalSteppingAction

(

)

const [inline]

Definition at line 311 of file G4Region.icc.

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

{
  return fRegionalSteppingAction;
}

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

(

)

[inline]

Definition at line 112 of file G4Region.icc.

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

{
  G4RootLVList::iterator iterator =
    G4RootLVList::iterator(fRootVolumes.begin());
  return iterator;
}

G4VUserRegionInformation * G4Region::GetUserInformation

(

)

const [inline]

Definition at line 166 of file G4Region.icc.

Referenced by G4RunManagerKernel::DumpRegion().

{
  return fUserInfo;
}

G4UserLimits * G4Region::GetUserLimits

(

)

const [inline]

Definition at line 186 of file G4Region.icc.

Referenced by G4RunManagerKernel::DumpRegion(), and G4LogicalVolume::GetUserLimits().

{
  return fUserLimits;
}

G4VPhysicalVolume * G4Region::GetWorldPhysical

(

)

const [inline]

Definition at line 275 of file G4Region.icc.

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

{
  return fWorldPhys;
}

G4bool G4Region::IsInMassGeometry

(

)

const [inline]

Definition at line 341 of file G4Region.icc.

Referenced by G4RunManagerKernel::DumpRegion().

{
  return fInMassGeometry;
}

G4bool G4Region::IsInParallelGeometry

(

)

const [inline]

Definition at line 351 of file G4Region.icc.

Referenced by G4RunManagerKernel::DumpRegion().

{
  return fInParallelGeometry;
}

G4bool G4Region::IsModified

(

)

const [inline]

Definition at line 80 of file G4Region.icc.

{
  return fRegionMod;
}

G4bool G4Region::operator==

(

const G4Region &

rg

)

const [inline]

Definition at line 40 of file G4Region.icc.

{
  return (this==&rg) ? true : false;
}

void G4Region::RegionModified

(

G4bool

flag

)

[inline]

Definition at line 70 of file G4Region.icc.

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

{
  fRegionMod = flag;
}

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

Definition at line 211 of file G4Region.icc.

{
  fMaterialCoupleMap.insert(G4MaterialCouplePair(mat,couple));
}

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

Definition at line 256 of file G4Region.cc.

References G4LogicalVolume::SetRegionRootFlag(), and UpdateMaterialList().

Referenced by G4RunManagerKernel::DefineWorldVolume(), and G4LogicalVolume::~G4LogicalVolume().

{
  // Find and remove logical volume from the list
  //
  G4RootLVList::iterator pos;
  pos = std::find(fRootVolumes.begin(),fRootVolumes.end(),lv);
  if (pos != fRootVolumes.end())
  {
    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;
}

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

Definition at line 106 of file G4Region.cc.

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

Referenced by AddRootLogicalVolume(), G4LogicalVolume::PropagateRegion(), and UpdateMaterialList().

{
  // If logical volume is going to become a region, add 
  // its material to the list if not already present
  //
  G4Region* currentRegion = 0;
  size_t noDaughters = lv->GetNoDaughters();
  G4Material* volMat = lv->GetMaterial();
  if(!volMat && 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)
    { 
      AddMaterial(volMat); 
      G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial());
      if (baseMat) { 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())
    {
      size_t matNo = pParam->GetMaterialScanner()->GetNumberOfMaterials();
      for (register 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)
        { 
          AddMaterial(volMat); 
          G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial());
          if (baseMat) { AddMaterial(baseMat); }
        }
      }
    }
    else
    {
      size_t repNo = daughterPVol->GetMultiplicity();
      for (register size_t rep=0; rep<repNo; rep++)
      {
        volMat = pParam->ComputeMaterial(rep, daughterPVol);
        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)
        { 
          AddMaterial(volMat);
          G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial());
          if (baseMat) { AddMaterial(baseMat); }
        }
      }
    }
    G4LogicalVolume* daughterLVol = daughterPVol->GetLogicalVolume();
    ScanVolumeTree(daughterLVol, region);
  }
  else
  {
    for (register 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);
      }
    }
  }
}

void G4Region::SetFastSimulationManager

(

G4FastSimulationManager *

fsm

)

[inline]

Definition at line 235 of file G4Region.icc.

Referenced by G4FastSimulationManager::G4FastSimulationManager().

{
  fFastSimulationManager = fsm;
}

void G4Region::SetFieldManager

(

G4FieldManager *

fm

)

[inline]

Definition at line 265 of file G4Region.icc.

{
  fFieldManager = fm;
}

void G4Region::SetName

(

const G4String &

name

)

[inline]

Definition at line 60 of file G4Region.icc.

{
  fName = pName;
}

void G4Region::SetProductionCuts

(

G4ProductionCuts *

cut

)

[inline]

Definition at line 90 of file G4Region.icc.

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

{
  fCut = cut;
  fRegionMod = true;
}

void G4Region::SetRegionalSteppingAction

(

G4UserSteppingAction *

rusa

)

[inline]

Definition at line 301 of file G4Region.icc.

{
  fRegionalSteppingAction = rusa;
}

void G4Region::SetUserInformation

(

G4VUserRegionInformation *

ui

)

[inline]

Definition at line 156 of file G4Region.icc.

{
  fUserInfo = ui;
}

void G4Region::SetUserLimits

(

G4UserLimits *

ul

)

[inline]

Definition at line 176 of file G4Region.icc.

{
  fUserLimits = ul;
}

void G4Region::SetWorld

(

G4VPhysicalVolume *

wp

)

Definition at line 319 of file G4Region.cc.

References BelongsTo().

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

  return;
}

void G4Region::UpdateMaterialList

(

)

Definition at line 297 of file G4Region.cc.

References ClearMaterialList(), and ScanVolumeTree().

Referenced by RemoveRootLogicalVolume().

{
  // Reset the materials list
  //
  ClearMaterialList();

  // Loop over the root logical volumes and rebuild the list
  // of materials from scratch
  //
  G4RootLVList::iterator pLV;
  for (pLV=fRootVolumes.begin(); pLV!=fRootVolumes.end(); pLV++)
  {
    ScanVolumeTree(*pLV, true);
  }
}

void G4Region::UsedInMassGeometry

(

G4bool

val = true

)

[inline]

Definition at line 321 of file G4Region.icc.

{
  fInMassGeometry = val;
}

void G4Region::UsedInParallelGeometry

(

G4bool

val = true

)

[inline]

Definition at line 331 of file G4Region.icc.

{
  fInParallelGeometry = val;
}

---

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

• G4Region.hh
• G4Region.icc
• G4Region.cc

---