#include <G4MoleculeCounterManager.hh>

Public Member Functions
	G4MoleculeCounterManager (Private)
	~G4MoleculeCounterManager ()
void	Initialize ()
G4int	RegisterCounter (std::unique_ptr< G4VMoleculeCounter >)
G4int	RegisterCounter (std::unique_ptr< G4VMoleculeReactionCounter >)
void	DeregisterAllCounters ()
void	BeginOfEventAction (const G4Event *)
void	BeginOfRunAction (const G4Run *)
void	EndOfEventAction (const G4Event *)
void	EndOfRunAction (const G4Run *)
void	DumpMasterCounters () const
void	DumpWorkerCounters () const
void	AbsorbWorkerManagerCounters (const G4MoleculeCounterManager *=nullptr)
void	AddMoleculeWithoutTrack (const G4MolecularConfiguration *, G4double, G4int=1)
void	RemoveMoleculeWithoutTrack (const G4MolecularConfiguration *, G4double, G4int=1)
void	AddMolecule (const G4Track *, G4double, G4int=1)
void	RemoveMolecule (const G4Track *, G4double, G4int=1)
void	AddMolecule (const G4Track , const G4StepPoint , G4double, G4int=1)
void	RemoveMolecule (const G4Track , const G4StepPoint , G4double, G4int=1)
void	ActivateCounterAtTimes (G4int, G4double, G4double, G4bool=true, G4bool=true)
void	RecordReaction (const G4DNAMolecularReactionData *, G4double, G4int=1)
void	ActivateReactionCounterAtTimes (G4int, G4double, G4double, G4bool=true, G4bool=true)
void	ResetCounters ()
void	NotifyOfStep (const G4Step *)
void	NotifyOfFinalize ()
void	BroadcastIgnoreMolecule (const G4MoleculeDefinition *)
void	BroadcastIgnoreReactant (const G4MolecularConfiguration *)
void	BroadcastRegisterAllMoleculesAndReactants ()
G4bool	GetIsActive () const
void	SetIsActive (G4bool flag)
G4int	GetVerbosity () const
void	SetVerbosity (G4int v)
G4bool	GetResetCountersBeforeEvent () const
void	SetResetCountersBeforeEvent (G4bool=true)
G4bool	GetResetCountersBeforeRun () const
void	SetResetCountersBeforeRun (G4bool=true)
G4bool	GetResetMasterCounterWithWorkers () const
void	SetResetMasterCounterWithWorkers (G4bool=true)
G4bool	GetAccumulateCounterIntoMaster () const
void	SetAccumulateCounterIntoMaster (G4bool=true)
std::vector< const G4VMoleculeCounter * >	GetMoleculeCounters () const
std::vector< const G4VMoleculeCounter * >	GetMoleculeCounters (G4String) const
template<typename T = G4VMoleculeCounter>
const T *	GetMoleculeCounter (G4int) const
G4VMoleculeCounter *	GetEditableMoleculeCounter (G4int) const
std::vector< const G4VMoleculeReactionCounter * >	GetMoleculeReactionCounters () const
std::vector< const G4VMoleculeReactionCounter * >	GetMoleculeReactionCounters (G4String) const
G4VMoleculeReactionCounter *	GetEditableMoleculeReactionCounter (G4int) const
template<typename T = G4VMoleculeReactionCounter>
const T *	GetMoleculeReactionCounter (G4int) const

Static Public Member Functions
static G4MoleculeCounterManager *	Instance ()
static G4MoleculeCounterManager *	GetInstanceIfExists ()
static void	DeleteInstance ()

Detailed Description

Definition at line 50 of file G4MoleculeCounterManager.hh.

Constructor & Destructor Documentation

◆ G4MoleculeCounterManager()

G4MoleculeCounterManager::G4MoleculeCounterManager ( G4MoleculeCounterManager::Private )

Definition at line 58 of file G4MoleculeCounterManager.cc.

  : fVerbosity(0), fIsInitialized(false), fIsActive(true)
{
  fpMessenger = std::make_unique<G4MoleculeCounterManagerMessenger>(this);
}

Referenced by AbsorbWorkerManagerCounters(), GetInstanceIfExists(), and Instance().

◆ ~G4MoleculeCounterManager()

G4MoleculeCounterManager::~G4MoleculeCounterManager ( )

Definition at line 64 of file G4MoleculeCounterManager.cc.

