G4PersistencyCenter Class Reference

#include <G4PersistencyCenter.hh>


Public Member Functions

void SelectSystem (std::string systemName)
const std::string CurrentSystem ()
void SetHepMCObjyReaderFile (std::string file)
std::string CurrentHepMCObjyReaderFile ()
void SetStoreMode (std::string objName, StoreMode mode)
void SetRetrieveMode (std::string objName, G4bool mode)
StoreMode CurrentStoreMode (std::string objName)
G4bool CurrentRetrieveMode (std::string objName)
G4bool SetWriteFile (std::string objName, std::string writeFileName)
G4bool SetReadFile (std::string objName, std::string readFileName)
std::string CurrentWriteFile (std::string objName)
std::string CurrentReadFile (std::string objName)
std::string CurrentObject (std::string file)
void AddHCIOmanager (std::string detName, std::string colName)
std::string CurrentHCIOmanager ()
void AddDCIOmanager (std::string detName)
std::string CurrentDCIOmanager ()
void PrintAll ()
G4PersistencyManagerCurrentPersistencyManager ()
void SetPersistencyManager (G4PersistencyManager *pm, std::string name)
G4PersistencyManagerGetPersistencyManager (std::string nam)
void RegisterPersistencyManager (G4PersistencyManager *pm)
void DeletePersistencyManager ()
void SetVerboseLevel (int v)
int VerboseLevel ()
 G4PersistencyCenter ()
 ~G4PersistencyCenter ()

Static Public Member Functions

static G4PersistencyCenterGetPersistencyCenter ()


Detailed Description

Definition at line 63 of file G4PersistencyCenter.hh.


Constructor & Destructor Documentation

G4PersistencyCenter::G4PersistencyCenter (  ) 

Definition at line 45 of file G4PersistencyCenter.cc.

References kOff, kOn, and kRecycle.

00046  : m_verbose(0)
00047 {
00048   f_wrObj[0] = "HepMC";
00049   f_wrObj[1] = "MCTruth";
00050   f_wrObj[2] = "Hits";
00051   f_wrObj[3] = "Digits";
00052 
00053   f_rdObj[0] = "Hits";
00054   f_rdObj[1] = "HitsBG";
00055 
00056   ObjMap::iterator itr;
00057 
00058   for ( itr = f_wrObj.begin(); itr != f_wrObj.end(); itr++ ) {
00059     f_writeFileName[(*itr).second] = "G4defaultOutput";
00060   }
00061 
00062   for ( itr = f_rdObj.begin(); itr != f_rdObj.end(); itr++ ) {
00063     f_readFileName[(*itr).second] = "G4defaultInput";
00064   }
00065 
00066   f_writeFileMode["HepMC"]   = kRecycle;
00067   f_writeFileMode["MCTruth"] = kOn;
00068   f_writeFileMode["Hits"]    = kOn;
00069   f_writeFileMode["Digits"]  = kOff;
00070 
00071   f_readFileMode["Hits"]   = false;
00072   f_readFileMode["HitsBG"] = false;
00073 
00074   f_theMessenger = new G4PersistencyCenterMessenger(this);
00075   f_currentManager = new G4PersistencyManager(this, "Default");
00076 }

G4PersistencyCenter::~G4PersistencyCenter (  ) 

Definition at line 79 of file G4PersistencyCenter.cc.

00080 {
00081   delete f_theMessenger;
00082   delete f_currentManager;
00083 }


Member Function Documentation

void G4PersistencyCenter::AddDCIOmanager ( std::string  detName  ) 

Definition at line 282 of file G4PersistencyCenter.cc.

References G4VDCIOentry::CreateDCIOmanager(), G4cerr, G4endl, G4DCIOcatalog::GetDCIOcatalog(), and G4DCIOcatalog::GetEntry().

00283 {
00284   G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOcatalog();
00285 
00286   std::string colName = "";
00287   G4VDCIOentry* ioe = ioc->GetEntry(detName);
00288   if ( ioe != 0 ) {
00289     ioe->CreateDCIOmanager(detName, colName);
00290   } else {
00291     G4cerr << "Error! -- DCIO assignment failed for detector " << detName
00292               << ", collection " << colName << G4endl;
00293   }
00294 }

