#include <G4MoleculeCounter.hh>

Inheritance diagram for G4MoleculeCounter:

Data Structures
struct	Search

Public Types
using	CounterMapType = std::map< Reactant *, NbMoleculeAgainstTime >

using	Reactant = const G4MolecularConfiguration

using	ReactantList = std::vector< Reactant * >

using	RecordedMolecules = std::unique_ptr< ReactantList >

Public Member Functions
void	CheckTimeForConsistency (G4bool flag)

void	DontRegister (const G4MoleculeDefinition *) override

void	Dump ()

const NbMoleculeAgainstTime &	GetNbMoleculeAgainstTime (Reactant *molecule)

int	GetNMoleculesAtTime (Reactant *molecule, double time)

RecordedMolecules	GetRecordedMolecules ()

RecordedTimes	GetRecordedTimes ()

G4int	GetVerbose ()

void	Initialize () override

bool	IsRegistered (const G4MoleculeDefinition *) override

G4bool	IsTimeCheckedForConsistency () const

void	RegisterAll () override

void	ResetCounter () override

void	SetVerbose (G4int)

Static Public Member Functions
static void	DeleteInstance ()

static void	InitializeInstance ()

static G4MoleculeCounter *	Instance ()

static G4bool	InUse ()

static void	SetInstance (G4VMoleculeCounter *)

static void	SetTimeSlice (double)

static void	Use (G4bool flag=true)

Protected Member Functions
void	AddAMoleculeAtTime (Reactant , G4double time, const G4ThreeVector position=nullptr, int number=1) override

	G4MoleculeCounter ()

void	RemoveAMoleculeAtTime (Reactant , G4double time, const G4ThreeVector position=nullptr, int number=1) override

G4bool	SearchTimeMap (Reactant *molecule)

int	SearchUpperBoundTime (double time, bool sameTypeOfMolecule)

	~G4MoleculeCounter () override

Protected Attributes
G4bool	fCheckTimeIsConsistentWithScheduler

CounterMapType	fCounterMap

std::map< const G4MoleculeDefinition *, G4bool >	fDontRegister

std::unique_ptr< Search >	fpLastSearch

G4int	fVerbose

Static Protected Attributes
static G4ThreadLocal G4VMoleculeCounter *	fpInstance = nullptr

static G4bool	fUse = false

Friends
class	G4Molecule

class	G4VMoleculeCounter

Detailed Description

Definition at line 69 of file G4MoleculeCounter.hh.

Member Typedef Documentation

◆ CounterMapType

using G4MoleculeCounter::CounterMapType = std::map<Reactant*, NbMoleculeAgainstTime>

Definition at line 74 of file G4MoleculeCounter.hh.

◆ Reactant

using G4VMoleculeCounter::Reactant = const G4MolecularConfiguration

inherited

Definition at line 58 of file G4VMoleculeCounter.hh.

◆ ReactantList

using G4MoleculeCounter::ReactantList = std::vector<Reactant*>

Definition at line 73 of file G4MoleculeCounter.hh.

◆ RecordedMolecules

using G4MoleculeCounter::RecordedMolecules = std::unique_ptr<ReactantList>

Definition at line 75 of file G4MoleculeCounter.hh.

Constructor & Destructor Documentation

◆ G4MoleculeCounter()

G4MoleculeCounter::G4MoleculeCounter ( )

protected

Definition at line 71 of file G4MoleculeCounter.cc.

{
    fVerbose = 0;
    fCheckTimeIsConsistentWithScheduler = true;
}

References fCheckTimeIsConsistentWithScheduler, and fVerbose.

Referenced by Instance().

◆ ~G4MoleculeCounter()

G4MoleculeCounter::~G4MoleculeCounter ( )

overrideprotecteddefault

Member Function Documentation

◆ AddAMoleculeAtTime()

void G4MoleculeCounter::AddAMoleculeAtTime	(	Reactant *	molecule,
		G4double	time,
		const G4ThreeVector *	position = `nullptr`,
		int	number = `1`
	)

overrideprotectedvirtual

Implements G4VMoleculeCounter.

Definition at line 208 of file G4MoleculeCounter.cc.

