TSRun Class Reference

#include <Doxymodules_parallel.h>

Inheritance diagram for TSRun:

Public Types
typedef std::map< G4int, G4double >	MutexHitsMap_t

Public Member Functions
	TSRun (const G4String &)
virtual	~TSRun ()
virtual void	RecordEvent (const G4Event *)
G4THitsMap< G4double > *	GetHitsMap (const G4String &collname) const
G4TAtomicHitsMap< G4double > *	GetAtomicHitsMap (const G4String &) const
MutexHitsMap_t *	GetMutexHitsMap (const G4String &) const
G4StatContainer< G4StatAnalysis > *	GetStatMap (const G4String &collname) const
G4StatContainer< G4ConvergenceTester > *	GetConvMap (const G4String &) const
void	ConstructMFD (const G4String &)
virtual void	Merge (const G4Run *)

Private Attributes
std::vector< G4String >	fCollNames
std::vector< G4int >	fCollIDs
std::vector< G4THitsMap< G4double > * >	fRunMaps
std::vector< G4StatContainer< G4StatAnalysis > * >	fStatMaps

Static Private Attributes
static std::vector< G4TAtomicHitsMap< G4double > * >	fAtomicRunMaps
	TSRun contains five hits collections types: 1) a thread-local hits map, 2) a global atomic hits map 3) a global "mutex" hits map 4) a global G4StatAnalysis hits deque 5) a global G4ConvergenceTester hits deque.
static std::map< G4String, MutexHitsMap_t >	fMutexRunMaps
static std::vector< G4StatContainer< G4ConvergenceTester > * >	fConvMaps

Detailed Description

Definition at line 149 of file Doxymodules_parallel.h.

Member Typedef Documentation

MutexHitsMap_t

typedef std::map<G4int, G4double> TSRun::MutexHitsMap_t

Definition at line 79 of file TSRun.hh.

Constructor & Destructor Documentation

TSRun()

TSRun::TSRun

(

const G4String &

mfd_name

)

Definition at line 89 of file TSRun.cc.

  : G4Run()
{
  ConstructMFD(mfd_name);
}

~TSRun()

TSRun::~TSRun ( )

virtual

Definition at line 97 of file TSRun.cc.

{
  //--- Clear HitsMap for RUN
  for(unsigned i = 0; i < fRunMaps.size(); ++i)
    delete fRunMaps[i];
 
  if(!G4Threading::IsWorkerThread())
  {
    for(unsigned i = 0; i < fAtomicRunMaps.size(); ++i)
      delete fAtomicRunMaps[i];
 
    for(auto& itr : fConvMaps)
      delete itr;
 
    fAtomicRunMaps.clear();
    fMutexRunMaps.clear();
    fConvMaps.clear();
  }
}

Member Function Documentation

RecordEvent()

void TSRun::RecordEvent ( const G4Event *  aEvent )

virtual

Definition at line 182 of file TSRun.cc.

{
  G4Run::RecordEvent(aEvent);
 
  //=============================
  // HitsCollection of This Event
  //============================
  G4HCofThisEvent* HCE = aEvent->GetHCofThisEvent();
  if(!HCE)
    return;
 
  for(unsigned i = 0; i < fCollIDs.size(); ++i)
  {
    G4int fCollID = fCollIDs.at(i);
    //=======================================================
    // Sum up HitsMap of this Event into HitsMap of this RUN
    //=======================================================
    G4THitsMap<G4double>* EvtMap = 0;
    if(fCollID >= 0)  // Collection is attached to HCE
      EvtMap = static_cast<G4THitsMap<G4double>*>(HCE->GetHC(fCollID));
    else
      G4cout << " Error EvtMap Not Found " << G4endl;
 
    G4USER_SCOPED_PROFILE(fCollNames.at(i));
    if(EvtMap)
    {
      //=== Sum up HitsMap of this event to HitsMap of RUN.===
      {
        G4USER_SCOPED_PROFILE("ThreadLocal");
        *fRunMaps[fCollID] += *EvtMap;
      }
      //=== Sum up HitsMap of this event to StatMap of RUN.===
      {
        G4USER_SCOPED_PROFILE("ThreadLocal/G4StatAnalysis");
        // G4StatAnalysis map
        *fStatMaps[fCollID] += *EvtMap;
      }
      //=== Sum up HitsMap of this event to atomic HitsMap of RUN.===
      {
        G4USER_SCOPED_PROFILE("Global/Atomic");
        *fAtomicRunMaps[fCollID] += *EvtMap;
      }
      //=== Sum up HitsMap of this event to MutexMap of RUN.===
      {
        G4USER_SCOPED_PROFILE("Global/Mutex");
        // mutex run map
        static G4Mutex mtx = G4MUTEX_INITIALIZER;
        G4AutoLock lock(&mtx);
        for(const auto& itr : *EvtMap)
          fMutexRunMaps[fCollNames[fCollID]][itr.first] += *itr.second;
      }
      //=== Sum up HitsMap of this event to MutexMap of RUN.===
      {
        G4USER_SCOPED_PROFILE("Global/Mutex/G4ConvergenceTester");
        // G4ConvergenceTester run map
        static G4Mutex mtx = G4MUTEX_INITIALIZER;
        G4AutoLock lock(&mtx);
        *fConvMaps[fCollID] += *EvtMap;
      }
    }
  }
}

