| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
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* G4Persisten
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_wr
53 {
54 f_writeFileName[(*itr).second] = "G4defaul
55 }
56
57 for(auto itr = f_rdObj.cbegin(); itr != f_rd
58 {
59 f_readFileName[(*itr).second] = "G4default
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 G4PersistencyCenterMe
71 f_currentManager = new G4PersistencyManager(
72 }
73
74 // -------------------------------------------
75 G4PersistencyCenter::~G4PersistencyCenter()
76 {
77 delete f_theMessenger;
78 delete f_currentManager;
79 }
80
81 // -------------------------------------------
82 G4PersistencyCenter* G4PersistencyCenter::GetP
83 {
84 if(f_thePointer == nullptr)
85 f_thePointer = new G4PersistencyCenter;
86 return f_thePointer;
87 }
88
89 // -------------------------------------------
90 void G4PersistencyCenter::SelectSystem(const G
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\"
102 << G4endl;
103 // G4UImanager *man=G4UImanager::GetUIpoin
104 // std::string libs="Cint:Core:Tree:Rint:M
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\"
114 // G4UImanager *man=G4UImanager::GetUIpoin
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 i
125 pm = new G4PersistencyManager(this, "Defau
126 }
127
128 if(st == 0)
129 {
130 f_currentManager = pm->Create();
131 if(f_currentManager != nullptr)
132 f_currentManager->SetVerboseLevel(m_verb
133 f_currentSystemName = systemName;
134 }
135 }
136
137 // -------------------------------------------
138 void G4PersistencyCenter::SetHepMCObjyReaderFi
139 {
140 if(SetReadFile("HepMC", file))
141 {
142 SetRetrieveMode("HepMC", true);
143 }
144 }
145
146 // -------------------------------------------
147 G4String G4PersistencyCenter::CurrentHepMCObjy
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 G
161 {
162 if((*(f_writeFileName.find(objName))).second
163 {
164 f_writeFileMode[objName] = mode;
165 }
166 else
167 {
168 G4cerr << "!! unknown object type " << obj
169 }
170 }
171
172 // -------------------------------------------
173 void G4PersistencyCenter::SetRetrieveMode(cons
174 {
175 if((*(f_readFileName.find(objName))).second
176 {
177 f_readFileMode[objName] = mode;
178 }
179 else
180 {
181 G4cerr << "!! unknown object type " << obj
182 }
183 }
184
185 // -------------------------------------------
186 StoreMode G4PersistencyCenter::CurrentStoreMod
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::CurrentRetrieveMod
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
213 const
214 {
215 if((*(f_writeFileName.find(objName))).second
216 {
217 f_writeFileName[objName] = writeFileName;
218 }
219 else
220 {
221 G4cerr << "!! unknown object type " << obj
222 return false;
223 }
224 return true;
225 }
226
227 // -------------------------------------------
228 G4bool G4PersistencyCenter::SetReadFile(const
229 const
230 {
231 #ifndef WIN32
232 if(f_ut.FileExists(readFileName))
233 {
234 f_readFileName[objName] = readFileName;
235 }
236 else
237 {
238 G4cerr << "!! File \"" << objName << "\" d
239 return false;
240 }
241 #endif
242 return true;
243 }
244
245 // -------------------------------------------
246 G4String G4PersistencyCenter::CurrentWriteFile
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(
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(co
273 {
274 for(auto itr = f_readFileName.cbegin(); itr
275 {
276 if(file == (*itr).second)
277 return (*itr).first;
278 }
279 for(auto itr = f_writeFileName.cbegin(); itr
280 {
281 if(file == (*itr).second)
282 return (*itr).first;
283 }
284 return "?????";
285 }
286
287 // -------------------------------------------
288 void G4PersistencyCenter::AddHCIOmanager(const
289 const
290 {
291 G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOc
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 faile
301 << ", collection " << colName << G4
302 }
303 }
304
305 // -------------------------------------------
306 G4String G4PersistencyCenter::CurrentHCIOmanag
307 {
308 G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOc
309 return ioc->CurrentHCIOmanager();
310 }
311
312 // -------------------------------------------
313 void G4PersistencyCenter::AddDCIOmanager(const
314 {
315 G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOc
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 faile
326 << ", collection " << colName << G4
327 }
328 }
329
330 // -------------------------------------------
331 G4String G4PersistencyCenter::CurrentDCIOmanag
332 {
333 G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOc
334 return ioc->CurrentDCIOmanager();
335 }
336
337 // -------------------------------------------
338 void G4PersistencyCenter::PrintAll()
339 {
340 G4cout << "Persistency Package: " << Current
341 G4cout << G4endl;
342
343 G4String name, file;
344 StoreMode mode;
345
346 G4cout << "Output object types and file name
347 for(auto itr = f_wrObj.cbegin(); itr != f_wr
348 {
349 name = (*itr).second;
350 // disabled HepMC and MCTruth for now
351 if(name != "HepMC" && name != "MCTruth")
352 {
353 G4cout << " Object: " << PadString(name
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
376 for(auto itr = f_rdObj.cbegin(); itr != f_rd
377 {
378 name = (*itr).second;
379 // disabled HepMC and MCTruth for now
380 if(name != "HepMC" && name != "MCTruth")
381 {
382 G4cout << " Object: " << PadString(name
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(n
395 }
396 }
397 G4cout << G4endl;
398
399 G4HCIOcatalog* hioc = G4HCIOcatalog::GetHCIO
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 r
410 }
411
412 G4DCIOcatalog* dioc = G4DCIOcatalog::GetDCIO
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
423 }
424 }
425
426 // -------------------------------------------
427 void G4PersistencyCenter::SetPersistencyManage
428
429 {
430 f_currentManager = pm;
431 f_currentSystemName = name;
432 }
433
434 // -------------------------------------------
435 G4PersistencyManager*
436 G4PersistencyCenter::GetPersistencyManager(con
437 {
438 if(f_theCatalog.find(nam) != f_theCatalog.ce
439 return f_theCatalog[nam];
440 return nullptr;
441 }
442
443 // -------------------------------------------
444 void G4PersistencyCenter::RegisterPersistencyM
445 {
446 f_theCatalog[pm->GetName()] = pm;
447 }
448
449 // -------------------------------------------
450 void G4PersistencyCenter::DeletePersistencyMan
451 {
452 if(f_currentManager != nullptr)
453 delete f_currentManager;
454 f_currentManager = nullptr;
455 }
456
457 // -------------------------------------------
458 void G4PersistencyCenter::SetVerboseLevel(G4in
459 {
460 m_verbose = v;
461 if(f_currentManager != nullptr)
462 f_currentManager->SetVerboseLevel(m_verbos
463 }
464
465 // -------------------------------------------
466 G4String G4PersistencyCenter::PadString(const
467 unsign
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.l
477 wname = wname + " ";
478 return wname;
479 }
480 }
481