{
    if (fDontRegister[molecule->GetDefinition()])
    {
        return;
    }
 
    if (fVerbose)
    {
        G4cout << "G4MoleculeCounter::AddAMoleculeAtTime : " << molecule->GetName()
               << " at time : " << G4BestUnit(time, "Time") << G4endl;
    }
 
    auto counterMap_i = fCounterMap.find(molecule);
 
    if (counterMap_i == fCounterMap.end())
    {
        fCounterMap[molecule][time] = number;
    }
    else if (counterMap_i->second.empty())
    {
        counterMap_i->second[time] = number;
    }
    else
    {
        NbMoleculeAgainstTime::reverse_iterator end = counterMap_i->second.rbegin();
 
        if (end->first <= time ||
            fabs(end->first - time) <= G4::MoleculeCounter::TimePrecision::fPrecision)
            // Case 1 = new time comes after last recorded data
            // Case 2 = new time is about the same as the last recorded one
        {
            double newValue = end->second + number;
            counterMap_i->second[time] = newValue;
        }
        else
        {
            //      if(fabs(time - G4Scheduler::Instance()->GetGlobalTime()) >
            //         G4Scheduler::Instance()->GetTimeTolerance())
            {
                G4ExceptionDescription errMsg;
                errMsg << "Time of species "
                       << molecule->GetName() << " is "
                       << G4BestUnit(time, "Time") << " while "
                       << " global time is "
                       << G4BestUnit(G4Scheduler::Instance()->GetGlobalTime(), "Time")
                       << G4endl;
                G4Exception("G4MoleculeCounter::AddAMoleculeAtTime",
                            "TIME_DONT_MATCH",
                            FatalException, errMsg);
            }
        }
    }
}

References FatalException, fCounterMap, fDontRegister, G4::MoleculeCounter::TimePrecision::fPrecision, fVerbose, G4BestUnit, G4cout, G4endl, G4Exception(), G4MolecularConfiguration::GetDefinition(), G4MolecularConfiguration::GetName(), and G4Scheduler::Instance().

◆ CheckTimeForConsistency()

void G4MoleculeCounter::CheckTimeForConsistency ( G4bool flag )

Definition at line 509 of file G4MoleculeCounter.cc.

{
    fCheckTimeIsConsistentWithScheduler = flag;
}

References fCheckTimeIsConsistentWithScheduler.

◆ DeleteInstance()

void G4VMoleculeCounter::DeleteInstance ( )

staticinherited

Definition at line 78 of file G4VMoleculeCounter.cc.

{
    if (fpInstance != nullptr)
    {
        delete fpInstance;
        fpInstance = nullptr;
    }
}

References G4VMoleculeCounter::fpInstance.

Referenced by G4DNAChemistryManager::Clear().

◆ DontRegister()

void G4MoleculeCounter::DontRegister ( const G4MoleculeDefinition * molDef )

overridevirtual

Reimplemented from G4VMoleculeCounter.

Definition at line 481 of file G4MoleculeCounter.cc.

{
    fDontRegister[molDef] = true;
}

References fDontRegister.

◆ Dump()

void G4MoleculeCounter::Dump ( )

Definition at line 430 of file G4MoleculeCounter.cc.

{
    for (auto it : fCounterMap)
    {
        auto pReactant = it.first;
 
        G4cout << " --- > For " << pReactant->GetName() << G4endl;
 
        for (auto it2 : it.second)
        {
            G4cout << " " << G4BestUnit(it2.first, "Time")
                   << "    " << it2.second << G4endl;
        }
    }
}

References fCounterMap, G4BestUnit, G4cout, and G4endl.

Referenced by RemoveAMoleculeAtTime(), and G4DNAUpdateSystemModel::UpdateSystem().

◆ GetNbMoleculeAgainstTime()

const NbMoleculeAgainstTime & G4MoleculeCounter::GetNbMoleculeAgainstTime ( Reactant * molecule )

Definition at line 460 of file G4MoleculeCounter.cc.

{
    return fCounterMap[molecule];
}

References fCounterMap.

◆ GetNMoleculesAtTime()

int G4MoleculeCounter::GetNMoleculesAtTime	(	Reactant *	molecule,
		double	time
	)

Definition at line 199 of file G4MoleculeCounter.cc.

{
    G4bool sameTypeOfMolecule = SearchTimeMap(molecule);
    return SearchUpperBoundTime(time, sameTypeOfMolecule);
}

References SearchTimeMap(), and SearchUpperBoundTime().

Referenced by G4DNAEventScheduler::ClearAndReChargeCounter().

◆ GetRecordedMolecules()

G4MoleculeCounter::RecordedMolecules G4MoleculeCounter::GetRecordedMolecules ( )

Definition at line 370 of file G4MoleculeCounter.cc.

