G4MoleculeCounter Class Reference

#include <G4MoleculeCounter.hh>


Public Member Functions

const NbMoleculeAgainstTimeGetNbMoleculeAgainstTime (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 G4MoleculeCounterGetMoleculeCounter ()

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 G4MoleculeCounterfpInstance = 0


Detailed Description

Definition at line 55 of file G4MoleculeCounter.hh.


Member Typedef Documentation

typedef std::map<G4Molecule, NbMoleculeAgainstTime> G4MoleculeCounter::CounterMapType [protected]

Definition at line 61 of file G4MoleculeCounter.hh.


Constructor & Destructor Documentation

G4MoleculeCounter::G4MoleculeCounter (  )  [protected]

Definition at line 35 of file G4MoleculeCounter.cc.

References FALSE, fUse, and fVerbose.

Referenced by GetMoleculeCounter().

00036 {
00037     fUse = FALSE;
00038     fVerbose = 0 ;
00039 }

virtual G4MoleculeCounter::~G4MoleculeCounter (  )  [inline, protected, virtual]

Definition at line 59 of file G4MoleculeCounter.hh.

00059 {;}


Member Function Documentation

void G4MoleculeCounter::AddAMoleculeAtTime ( const G4Molecule ,
G4double   
) [virtual]

Definition at line 60 of file G4MoleculeCounter.cc.

References fCounterMap, fDontRegister, fVerbose, G4BestUnit, G4cout, G4endl, G4Molecule::GetDefinition(), and G4Molecule::GetName().

Referenced by G4Molecule::BuildTrack().

00061 {
00062     if(fVerbose > 1)
00063     {
00064         G4cout<<"G4MoleculeCounter::AddAMoleculeAtTime : "<< molecule.GetName()
00065               << " at time : " << G4BestUnit(time, "Time") <<G4endl;
00066     }
00067 
00068     if(fDontRegister[molecule.GetDefinition()]) return ;
00069 
00070     // G4double pstime = time/picosecond;
00071     //
00072     // G4double fractpart=-1, intpart=-1;
00073     // fractpart = modf (pstime , &intpart);
00074     //
00075     // if(pstime<10.1)
00076     // {
00077     // fractpart *= 10 ;
00078     // fractpart = floor(fractpart)/10;
00079     // pstime = intpart+fractpart;
00080     // }
00081     //
00082     // else
00083     // {
00084     // pstime = intpart;
00085     // }
00086     // time = pstime*picosecond ;
00087 
00088     if(fVerbose)
00089     {
00090         G4cout<<"-------------------------"<<G4endl ;
00091         G4cout << "G4MoleculeCounter::AddAMoleculeAtTime " << G4endl;
00092         G4cout<<"!! Molecule = " << molecule.GetName() << G4endl;
00093         G4cout<<"!! At Time = "<< G4BestUnit(time, "Time") <<G4endl;
00094     }
00095 
00096     CounterMapType::iterator counterMap_i = fCounterMap.find(molecule) ;
00097 
00098     if(counterMap_i == fCounterMap.end())
00099     {
00100         if(fVerbose)    G4cout << " !! ***** Map is empty " << G4endl;
00101         fCounterMap[molecule][time] = 1;
00102     }
00103     else if(counterMap_i->second.empty())
00104     {
00105         if(fVerbose)    G4cout << " !! ***** Map is empty " << G4endl;
00106         counterMap_i->second[time] = 1;
00107     }
00108     else
00109     {
00110         NbMoleculeAgainstTime::iterator end = counterMap_i->second.end();
00111         end--;
00112 
00113         if(fVerbose)
00114             G4cout<<"!! End Time = "<< G4BestUnit(end->first, "Time") <<G4endl;
00115 
00116         if(end->first <= time)
00117         {
00118             counterMap_i->second[time]=end->second + 1;
00119         }
00120         else
00121         {
00122             NbMoleculeAgainstTime::iterator it = counterMap_i->second.lower_bound(time);
00123 
00124             while(it->first > time && it!=counterMap_i->second.begin())
00125             {
00126                 if(fVerbose)
00127                     G4cout<<"!!  ********** Is going back!!!!"<<G4endl;
00128                 it--;
00129             }
00130 
00131             if(it==counterMap_i->second.begin() && it->first > time)
00132             {
00133                 if(fVerbose)
00134                     G4cout<<"!!  ********** Illegal !!!!"<<G4endl;
00135                 return ;
00136             }
00137 
00138             if(fVerbose)
00139             {
00140                 G4cout<<"!! PREVIOUS NB = "<< it->second <<G4endl;
00141                 G4cout<<"!! PREVIOUS TIME = "<< G4BestUnit(it->first,"Time") <<G4endl;
00142             }
00143             counterMap_i->second[time]=it->second + 1;
00144         }
00145     }
00146 
00147     if(fVerbose)
00148         G4cout<<"!! NB = "<< fCounterMap[molecule][time]<<G4endl;
00149 }

void G4MoleculeCounter::DeleteInstance (  )  [static]

Definition at line 51 of file G4MoleculeCounter.cc.

References fpInstance.

00052 {
00053     if(fpInstance)
00054     {
00055         delete fpInstance;
00056         fpInstance = 0;
00057     }
00058 }

void G4MoleculeCounter::DontRegister ( const G4MoleculeDefinition  )  [inline, virtual]

Definition at line 118 of file G4MoleculeCounter.hh.

References fDontRegister.

00119 {
00120     fDontRegister[molDef] = true ;
00121 }

G4MoleculeCounter * G4MoleculeCounter::GetMoleculeCounter (  )  [static]

Definition at line 43 of file G4MoleculeCounter.cc.

References fpInstance, and G4MoleculeCounter().

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

00044 {
00045     if(!fpInstance)
00046         fpInstance = new G4MoleculeCounter();
00047 
00048     return fpInstance;
00049 }

const NbMoleculeAgainstTime & G4MoleculeCounter::GetNbMoleculeAgainstTime ( const G4Molecule molecule  )  [inline]

Definition at line 103 of file G4MoleculeCounter.hh.

References fCounterMap.

00104 {
00105     return fCounterMap[molecule];
00106 }

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

Definition at line 258 of file G4MoleculeCounter.cc.

References fCounterMap, fVerbose, G4cout, and G4endl.

00259 {
00260     if(fVerbose > 1)
00261     {
00262         G4cout<<"Entering in G4MoleculeCounter::RecordMolecules"<<G4endl;
00263     }
00264 
00265     CounterMapType::iterator it;
00266     std::auto_ptr< vector<G4Molecule> > output (new vector<G4Molecule>) ;
00267 
00268     for(it = fCounterMap.begin() ; it != fCounterMap.end() ; it++)
00269     {
00270         output->push_back((*it).first);
00271     }
00272     return output;
00273 }

G4int G4MoleculeCounter::GetVerbose (  )  [inline]

Definition at line 113 of file G4MoleculeCounter.hh.

References fVerbose.

00114 {
00115     return fVerbose ;
00116 }

G4bool G4MoleculeCounter::InUse (  )  [inline]

Definition at line 87 of file G4MoleculeCounter.hh.

References fUse.

00088     {
00089         return fUse;
00090     }

void G4MoleculeCounter::RemoveAMoleculeAtTime ( const G4Molecule ,
G4double   
) [virtual]

Definition at line 151 of file G4MoleculeCounter.cc.

References FatalErrorInArgument, fCounterMap, fDontRegister, compDoubleWithPrecision::fPrecision, fVerbose, G4BestUnit, G4cout, G4endl, G4Exception(), G4Molecule::GetDefinition(), G4Molecule::GetName(), and G4Molecule::PrintState().

Referenced by G4Molecule::~G4Molecule().

00152 {
00153     if(fVerbose > 1)
00154     {
00155         G4cout<<"-------------------------"<<G4endl ;
00156         G4cout<<"G4MoleculeCounter::RemoveAMoleculeAtTime : "<< molecule.GetName()
00157              << " at time : " << G4BestUnit(time,"Time") <<G4endl;
00158         G4cout<<"-------------------------"<<G4endl ;
00159     }
00160 
00161     if(fDontRegister[molecule.GetDefinition()]) return ;
00162 
00163     NbMoleculeAgainstTime& nbMolPerTime = fCounterMap[molecule];
00164 
00165     if(nbMolPerTime.empty())
00166     {
00167         molecule.PrintState();
00168         G4String errMsg = "You are trying to remove molecule "
00169                           + molecule.GetName()
00170                           +" from the counter while this kind of molecules has not been registered yet";
00171         G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime","",FatalErrorInArgument, errMsg);
00172 
00173         return;
00174     }
00175     else
00176     {
00177         NbMoleculeAgainstTime::iterator it ;
00178 
00179         if(nbMolPerTime.size() == 1)
00180         {
00181             it = nbMolPerTime.begin() ;
00182             if(fVerbose)
00183                 G4cout << "!! fCounterMap[molecule].size() == 1" << G4endl;
00184         }
00185         else
00186         {
00187             it = nbMolPerTime.lower_bound(time);
00188         }
00189 
00190         if(it==nbMolPerTime.end())
00191         {
00192             if(fVerbose)
00193                 G4cout << " ********** NO ITERATOR !!!!!!!!! " << G4endl;
00194             it--;
00195 
00196             if(time<it->first)
00197             {
00198                 G4String errMsg = "There was no "+ molecule.GetName()
00199                         + " record at the time or even before the time asked";
00200                 G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime","",FatalErrorInArgument, errMsg);
00201             }
00202         }
00203 
00204         if(fVerbose)
00205         {
00206 //            G4cout << "G4MoleculeCounter::RemoveAMoleculeAtTime " << G4endl;
00207             G4cout<<"!! Molecule = " << molecule.GetName() << G4endl;
00208             G4cout<<"!! At Time = "<< G4BestUnit(time,"Time") <<G4endl;
00209             G4cout<<"!! PREVIOUS TIME = "<< G4BestUnit(it->first,"Time")<<G4endl;
00210             G4cout<<"!! PREVIOUS Nb = "<< it->second <<G4endl;
00211         }
00212 
00213         // If valgrind problem on the line below, it means that the pointer "it"
00214         // points nowhere
00215         if(nbMolPerTime.value_comp()(*it, *nbMolPerTime.begin()))
00216         {
00217             if(fVerbose)
00218                 G4cout<<"!! ***** In value_comp ... " << G4endl;
00219             it++;
00220             if(time<it->first)
00221             {
00222                 G4String errMsg = "There was no "+ molecule.GetName()
00223                         + " record at the time or even before the time asked";
00224                 G4Exception("G4MoleculeCounter::RemoveAMoleculeAtTime","",FatalErrorInArgument, errMsg);
00225             }
00226         }
00227 
00228         while(it->first - time > compDoubleWithPrecision::fPrecision  && it!=nbMolPerTime.begin())
00229         {
00230             if(fVerbose)
00231             {
00232                 G4cout<<"!! ***** Is going back!!!!"<<G4endl;
00233                 G4cout<<"!! PREVIOUS TIME = "<< G4BestUnit(it-> first,"Time") <<G4endl;
00234             }
00235             it--;
00236         }
00237 
00238         if(it==nbMolPerTime.begin() && it->first > time)
00239         {
00240             if(fVerbose)
00241                 G4cout<<"!!  ********** Illegal !!!!"<<G4endl;
00242             return ;
00243         }
00244 
00245         if(fVerbose)
00246         {
00247             G4cout<<"!! PREVIOUS NB = "<< (*it).second <<G4endl;
00248             G4cout<<"!! PREVIOUS TIME = "<< G4BestUnit(it->first,"Time")<<G4endl;
00249         }
00250         nbMolPerTime[time]=it->second - 1;
00251     }
00252     if(fVerbose)
00253     {
00254         G4cout<<"!! NB = "<< nbMolPerTime[time]<<G4endl;
00255     }
00256 }

void G4MoleculeCounter::ResetCounter (  )  [inline, virtual]

Definition at line 98 of file G4MoleculeCounter.hh.

References fCounterMap.

00099 {
00100     fCounterMap.clear();
00101 }

void G4MoleculeCounter::ResetDontRegister (  )  [inline, virtual]

Definition at line 123 of file G4MoleculeCounter.hh.

References fDontRegister.

00124 {
00125     fDontRegister.clear();
00126 }

void G4MoleculeCounter::SetVerbose ( G4int   )  [inline]

Definition at line 108 of file G4MoleculeCounter.hh.

References fVerbose.

00109 {
00110     fVerbose = level;
00111 }

void G4MoleculeCounter::Use ( G4bool  flag = true  )  [inline]

Definition at line 83 of file G4MoleculeCounter.hh.

References fUse.

00084     {
00085         fUse=flag;
00086     }


Field Documentation

CounterMapType G4MoleculeCounter::fCounterMap [protected]

Definition at line 63 of file G4MoleculeCounter.hh.

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

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

Definition at line 65 of file G4MoleculeCounter.hh.

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

G4MoleculeCounter * G4MoleculeCounter::fpInstance = 0 [static, protected]

Definition at line 60 of file G4MoleculeCounter.hh.

Referenced by DeleteInstance(), and GetMoleculeCounter().

G4bool G4MoleculeCounter::fUse [protected]

Definition at line 66 of file G4MoleculeCounter.hh.

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

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:
Generated on Mon May 27 17:52:30 2013 for Geant4 by  doxygen 1.4.7