{
  // The manager owns all the counters as raw pointers, clean up:
  DeregisterAllCounters();
 
  if (fVerbosity > 0) {
    if (GetResetCountersBeforeRun() && !fBeginOfRunTriggered.load()) {
      G4Exception("G4MoleculeCounterManager::~G4MoleculeCounterManager", "MOLMAN000", JustWarning,
                  "The molecule counter manager was configured to reset counters before each run"
                  " but the BeginOfRunAction was never triggered!\n"
                  "Ensure that the user code calls either the G4DNAChemistryManager's or "
                  "G4MoleculeCounterManager's Run methods!");
    }
    if (GetResetCountersBeforeEvent() && !fBeginOfEventTriggered.load()
        && (!G4Threading::IsMultithreadedApplication() || G4Threading::IsWorkerThread()))
    {
      // ignore, if this is the master of a MT application
      G4Exception("G4MoleculeCounterManager::~G4MoleculeCounterManager", "MOLMAN000", JustWarning,
                  "The molecule counter manager was configured to reset counters before each event"
                  " but the BeginOfEventAction was never triggered!\n"
                  "This can occurr if this thread is never processing an event but:\n"
                  "Ensure that the user code calls either the G4DNAChemistryManager's or "
                  "G4MoleculeCounterManager's Event methods!");
    }
  }
 
  // Handle the recorded master and worker instances
  if (G4Threading::IsMasterThread()) {
    // This is the master's dtor: set the master const* to nullptr (as it will point to nothing of use)
    G4AutoLock lockMaster(&masterInstanceMutex);
    fpMasterInstance = nullptr;
  }
  else {
    // This is a worker's dtor: make sure that this worker is still in the list of instances.
    // If not, throw a warning (something fishy going on?)
    // Either way, set this worker's const* to nullptr in the list of instances.
    G4AutoLock lock(&workerInstancesMutex);
    auto it = std::find(fWorkerInstances.begin(), fWorkerInstances.end(), this);
    if (it == fWorkerInstances.end()) {
      G4Exception(
        "G4MoleculeCounterManager::~G4MoleculeCounterManager", "MOLMAN_DTOR", JustWarning,
        "The destroyed instance of G4MoleculeCounterManager has not been registered as a worker!");
    }
    else {
      (*it) = nullptr;
    }
  }
}

Member Function Documentation

◆ AbsorbWorkerManagerCounters()

void G4MoleculeCounterManager::AbsorbWorkerManagerCounters ( const G4MoleculeCounterManager * selectedWorker = nullptr )

Definition at line 565 of file G4MoleculeCounterManager.cc.

{
  if (selectedWorker == nullptr && !G4Threading::IsMasterThread()) {
    // Can only call without worker from master thread!
    G4ExceptionDescription description;
    description << "This method may only be called from the master thread!";
    G4Exception("G4MoleculeCounterManager::AbsorbWorkerManagerCounters", "MOLMAN999",
                FatalException, description);
  }
 
  // prevent changes to any of the instances
  G4AutoLock lockMaster(&masterInstanceMutex);
  G4AutoLock lockWorker(&workerInstancesMutex);
 
  for (auto const& worker : fWorkerInstances) {
    if (selectedWorker == nullptr || worker != selectedWorker) continue;
 
    for (auto& [id, masterCounter] : fpMasterInstance->fCounters) {
      // acquire worker counter
      auto workerCounter = worker->GetMoleculeCounter(id);
      masterCounter->AbsorbCounter(workerCounter);
    }
 
    for (auto& [id, masterCounter] : fpMasterInstance->fReactionCounters) {
      // acquire worker counter
      auto workerCounter = worker->GetMoleculeReactionCounter(id);
      masterCounter->AbsorbCounter(workerCounter);
    }
  }
}

Referenced by EndOfEventAction(), and EndOfRunAction().

◆ ActivateCounterAtTimes()

void G4MoleculeCounterManager::ActivateCounterAtTimes	(	G4int	id,
		G4double	aboveTime,
		G4double	belowTime,
		G4bool	aboveTimeInclusive = true,
		G4bool	belowTimeInclusive = true )

Definition at line 401 of file G4MoleculeCounterManager.cc.

{
  if (fVerbosity > 0) {
    G4cout << "G4MoleculeCounterManager::ActivateCounterAtTimes ("
           << (G4Threading::IsMasterThread() ? "master" : "worker") << ")" << G4endl;
  }
 
  auto counter = GetEditableMoleculeCounter(id);
  counter->SetActiveLowerBound(aboveTime, aboveTimeInclusive);
  counter->SetActiveUpperBound(belowTime, belowTimeInclusive);
}