GetHitsMap()

G4THitsMap< G4double > * TSRun::GetHitsMap

(

const G4String &

collname

)

const

Definition at line 266 of file TSRun.cc.

{
  for(unsigned i = 0; i < fCollNames.size(); ++i)
  {
    if(collName == fCollNames[i])
      return fRunMaps[i];
  }
 
  G4Exception("TSRun", collName.c_str(), JustWarning,
              "GetHitsMap failed to locate the requested HitsMap");
  return nullptr;
}

GetAtomicHitsMap()

G4TAtomicHitsMap< G4double > * TSRun::GetAtomicHitsMap

(

const G4String &

collName

)

const

Definition at line 284 of file TSRun.cc.

{
  for(unsigned i = 0; i < fCollNames.size(); ++i)
  {
    if(collName == fCollNames[i])
      return fAtomicRunMaps[i];
  }
 
  G4Exception("TSRun", collName.c_str(), JustWarning,
              "GetHitsMap failed to locate the requested AtomicHitsMap");
  return nullptr;
}

GetMutexHitsMap()

TSRun::MutexHitsMap_t * TSRun::GetMutexHitsMap

(

const G4String &

collName

)

const

Definition at line 303 of file TSRun.cc.

{
  if(fMutexRunMaps.find(collName) != fMutexRunMaps.end())
    return &fMutexRunMaps[collName];
 
  G4Exception("TSRun", collName.c_str(), JustWarning,
              "GetHitsMap failed to locate the requested MutexHitsMap");
  return nullptr;
}

GetStatMap()

G4StatContainer< G4StatAnalysis > * TSRun::GetStatMap

(

const G4String &

collname

)

const

Definition at line 318 of file TSRun.cc.

{
  for(unsigned i = 0; i < fCollNames.size(); ++i)
  {
    if(collName == fCollNames[i])
      return fStatMaps[i];
  }
 
  G4Exception("TSRun", collName.c_str(), JustWarning,
              "GetStatMap failed to locate the requested StatMap");
  return nullptr;
}

GetConvMap()

G4StatContainer< G4ConvergenceTester > * TSRun::GetConvMap

(

const G4String &

collName

)

const

Definition at line 334 of file TSRun.cc.

{
  for(unsigned i = 0; i < fCollNames.size(); ++i)
  {
    if(collName == fCollNames[i])
      return fConvMaps[i];
  }
 
  G4Exception("TSRun", collName.c_str(), JustWarning,
              "GetHitsMap failed to locate the requested AtomicHitsMap");
  return nullptr;
}

ConstructMFD()

void TSRun::ConstructMFD

(

const G4String &

mfdName

)

Definition at line 120 of file TSRun.cc.

