G4RegionStore Class Reference

G4RegionStore is a singleton class, acting as container for all geometrical regions, with functionality derived from std::vector<T>. All regions should be registered with G4RegionStore, and removed on their destruction. The underlying container initially has a capacity of 20. A map indexed by volume names is also recorded for fast search; pointers to regions with same name are stored in buckets. More...

#include <G4RegionStore.hh>

Inheritance diagram for G4RegionStore:

Public Member Functions
virtual	~G4RegionStore ()
	G4RegionStore (const G4RegionStore &)=delete
G4RegionStore &	operator= (const G4RegionStore &)=delete
G4bool	IsModified () const
void	ResetRegionModified ()
void	UpdateMaterialList (G4VPhysicalVolume *currentWorld=nullptr)
G4Region *	GetRegion (const G4String &name, G4bool verbose=true) const
G4bool	IsMapValid () const
void	SetMapValid (G4bool val)
const std::map< G4String, std::vector< G4Region * > > &	GetMap () const
void	UpdateMap ()
G4Region *	FindOrCreateRegion (const G4String &name)
void	SetWorldVolume ()

Static Public Member Functions
static void	Register (G4Region *pRegion)
static void	DeRegister (G4Region *pRegion)
static G4RegionStore *	GetInstance ()
static void	SetNotifier (G4VStoreNotifier *pNotifier)
static void	Clean ()

Protected Member Functions
	G4RegionStore ()

Detailed Description

G4RegionStore is a singleton class, acting as container for all geometrical regions, with functionality derived from std::vector<T>. All regions should be registered with G4RegionStore, and removed on their destruction. The underlying container initially has a capacity of 20. A map indexed by volume names is also recorded for fast search; pointers to regions with same name are stored in buckets.

Definition at line 67 of file G4RegionStore.hh.

Constructor & Destructor Documentation

~G4RegionStore()

G4RegionStore::~G4RegionStore ( )

virtual

Destructor: takes care to delete allocated regions.

Definition at line 68 of file G4RegionStore.cc.

{
  Clean();  // Delete all regions in the store
  G4Region::Clean();  // Delete allocated sub-instance data
}

G4RegionStore() [1/2]

G4RegionStore::G4RegionStore ( const G4RegionStore & )

delete

Copy constructor and assignment operator not allowed.

Referenced by Clean(), DeRegister(), G4RegionStore(), GetInstance(), GetRegion(), operator=(), and Register().

G4RegionStore() [2/2]

G4RegionStore::G4RegionStore ( )

protected

Protected singleton constructor.

Definition at line 58 of file G4RegionStore.cc.

{
  reserve(20);
}

Member Function Documentation

Clean()

void G4RegionStore::Clean ( )

static

Deletes all regions from the store, except for the world region.

Definition at line 78 of file G4RegionStore.cc.

{
  // Do nothing if geometry is closed
  //
  if (G4GeometryManager::GetInstance()->IsGeometryClosed())
  {
    G4cout << "WARNING - Attempt to delete the region store"
           << " while geometry closed !" << G4endl;
    return;
  }
 
  // Locks store for deletion of regions. De-registration will be
  // performed at this stage. G4Regions will not de-register themselves.
  //
  locked = true;  
 
  G4RegionStore* store = GetInstance();
 
  for(const auto & pos : *store)
  {
    if (fgNotifier != nullptr) { fgNotifier->NotifyDeRegistration(); }
    delete pos;
  }
 
  store->bmap.clear(); store->mvalid = false;
  locked = false;
  store->clear();
}

Referenced by ~G4RegionStore().

DeRegister()

void G4RegionStore::DeRegister ( G4Region * pRegion )

static

Removes the region 'pRegion' from the collection.

Definition at line 171 of file G4RegionStore.cc.

{
  G4RegionStore* store = GetInstance();
  if (!locked)    // Do not de-register if locked !
  {
    if (fgNotifier != nullptr)  { fgNotifier->NotifyDeRegistration(); }
    for (auto i=store->cbegin(); i!=store->cend(); ++i)
    {
      if (**i==*pRegion)
      {
        store->erase(i);
        break;
      }
    }
    const G4String& reg_name = pRegion->GetName();
    auto it = store->bmap.find(reg_name);
    if (it != store->bmap.cend())
    {
      if (it->second.size() > 1)
      {
        for (auto i=it->second.cbegin(); i!=it->second.cend(); ++i)
        {
          if (**i==*pRegion)
          {
            it->second.erase(i);
            break;
          }
        }
      }
      else
      {
        store->bmap.erase(it);
      }
    }
  }
}

Referenced by G4Region::~G4Region().

FindOrCreateRegion()

G4Region * G4RegionStore::FindOrCreateRegion

(

const G4String &

name

)

