source: trunk/source/persistency/mctruth/src/G4PersistencyCenter.cc

Last change on this file was 1347, checked in by garnier, 14 years ago

geant4 tag 9.4
File size: 12.3 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26// File: G4PersistencyCenter.cc
27//
28// History:
29//   '01.08.10  Youhei Morita  Initial creation (with "fadsclass3")
30
31#include "G4PersistencyCenter.hh"
32
33// Forward Declarations:
34#include "G4PersistencyCenterMessenger.hh"
35
36// Addtional Include:
37#include "G4UImanager.hh"
38#include "G4PersistencyManager.hh"
39#include "G4VHCIOentry.hh"
40#include "G4VDCIOentry.hh"
41
42G4PersistencyCenter* G4PersistencyCenter::f_thePointer=G4PersistencyCenter::GetPersistencyCenter();
43
44// Implementation of Constructor #1
45G4PersistencyCenter::G4PersistencyCenter()
46 : m_verbose(0)
47{
48  f_wrObj[0] = "HepMC";
49  f_wrObj[1] = "MCTruth";
50  f_wrObj[2] = "Hits";
51  f_wrObj[3] = "Digits";
52
53  f_rdObj[0] = "Hits";
54  f_rdObj[1] = "HitsBG";
55
56  ObjMap::iterator itr;
57
58  for ( itr = f_wrObj.begin(); itr != f_wrObj.end(); itr++ ) {
59    f_writeFileName[(*itr).second] = "G4defaultOutput";
60  }
61
62  for ( itr = f_rdObj.begin(); itr != f_rdObj.end(); itr++ ) {
63    f_readFileName[(*itr).second] = "G4defaultInput";
64  }
65
66  f_writeFileMode["HepMC"]   = kRecycle;
67  f_writeFileMode["MCTruth"] = kOn;
68  f_writeFileMode["Hits"]    = kOn;
69  f_writeFileMode["Digits"]  = kOff;
70
71  f_readFileMode["Hits"]   = false;
72  f_readFileMode["HitsBG"] = false;
73
74  f_theMessenger = new G4PersistencyCenterMessenger(this);
75  f_currentManager = new G4PersistencyManager(this, "Default");
76}
77
78// Fake implementation of Copy Constructor
79G4PersistencyCenter::G4PersistencyCenter(const G4PersistencyCenter& c)
80  : f_theMessenger(0), f_currentManager(0), m_verbose(0)
81{
82  *this = c;
83}
84
85// Implementation of Destructor #1
86G4PersistencyCenter::~G4PersistencyCenter()
87{
88  delete f_theMessenger;
89  delete f_currentManager;
90}
91
92// Implementation of GetPersistencyCenter
93G4PersistencyCenter* G4PersistencyCenter::GetPersistencyCenter()
94{
95  if ( f_thePointer == 0 ) f_thePointer = new G4PersistencyCenter;
96  return f_thePointer;
97}
98
99
100// Implementation of SelectSystem
101void G4PersistencyCenter::SelectSystem(std::string systemName)
102{
103  G4int st = 0;
104
105  if (f_currentManager!=0) delete f_currentManager;
106
107  G4PersistencyManager* pm = 0;
108
109  if (systemName=="ROOT")
110  {
111    G4cout<<" G4PersistencyCenter: \"ROOT\" Persistency Package is selected."
112          <<G4endl;
113    // G4UImanager *man=G4UImanager::GetUIpointer();
114    // std::string libs="Cint:Core:Tree:Rint:Matrix:Physics:fadsROOT";
115    // st = man->ApplyCommand("/load "+libs);
116    if ( st == 0 ) {
117      pm = GetPersistencyManager("ROOT");
118    }
119  }
120  else if (systemName=="ODBMS")
121  {
122    G4cout<<" G4PersistencyCenter: \"ODBMS\" package is selected."<<G4endl;
123    // G4UImanager *man=G4UImanager::GetUIpointer();
124    // std::string libs="fadsODBMS";
125    // st = man->ApplyCommand("/load "+libs);
126    if ( st == 0 ) {
127      pm = GetPersistencyManager("ODBMS");
128    }
129  }
130  else
131  {
132    G4cout<<" G4PersistencyCenter: Default is selected."<< G4endl;
133    pm = new G4PersistencyManager(this, "Default");
134  }
135
136  if ( st == 0 ) {
137    f_currentManager = pm->Create();
138    if (f_currentManager!=0) f_currentManager->SetVerboseLevel(m_verbose);
139    f_currentSystemName = systemName;
140  }
141}
142
143// Implementation of SetHepMCObjyReaderFile
144void G4PersistencyCenter::SetHepMCObjyReaderFile(std::string file)
145{
146  if ( SetReadFile("HepMC", file) ) {
147    SetRetrieveMode("HepMC", true);
148  }
149}
150
151// Implementation of CurrentHepMCObjyReaderFile
152std::string G4PersistencyCenter::CurrentHepMCObjyReaderFile()
153{
154  if ( CurrentRetrieveMode("HepMC") ) {
155    return CurrentReadFile("HepMC");
156  } else {
157    return "";
158  }
159}
160
161// Implementation of SetStoreMode
162void G4PersistencyCenter::SetStoreMode(std::string objName, StoreMode mode)
163{
164  if ( (*(f_writeFileName.find(objName))).second != "" ) {
165    f_writeFileMode[objName] = mode;
166  } else {
167    G4cerr << "!! unknown object type " << objName << " for output."
168           << G4endl;
169  }
170}
171
172// Implementation of SetRetrieveMode
173void G4PersistencyCenter::SetRetrieveMode(std::string objName, G4bool mode)
174{
175  if ( (*(f_readFileName.find(objName))).second != "" ) {
176    f_readFileMode[objName] = mode;
177  } else {
178    G4cerr << "!! unknown object type " << objName << " for input."
179           << G4endl;
180  }
181}
182
183// Implementation of CurrentStoreMode
184StoreMode G4PersistencyCenter::CurrentStoreMode(std::string objName)
185{
186
187
188  if ( (*(f_writeFileName.find(objName))).second != "" ) {
189    return f_writeFileMode[objName];
190  } else {
191    return kOff;
192  }
193}
194
195// Implementation of CurrentRetrieveMode
196G4bool G4PersistencyCenter::CurrentRetrieveMode(std::string objName)
197{
198  if ( (*(f_readFileName.find(objName))).second != "" ) {
199    return f_readFileMode[objName];
200  } else {
201    return false;
202  }
203}
204
205// Implementation of SetWriteFile
206G4bool G4PersistencyCenter::SetWriteFile(std::string objName, std::string writeFileName)
207{
208  if ( (*(f_writeFileName.find(objName))).second != "" ) {
209    f_writeFileName[objName] = writeFileName;
210  } else {
211    G4cerr << "!! unknown object type " << objName << " for output."
212           << G4endl;
213    return false;
214  }
215  return true;
216}
217
218// Implementation of SetReadFile
219G4bool G4PersistencyCenter::SetReadFile(std::string objName, std::string readFileName)
220{
221#ifndef WIN32
222  if ( f_ut.FileExists(readFileName) )
223  {
224    f_readFileName[objName] = readFileName;
225  }
226  else
227  {
228    G4cerr << "!! File \"" << objName << "\" does not exist."
229           << G4endl;
230    return false;
231  }
232#endif
233  return true;
234}
235
236// Implementation of CurrentWriteFile
237std::string G4PersistencyCenter::CurrentWriteFile(std::string objName)
238{
239  if ( (*(f_writeFileName.find(objName))).second != "" ) {
240    return f_writeFileName[objName];
241  } else {
242    return "?????";
243  }
244}
245
246// Implementation of CurrentReadFile
247std::string G4PersistencyCenter::CurrentReadFile(std::string objName)
248{
249  if ( (*(f_readFileName.find(objName))).second != "" ) {
250    return f_readFileName[objName];
251  } else {
252    return "?????";
253  }
254}
255
256// Implementation of CurrentObject
257std::string G4PersistencyCenter::CurrentObject(std::string file)
258{
259  FileMap::iterator itr;
260  for ( itr = f_readFileName.begin(); itr != f_readFileName.end(); itr++ ) {
261    if ( file == (*itr).second ) return (*itr).first;
262  }
263  for ( itr = f_writeFileName.begin(); itr != f_writeFileName.end(); itr++ ) {
264    if ( file == (*itr).second ) return (*itr).first;
265  }
266  return "?????";
267}
268
269// Implementation of AddHCIOmanager
270void G4PersistencyCenter::AddHCIOmanager(std::string detName, std::string colName)
271{
272  G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOcatalog();
273
274  G4VHCIOentry* ioe = ioc->GetEntry(detName);
275  if ( ioe != 0 ) {
276    ioe->CreateHCIOmanager(detName, colName);
277  } else {
278    G4cerr << "Error! -- HCIO assignment failed for detector " << detName
279              << ", collection " << colName << G4endl;
280  }
281}
282
283// Implementation of CurrentHCIOmanager
284std::string G4PersistencyCenter::CurrentHCIOmanager()
285{
286  G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOcatalog();
287  return ioc->CurrentHCIOmanager();
288}
289
290// Implementation of AddDCIOmanager
291void G4PersistencyCenter::AddDCIOmanager(std::string detName)
292{
293  G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOcatalog();
294
295  std::string colName = "";
296  G4VDCIOentry* ioe = ioc->GetEntry(detName);
297  if ( ioe != 0 ) {
298    ioe->CreateDCIOmanager(detName, colName);
299  } else {
300    G4cerr << "Error! -- DCIO assignment failed for detector " << detName
301              << ", collection " << colName << G4endl;
302  }
303}
304
305// Implementation of CurrentDCIOmanager
306std::string G4PersistencyCenter::CurrentDCIOmanager()
307{
308  G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOcatalog();
309  return ioc->CurrentDCIOmanager();
310}
311
312// Implementation of PrintAll
313void G4PersistencyCenter::PrintAll()
314{
315  G4cout << "Persistency Package: " << CurrentSystem() << G4endl;
316  G4cout << G4endl;
317
318  ObjMap::iterator itr;
319  std::string name;
320  std::string file;
321  StoreMode   mode;
322
323  G4cout << "Output object types and file names:" << G4endl;
324  for ( itr = f_wrObj.begin(); itr != f_wrObj.end(); itr++ ) {
325    name = (*itr).second;
326    // disabled HepMC and MCTruth for now
327    if ( name != "HepMC" && name != "MCTruth" ) {
328      G4cout << "  Object: " << PadString(name, 9);
329      mode = CurrentStoreMode(name);
330      if ( mode == kOn ) {
331        G4cout << " <on>    ";
332      } else if ( mode == kOff ) {
333        G4cout << " <off>   ";
334      } else if ( mode == kRecycle ) {
335        G4cout << "<recycle>";
336      }
337      file = CurrentWriteFile(name);
338      if ( file == "" ) file = "   <N/A>";
339      G4cout << " File: " << file << G4endl;
340    }
341  }
342  G4cout << G4endl;
343
344  G4cout << "Input object types and file names:" << G4endl;
345  for ( itr = f_rdObj.begin(); itr != f_rdObj.end(); itr++ ) {
346    name = (*itr).second;
347    // disabled HepMC and MCTruth for now
348    if ( name != "HepMC" && name != "MCTruth" ) {
349      G4cout << "  Object: " << PadString(name, 9);
350      if ( CurrentRetrieveMode(name) ) {
351        G4cout << " <on>    ";
352      } else {
353        G4cout << " <off>   ";
354      }
355      file = CurrentReadFile(name);
356      if ( file == "" ) file = "   <N/A>";
357      G4cout << " File: " << CurrentReadFile(name) << G4endl;
358    }
359  }
360  G4cout << G4endl;
361
362  G4HCIOcatalog* hioc = G4HCIOcatalog::GetHCIOcatalog();
363  if ( hioc != 0 ) {
364    G4cout << "Hit IO Managers:" << G4endl;
365    hioc->PrintEntries();
366    hioc->PrintHCIOmanager();
367    G4cout << G4endl;
368  } else {
369    G4cout << "Hit IO Manager catalog is not registered." << G4endl;
370  }
371
372  G4DCIOcatalog* dioc = G4DCIOcatalog::GetDCIOcatalog();
373  if ( dioc != 0 ) {
374    G4cout << "Digit IO Managers:" << G4endl;
375    dioc->PrintEntries();
376    dioc->PrintDCIOmanager();
377    G4cout << G4endl;
378  } else {
379    G4cout << "Digit IO Manager catalog is not registered." << G4endl;
380  }
381}
382
383// Implementation of SetPersistencyManager
384void G4PersistencyCenter::SetPersistencyManager(G4PersistencyManager* pm,
385                                                  std::string name)
386{
387  f_currentManager=pm;
388  f_currentSystemName=name;
389}
390
391// Implementation of GetPersistencyManager
392G4PersistencyManager* G4PersistencyCenter::GetPersistencyManager(std::string nam)
393{
394  if (f_theCatalog.find(nam)!=f_theCatalog.end())
395    return f_theCatalog[nam];
396  return 0;
397}
398
399// Implementation of RegisterPersistencyManager
400void G4PersistencyCenter::RegisterPersistencyManager(G4PersistencyManager* pm)
401{
402  f_theCatalog[pm->GetName()]=pm;
403}
404
405// Implementation of DeletePersistencyManager
406void G4PersistencyCenter::DeletePersistencyManager()
407{
408  if (f_currentManager!=0) delete f_currentManager;
409  f_currentManager=0;
410}
411
412// Implementation of SetVerboseLevel
413void G4PersistencyCenter::SetVerboseLevel(int v)
414{
415  m_verbose = v;
416  if ( f_currentManager != 0 ) f_currentManager->SetVerboseLevel(m_verbose);
417}
418
419// Implementation of PadString
420std::string G4PersistencyCenter::PadString(std::string name, unsigned int width)
421{
422  if ( name.length() > width ) {
423    return name.substr(0,width-1) + "#";
424  } else {
425    std::string wname = name;
426    for ( unsigned int i=0; i < width-name.length(); i++) wname = wname + " ";
427    return wname;
428  }
429}
430
431// End of G4PersistencyCenter.cc
432
Note: See TracBrowser for help on using the repository browser.