void G4PersistencyCenter::AddHCIOmanager ( std::string  detName,
std::string  colName 
)

Definition at line 261 of file G4PersistencyCenter.cc.

References G4VHCIOentry::CreateHCIOmanager(), G4cerr, G4endl, G4HCIOcatalog::GetEntry(), and G4HCIOcatalog::GetHCIOcatalog().

Referenced by G4PersistencyCenterMessenger::SetNewValue().

00262 {
00263   G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOcatalog();
00264 
00265   G4VHCIOentry* ioe = ioc->GetEntry(detName);
00266   if ( ioe != 0 ) {
00267     ioe->CreateHCIOmanager(detName, colName);
00268   } else {
00269     G4cerr << "Error! -- HCIO assignment failed for detector " << detName
00270               << ", collection " << colName << G4endl;
00271   }
00272 }

std::string G4PersistencyCenter::CurrentDCIOmanager (  ) 

Definition at line 297 of file G4PersistencyCenter.cc.

References G4DCIOcatalog::CurrentDCIOmanager(), and G4DCIOcatalog::GetDCIOcatalog().

00298 {
00299   G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOcatalog();
00300   return ioc->CurrentDCIOmanager();
00301 }

std::string G4PersistencyCenter::CurrentHCIOmanager (  ) 

Definition at line 275 of file G4PersistencyCenter.cc.

References G4HCIOcatalog::CurrentHCIOmanager(), and G4HCIOcatalog::GetHCIOcatalog().

Referenced by G4PersistencyCenterMessenger::GetCurrentValue().

00276 {
00277   G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOcatalog();
00278   return ioc->CurrentHCIOmanager();
00279 }

std::string G4PersistencyCenter::CurrentHepMCObjyReaderFile (  ) 

Definition at line 145 of file G4PersistencyCenter.cc.

References CurrentReadFile(), and CurrentRetrieveMode().

00146 {
00147   if ( CurrentRetrieveMode("HepMC") ) {
00148     return CurrentReadFile("HepMC");
00149   } else {
00150     return "";
00151   }
00152 }

std::string G4PersistencyCenter::CurrentObject ( std::string  file  ) 

Definition at line 248 of file G4PersistencyCenter.cc.

00249 {
00250   FileMap::iterator itr;
00251   for ( itr = f_readFileName.begin(); itr != f_readFileName.end(); itr++ ) {
00252     if ( file == (*itr).second ) return (*itr).first;
00253   }
00254   for ( itr = f_writeFileName.begin(); itr != f_writeFileName.end(); itr++ ) {
00255     if ( file == (*itr).second ) return (*itr).first;
00256   }
00257   return "?????";
00258 }

G4PersistencyManager* G4PersistencyCenter::CurrentPersistencyManager (  )  [inline]

Definition at line 124 of file G4PersistencyCenter.hh.

Referenced by G4PersistencyManager::GetPersistencyManager().

00124 { return f_currentManager; }

std::string G4PersistencyCenter::CurrentReadFile ( std::string  objName  ) 

Definition at line 238 of file G4PersistencyCenter.cc.

Referenced by CurrentHepMCObjyReaderFile(), G4PersistencyCenterMessenger::GetCurrentValue(), PrintAll(), and G4PersistencyManager::Retrieve().

00239 {
00240   if ( (*(f_readFileName.find(objName))).second != "" ) {
00241     return f_readFileName[objName];
00242   } else {
00243     return "?????";
00244   }
00245 }

G4bool G4PersistencyCenter::CurrentRetrieveMode ( std::string  objName  ) 

Definition at line 187 of file G4PersistencyCenter.cc.

Referenced by CurrentHepMCObjyReaderFile(), PrintAll(), and G4PersistencyManager::Retrieve().

00188 {
00189   if ( (*(f_readFileName.find(objName))).second != "" ) {
00190     return f_readFileMode[objName];
00191   } else {
00192     return false;
00193   }
00194 }

