#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)

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 ()

static void	Use (G4bool flag=true)

static G4bool	InUse ()

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

Friends
class	G4Molecule

class	G4VMoleculeCounter

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

static G4bool	fUse = false

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::RemoveAMoleculeAtTime",
                            "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 (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;
        }
    }
}

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

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

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

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

◆ 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