G4MoleculeCounter Class Reference

#include <G4MoleculeCounter.hh>

Public Member Functions
const NbMoleculeAgainstTime &	GetNbMoleculeAgainstTime (const G4Molecule &molecule)
std::auto_ptr< vector< G4Molecule > >	GetRecordedMolecules ()
virtual void	AddAMoleculeAtTime (const G4Molecule &, G4double)
virtual void	RemoveAMoleculeAtTime (const G4Molecule &, G4double)
virtual void	DontRegister (const G4MoleculeDefinition *)
virtual void	ResetDontRegister ()
void	Use (G4bool flag=true)
G4bool	InUse ()
void	SetVerbose (G4int)
G4int	GetVerbose ()
virtual void	ResetCounter ()

Static Public Member Functions
static void	DeleteInstance ()
static G4MoleculeCounter *	GetMoleculeCounter ()

Protected Types
typedef std::map< G4Molecule, NbMoleculeAgainstTime >	CounterMapType

Protected Member Functions
	G4MoleculeCounter ()
virtual	~G4MoleculeCounter ()

Protected Attributes
CounterMapType	fCounterMap
std::map< const G4MoleculeDefinition *, G4bool >	fDontRegister
G4bool	fUse
G4int	fVerbose

Static Protected Attributes
static G4MoleculeCounter *	fpInstance = 0

Detailed Description

Definition at line 55 of file G4MoleculeCounter.hh.

Member Typedef Documentation

CounterMapType

typedef std::map<G4Molecule, NbMoleculeAgainstTime> G4MoleculeCounter::CounterMapType

protected

Definition at line 61 of file G4MoleculeCounter.hh.

Constructor & Destructor Documentation

G4MoleculeCounter()

G4MoleculeCounter::G4MoleculeCounter ( )

protected

Definition at line 35 of file G4MoleculeCounter.cc.

{
    fUse = FALSE;
    fVerbose = 0 ;
}

Referenced by GetMoleculeCounter().

~G4MoleculeCounter()

virtual G4MoleculeCounter::~G4MoleculeCounter ( )

inlineprotectedvirtual

Definition at line 59 of file G4MoleculeCounter.hh.

{;}

Member Function Documentation

AddAMoleculeAtTime()

void G4MoleculeCounter::AddAMoleculeAtTime ( const G4Molecule &  molecule, G4double  time  )

virtual

Definition at line 60 of file G4MoleculeCounter.cc.

{
    if(fVerbose > 1)
    {
        G4cout<<"G4MoleculeCounter::AddAMoleculeAtTime : "<< molecule.GetName()
              << " at time : " << G4BestUnit(time, "Time") <<G4endl;
    }
 
    if(fDontRegister[molecule.GetDefinition()]) return ;
 
    // G4double pstime = time/picosecond;
    //
    // G4double fractpart=-1, intpart=-1;
    // fractpart = modf (pstime , &intpart);
    //
    // if(pstime<10.1)
    // {
    // fractpart *= 10 ;
    // fractpart = floor(fractpart)/10;
    // pstime = intpart+fractpart;
    // }
    //
    // else
    // {
    // pstime = intpart;
    // }
    // time = pstime*picosecond ;
 
    if(fVerbose)
    {
        G4cout<<"-------------------------"<<G4endl ;
        G4cout << "G4MoleculeCounter::AddAMoleculeAtTime " << G4endl;
        G4cout<<"!! Molecule = " << molecule.GetName() << G4endl;
        G4cout<<"!! At Time = "<< G4BestUnit(time, "Time") <<G4endl;
    }
 
    CounterMapType::iterator counterMap_i = fCounterMap.find(molecule) ;
 
    if(counterMap_i == fCounterMap.end())
    {
        if(fVerbose)    G4cout << " !! ***** Map is empty " << G4endl;
        fCounterMap[molecule][time] = 1;
    }
    else if(counterMap_i->second.empty())
    {
        if(fVerbose)    G4cout << " !! ***** Map is empty " << G4endl;
        counterMap_i->second[time] = 1;
    }
    else
    {
        NbMoleculeAgainstTime::iterator end = counterMap_i->second.end();
        end--;
 
        if(fVerbose)
            G4cout<<"!! End Time = "<< G4BestUnit(end->first, "Time") <<G4endl;
 
        if(end->first <= time)
        {
            counterMap_i->second[time]=end->second + 1;
        }
        else
        {
            NbMoleculeAgainstTime::iterator it = counterMap_i->second.lower_bound(time);
 
            while(it->first > time && it!=counterMap_i->second.begin())
            {
                if(fVerbose)
                    G4cout<<"!!  ********** Is going back!!!!"<<G4endl;
                it--;
            }
 
            if(it==counterMap_i->second.begin() && it->first > time)
            {
                if(fVerbose)
                    G4cout<<"!!  ********** Illegal !!!!"<<G4endl;
                return ;
            }
 
            if(fVerbose)
            {
                G4cout<<"!! PREVIOUS NB = "<< it->second <<G4endl;
                G4cout<<"!! PREVIOUS TIME = "<< G4BestUnit(it->first,"Time") <<G4endl;
            }
            counterMap_i->second[time]=it->second + 1;
        }
    }
 
    if(fVerbose)
        G4cout<<"!! NB = "<< fCounterMap[molecule][time]<<G4endl;
}

