#include <G4MoleculeCounter.hh>

Inheritance diagram for G4MoleculeCounter:

Classes
struct	Search

Public Types
using	ReactantList = std::vector< Reactant * >

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

using	RecordedMolecules = std::unique_ptr< ReactantList >

Public Types inherited from G4VMoleculeCounter
using	Reactant = const G4MolecularConfiguration

Public Member Functions
void	Initialize () override

void	ResetCounter () override

void	DontRegister (const G4MoleculeDefinition *) override

bool	IsRegistered (const G4MoleculeDefinition *) override

void	RegisterAll () override

int	GetNMoleculesAtTime (Reactant *molecule, double time)

const NbMoleculeAgainstTime &	GetNbMoleculeAgainstTime (Reactant *molecule)

RecordedMolecules	GetRecordedMolecules ()

RecordedTimes	GetRecordedTimes ()

void	SetVerbose (G4int)

G4int	GetVerbose ()

void	Dump ()

G4bool	IsTimeCheckedForConsistency () const

void	CheckTimeForConsistency (G4bool flag)

Public Member Functions inherited from G4VMoleculeCounter
void	Use (G4bool flag=true)

G4bool	InUse ()

virtual void	Initialize ()=0

virtual void	ResetCounter ()=0

virtual void	AddAMoleculeAtTime (Reactant , G4double time, const G4ThreeVector position=nullptr, int number=1)=0

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

virtual void	DontRegister (const G4MoleculeDefinition *)

virtual bool	IsRegistered (const G4MoleculeDefinition *)

virtual void	RegisterAll ()

Static Public Member Functions
static G4MoleculeCounter *	Instance ()

static void	SetTimeSlice (double)

Static Public Member Functions inherited from G4VMoleculeCounter
static void	SetInstance (G4VMoleculeCounter *)

static void	DeleteInstance ()

static G4VMoleculeCounter *	Instance ()

static void	InitializeInstance ()

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

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

G4bool	SearchTimeMap (Reactant *molecule)

int	SearchUpperBoundTime (double time, bool sameTypeOfMolecule)

	G4MoleculeCounter ()

	~G4MoleculeCounter () override

Protected Member Functions inherited from G4VMoleculeCounter
	G4VMoleculeCounter ()=default

virtual	~G4VMoleculeCounter ()=default

Protected Attributes
CounterMapType	fCounterMap

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

G4int	fVerbose

G4bool	fCheckTimeIsConsistentWithScheduler

std::unique_ptr< Search >	fpLastSearch

Protected Attributes inherited from G4VMoleculeCounter
G4bool	fUse = false

Friends
class	G4Molecule

class	G4VMoleculeCounter

Additional Inherited Members
Static Protected Attributes inherited from G4VMoleculeCounter
static G4ThreadLocal G4VMoleculeCounter *	fpInstance = nullptr

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.

◆ 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;
}

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);
            }
        }
    }
}

◆ CheckTimeForConsistency()

void G4MoleculeCounter::CheckTimeForConsistency ( G4bool flag )

Definition at line 509 of file G4MoleculeCounter.cc.

{
    fCheckTimeIsConsistentWithScheduler = flag;
}

◆ DontRegister()

void G4MoleculeCounter::DontRegister ( const G4MoleculeDefinition * molDef )

overridevirtual

Reimplemented from G4VMoleculeCounter.

Definition at line 481 of file G4MoleculeCounter.cc.

{
    fDontRegister[molDef] = true;
}

◆ Dump()

void G4MoleculeCounter::Dump ( )

Definition at line 430 of file G4MoleculeCounter.cc.

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

Referenced by RemoveAMoleculeAtTime().

◆ GetNbMoleculeAgainstTime()

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

Definition at line 460 of file G4MoleculeCounter.cc.

{
    return fCounterMap[molecule];
}

◆ GetNMoleculesAtTime()

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

Definition at line 199 of file G4MoleculeCounter.cc.

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

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 (const auto & it : fCounterMap)
    {
        output->push_back(it.first);
    }
    return output;
}

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;
}

◆ GetVerbose()

G4int G4MoleculeCounter::GetVerbose ( )

Definition at line 474 of file G4MoleculeCounter.cc.

{
    return 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
    }
}

◆ Instance()

G4MoleculeCounter * G4MoleculeCounter::Instance ( )

static

Definition at line 60 of file G4MoleculeCounter.cc.

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

Referenced by G4DNAEventScheduler::ClearAndReChargeCounter().

◆ 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;
}

Referenced by Initialize().

◆ IsTimeCheckedForConsistency()

G4bool G4MoleculeCounter::IsTimeCheckedForConsistency ( ) const

Definition at line 504 of file G4MoleculeCounter.cc.

{
    return fCheckTimeIsConsistentWithScheduler;
}

◆ RegisterAll()

void G4MoleculeCounter::RegisterAll ( )

overridevirtual

Reimplemented from G4VMoleculeCounter.

Definition at line 499 of file G4MoleculeCounter.cc.

{
    fDontRegister.clear();
}

◆ 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;
    }
}

◆ 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);
}

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;
}

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;
}

Referenced by GetNMoleculesAtTime().

◆ SetTimeSlice()

void G4MoleculeCounter::SetTimeSlice ( double timeSlice )

static

Definition at line 99 of file G4MoleculeCounter.cc.

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

◆ SetVerbose()

void G4MoleculeCounter::SetVerbose ( G4int level )

Definition at line 467 of file G4MoleculeCounter.cc.

{
    fVerbose = level;
}

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.

Member Data 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().

◆ fpLastSearch

std::unique_ptr<Search> G4MoleculeCounter::fpLastSearch

protected

Definition at line 146 of file G4MoleculeCounter.hh.

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

◆ 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:

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ CounterMapType

◆ ReactantList

◆ RecordedMolecules

Constructor & Destructor Documentation

◆ G4MoleculeCounter()

◆ ~G4MoleculeCounter()

Member Function Documentation

◆ AddAMoleculeAtTime()

◆ CheckTimeForConsistency()

◆ DontRegister()

◆ Dump()

◆ GetNbMoleculeAgainstTime()

◆ GetNMoleculesAtTime()

◆ GetRecordedMolecules()

◆ GetRecordedTimes()

◆ GetVerbose()

◆ Initialize()

◆ Instance()

◆ IsRegistered()

◆ IsTimeCheckedForConsistency()

◆ RegisterAll()

◆ RemoveAMoleculeAtTime()

◆ ResetCounter()

◆ SearchTimeMap()

◆ SearchUpperBoundTime()

◆ SetTimeSlice()

◆ SetVerbose()

Friends And Related Function Documentation

◆ G4Molecule

◆ G4VMoleculeCounter

Member Data Documentation

◆ fCheckTimeIsConsistentWithScheduler

◆ fCounterMap

◆ fDontRegister

◆ fpLastSearch

◆ fVerbose