{
    if (fVerbose > 1)
    {
        G4cout << "Entering in G4MoleculeCounter::RecordMolecules" << G4endl;
    }
 
    RecordedMolecules output(new ReactantList());
 
    for (auto it : fCounterMap)
    {
        output->push_back(it.first);
    }
    return output;
}

References fCounterMap, fVerbose, G4cout, and G4endl.

Referenced by G4DNAEventScheduler::ClearAndReChargeCounter().

◆ GetRecordedTimes()

RecordedTimes G4MoleculeCounter::GetRecordedTimes ( )

Definition at line 388 of file G4MoleculeCounter.cc.

{
    RecordedTimes output(new std::set<G4double>);
 
    for(const auto& it : fCounterMap)
    {
        for(const auto& it2 : it.second)
        {
            //time = it2->first;
            output->insert(it2.first);
        }
    }
 
    return output;
}

References fCounterMap.

◆ GetVerbose()

G4int G4MoleculeCounter::GetVerbose ( )

Definition at line 474 of file G4MoleculeCounter.cc.

{
    return fVerbose;
}

References fVerbose.

◆ Initialize()

void G4MoleculeCounter::Initialize ( )

overridevirtual

Implements G4VMoleculeCounter.

Definition at line 83 of file G4MoleculeCounter.cc.

{
    auto mol_iterator = G4MoleculeTable::Instance()->GetConfigurationIterator();
    while ((mol_iterator)())
    {
        if (IsRegistered(mol_iterator.value()->GetDefinition()) == false)
        {
            continue;
        }
 
        fCounterMap[mol_iterator.value()]; // initialize the second map
    }
}

References fCounterMap, G4MoleculeTable::GetConfigurationIterator(), G4MoleculeTable::Instance(), and IsRegistered().

◆ InitializeInstance()

void G4VMoleculeCounter::InitializeInstance ( )

staticinherited

Definition at line 89 of file G4VMoleculeCounter.cc.

{
    if (fpInstance)
    {
        fpInstance->Initialize();
    }
}

References G4VMoleculeCounter::fpInstance, and G4VMoleculeCounter::Initialize().

Referenced by G4DNAChemistryManager::InitializeThread().

◆ Instance()

G4MoleculeCounter * G4MoleculeCounter::Instance ( )

static

Definition at line 60 of file G4MoleculeCounter.cc.

{
    if (!fpInstance)
    {
        fpInstance = new G4MoleculeCounter();
    }
    return dynamic_cast<G4MoleculeCounter*>(fpInstance);
}

References G4VMoleculeCounter::fpInstance, and G4MoleculeCounter().

Referenced by G4DNAEventScheduler::ClearAndReChargeCounter(), G4DNAEventScheduler::RecordTime(), and G4DNAUpdateSystemModel::UpdateSystem().

◆ InUse()

G4bool G4VMoleculeCounter::InUse ( )

staticinherited

Definition at line 106 of file G4VMoleculeCounter.cc.

{
    return fUse;
}

References G4VMoleculeCounter::fUse.

Referenced by G4Molecule::BuildTrack(), G4DNAUpdateSystemModel::CreateMolecule(), and G4DNAElectronHoleRecombination::MakeReaction().

◆ IsRegistered()

bool G4MoleculeCounter::IsRegistered ( const G4MoleculeDefinition * molDef )

overridevirtual

Reimplemented from G4VMoleculeCounter.

Definition at line 488 of file G4MoleculeCounter.cc.

{
    if (fDontRegister.find(molDef) == fDontRegister.end())
    {
        return true;
    }
    return false;
}

References fDontRegister.

Referenced by Initialize().

◆ IsTimeCheckedForConsistency()

G4bool G4MoleculeCounter::IsTimeCheckedForConsistency ( ) const

Definition at line 504 of file G4MoleculeCounter.cc.

{
    return fCheckTimeIsConsistentWithScheduler;
}

References fCheckTimeIsConsistentWithScheduler.

◆ RegisterAll()

void G4MoleculeCounter::RegisterAll ( )

overridevirtual

Reimplemented from G4VMoleculeCounter.

Definition at line 499 of file G4MoleculeCounter.cc.

{
    fDontRegister.clear();
}

References fDontRegister.

◆ RemoveAMoleculeAtTime()

void G4MoleculeCounter::RemoveAMoleculeAtTime	(	Reactant *	,
		G4double	time,
		const G4ThreeVector *	position = `nullptr`,
		int	number = `1`
	)

