EIC code displayed by LXR master/​include/​Geant4/​G4RegionStore.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:59:02

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 // G4RegionStore
 //
 // Class description:
 //
 // Container for all regions, with functionality derived from
 // std::vector<T>. The class is a 'singleton', in that only
 // one can exist, and access is provided via the static method
 // G4RegionStore::GetInstance().
 //
 // 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.
 //
 // If much additional functionality is added, should consider containment
 // instead of inheritance for std::vector<T>.
 
 // 18.09.02, G.Cosmo - Initial version
 // --------------------------------------------------------------------
 #ifndef G4REGIONSTORE_HH
 #define G4REGIONSTORE_HH 1
 
 #include <vector>
 #include <map>
 
 #include "G4Types.hh"
 #include "G4String.hh"
 #include "G4VStoreNotifier.hh"
 
 class G4Region;
 class G4VPhysicalVolume;
 
 class G4RegionStore : public std::vector<G4Region*>
 {
   public:
 
     static void Register(G4Region* pRegion);
       // Add the region to the collection.
     static void DeRegister(G4Region* pRegion);
       // Remove the region from the collection.
     static G4RegionStore* GetInstance();
       // Get a ptr to the unique G4RegionStore, creating it if necessary.
     static void SetNotifier(G4VStoreNotifier* pNotifier);
       // Assign a notifier for allocation/deallocation of regions.
     static void Clean();
       // Delete all regions from the store except for the world region.
 
     G4bool IsModified() const;
       // Loops through all regions to verify if a region has been
       // modified. It returns TRUE if just one region is modified.
     void ResetRegionModified();
       // Loops through all regions to reset flag for modification
       // to FALSE. Used by the run manager to notify that the
       // physics table has been updated.
 
     void UpdateMaterialList(G4VPhysicalVolume* currentWorld=nullptr);
       // Forces recomputation of material lists in all regions
       // in the store.
 
     G4Region* GetRegion(const G4String& name, G4bool verbose = true) const;
       // Returns a region through its name specification. Uses the internal
       // map for fast search and warns if a region in the collection is not
       // unique or not found.
 
     inline G4bool IsMapValid() const  { return mvalid; }
     inline void SetMapValid(G4bool val)  { mvalid = val; }
       // Accessor to assess validity of the internal map.
     inline const std::map<G4String,
             std::vector<G4Region*> >& GetMap() const { return bmap; }
       // Return the internal map.
     void UpdateMap();
       // Bring contents of internal map up to date and resets validity flag.
 
     G4Region* FindOrCreateRegion(const G4String& name);
       // Returns a region through its name specification, if it exists.
       // If it does not exist it will allocate one delegating ownership
       // to the client.
 
     void SetWorldVolume();
       // Set a world volume pointer to a region that belongs to it.
       // Scan over all world volumes.
       // This method should be exclusively used by G4RunManagerKernel.
 
     virtual ~G4RegionStore();
       // Destructor: takes care to delete allocated regions.
 
     G4RegionStore(const G4RegionStore&) = delete;
     G4RegionStore& operator=(const G4RegionStore&) = delete;
       // Forbidden copy constructor and assignment operator
 
   protected:
 
     G4RegionStore();
       // Protected singleton constructor.
 
   private:
 
     static G4RegionStore* fgInstance;
     static G4ThreadLocal G4VStoreNotifier* fgNotifier;
     static G4ThreadLocal G4bool locked;
 
     std::map<G4String, std::vector<G4Region*> > bmap;
     G4bool mvalid = false;  // Flag to indicate if map is up to date or not
 };
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team