◆ ActivateReactionCounterAtTimes()

void G4MoleculeCounterManager::ActivateReactionCounterAtTimes	(	G4int	id,
		G4double	aboveTime,
		G4double	belowTime,
		G4bool	aboveTimeInclusive = true,
		G4bool	belowTimeInclusive = true )

Definition at line 415 of file G4MoleculeCounterManager.cc.

{
  if (fVerbosity > 0) {
    G4cout << "G4MoleculeCounterManager::ActivateReactionCounterAtTimes ("
           << (G4Threading::IsMasterThread() ? "master" : "worker") << ")" << G4endl;
  }
 
  auto counter = GetEditableMoleculeReactionCounter(id);
  counter->SetActiveLowerBound(aboveTime, aboveTimeInclusive);
  counter->SetActiveUpperBound(belowTime, belowTimeInclusive);
}

◆ AddMolecule() [1/2]

void G4MoleculeCounterManager::AddMolecule	(	const G4Track *	aTrack,
		const G4StepPoint *	aStepPoint,
		G4double	time,
		G4int	n = 1 )

Definition at line 235 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    if (counter->GetSensitiveToStepping()) {
      counter->AddMolecule(counter->BuildIndex(aTrack, aStepPoint), time, n);
    }
  }
}

◆ AddMolecule() [2/2]

void G4MoleculeCounterManager::AddMolecule	(	const G4Track *	aTrack,
		G4double	time,
		G4int	n = 1 )

Definition at line 221 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    counter->AddMolecule(counter->BuildIndex(aTrack), time, n);
  }
}

Referenced by G4Molecule::BuildTrack().

◆ AddMoleculeWithoutTrack()

void G4MoleculeCounterManager::AddMoleculeWithoutTrack	(	const G4MolecularConfiguration *	molecule,
		G4double	time,
		G4int	n = 1 )

Definition at line 205 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    counter->AddMolecule(counter->BuildSimpleIndex(molecule), time, n);
  }
}

◆ BeginOfEventAction()

void G4MoleculeCounterManager::BeginOfEventAction ( const G4Event * )

Definition at line 504 of file G4MoleculeCounterManager.cc.

{
  fBeginOfEventTriggered = true;
 
  if (GetResetCountersBeforeEvent()) {
    // trigger reset if:
    // * is not an MT app (master = worker)
    // * is an MT app, master, and we want to reset the master
    // * is an MT app and worker
    if (!G4Threading::IsMultithreadedApplication()
        || (G4Threading::IsMultithreadedApplication() && G4Threading::IsMasterThread()
            && GetResetMasterCounterWithWorkers())
        || (G4Threading::IsMultithreadedApplication() && G4Threading::IsWorkerThread()))
      ResetCounters();
  }
}

Referenced by G4DNAChemistryManager::BeginOfEventAction().

◆ BeginOfRunAction()

void G4MoleculeCounterManager::BeginOfRunAction ( const G4Run * )

Definition at line 523 of file G4MoleculeCounterManager.cc.

{
  fBeginOfRunTriggered = true;
 
  if (GetResetCountersBeforeRun()) {
    // trigger reset if:
    // * is not an MT app (master = worker)
    // * is an MT app, master, and we want to reset the master
    // * is an MT app and worker
    if (!G4Threading::IsMultithreadedApplication()
        || (G4Threading::IsMultithreadedApplication() && G4Threading::IsMasterThread()
            && GetResetMasterCounterWithWorkers())
        || (G4Threading::IsMultithreadedApplication() && G4Threading::IsWorkerThread()))
      ResetCounters();
  }
}

Referenced by G4DNAChemistryManager::BeginOfRunAction().

◆ BroadcastIgnoreMolecule()

void G4MoleculeCounterManager::BroadcastIgnoreMolecule ( const G4MoleculeDefinition * molecule )

Definition at line 312 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    counter->IgnoreMolecule(molecule);
  }
}

◆ BroadcastIgnoreReactant()

void G4MoleculeCounterManager::BroadcastIgnoreReactant ( const G4MolecularConfiguration * molecule )

Definition at line 319 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    counter->IgnoreReactant(molecule);
  }
}

◆ BroadcastRegisterAllMoleculesAndReactants()

void G4MoleculeCounterManager::BroadcastRegisterAllMoleculesAndReactants ( )

Definition at line 326 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    counter->RegisterAll();
  }
}

◆ DeleteInstance()

void G4MoleculeCounterManager::DeleteInstance ( )

static

Definition at line 151 of file G4MoleculeCounterManager.cc.