overrideprotectedvirtual

Implements G4VMoleculeCounter.

Definition at line 268 of file G4MoleculeCounter.cc.

{
    if (fDontRegister[pMolecule->GetDefinition()])
    {
        return;
    }
 
    if (fVerbose)
    {
        G4cout << "G4MoleculeCounter::RemoveAMoleculeAtTime : "
               << pMolecule->GetName() << " at time : " << G4BestUnit(time, "Time")
               << G4endl;
    }
 
    if (fCheckTimeIsConsistentWithScheduler)
    {
        if (fabs(time - G4Scheduler::Instance()->GetGlobalTime()) >
            G4Scheduler::Instance()->GetTimeTolerance())
        {
            G4ExceptionDescription errMsg;
            errMsg << "Time of species "
                   << pMolecule->GetName() << " is "
                   << G4BestUnit(time, "Time") << " while "
                   << " global time is "
                   << G4BestUnit(G4Scheduler::Instance()->GetGlobalTime(), "Time")
                   << G4endl;
            G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime",
                        "TIME_DONT_MATCH",
                        FatalException, errMsg);
        }
    }
 
    NbMoleculeAgainstTime& nbMolPerTime = fCounterMap[pMolecule];
 
    if (nbMolPerTime.empty())
    {
        pMolecule->PrintState();
        Dump();
        G4String errMsg =
                "You are trying to remove molecule " + pMolecule->GetName() +
                " from the counter while this kind of molecules has not been registered yet";
        G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime", "",
                    FatalErrorInArgument, errMsg);
 
        return;
    }
    else
    {
        NbMoleculeAgainstTime::reverse_iterator it = nbMolPerTime.rbegin();
 
        if (it == nbMolPerTime.rend())
        {
            it--;
 
            G4String errMsg =
                    "There was no " + pMolecule->GetName() + " recorded at the time or even before the time asked";
            G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime", "",
                        FatalErrorInArgument, errMsg);
        }
 
        if (time - it->first < -G4::MoleculeCounter::TimePrecision::fPrecision)
        {
            Dump();
            G4ExceptionDescription errMsg;
            errMsg << "Is time going back?? " << pMolecule->GetName()
                   << " is being removed at time " << G4BestUnit(time, "Time")
                   << " while last recorded time was "
                   << G4BestUnit(it->first, "Time") << ".";
            G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime",
                        "RETURN_TO_THE_FUTUR",
                        FatalErrorInArgument,
                        errMsg);
        }
 
        double finalN = it->second - number;
 
        if (finalN < 0)
        {
            Dump();
            G4ExceptionDescription errMsg;
            errMsg << "After removal of " << number << " species of "
                   << pMolecule->GetName() << " the final number at time "
                   << G4BestUnit(time, "Time") << " is less than zero and so not valid."
                   << " Global time is "
                   << G4BestUnit(G4Scheduler::Instance()->GetGlobalTime(), "Time")
                   << ". Previous selected time is "
                   << G4BestUnit(it->first, "Time")
                   << G4endl;
            G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime",
                        "N_INF_0",
                        FatalException, errMsg);
        }
 
        nbMolPerTime[time] = finalN;
    }
}

References Dump(), FatalErrorInArgument, FatalException, fCheckTimeIsConsistentWithScheduler, fCounterMap, fDontRegister, G4::MoleculeCounter::TimePrecision::fPrecision, fVerbose, G4BestUnit, G4cout, G4endl, G4Exception(), G4MolecularConfiguration::GetDefinition(), G4MolecularConfiguration::GetName(), G4Scheduler::Instance(), and G4MolecularConfiguration::PrintState().

◆ ResetCounter()

void G4MoleculeCounter::ResetCounter ( )

overridevirtual

Implements G4VMoleculeCounter.

Definition at line 448 of file G4MoleculeCounter.cc.

{
    if (fVerbose)
    {
        G4cout << " ---> G4MoleculeCounter::ResetCounter" << G4endl;
    }
    fCounterMap.clear();
    fpLastSearch.reset(0);
}

References fCounterMap, fpLastSearch, fVerbose, G4cout, and G4endl.

Referenced by G4DNAEventScheduler::ClearAndReChargeCounter().

◆ SearchTimeMap()

G4bool G4MoleculeCounter::SearchTimeMap ( Reactant * molecule )

protected

Definition at line 106 of file G4MoleculeCounter.cc.