{
  G4SDManager* SDman = G4SDManager::GetSDMpointer();
  //=================================================
  //  Initalize RunMaps for accumulation.
  //  Get CollectionIDs for HitCollections.
  //=================================================
  G4MultiFunctionalDetector* mfd =
    (G4MultiFunctionalDetector*) (SDman->FindSensitiveDetector(mfdName));
  //
  if(mfd)
  {
    //--- Loop over the registered primitive scorers.
    for(G4int icol = 0; icol < mfd->GetNumberOfPrimitives(); icol++)
    {
      // Get Primitive Scorer object.
      G4VPrimitiveScorer* scorer = mfd->GetPrimitive(icol);
      // collection name and collectionID for HitsCollection,
      // where type of HitsCollection is G4THitsMap in case
      // of primitive scorer.
      // The collection name is given by <MFD name>/<Primitive
      // Scorer name>.
      G4String collectionName     = scorer->GetName();
      G4String fullCollectionName = mfdName + "/" + collectionName;
      G4int collectionID          = SDman->GetCollectionID(fullCollectionName);
      //
      if(collectionID >= 0)
      {
        G4cout << "++ " << fullCollectionName << " id " << collectionID
               << G4endl;
        // Store obtained HitsCollection information into data members.
        // And, creates new G4THitsMap for accumulating quantities during RUN.
        fCollNames.push_back(fullCollectionName);
        fCollIDs.push_back(collectionID);
        fRunMaps.push_back(new G4THitsMap<G4double>(mfdName, collectionName));
        fStatMaps.push_back(new G4StatContainer<G4StatAnalysis>(
          mfdName, collectionName,
          TSDetectorConstruction::Instance()->GetTotalTargets()));
        if(!G4Threading::IsWorkerThread())
        {
          fAtomicRunMaps.push_back(
            new G4TAtomicHitsMap<G4double>(mfdName, collectionName));
          fMutexRunMaps[fCollNames[collectionID]].clear();
          fConvMaps.push_back(new G4StatContainer<G4ConvergenceTester>(
            mfdName, collectionName,
            TSDetectorConstruction::Instance()->GetTotalTargets()));
        }
      }
      else
      {
        G4cout << "** collection " << fullCollectionName << " not found. "
               << G4endl;
      }
    }
  }
}

Merge()

void TSRun::Merge ( const G4Run *  aTSRun )

virtual

Definition at line 248 of file TSRun.cc.

{
  const TSRun* localTSRun = static_cast<const TSRun*>(aTSRun);
 
  for(unsigned i = 0; i < fRunMaps.size(); ++i)
  {
    *fRunMaps[i] += *localTSRun->fRunMaps[i];
    *fStatMaps[i] += *localTSRun->fStatMaps[i];
  }
 
  G4Run::Merge(aTSRun);
}

Member Data Documentation

fCollNames

std::vector<G4String> TSRun::fCollNames

private

Definition at line 102 of file TSRun.hh.

fCollIDs

std::vector<G4int> TSRun::fCollIDs

private

Definition at line 103 of file TSRun.hh.

fRunMaps

std::vector<G4THitsMap<G4double>*> TSRun::fRunMaps

private

Definition at line 104 of file TSRun.hh.

fStatMaps

std::vector<G4StatContainer<G4StatAnalysis>*> TSRun::fStatMaps

private

Definition at line 105 of file TSRun.hh.

fAtomicRunMaps

std::vector< G4TAtomicHitsMap< G4double > * > TSRun::fAtomicRunMaps

staticprivate

TSRun contains five hits collections types: 1) a thread-local hits map, 2) a global atomic hits map 3) a global "mutex" hits map 4) a global G4StatAnalysis hits deque 5) a global G4ConvergenceTester hits deque.

The thread-local hits map is the same as you will find in many other examples.

The atomics hits map is the purpose of this example. Code-wise, the implementation looks extremely similar to the thread-local version with 3 primary exceptions: (1) construction - there should only be one instance so it should be a static member variable or a pointer/reference to a single instance (2) It does not need to, nor should be, summed in G4Run::Merge() (3) destruction – it should only be cleared by the master thread since there is only one instance.

The "mutex" hits map is also included as reference for checking the results accumulated by the thread-local hits maps and atomic hits maps. The differences w.r.t. this hits maps are computed in TSRunAction::EndOfRunAction

The "G4StatAnalysis" and "G4ConvergenceTester" hits deques are memory-efficient version of the standard G4THitsMap. While maps are ideal for scoring at the G4Event-level, where sparsity w.r.t. indices is common; at the G4Run-level, these data structures require much less memory overhead. Due to a lack of G4ConvergenceTester::operator+=(G4ConvergenceTester), the static version of G4ConvergenceTester is the only valid way to use G4ConvergenceTester in a scoring container. This is not the case for G4StatAnalysis, which can be used in lieu of G4double.

Definition at line 106 of file TSRun.hh.

fMutexRunMaps

std::map< G4String, TSRun::MutexHitsMap_t > TSRun::fMutexRunMaps

staticprivate

Definition at line 107 of file TSRun.hh.

fConvMaps

std::vector< G4StatContainer< G4ConvergenceTester > * > TSRun::fConvMaps

staticprivate

Definition at line 108 of file TSRun.hh.

---

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

• .doxygen/Doxymodules_parallel.h
• extended/parallel/ThreadsafeScorers/include/TSRun.hh
• extended/parallel/ThreadsafeScorers/src/TSRun.cc