| Geant4 Cross Reference |
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 // G4PersistencyCenter implementation
27 //
28 // Author: Youhei Morita, 10.08.2001
29 // --------------------------------------------------------------------
30
31 #include "G4PersistencyCenter.hh"
32 #include "G4PersistencyCenterMessenger.hh"
33
34 #include "G4UImanager.hh"
35 #include "G4PersistencyManager.hh"
36 #include "G4VHCIOentry.hh"
37 #include "G4VDCIOentry.hh"
38
39 G4ThreadLocal G4PersistencyCenter* G4PersistencyCenter::f_thePointer = nullptr;
40
41 // --------------------------------------------------------------------
42 G4PersistencyCenter::G4PersistencyCenter()
43 {
44 f_wrObj[0] = "HepMC";
45 f_wrObj[1] = "MCTruth";
46 f_wrObj[2] = "Hits";
47 f_wrObj[3] = "Digits";
48
49 f_rdObj[0] = "Hits";
50 f_rdObj[1] = "HitsBG";
51
52 for(auto itr = f_wrObj.cbegin(); itr != f_wrObj.cend(); ++itr)
53 {
54 f_writeFileName[(*itr).second] = "G4defaultOutput";
55 }
56
57 for(auto itr = f_rdObj.cbegin(); itr != f_rdObj.cend(); ++itr)
58 {
59 f_readFileName[(*itr).second] = "G4defaultInput";
60 }
61
62 f_writeFileMode["HepMC"] = kRecycle;
63 f_writeFileMode["MCTruth"] = kOn;
64 f_writeFileMode["Hits"] = kOn;
65 f_writeFileMode["Digits"] = kOff;
66
67 f_readFileMode["Hits"] = false;
68 f_readFileMode["HitsBG"] = false;
69
70 f_theMessenger = new G4PersistencyCenterMessenger(this);
71 f_currentManager = new G4PersistencyManager(this, "Default");
72 }
73
74 // --------------------------------------------------------------------
75 G4PersistencyCenter::~G4PersistencyCenter()
76 {
77 delete f_theMessenger;
78 delete f_currentManager;
79 }
80
81 // --------------------------------------------------------------------
82 G4PersistencyCenter* G4PersistencyCenter::GetPersistencyCenter()
83 {
84 if(f_thePointer == nullptr)
85 f_thePointer = new G4PersistencyCenter;
86 return f_thePointer;
87 }
88
89 // --------------------------------------------------------------------
90 void G4PersistencyCenter::SelectSystem(const G4String& systemName)
91 {
92 G4int st = 0;
93
94 if(f_currentManager != nullptr)
95 delete f_currentManager;
96
97 G4PersistencyManager* pm = nullptr;
98
99 if(systemName == "ROOT")
100 {
101 G4cout << " G4PersistencyCenter: \"ROOT\" Persistency Package is selected."
102 << G4endl;
103 // G4UImanager *man=G4UImanager::GetUIpointer();
104 // std::string libs="Cint:Core:Tree:Rint:Matrix:Physics:fadsROOT";
105 // st = man->ApplyCommand("/load "+libs);
106 if(st == 0)
107 {
108 pm = GetPersistencyManager("ROOT");
109 }
110 }
111 else if(systemName == "ODBMS")
112 {
113 G4cout << " G4PersistencyCenter: \"ODBMS\" package is selected." << G4endl;
114 // G4UImanager *man=G4UImanager::GetUIpointer();
115 // std::string libs="fadsODBMS";
116 // st = man->ApplyCommand("/load "+libs);
117 if(st == 0)
118 {
119 pm = GetPersistencyManager("ODBMS");
120 }
121 }
122 else
123 {
124 G4cout << " G4PersistencyCenter: Default is selected." << G4endl;
125 pm = new G4PersistencyManager(this, "Default");
126 }
127
128 if(st == 0)
129 {
130 f_currentManager = pm->Create();
131 if(f_currentManager != nullptr)
132 f_currentManager->SetVerboseLevel(m_verbose);
133 f_currentSystemName = systemName;
134 }
135 }
136
137 // --------------------------------------------------------------------
138 void G4PersistencyCenter::SetHepMCObjyReaderFile(const G4String& file)
139 {
140 if(SetReadFile("HepMC", file))
141 {
142 SetRetrieveMode("HepMC", true);
143 }
144 }
145
146 // --------------------------------------------------------------------
147 G4String G4PersistencyCenter::CurrentHepMCObjyReaderFile()
148 {
149 if(CurrentRetrieveMode("HepMC"))
150 {
151 return CurrentReadFile("HepMC");
152 }
153 else
154 {
155 return "";
156 }
157 }
158
159 // --------------------------------------------------------------------
160 void G4PersistencyCenter::SetStoreMode(const G4String& objName, StoreMode mode)
161 {
162 if((*(f_writeFileName.find(objName))).second != "")
163 {
164 f_writeFileMode[objName] = mode;
165 }
166 else
167 {
168 G4cerr << "!! unknown object type " << objName << " for output." << G4endl;
169 }
170 }
171
172 // --------------------------------------------------------------------
173 void G4PersistencyCenter::SetRetrieveMode(const G4String& objName, G4bool mode)
174 {
175 if((*(f_readFileName.find(objName))).second != "")
176 {
177 f_readFileMode[objName] = mode;
178 }
179 else
180 {
181 G4cerr << "!! unknown object type " << objName << " for input." << G4endl;
182 }
183 }
184
185 // --------------------------------------------------------------------
186 StoreMode G4PersistencyCenter::CurrentStoreMode(const G4String& objName)
187 {
188 if((*(f_writeFileName.find(objName))).second != "")
189 {
190 return f_writeFileMode[objName];
191 }
192 else
193 {
194 return kOff;
195 }
196 }
197
198 // --------------------------------------------------------------------
199 G4bool G4PersistencyCenter::CurrentRetrieveMode(const G4String& objName)
200 {
201 if((*(f_readFileName.find(objName))).second != "")
202 {
203 return f_readFileMode[objName];
204 }
205 else
206 {
207 return false;
208 }
209 }
210
211 // --------------------------------------------------------------------
212 G4bool G4PersistencyCenter::SetWriteFile(const G4String& objName,
213 const G4String& writeFileName)
214 {
215 if((*(f_writeFileName.find(objName))).second != "")
216 {
217 f_writeFileName[objName] = writeFileName;
218 }
219 else
220 {
221 G4cerr << "!! unknown object type " << objName << " for output." << G4endl;
222 return false;
223 }
224 return true;
225 }
226
227 // --------------------------------------------------------------------
228 G4bool G4PersistencyCenter::SetReadFile(const G4String& objName,
229 const G4String& readFileName)
230 {
231 #ifndef WIN32
232 if(f_ut.FileExists(readFileName))
233 {
234 f_readFileName[objName] = readFileName;
235 }
236 else
237 {
238 G4cerr << "!! File \"" << objName << "\" does not exist." << G4endl;
239 return false;
240 }
241 #endif
242 return true;
243 }
244
245 // --------------------------------------------------------------------
246 G4String G4PersistencyCenter::CurrentWriteFile(const G4String& objName)
247 {
248 if((*(f_writeFileName.find(objName))).second != "")
249 {
250 return f_writeFileName[objName];
251 }
252 else
253 {
254 return "?????";
255 }
256 }
257
258 // --------------------------------------------------------------------
259 G4String G4PersistencyCenter::CurrentReadFile(const G4String& objName)
260 {
261 if((*(f_readFileName.find(objName))).second != "")
262 {
263 return f_readFileName[objName];
264 }
265 else
266 {
267 return "?????";
268 }
269 }
270
271 // --------------------------------------------------------------------
272 G4String G4PersistencyCenter::CurrentObject(const G4String& file)
273 {
274 for(auto itr = f_readFileName.cbegin(); itr != f_readFileName.cend(); ++itr)
275 {
276 if(file == (*itr).second)
277 return (*itr).first;
278 }
279 for(auto itr = f_writeFileName.cbegin(); itr != f_writeFileName.cend(); ++itr)
280 {
281 if(file == (*itr).second)
282 return (*itr).first;
283 }
284 return "?????";
285 }
286
287 // --------------------------------------------------------------------
288 void G4PersistencyCenter::AddHCIOmanager(const G4String& detName,
289 const G4String& colName)
290 {
291 G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOcatalog();
292
293 G4VHCIOentry* ioe = ioc->GetEntry(detName);
294 if(ioe != nullptr)
295 {
296 ioe->CreateHCIOmanager(detName, colName);
297 }
298 else
299 {
300 G4cerr << "Error! -- HCIO assignment failed for detector " << detName
301 << ", collection " << colName << G4endl;
302 }
303 }
304
305 // --------------------------------------------------------------------
306 G4String G4PersistencyCenter::CurrentHCIOmanager()
307 {
308 G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOcatalog();
309 return ioc->CurrentHCIOmanager();
310 }
311
312 // --------------------------------------------------------------------
313 void G4PersistencyCenter::AddDCIOmanager(const G4String& detName)
314 {
315 G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOcatalog();
316
317 G4String colName = "";
318 G4VDCIOentry* ioe = ioc->GetEntry(detName);
319 if(ioe != nullptr)
320 {
321 ioe->CreateDCIOmanager(detName, colName);
322 }
323 else
324 {
325 G4cerr << "Error! -- DCIO assignment failed for detector " << detName
326 << ", collection " << colName << G4endl;
327 }
328 }
329
330 // --------------------------------------------------------------------
331 G4String G4PersistencyCenter::CurrentDCIOmanager()
332 {
333 G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOcatalog();
334 return ioc->CurrentDCIOmanager();
335 }
336
337 // --------------------------------------------------------------------
338 void G4PersistencyCenter::PrintAll()
339 {
340 G4cout << "Persistency Package: " << CurrentSystem() << G4endl;
341 G4cout << G4endl;
342
343 G4String name, file;
344 StoreMode mode;
345
346 G4cout << "Output object types and file names:" << G4endl;
347 for(auto itr = f_wrObj.cbegin(); itr != f_wrObj.cend(); ++itr)
348 {
349 name = (*itr).second;
350 // disabled HepMC and MCTruth for now
351 if(name != "HepMC" && name != "MCTruth")
352 {
353 G4cout << " Object: " << PadString(name, 9);
354 mode = CurrentStoreMode(name);
355 if(mode == kOn)
356 {
357 G4cout << " <on> ";
358 }
359 else if(mode == kOff)
360 {
361 G4cout << " <off> ";
362 }
363 else if(mode == kRecycle)
364 {
365 G4cout << "<recycle>";
366 }
367 file = CurrentWriteFile(name);
368 if(file == "")
369 file = " <N/A>";
370 G4cout << " File: " << file << G4endl;
371 }
372 }
373 G4cout << G4endl;
374
375 G4cout << "Input object types and file names:" << G4endl;
376 for(auto itr = f_rdObj.cbegin(); itr != f_rdObj.cend(); ++itr)
377 {
378 name = (*itr).second;
379 // disabled HepMC and MCTruth for now
380 if(name != "HepMC" && name != "MCTruth")
381 {
382 G4cout << " Object: " << PadString(name, 9);
383 if(CurrentRetrieveMode(name))
384 {
385 G4cout << " <on> ";
386 }
387 else
388 {
389 G4cout << " <off> ";
390 }
391 file = CurrentReadFile(name);
392 if(file == "")
393 file = " <N/A>";
394 G4cout << " File: " << CurrentReadFile(name) << G4endl;
395 }
396 }
397 G4cout << G4endl;
398
399 G4HCIOcatalog* hioc = G4HCIOcatalog::GetHCIOcatalog();
400 if(hioc != nullptr)
401 {
402 G4cout << "Hit IO Managers:" << G4endl;
403 hioc->PrintEntries();
404 hioc->PrintHCIOmanager();
405 G4cout << G4endl;
406 }
407 else
408 {
409 G4cout << "Hit IO Manager catalog is not registered." << G4endl;
410 }
411
412 G4DCIOcatalog* dioc = G4DCIOcatalog::GetDCIOcatalog();
413 if(dioc != nullptr)
414 {
415 G4cout << "Digit IO Managers:" << G4endl;
416 dioc->PrintEntries();
417 dioc->PrintDCIOmanager();
418 G4cout << G4endl;
419 }
420 else
421 {
422 G4cout << "Digit IO Manager catalog is not registered." << G4endl;
423 }
424 }
425
426 // --------------------------------------------------------------------
427 void G4PersistencyCenter::SetPersistencyManager(G4PersistencyManager* pm,
428 const G4String& name)
429 {
430 f_currentManager = pm;
431 f_currentSystemName = name;
432 }
433
434 // --------------------------------------------------------------------
435 G4PersistencyManager*
436 G4PersistencyCenter::GetPersistencyManager(const G4String& nam)
437 {
438 if(f_theCatalog.find(nam) != f_theCatalog.cend())
439 return f_theCatalog[nam];
440 return nullptr;
441 }
442
443 // --------------------------------------------------------------------
444 void G4PersistencyCenter::RegisterPersistencyManager(G4PersistencyManager* pm)
445 {
446 f_theCatalog[pm->GetName()] = pm;
447 }
448
449 // --------------------------------------------------------------------
450 void G4PersistencyCenter::DeletePersistencyManager()
451 {
452 if(f_currentManager != nullptr)
453 delete f_currentManager;
454 f_currentManager = nullptr;
455 }
456
457 // --------------------------------------------------------------------
458 void G4PersistencyCenter::SetVerboseLevel(G4int v)
459 {
460 m_verbose = v;
461 if(f_currentManager != nullptr)
462 f_currentManager->SetVerboseLevel(m_verbose);
463 }
464
465 // --------------------------------------------------------------------
466 G4String G4PersistencyCenter::PadString(const G4String& name,
467 unsigned int width)
468 {
469 if(name.length() > width)
470 {
471 return name.substr(0, width - 1) + "#";
472 }
473 else
474 {
475 G4String wname = name;
476 for(unsigned int i = 0; i < width - name.length(); ++i)
477 wname = wname + " ";
478 return wname;
479 }
480 }
481