{
    if (fpLastSearch == nullptr)
    {
        fpLastSearch.reset(new Search());
    }
    else
    {
        if (fpLastSearch->fLowerBoundSet &&
            fpLastSearch->fLastMoleculeSearched->first == molecule)
        {
            return true;
        }
    }
 
    auto mol_it = fCounterMap.find(molecule);
    fpLastSearch->fLastMoleculeSearched = mol_it;
 
    if (mol_it != fCounterMap.end())
    {
        fpLastSearch->fLowerBoundTime = fpLastSearch->fLastMoleculeSearched->second
                .end();
        fpLastSearch->fLowerBoundSet = true;
    }
    else
    {
        fpLastSearch->fLowerBoundSet = false;
    }
 
    return false;
}

References fCounterMap, and fpLastSearch.

Referenced by GetNMoleculesAtTime().

◆ SearchUpperBoundTime()

int G4MoleculeCounter::SearchUpperBoundTime	(	double	time,
		bool	sameTypeOfMolecule
	)

protected

Definition at line 140 of file G4MoleculeCounter.cc.

{
    auto mol_it = fpLastSearch->fLastMoleculeSearched;
    if (mol_it == fCounterMap.end())
    {
        return 0;
    }
 
    NbMoleculeAgainstTime& timeMap = mol_it->second;
    if (timeMap.empty())
    {
        return 0;
    }
 
    if (sameTypeOfMolecule == true)
    {
        if (fpLastSearch->fLowerBoundSet && fpLastSearch->fLowerBoundTime != timeMap.end())
        {
            if (fpLastSearch->fLowerBoundTime->first < time)
            {
                auto upperToLast = fpLastSearch->fLowerBoundTime;
                upperToLast++;
 
                if (upperToLast == timeMap.end())
                {
                    return fpLastSearch->fLowerBoundTime->second;
                }
 
                if (upperToLast->first > time)
                {
                    return fpLastSearch->fLowerBoundTime->second;
                }
            }
        }
    }
 
    auto up_time_it = timeMap.upper_bound(time);
 
    if (up_time_it == timeMap.end())
    {
        NbMoleculeAgainstTime::reverse_iterator last_time = timeMap.rbegin();
        return last_time->second;
    }
    if (up_time_it == timeMap.begin())
    {
        return 0;
    }
 
    up_time_it--;
 
    fpLastSearch->fLowerBoundTime = up_time_it;
    fpLastSearch->fLowerBoundSet = true;
 
    return fpLastSearch->fLowerBoundTime->second;
}

References fCounterMap, and fpLastSearch.

Referenced by GetNMoleculesAtTime().

◆ SetInstance()

void G4VMoleculeCounter::SetInstance ( G4VMoleculeCounter * pCounterInstance )

staticinherited

Definition at line 43 of file G4VMoleculeCounter.cc.

{
    if (fpInstance != nullptr)
    {
        G4ExceptionDescription errMsg;
        errMsg << "The G4MoleculeCounter was already initialized." << G4endl
               << "The previous instance will be deleted in order to use yours." << G4endl
               << "However this can generate conflicts. Make sure you call G4MoleculeCounter::SetInstance"
                  "at the beginning of your application."
               << "A good place would be ActionInitialization::Build & BuildForMaster"
               << G4endl;
 
        G4Exception("G4MoleculeCounter::SetInstance",
                    "SINGLETON_ALREADY_INITIALIZED",
                    JustWarning, errMsg);
        delete fpInstance;
        fpInstance = nullptr;
    }
 
    fpInstance = pCounterInstance;
}

References G4VMoleculeCounter::fpInstance, G4endl, G4Exception(), and JustWarning.

◆ SetTimeSlice()

void G4MoleculeCounter::SetTimeSlice ( double timeSlice )

static

Definition at line 99 of file G4MoleculeCounter.cc.

{
    G4::MoleculeCounter::TimePrecision::fPrecision = timeSlice;
}

References G4::MoleculeCounter::TimePrecision::fPrecision.

◆ SetVerbose()

void G4MoleculeCounter::SetVerbose ( G4int level )

Definition at line 467 of file G4MoleculeCounter.cc.

{
    fVerbose = level;
}

References fVerbose.

◆ Use()

void G4VMoleculeCounter::Use ( G4bool flag = true )

staticinherited

Definition at line 99 of file G4VMoleculeCounter.cc.

{
    fUse = flag;
}

References G4VMoleculeCounter::fUse.