Referenced by G4Molecule::BuildTrack().

DeleteInstance()

void G4MoleculeCounter::DeleteInstance ( )

static

Definition at line 51 of file G4MoleculeCounter.cc.

{
    if(fpInstance)
    {
        delete fpInstance;
        fpInstance = 0;
    }
}

DontRegister()

void G4MoleculeCounter::DontRegister ( const G4MoleculeDefinition *  molDef )

inlinevirtual

Definition at line 118 of file G4MoleculeCounter.hh.

{
    fDontRegister[molDef] = true ;
}

GetMoleculeCounter()

G4MoleculeCounter * G4MoleculeCounter::GetMoleculeCounter ( )

static

Definition at line 43 of file G4MoleculeCounter.cc.

{
    if(!fpInstance)
        fpInstance = new G4MoleculeCounter();
 
    return fpInstance;
}

Referenced by G4Molecule::BuildTrack(), and G4Molecule::~G4Molecule().

GetNbMoleculeAgainstTime()

const NbMoleculeAgainstTime & G4MoleculeCounter::GetNbMoleculeAgainstTime ( const G4Molecule &  molecule )

inline

Definition at line 103 of file G4MoleculeCounter.hh.

{
    return fCounterMap[molecule];
}

GetRecordedMolecules()

std::auto_ptr< vector< G4Molecule > > G4MoleculeCounter::GetRecordedMolecules

(

)

Definition at line 258 of file G4MoleculeCounter.cc.

{
    if(fVerbose > 1)
    {
        G4cout<<"Entering in G4MoleculeCounter::RecordMolecules"<<G4endl;
    }
 
    CounterMapType::iterator it;
    std::auto_ptr< vector<G4Molecule> > output (new vector<G4Molecule>) ;
 
    for(it = fCounterMap.begin() ; it != fCounterMap.end() ; it++)
    {
        output->push_back((*it).first);
    }
    return output;
}

GetVerbose()

G4int G4MoleculeCounter::GetVerbose ( )

inline

Definition at line 113 of file G4MoleculeCounter.hh.

{
    return fVerbose ;
}

InUse()

G4bool G4MoleculeCounter::InUse ( )

inline

Definition at line 87 of file G4MoleculeCounter.hh.

    {
        return fUse;
    }

RemoveAMoleculeAtTime()

void G4MoleculeCounter::RemoveAMoleculeAtTime ( const G4Molecule &  molecule, G4double  time  )

virtual

Definition at line 151 of file G4MoleculeCounter.cc.