StoreMode G4PersistencyCenter::CurrentStoreMode ( std::string  objName  ) 

Definition at line 177 of file G4PersistencyCenter.cc.

References kOff.

Referenced by G4PersistencyCenterMessenger::GetCurrentValue(), PrintAll(), and G4PersistencyManager::Store().

00178 {
00179   if ( (*(f_writeFileName.find(objName))).second != "" ) {
00180     return f_writeFileMode[objName];
00181   } else {
00182     return kOff;
00183   }
00184 }

const std::string G4PersistencyCenter::CurrentSystem (  )  [inline]

Definition at line 73 of file G4PersistencyCenter.hh.

Referenced by G4PersistencyCenterMessenger::GetCurrentValue(), and PrintAll().

00073 { return f_currentSystemName; }

std::string G4PersistencyCenter::CurrentWriteFile ( std::string  objName  ) 

Definition at line 228 of file G4PersistencyCenter.cc.

Referenced by G4PersistencyCenterMessenger::GetCurrentValue(), PrintAll(), and G4PersistencyManager::Store().

00229 {
00230   if ( (*(f_writeFileName.find(objName))).second != "" ) {
00231     return f_writeFileName[objName];
00232   } else {
00233     return "?????";
00234   }
00235 }

void G4PersistencyCenter::DeletePersistencyManager (  ) 

Definition at line 397 of file G4PersistencyCenter.cc.

00398 {
00399   if (f_currentManager!=0) delete f_currentManager;
00400   f_currentManager=0;
00401 }

G4PersistencyCenter * G4PersistencyCenter::GetPersistencyCenter (  )  [static]

Definition at line 86 of file G4PersistencyCenter.cc.

Referenced by G4PersistencyManagerT< T >::G4PersistencyManagerT(), G4VDCIOentry::G4VDCIOentry(), G4VHCIOentry::G4VHCIOentry(), and G4PersistencyManager::GetPersistencyManager().

00087 {
00088   if ( f_thePointer == 0 ) f_thePointer = new G4PersistencyCenter;
00089   return f_thePointer;
00090 }

G4PersistencyManager * G4PersistencyCenter::GetPersistencyManager ( std::string  nam  ) 

Definition at line 383 of file G4PersistencyCenter.cc.

Referenced by SelectSystem().

00384 {
00385   if (f_theCatalog.find(nam)!=f_theCatalog.end())
00386     return f_theCatalog[nam];
00387   return 0;
00388 }

void G4PersistencyCenter::PrintAll (  ) 

Definition at line 304 of file G4PersistencyCenter.cc.

References CurrentReadFile(), CurrentRetrieveMode(), CurrentStoreMode(), CurrentSystem(), CurrentWriteFile(), G4cout, G4endl, G4DCIOcatalog::GetDCIOcatalog(), G4HCIOcatalog::GetHCIOcatalog(), kOff, kOn, kRecycle, G4DCIOcatalog::PrintDCIOmanager(), G4DCIOcatalog::PrintEntries(), G4HCIOcatalog::PrintEntries(), and G4HCIOcatalog::PrintHCIOmanager().

Referenced by G4PersistencyCenterMessenger::SetNewValue().