{
  G4AutoLock lock(&managerInstance);
 
  if (fpInstance != nullptr) {
    fpInstance.reset();
    // this should (test!) trigger the dtor, which will delete/deregister the counters
  }
}

Referenced by G4DNAChemistryManager::Clear().

◆ DeregisterAllCounters()

void G4MoleculeCounterManager::DeregisterAllCounters ( )

Definition at line 367 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, ctr] : fCounters) {
    delete ctr;
  }
  fCounters.clear();
 
  for (auto& [id, ctr] : fReactionCounters) {
    delete ctr;
  }
  fReactionCounters.clear();
}

Referenced by ~G4MoleculeCounterManager().

◆ DumpMasterCounters()

void G4MoleculeCounterManager::DumpMasterCounters ( ) const

Definition at line 599 of file G4MoleculeCounterManager.cc.

{
  G4AutoLock lock(&masterInstanceMutex);
 
  for (auto const& pCounter : fpMasterInstance->GetMoleculeCounters()) {
    G4cout << "===========================================================================  \n"
           << " >> [MASTER] Dumping Molecule Counter `" << pCounter->GetName() << "`\n"
           << G4endl;
    pCounter->Dump();
    G4cout << "\n===========================================================================  "
           << G4endl;
  }
 
  for (auto const& pCounter : fpMasterInstance->GetMoleculeReactionCounters()) {
    G4cout << "===========================================================================  \n"
           << " >> [MASTER] Dumping Molecule Reaction Counter `" << pCounter->GetName() << "`\n"
           << G4endl;
    pCounter->Dump();
    G4cout << "\n===========================================================================  "
           << G4endl;
  }
}

◆ DumpWorkerCounters()

void G4MoleculeCounterManager::DumpWorkerCounters ( ) const

Definition at line 624 of file G4MoleculeCounterManager.cc.

{
  G4AutoLock lock(&workerInstancesMutex);
 
  for (auto const& worker : G4MoleculeCounterManager::fWorkerInstances) {
    for (auto const& pCounter : worker->GetMoleculeCounters()) {
      G4cout << "===========================================================================  \n"
             << " >> [WORKER<" << worker << ">] Dumping Molecule Counter `" << pCounter->GetName()
             << "`\n"
             << G4endl;
      pCounter->Dump();
      G4cout << "\n===========================================================================  "
             << G4endl;
    }
 
    for (auto const& pCounter : worker->GetMoleculeReactionCounters()) {
      G4cout << "===========================================================================  \n"
             << " >> [WORKER<" << worker << ">] Dumping Molecule Reaction Counter `"
             << pCounter->GetName() << "`\n"
             << G4endl;
      pCounter->Dump();
      G4cout << "\n===========================================================================  "
             << G4endl;
    }
  }
}

◆ EndOfEventAction()

void G4MoleculeCounterManager::EndOfEventAction ( const G4Event * )

Definition at line 542 of file G4MoleculeCounterManager.cc.

{
  // EndOfEvent is never triggered on the master of a G4MT
  if (GetAccumulateCounterIntoMaster() && GetResetCountersBeforeEvent()
      && G4Threading::IsMultithreadedApplication() && G4Threading::IsWorkerThread())
  {
    AbsorbWorkerManagerCounters(this);
  }
}

Referenced by G4DNAChemistryManager::EndOfEventAction().

◆ EndOfRunAction()

void G4MoleculeCounterManager::EndOfRunAction ( const G4Run * )

Definition at line 554 of file G4MoleculeCounterManager.cc.

{
  if (GetAccumulateCounterIntoMaster() && GetResetCountersBeforeRun()
      && !GetResetCountersBeforeEvent() &&
      // if ResetBeforeEvent, AbsorbWorkerManagerCounters will have been triggered already
      G4Threading::IsMultithreadedApplication() && G4Threading::IsMasterThread())
    AbsorbWorkerManagerCounters();
}

Referenced by G4DNAChemistryManager::EndOfRunAction().

◆ GetAccumulateCounterIntoMaster()

G4bool G4MoleculeCounterManager::GetAccumulateCounterIntoMaster ( ) const

Definition at line 685 of file G4MoleculeCounterManager.cc.

{
  return fAccumulateCounterIntoMaster.load();
}

Referenced by EndOfEventAction(), and EndOfRunAction().

◆ GetEditableMoleculeCounter()

G4VMoleculeCounter * G4MoleculeCounterManager::GetEditableMoleculeCounter ( G4int id ) const