{
    if(fVerbose > 1)
    {
        G4cout<<"-------------------------"<<G4endl ;
        G4cout<<"G4MoleculeCounter::RemoveAMoleculeAtTime : "<< molecule.GetName()
             << " at time : " << G4BestUnit(time,"Time") <<G4endl;
        G4cout<<"-------------------------"<<G4endl ;
    }
 
    if(fDontRegister[molecule.GetDefinition()]) return ;
 
    NbMoleculeAgainstTime& nbMolPerTime = fCounterMap[molecule];
 
    if(nbMolPerTime.empty())
    {
        molecule.PrintState();
        G4String errMsg = "You are trying to remove molecule "
                          + molecule.GetName()
                          +" from the counter while this kind of molecules has not been registered yet";
        G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime","",FatalErrorInArgument, errMsg);
 
        return;
    }
    else
    {
        NbMoleculeAgainstTime::iterator it ;
 
        if(nbMolPerTime.size() == 1)
        {
            it = nbMolPerTime.begin() ;
            if(fVerbose)
                G4cout << "!! fCounterMap[molecule].size() == 1" << G4endl;
        }
        else
        {
            it = nbMolPerTime.lower_bound(time);
        }
 
        if(it==nbMolPerTime.end())
        {
            if(fVerbose)
                G4cout << " ********** NO ITERATOR !!!!!!!!! " << G4endl;
            it--;
 
            if(time<it->first)
            {
                G4String errMsg = "There was no "+ molecule.GetName()
                        + " record at the time or even before the time asked";
                G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime","",FatalErrorInArgument, errMsg);
            }
        }
 
        if(fVerbose)
        {
//            G4cout << "G4MoleculeCounter::RemoveAMoleculeAtTime " << G4endl;
            G4cout<<"!! Molecule = " << molecule.GetName() << G4endl;
            G4cout<<"!! At Time = "<< G4BestUnit(time,"Time") <<G4endl;
            G4cout<<"!! PREVIOUS TIME = "<< G4BestUnit(it->first,"Time")<<G4endl;
            G4cout<<"!! PREVIOUS Nb = "<< it->second <<G4endl;
        }
 
        // If valgrind problem on the line below, it means that the pointer "it"
        // points nowhere
        if(nbMolPerTime.value_comp()(*it, *nbMolPerTime.begin()))
        {
            if(fVerbose)
                G4cout<<"!! ***** In value_comp ... " << G4endl;
            it++;
            if(time<it->first)
            {
                G4String errMsg = "There was no "+ molecule.GetName()
                        + " record at the time or even before the time asked";
                G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime","",FatalErrorInArgument, errMsg);
            }
        }
 
        while(it->first - time > compDoubleWithPrecision::fPrecision  && it!=nbMolPerTime.begin())
        {
            if(fVerbose)
            {
                G4cout<<"!! ***** Is going back!!!!"<<G4endl;
                G4cout<<"!! PREVIOUS TIME = "<< G4BestUnit(it-> first,"Time") <<G4endl;
            }
            it--;
        }
 
        if(it==nbMolPerTime.begin() && it->first > time)
        {
            if(fVerbose)
                G4cout<<"!!  ********** Illegal !!!!"<<G4endl;
            return ;
        }
 
        if(fVerbose)
        {
            G4cout<<"!! PREVIOUS NB = "<< (*it).second <<G4endl;
            G4cout<<"!! PREVIOUS TIME = "<< G4BestUnit(it->first,"Time")<<G4endl;
        }
        nbMolPerTime[time]=it->second - 1;
    }
    if(fVerbose)
    {
        G4cout<<"!! NB = "<< nbMolPerTime[time]<<G4endl;
    }
}

Referenced by G4Molecule::~G4Molecule().

ResetCounter()

void G4MoleculeCounter::ResetCounter ( )

inlinevirtual

Definition at line 98 of file G4MoleculeCounter.hh.

{
    fCounterMap.clear();
}

ResetDontRegister()

void G4MoleculeCounter::ResetDontRegister ( )

inlinevirtual

Definition at line 123 of file G4MoleculeCounter.hh.

{
    fDontRegister.clear();
}

SetVerbose()

void G4MoleculeCounter::SetVerbose ( G4int  level )

inline

Definition at line 108 of file G4MoleculeCounter.hh.

{
    fVerbose = level;
}

Use()

void G4MoleculeCounter::Use ( G4bool  flag = true )

inline

Definition at line 83 of file G4MoleculeCounter.hh.

    {
        fUse=flag;
    }

Member Data Documentation

fCounterMap

CounterMapType G4MoleculeCounter::fCounterMap

protected

Definition at line 63 of file G4MoleculeCounter.hh.

Referenced by AddAMoleculeAtTime(), GetNbMoleculeAgainstTime(), GetRecordedMolecules(), RemoveAMoleculeAtTime(), and ResetCounter().

fDontRegister

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

protected

Definition at line 65 of file G4MoleculeCounter.hh.

Referenced by AddAMoleculeAtTime(), DontRegister(), RemoveAMoleculeAtTime(), and ResetDontRegister().

fpInstance

G4MoleculeCounter * G4MoleculeCounter::fpInstance = 0

staticprotected

Definition at line 60 of file G4MoleculeCounter.hh.

Referenced by DeleteInstance(), and GetMoleculeCounter().

fUse

G4bool G4MoleculeCounter::fUse

protected

Definition at line 66 of file G4MoleculeCounter.hh.

Referenced by G4MoleculeCounter(), InUse(), and Use().

fVerbose

G4int G4MoleculeCounter::fVerbose

protected

Definition at line 68 of file G4MoleculeCounter.hh.

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

---

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

• G4MoleculeCounter.hh
• G4MoleculeCounter.cc