Referenced by G4DNAEventScheduler::ClearAndReChargeCounter().

Friends And Related Function Documentation

◆ G4Molecule

friend class G4Molecule

friend

Definition at line 148 of file G4MoleculeCounter.hh.

◆ G4VMoleculeCounter

friend class G4VMoleculeCounter

friend

Definition at line 149 of file G4MoleculeCounter.hh.

Field Documentation

◆ fCheckTimeIsConsistentWithScheduler

G4bool G4MoleculeCounter::fCheckTimeIsConsistentWithScheduler

protected

Definition at line 133 of file G4MoleculeCounter.hh.

Referenced by CheckTimeForConsistency(), G4MoleculeCounter(), IsTimeCheckedForConsistency(), and RemoveAMoleculeAtTime().

◆ fCounterMap

CounterMapType G4MoleculeCounter::fCounterMap

protected

Definition at line 129 of file G4MoleculeCounter.hh.

Referenced by AddAMoleculeAtTime(), Dump(), GetNbMoleculeAgainstTime(), GetRecordedMolecules(), GetRecordedTimes(), Initialize(), RemoveAMoleculeAtTime(), ResetCounter(), SearchTimeMap(), and SearchUpperBoundTime().

◆ fDontRegister

std::map<const G4MoleculeDefinition*, G4bool> G4MoleculeCounter::fDontRegister

protected

Definition at line 130 of file G4MoleculeCounter.hh.

Referenced by AddAMoleculeAtTime(), DontRegister(), IsRegistered(), RegisterAll(), and RemoveAMoleculeAtTime().

◆ fpInstance

G4ThreadLocal G4VMoleculeCounter * G4VMoleculeCounter::fpInstance = nullptr

staticprotectedinherited

Definition at line 46 of file G4VMoleculeCounter.hh.

Referenced by G4VMoleculeCounter::DeleteInstance(), G4VMoleculeCounter::InitializeInstance(), Instance(), G4VMoleculeCounter::Instance(), and G4VMoleculeCounter::SetInstance().

◆ fpLastSearch

std::unique_ptr<Search> G4MoleculeCounter::fpLastSearch

protected

Definition at line 146 of file G4MoleculeCounter.hh.

Referenced by ResetCounter(), SearchTimeMap(), and SearchUpperBoundTime().

◆ fUse

G4bool G4VMoleculeCounter::fUse = false

staticprotectedinherited

Definition at line 47 of file G4VMoleculeCounter.hh.

Referenced by G4VMoleculeCounter::InUse(), and G4VMoleculeCounter::Use().

◆ fVerbose

G4int G4MoleculeCounter::fVerbose

protected

Definition at line 132 of file G4MoleculeCounter.hh.

Referenced by AddAMoleculeAtTime(), G4MoleculeCounter(), GetRecordedMolecules(), GetVerbose(), RemoveAMoleculeAtTime(), ResetCounter(), and SetVerbose().

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

source/processes/electromagnetic/dna/molecules/management/include/G4MoleculeCounter.hh
source/processes/electromagnetic/dna/molecules/management/src/G4MoleculeCounter.cc

Data Structures

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ CounterMapType

◆ Reactant

◆ ReactantList

◆ RecordedMolecules

Constructor & Destructor Documentation

◆ G4MoleculeCounter()

◆ ~G4MoleculeCounter()

Member Function Documentation

◆ AddAMoleculeAtTime()

◆ CheckTimeForConsistency()

◆ DeleteInstance()

◆ DontRegister()

◆ Dump()

◆ GetNbMoleculeAgainstTime()

◆ GetNMoleculesAtTime()

◆ GetRecordedMolecules()

◆ GetRecordedTimes()

◆ GetVerbose()

◆ Initialize()

◆ InitializeInstance()

◆ Instance()

◆ InUse()

◆ IsRegistered()

◆ IsTimeCheckedForConsistency()

◆ RegisterAll()

◆ RemoveAMoleculeAtTime()

◆ ResetCounter()

◆ SearchTimeMap()

◆ SearchUpperBoundTime()

◆ SetInstance()

◆ SetTimeSlice()

◆ SetVerbose()

◆ Use()

Friends And Related Function Documentation

◆ G4Molecule

◆ G4VMoleculeCounter

Field Documentation

◆ fCheckTimeIsConsistentWithScheduler

◆ fCounterMap

◆ fDontRegister

◆ fpInstance

◆ fpLastSearch

◆ fUse

◆ fVerbose