Definition at line 432 of file G4MoleculeCounterManager.cc.

{
  auto it = fCounters.find(id);
  if (it == fCounters.end()) {
    G4ExceptionDescription description;
    description << "No molecule counter with Id = " << id << " was found!\n";
    G4Exception("G4MoleculeCounterManager::GetMoleculeCounter", "MOLMAN001", FatalErrorInArgument,
                description);
    return nullptr;
  }else{
    return it->second;
  }
}

Referenced by ActivateCounterAtTimes(), and GetMoleculeCounter().

◆ GetEditableMoleculeReactionCounter()

G4VMoleculeReactionCounter * G4MoleculeCounterManager::GetEditableMoleculeReactionCounter ( G4int id ) const

Definition at line 467 of file G4MoleculeCounterManager.cc.

{
  auto it = fReactionCounters.find(id);
  if (it == fReactionCounters.end()) {
    G4ExceptionDescription description;
    description << "No molecule reaction counter with Id = " << id << " was found!\n";
    G4Exception("G4MoleculeCounterManager::GetMoleculeReactionCounter", "MOLMAN001",
                FatalErrorInArgument, description);
    return nullptr;
  }else
  {
    return it->second;
  }
}

Referenced by ActivateReactionCounterAtTimes(), and GetMoleculeReactionCounter().

◆ GetInstanceIfExists()

G4MoleculeCounterManager * G4MoleculeCounterManager::GetInstanceIfExists ( )

static

Definition at line 146 of file G4MoleculeCounterManager.cc.

{
  return fpInstance.get();
}

Referenced by G4DNAChemistryManager::Clear(), G4DNAChemistryManager::InitializeMaster(), and G4DNAChemistryManager::InitializeThread().

◆ GetIsActive()

G4bool G4MoleculeCounterManager::GetIsActive ( ) const

inline

Definition at line 156 of file G4MoleculeCounterManager.hh.

156{ return fIsActive; }

◆ GetMoleculeCounter()

template<typename T>

const T * G4MoleculeCounterManager::GetMoleculeCounter ( G4int id ) const

Definition at line 227 of file G4MoleculeCounterManager.hh.

{
  static_assert(std::is_base_of<G4VMoleculeCounter, T>::value,
                "T must be derived from G4VMoleculeCounter!");
  auto base_ptr = GetEditableMoleculeCounter(id);
  if (base_ptr == nullptr) return nullptr;
  const T* ptr = dynamic_cast<const T*>(base_ptr);
  return ptr;
}

◆ GetMoleculeCounters() [1/2]

std::vector< const G4VMoleculeCounter * > G4MoleculeCounterManager::GetMoleculeCounters ( ) const

Definition at line 446 of file G4MoleculeCounterManager.cc.

{
  std::vector<const G4VMoleculeCounter*> output;
  output.reserve(fCounters.size());
  for (auto& [id, counter] : fCounters)
    output.push_back(counter);
  return output;
}

◆ GetMoleculeCounters() [2/2]

std::vector< const G4VMoleculeCounter * > G4MoleculeCounterManager::GetMoleculeCounters ( G4String name ) const

Definition at line 455 of file G4MoleculeCounterManager.cc.

{
  std::vector<const G4VMoleculeCounter*> output;
  for (auto& [id, counter] : fCounters) {
    if (name == counter->GetName()) output.push_back(counter);
  }
  return output;
}

◆ GetMoleculeReactionCounter()

template<typename T>

const T * G4MoleculeCounterManager::GetMoleculeReactionCounter ( G4int id ) const

Definition at line 238 of file G4MoleculeCounterManager.hh.

{
  static_assert(std::is_base_of<G4VMoleculeReactionCounter, T>::value,
                "T must be derived from G4VMoleculeReactionCounter!");
  auto base_ptr = GetEditableMoleculeReactionCounter(id);
  if (base_ptr == nullptr) return nullptr;
  const T* ptr = dynamic_cast<const T*>(base_ptr);
  return ptr;
}

◆ GetMoleculeReactionCounters() [1/2]

std::vector< const G4VMoleculeReactionCounter * > G4MoleculeCounterManager::GetMoleculeReactionCounters ( ) const

Definition at line 483 of file G4MoleculeCounterManager.cc.

{
  std::vector<const G4VMoleculeReactionCounter*> output;
  output.reserve(fReactionCounters.size());
  for (auto& [id, counter] : fReactionCounters)
    output.push_back(counter);
  return output;
}

◆ GetMoleculeReactionCounters() [2/2]