00305 {
00306   G4cout << "Persistency Package: " << CurrentSystem() << G4endl;
00307   G4cout << G4endl;
00308 
00309   ObjMap::iterator itr;
00310   std::string name;
00311   std::string file;
00312   StoreMode   mode;
00313 
00314   G4cout << "Output object types and file names:" << G4endl;
00315   for ( itr = f_wrObj.begin(); itr != f_wrObj.end(); itr++ ) {
00316     name = (*itr).second;
00317     // disabled HepMC and MCTruth for now
00318     if ( name != "HepMC" && name != "MCTruth" ) {
00319       G4cout << "  Object: " << PadString(name, 9);
00320       mode = CurrentStoreMode(name);
00321       if ( mode == kOn ) {
00322         G4cout << " <on>    ";
00323       } else if ( mode == kOff ) {
00324         G4cout << " <off>   ";
00325       } else if ( mode == kRecycle ) {
00326         G4cout << "<recycle>";
00327       }
00328       file = CurrentWriteFile(name);
00329       if ( file == "" ) file = "   <N/A>";
00330       G4cout << " File: " << file << G4endl;
00331     }
00332   }
00333   G4cout << G4endl;
00334 
00335   G4cout << "Input object types and file names:" << G4endl;
00336   for ( itr = f_rdObj.begin(); itr != f_rdObj.end(); itr++ ) {
00337     name = (*itr).second;
00338     // disabled HepMC and MCTruth for now
00339     if ( name != "HepMC" && name != "MCTruth" ) {
00340       G4cout << "  Object: " << PadString(name, 9);
00341       if ( CurrentRetrieveMode(name) ) {
00342         G4cout << " <on>    ";
00343       } else {
00344         G4cout << " <off>   ";
00345       }
00346       file = CurrentReadFile(name);
00347       if ( file == "" ) file = "   <N/A>";
00348       G4cout << " File: " << CurrentReadFile(name) << G4endl;
00349     }
00350   }
00351   G4cout << G4endl;
00352 
00353   G4HCIOcatalog* hioc = G4HCIOcatalog::GetHCIOcatalog();
00354   if ( hioc != 0 ) {
00355     G4cout << "Hit IO Managers:" << G4endl;
00356     hioc->PrintEntries();
00357     hioc->PrintHCIOmanager();
00358     G4cout << G4endl;
00359   } else {
00360     G4cout << "Hit IO Manager catalog is not registered." << G4endl;
00361   }
00362 
00363   G4DCIOcatalog* dioc = G4DCIOcatalog::GetDCIOcatalog();
00364   if ( dioc != 0 ) {
00365     G4cout << "Digit IO Managers:" << G4endl;
00366     dioc->PrintEntries();
00367     dioc->PrintDCIOmanager();
00368     G4cout << G4endl;
00369   } else {
00370     G4cout << "Digit IO Manager catalog is not registered." << G4endl;
00371   }
00372 }

void G4PersistencyCenter::RegisterPersistencyManager ( G4PersistencyManager pm  ) 

Definition at line 391 of file G4PersistencyCenter.cc.

References G4PersistencyManager::GetName().

00392 {
00393   f_theCatalog[pm->GetName()]=pm;
00394 }

void G4PersistencyCenter::SelectSystem ( std::string  systemName  ) 

Definition at line 94 of file G4PersistencyCenter.cc.

References G4PersistencyManager::Create(), G4cout, G4endl, GetPersistencyManager(), and G4PersistencyManager::SetVerboseLevel().

Referenced by G4PersistencyCenterMessenger::SetNewValue().

00095 {
00096   G4int st = 0;
00097 
00098   if (f_currentManager!=0) delete f_currentManager;
00099 
00100   G4PersistencyManager* pm = 0;
00101 
00102   if (systemName=="ROOT")
00103   {
00104     G4cout<<" G4PersistencyCenter: \"ROOT\" Persistency Package is selected."
00105           <<G4endl;
00106     // G4UImanager *man=G4UImanager::GetUIpointer();
00107     // std::string libs="Cint:Core:Tree:Rint:Matrix:Physics:fadsROOT";
00108     // st = man->ApplyCommand("/load "+libs);
00109     if ( st == 0 ) {
00110       pm = GetPersistencyManager("ROOT");
00111     }
00112   }
00113   else if (systemName=="ODBMS")
00114   {
00115     G4cout<<" G4PersistencyCenter: \"ODBMS\" package is selected."<<G4endl;
00116     // G4UImanager *man=G4UImanager::GetUIpointer();
00117     // std::string libs="fadsODBMS";
00118     // st = man->ApplyCommand("/load "+libs);
00119     if ( st == 0 ) {
00120       pm = GetPersistencyManager("ODBMS");
00121     }
00122   }
00123   else
00124   {
00125     G4cout<<" G4PersistencyCenter: Default is selected."<< G4endl;
00126     pm = new G4PersistencyManager(this, "Default");
00127   }
00128 
00129   if ( st == 0 ) {
00130     f_currentManager = pm->Create();
00131     if (f_currentManager!=0) f_currentManager->SetVerboseLevel(m_verbose);
00132     f_currentSystemName = systemName;
00133   }
00134 }