Returns a pointer to a region through its name specification, if it exists. If it does not exist, it will allocate one, delegating ownership to the client.

Definition at line 303 of file G4RegionStore.cc.

{
  G4Region* target = GetRegion(name,false);
  if (target == nullptr)
  {
    target = new G4Region(name);
  }
  return target;
}

GetInstance()

G4RegionStore * G4RegionStore::GetInstance ( )

static

Returns a pointer to the unique instance of G4RegionStore, creating it if necessary.

Definition at line 212 of file G4RegionStore.cc.

{
  static G4RegionStore worldStore;
  if (fgInstance == nullptr)
  {
    fgInstance = &worldStore;
  }
  return fgInstance;
}

Referenced by G4EmBiasingManager::ActivateForcedInteraction(), G4EmBiasingManager::ActivateSecondaryBiasing(), G4LowECapture::BuildPhysicsTable(), G4MicroElecCapture::BuildPhysicsTable(), G4RunManagerKernel::CheckRegions(), Clean(), G4CoherentPairProductionPhysics::ConstructProcess(), G4TheRayTracer::CreateBitMap(), G4EmExtraParameters::DefineRegParamForLoss(), DeRegister(), G4RunManagerKernel::DumpRegion(), G4RunManagerKernel::DumpRegion(), G4EmUtility::FillFluctFlags(), G4EmCalculator::FindCouple(), G4EmUtility::FindRegion(), G4ProductionCutsTable::G4ProductionCutsTable(), G4Region::G4Region(), G4Region::G4Region(), G4RunManagerKernel::G4RunManagerKernel(), G4VUserPhysicsList::GetCutValue(), GetRegion(), G4EmModelManager::Initialise(), G4PAIModel::Initialise(), G4PAIPhotModel::Initialise(), G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), IsModified(), Register(), G4RunManager::ReinitializeGeometry(), ResetRegionModified(), G4VUserPhysicsList::SetCutValue(), G4VAtomDeexcitation::SetDeexcitationActiveRegion(), G4ScoringProbe::SetMaterial(), G4Region::SetName(), SetNotifier(), G4VUserPhysicsList::SetParticleCuts(), G4MaterialScanner::SetRegionName(), G4ScoringProbe::SetupGeometry(), SetWorldVolume(), G4GlobalFastSimulationManager::ShowSetup(), G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster(), UpdateMap(), UpdateMaterialList(), G4RunManagerKernel::UpdateRegion(), and G4Region::~G4Region().

GetMap()

const std::map< G4String, std::vector< G4Region * > > & G4RegionStore::GetMap ( ) const

inline

Returns the internal map.

Definition at line 142 of file G4RegionStore.hh.

{ return bmap; }

GetRegion()

G4Region * G4RegionStore::GetRegion	(	const G4String &	name,
		G4bool	verbose = true ) const

Returns a pointer to a region through its name specification. It uses the internal map for fast search and warns if a region in the collection is not unique or not found.

Definition at line 267 of file G4RegionStore.cc.

{
  G4RegionStore* store = GetInstance();
  if (!store->mvalid)  { store->UpdateMap(); }
  auto pos = store->bmap.find(name);
  if(pos != store->bmap.cend())
  {
    if ((verbose) && (pos->second.size()>1))
    {
      std::ostringstream message;
      message << "There exists more than ONE region in store named: "
              << name << "!" << G4endl
              << "Returning the first found.";
      G4Exception("G4RegionStore::GetSolid()",
                  "GeomMgt1001", JustWarning, message);
    }
    return pos->second[0];
  }
  if (verbose)
  {
    std::ostringstream message;
    message << "Region NOT found in store !" << G4endl
            << "        Region " << name << " NOT found in store !" << G4endl
            << "        Returning NULL pointer.";
    G4Exception("G4RegionStore::GetRegion()",
                "GeomMgt1001", JustWarning, message);
  }
  return nullptr;
}

Referenced by G4EmBiasingManager::ActivateForcedInteraction(), G4EmBiasingManager::ActivateSecondaryBiasing(), G4LowECapture::BuildPhysicsTable(), G4CoherentPairProductionPhysics::ConstructProcess(), G4EmExtraParameters::DefineRegParamForLoss(), G4RunManagerKernel::DumpRegion(), G4EmUtility::FillFluctFlags(), FindOrCreateRegion(), G4EmUtility::FindRegion(), G4Region::G4Region(), G4RunManagerKernel::G4RunManagerKernel(), G4VUserPhysicsList::GetCutValue(), G4EmModelManager::Initialise(), G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), G4VUserPhysicsList::SetCutValue(), G4ScoringProbe::SetMaterial(), G4VUserPhysicsList::SetParticleCuts(), G4MaterialScanner::SetRegionName(), and G4ScoringProbe::SetupGeometry().

IsMapValid()