std::vector< const G4VMoleculeReactionCounter * > G4MoleculeCounterManager::GetMoleculeReactionCounters ( G4String name ) const

Definition at line 493 of file G4MoleculeCounterManager.cc.

{
  std::vector<const G4VMoleculeReactionCounter*> output;
  for (auto& [id, counter] : fReactionCounters) {
    if (name == counter->GetName()) output.push_back(counter);
  }
  return output;
}

◆ GetResetCountersBeforeEvent()

G4bool G4MoleculeCounterManager::GetResetCountersBeforeEvent ( ) const

Definition at line 658 of file G4MoleculeCounterManager.cc.

{
  return fResetCountersBeforeEvent.load();
}

Referenced by BeginOfEventAction(), EndOfEventAction(), EndOfRunAction(), and ~G4MoleculeCounterManager().

◆ GetResetCountersBeforeRun()

G4bool G4MoleculeCounterManager::GetResetCountersBeforeRun ( ) const

Definition at line 672 of file G4MoleculeCounterManager.cc.

{
  return fResetCountersBeforeRun.load();
}

Referenced by BeginOfRunAction(), EndOfRunAction(), and ~G4MoleculeCounterManager().

◆ GetResetMasterCounterWithWorkers()

G4bool G4MoleculeCounterManager::GetResetMasterCounterWithWorkers ( ) const

Definition at line 698 of file G4MoleculeCounterManager.cc.

{
  return fResetMasterCounterWithWorkers.load();
}

Referenced by BeginOfEventAction(), and BeginOfRunAction().

◆ GetVerbosity()

G4int G4MoleculeCounterManager::GetVerbosity ( ) const

inline

Definition at line 159 of file G4MoleculeCounterManager.hh.

159{ return fVerbosity; }

Referenced by NotifyOfStep().

◆ Initialize()

void G4MoleculeCounterManager::Initialize ( )

Definition at line 167 of file G4MoleculeCounterManager.cc.

{
  if (fVerbosity > 0) {
    G4cout << "G4MoleculeCounterManager::Initialize ("
           << (G4Threading::IsMasterThread() ? "master" : "worker") << ")" << G4endl;
  }
 
  if (G4Threading::IsMultithreadedApplication()) {
    if (G4Threading::IsWorkerThread())
      InitializeWorker();
    else
      InitializeMaster();
  }
  else {
    InitializeMaster();
  }
}

Referenced by G4DNAChemistryManager::InitializeMaster(), and G4DNAChemistryManager::InitializeThread().

◆ Instance()

G4MoleculeCounterManager * G4MoleculeCounterManager::Instance ( )

static

Definition at line 136 of file G4MoleculeCounterManager.cc.

{
  if (fpInstance == nullptr) {
    G4AutoLock lock(&managerInstance);
    fpInstance = std::make_unique<G4MoleculeCounterManager>(G4MoleculeCounterManager::Private());
    fpInstance->RegisterInstance();
  }
  return fpInstance.get();
}

Referenced by G4VUserMoleculeCounter< TIndex >::AddMolecule(), G4DNAChemistryManager::BeginOfEventAction(), G4DNAChemistryManager::BeginOfRunAction(), G4Molecule::BuildTrack(), G4DNAChemistryManager::EndOfEventAction(), G4DNAChemistryManager::EndOfRunAction(), G4DNAChemistryManager::InitializeMaster(), G4DNAChemistryManager::InitializeThread(), G4DNAIRT::MakeReaction(), G4DNAMakeReaction::MakeReaction(), G4DNAMolecularReaction::MakeReaction(), G4VUserMoleculeReactionCounter< TIndex >::RecordReaction(), G4VUserMoleculeCounter< TIndex >::RemoveMolecule(), and G4Molecule::~G4Molecule().

◆ NotifyOfFinalize()

void G4MoleculeCounterManager::NotifyOfFinalize ( )

Definition at line 301 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    counter->SchedulerFinalizedTracking();
  }
}

◆ NotifyOfStep()

void G4MoleculeCounterManager::NotifyOfStep ( const G4Step * aStep )

Definition at line 279 of file G4MoleculeCounterManager.cc.