void G4PersistencyCenter::SetHepMCObjyReaderFile ( std::string  file  ) 

Definition at line 137 of file G4PersistencyCenter.cc.

References SetReadFile(), and SetRetrieveMode().

00138 {
00139   if ( SetReadFile("HepMC", file) ) {
00140     SetRetrieveMode("HepMC", true);
00141   }
00142 }

void G4PersistencyCenter::SetPersistencyManager ( G4PersistencyManager pm,
std::string  name 
)

Definition at line 375 of file G4PersistencyCenter.cc.

00377 {
00378   f_currentManager=pm;
00379   f_currentSystemName=name;
00380 }

G4bool G4PersistencyCenter::SetReadFile ( std::string  objName,
std::string  readFileName 
)

Definition at line 210 of file G4PersistencyCenter.cc.

References G4FileUtilities::FileExists(), G4cerr, and G4endl.

Referenced by SetHepMCObjyReaderFile().

00211 {
00212 #ifndef WIN32
00213   if ( f_ut.FileExists(readFileName) )
00214   {
00215     f_readFileName[objName] = readFileName;
00216   }
00217   else
00218   {
00219     G4cerr << "!! File \"" << objName << "\" does not exist."
00220            << G4endl;
00221     return false;
00222   }
00223 #endif
00224   return true;
00225 }

void G4PersistencyCenter::SetRetrieveMode ( std::string  objName,
G4bool  mode 
)

Definition at line 166 of file G4PersistencyCenter.cc.

References G4cerr, and G4endl.

Referenced by SetHepMCObjyReaderFile().

00167 {
00168   if ( (*(f_readFileName.find(objName))).second != "" ) {
00169     f_readFileMode[objName] = mode;
00170   } else {
00171     G4cerr << "!! unknown object type " << objName << " for input."
00172            << G4endl;
00173   }
00174 }

void G4PersistencyCenter::SetStoreMode ( std::string  objName,
StoreMode  mode 
)

Definition at line 155 of file G4PersistencyCenter.cc.

References G4cerr, and G4endl.

Referenced by G4PersistencyCenterMessenger::SetNewValue().

00156 {
00157   if ( (*(f_writeFileName.find(objName))).second != "" ) {
00158     f_writeFileMode[objName] = mode;
00159   } else {
00160     G4cerr << "!! unknown object type " << objName << " for output."
00161            << G4endl;
00162   }
00163 }

void G4PersistencyCenter::SetVerboseLevel ( int  v  ) 

Definition at line 404 of file G4PersistencyCenter.cc.

References G4PersistencyManager::SetVerboseLevel().

Referenced by G4PersistencyCenterMessenger::SetNewValue().

00405 {
00406   m_verbose = v;
00407   if ( f_currentManager != 0 ) f_currentManager->SetVerboseLevel(m_verbose);
00408 }

G4bool G4PersistencyCenter::SetWriteFile ( std::string  objName,
std::string  writeFileName 
)

Definition at line 197 of file G4PersistencyCenter.cc.

References G4cerr, and G4endl.

Referenced by G4PersistencyCenterMessenger::SetNewValue().

00198 {
00199   if ( (*(f_writeFileName.find(objName))).second != "" ) {
00200     f_writeFileName[objName] = writeFileName;
00201   } else {
00202     G4cerr << "!! unknown object type " << objName << " for output."
00203            << G4endl;
00204     return false;
00205   }
00206   return true;
00207 }

int G4PersistencyCenter::VerboseLevel (  )  [inline]

Definition at line 142 of file G4PersistencyCenter.hh.

Referenced by G4PersistencyManager::G4PersistencyManager(), G4VDCIOentry::G4VDCIOentry(), G4VHCIOentry::G4VHCIOentry(), and G4PersistencyCenterMessenger::GetCurrentValue().

00142 { return m_verbose; }


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:52:53 2013 for Geant4 by  doxygen 1.4.7