G4bool G4RegionStore::IsMapValid ( ) const

inline

Accessor and modifier to assess validity of the internal map.

Definition at line 135 of file G4RegionStore.hh.

{ return mvalid; }

IsModified()

G4bool G4RegionStore::IsModified

(

)

const

Loops through all regions to verify if a region has been modified.

Returns

true if just one region is modified.

Definition at line 227 of file G4RegionStore.cc.

{
  for (const auto & i : *GetInstance())
  {
    if (i->IsModified()) { return true; }
  }
  return false;
}

operator=()

G4RegionStore & G4RegionStore::operator= ( const G4RegionStore & )

delete

Register()

void G4RegionStore::Register ( G4Region * pRegion )

static

Adds the region 'pRegion' to the collection.

Definition at line 148 of file G4RegionStore.cc.

{
  G4RegionStore* store = GetInstance();
  store->push_back(pRegion);
  const G4String& reg_name = pRegion->GetName();
  auto it = store->bmap.find(reg_name);
  if (it != store->bmap.cend())
  {
    it->second.push_back(pRegion);
  }
  else
  {
    std::vector<G4Region*> reg_vec { pRegion };
    store->bmap.insert(std::make_pair(reg_name, reg_vec));
  }
  if (fgNotifier != nullptr) { fgNotifier->NotifyRegistration(); }
  store->mvalid = true;
}

Referenced by G4Region::G4Region(), and G4Region::G4Region().

ResetRegionModified()

void G4RegionStore::ResetRegionModified

(

)

Loops through all regions to reset the flag for modification to false. Used by the run manager to notify that the physics table has been updated.

Definition at line 241 of file G4RegionStore.cc.

{
  for (const auto & i : *GetInstance())
  {
    i->RegionModified(false);
  }
}

SetMapValid()

void G4RegionStore::SetMapValid ( G4bool val )

inline

Definition at line 136 of file G4RegionStore.hh.

{ mvalid = val; }

Referenced by G4Region::SetName().

SetNotifier()

void G4RegionStore::SetNotifier ( G4VStoreNotifier * pNotifier )

static

Assigns a notifier for allocation/deallocation of regions.

Definition at line 111 of file G4RegionStore.cc.

{
  GetInstance();
  fgNotifier = pNotifier;
}

SetWorldVolume()

void G4RegionStore::SetWorldVolume

(

)

Sets a world volume pointer to a region that belongs to it. Scans over all world volumes. This method should be exclusively used by G4RunManagerKernel.

Definition at line 318 of file G4RegionStore.cc.

{
  // Reset all pointers first
  //
  for (const auto & i : *GetInstance())
  { i->SetWorld(nullptr); }
 
  // Find world volumes
  //
  G4PhysicalVolumeStore* fPhysicalVolumeStore
    = G4PhysicalVolumeStore::GetInstance();
  std::size_t nPhys = fPhysicalVolumeStore->size();
  for(std::size_t iPhys=0; iPhys<nPhys; ++iPhys)
  {
    G4VPhysicalVolume* fPhys = (*fPhysicalVolumeStore)[iPhys];
    if(fPhys->GetMotherLogical() != nullptr) { continue; } // not a world volume
 
    // Now 'fPhys' is a world volume, set it to regions that belong to it.
    //
    for (const auto & i : *GetInstance())
    { i->SetWorld(fPhys); }
  }
}

UpdateMap()

void G4RegionStore::UpdateMap

(

)

Brings contents of the internal map up to date and resets validity flag.

Definition at line 121 of file G4RegionStore.cc.

{
  G4AutoLock l(&mapMutex);  // to avoid thread contention at initialisation
  if (mvalid) { return; }
  bmap.clear();
  for(const auto & pos : *GetInstance())
  {
    const G4String& reg_name = pos->GetName();
    auto it = bmap.find(reg_name);
    if (it != bmap.cend())
    {
      it->second.push_back(pos);
    }
    else
    {
      std::vector<G4Region*> reg_vec { pos };
      bmap.insert(std::make_pair(reg_name, reg_vec));
    }
  }
  mvalid = true;
  l.unlock();
}

Referenced by GetRegion().

UpdateMaterialList()

void G4RegionStore::UpdateMaterialList

(

G4VPhysicalVolume *

currentWorld = nullptr

)

Forces recomputation of the material lists in all regions in the store.

Definition at line 253 of file G4RegionStore.cc.

{
  for (const auto & i : *GetInstance())
  {
    if(i->IsInMassGeometry() || i->IsInParallelGeometry()
                                || (currentWorld != nullptr))
    { i->UpdateMaterialList(); }
  }
}

Referenced by G4TheRayTracer::CreateBitMap(), and G4RunManagerKernel::UpdateRegion().

---

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

• G4RegionStore.hh
• G4RegionStore.cc