{
  const G4Track* aTrack = aStep->GetTrack();
 
  for (auto& [id, counter] : fCounters) {
    auto preStepIndex = counter->BuildIndex(aTrack, aStep->GetPreStepPoint());
    auto postStepIndex = counter->BuildIndex(aTrack, aStep->GetPostStepPoint());
 
    if (!(*preStepIndex == *postStepIndex)) {
#ifdef G4VERBOSE
      if (GetVerbosity() > 1) {
        G4cout << "G4MoleculeCounterManager::NotifyOfStep for counter " << counter->GetName()
               << ":\n-- Pre = " << preStepIndex->GetInfo() << "\n"
               << "-- Post = " << postStepIndex->GetInfo() << G4endl;
      }
#endif
      counter->RemoveMolecule(std::move(preStepIndex), aTrack->GetGlobalTime(), 1);
      counter->AddMolecule(std::move(postStepIndex), aTrack->GetGlobalTime(), 1);
    }
  }
}

◆ RecordReaction()

void G4MoleculeCounterManager::RecordReaction	(	const G4DNAMolecularReactionData *	reactionData,
		G4double	time,
		G4int	n = 1 )

Definition at line 257 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fReactionCounters) {
    counter->RecordReaction(counter->BuildSimpleIndex(reactionData), time, n);
  }
}

Referenced by G4DNAIRT::MakeReaction(), G4DNAMakeReaction::MakeReaction(), and G4DNAMolecularReaction::MakeReaction().

◆ RegisterCounter() [1/2]

G4int G4MoleculeCounterManager::RegisterCounter ( std::unique_ptr< G4VMoleculeCounter > counter )

Definition at line 339 of file G4MoleculeCounterManager.cc.

{
  auto idProvider = [&]() {
    if (fCounters.size() == 0) return 0;
    auto indices = G4::MoleculeCounter::GetMapIndices(fCounters);
    auto lastIndex = *indices.rbegin();
    return ++lastIndex;
  };
 
  return RegisterCounter(fCounters, std::move(counter), idProvider);
}

Referenced by RegisterCounter(), and RegisterCounter().

◆ RegisterCounter() [2/2]

G4int G4MoleculeCounterManager::RegisterCounter ( std::unique_ptr< G4VMoleculeReactionCounter > counter )

Definition at line 353 of file G4MoleculeCounterManager.cc.

{
  auto idProvider = [&] {
    if (fReactionCounters.size() == 0) return 0;
    auto indices = G4::MoleculeCounter::GetMapIndices(fReactionCounters);
    auto lastIndex = *indices.rbegin();
    return ++lastIndex;
  };
 
  return RegisterCounter(fReactionCounters, std::move(counter), idProvider);
}

◆ RemoveMolecule() [1/2]

void G4MoleculeCounterManager::RemoveMolecule	(	const G4Track *	aTrack,
		const G4StepPoint *	aStepPoint,
		G4double	time,
		G4int	n = 1 )

Definition at line 245 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    if (counter->GetSensitiveToStepping()) {
      counter->RemoveMolecule(counter->BuildIndex(aTrack, aStepPoint), time, n);
    }
  }
}

◆ RemoveMolecule() [2/2]

void G4MoleculeCounterManager::RemoveMolecule	(	const G4Track *	aTrack,
		G4double	time,
		G4int	n = 1 )

Definition at line 228 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    counter->RemoveMolecule(counter->BuildIndex(aTrack), time, n);
  }
}

Referenced by G4Molecule::~G4Molecule().

◆ RemoveMoleculeWithoutTrack()

void G4MoleculeCounterManager::RemoveMoleculeWithoutTrack	(	const G4MolecularConfiguration *	molecule,
		G4double	time,
		G4int	n = 1 )

Definition at line 213 of file G4MoleculeCounterManager.cc.

{
  for (auto& [id, counter] : fCounters) {
    counter->RemoveMolecule(counter->BuildSimpleIndex(molecule), time, n);
  }
}

◆ ResetCounters()

void G4MoleculeCounterManager::ResetCounters ( )

Definition at line 386 of file G4MoleculeCounterManager.cc.

{
  if (fVerbosity > 0) {
    G4cout << "G4MoleculeCounterManager::ResetCounters ("
           << (G4Threading::IsMasterThread() ? "master" : "worker") << ")" << G4endl;
  }
 
  for (auto& [id, counter] : fCounters)
    counter->ResetCounter();
  for (auto& [id, counter] : fReactionCounters)
    counter->ResetCounter();
}

Referenced by BeginOfEventAction(), and BeginOfRunAction().

◆ SetAccumulateCounterIntoMaster()

void G4MoleculeCounterManager::SetAccumulateCounterIntoMaster ( G4bool flag = true )

Definition at line 689 of file G4MoleculeCounterManager.cc.

{
  if (G4StateManager::GetStateManager()->GetCurrentState() == G4State_PreInit)
    fAccumulateCounterIntoMaster = flag;
  else
    G4Exception("G4DNAChemistryManager::SetAccumulateCounterIntoMaster", "WRONG_STATE",
                FatalException, "This flag may only be set during the PreInit state!");
}

◆ SetIsActive()

void G4MoleculeCounterManager::SetIsActive ( G4bool flag )

inline

Definition at line 157 of file G4MoleculeCounterManager.hh.

157{ fIsActive = flag; }

◆ SetResetCountersBeforeEvent()

void G4MoleculeCounterManager::SetResetCountersBeforeEvent ( G4bool flag = true )

Definition at line 662 of file G4MoleculeCounterManager.cc.

{
  if (G4StateManager::GetStateManager()->GetCurrentState() == G4State_PreInit) {
    fResetCountersBeforeEvent = flag;
  }
  else
    G4Exception("G4DNAChemistryManager::SetResetCountersBeforeEvent", "WRONG_STATE", FatalException,
                "This flag may only be set during the PreInit state!");
}

◆ SetResetCountersBeforeRun()

void G4MoleculeCounterManager::SetResetCountersBeforeRun ( G4bool flag = true )

Definition at line 676 of file G4MoleculeCounterManager.cc.

{
  if (G4StateManager::GetStateManager()->GetCurrentState() == G4State_PreInit)
    fResetCountersBeforeRun = flag;
  else
    G4Exception("G4DNAChemistryManager::SetResetCountersBeforeRun", "WRONG_STATE", FatalException,
                "This flag may only be set during the PreInit state!");
}

◆ SetResetMasterCounterWithWorkers()

void G4MoleculeCounterManager::SetResetMasterCounterWithWorkers ( G4bool flag = true )

Definition at line 702 of file G4MoleculeCounterManager.cc.

{
  if (G4StateManager::GetStateManager()->GetCurrentState() == G4State_PreInit)
    fResetMasterCounterWithWorkers = flag;
  else
    G4Exception("G4DNAChemistryManager::SetResetMasterCounterWithWorkers", "WRONG_STATE",
                FatalException, "This flag may only be set during the PreInit state!");
}

◆ SetVerbosity()

void G4MoleculeCounterManager::SetVerbosity ( G4int v )

inline

Definition at line 160 of file G4MoleculeCounterManager.hh.

160{ fVerbosity = v; }

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ G4MoleculeCounterManager()

◆ ~G4MoleculeCounterManager()

Member Function Documentation

◆ AbsorbWorkerManagerCounters()

◆ ActivateCounterAtTimes()

◆ ActivateReactionCounterAtTimes()

◆ AddMolecule() [1/2]

◆ AddMolecule() [2/2]

◆ AddMoleculeWithoutTrack()

◆ BeginOfEventAction()

◆ BeginOfRunAction()

◆ BroadcastIgnoreMolecule()

◆ BroadcastIgnoreReactant()

◆ BroadcastRegisterAllMoleculesAndReactants()

◆ DeleteInstance()

◆ DeregisterAllCounters()

◆ DumpMasterCounters()

◆ DumpWorkerCounters()

◆ EndOfEventAction()

◆ EndOfRunAction()

◆ GetAccumulateCounterIntoMaster()

◆ GetEditableMoleculeCounter()

◆ GetEditableMoleculeReactionCounter()

◆ GetInstanceIfExists()

◆ GetIsActive()

◆ GetMoleculeCounter()

◆ GetMoleculeCounters() [1/2]

◆ GetMoleculeCounters() [2/2]

◆ GetMoleculeReactionCounter()

◆ GetMoleculeReactionCounters() [1/2]

◆ GetMoleculeReactionCounters() [2/2]

◆ GetResetCountersBeforeEvent()

◆ GetResetCountersBeforeRun()

◆ GetResetMasterCounterWithWorkers()

◆ GetVerbosity()

◆ Initialize()

◆ Instance()

◆ NotifyOfFinalize()

◆ NotifyOfStep()

◆ RecordReaction()

◆ RegisterCounter() [1/2]

◆ RegisterCounter() [2/2]

◆ RemoveMolecule() [1/2]

◆ RemoveMolecule() [2/2]

◆ RemoveMoleculeWithoutTrack()

◆ ResetCounters()

◆ SetAccumulateCounterIntoMaster()

◆ SetIsActive()

◆ SetResetCountersBeforeEvent()

◆ SetResetCountersBeforeRun()

◆ SetResetMasterCounterWithWorkers()

◆ SetVerbosity()