| 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 // G4PersistencyManager implementation
27 //
28 // Author: Youhei Morita, 17.07.2001
29 // --------------------------------------------------------------------
30
31 #include "G4PersistencyManager.hh"
32
33 #include <iomanip>
34 #include "G4PersistencyCenter.hh"
35
36 // --------------------------------------------------------------------
37 G4PersistencyManager::G4PersistencyManager(G4PersistencyCenter* ptc,
38 const G4String& n)
39 : f_pc(ptc)
40 , nameMgr(n)
41 {
42 m_verbose = f_pc->VerboseLevel();
43 }
44
45 // --------------------------------------------------------------------
46 G4PersistencyManager::~G4PersistencyManager()
47 {
48 }
49
50 // --------------------------------------------------------------------
51 G4PersistencyManager* G4PersistencyManager::GetPersistencyManager()
52 {
53 return G4PersistencyCenter::GetPersistencyCenter()
54 ->CurrentPersistencyManager();
55 }
56
57 // --------------------------------------------------------------------
58 void G4PersistencyManager::SetVerboseLevel(G4int v)
59 {
60 m_verbose = v;
61 if(m_verbose > 2)
62 {
63 G4cout << "G4PersistencyManager[\"" << nameMgr << "\"," << this
64 << "]: verbose level is set to " << m_verbose << "." << G4endl;
65 }
66 if(EventIO() != nullptr)
67 EventIO()->SetVerboseLevel(m_verbose);
68 if(MCTruthIO() != nullptr)
69 MCTruthIO()->SetVerboseLevel(m_verbose);
70 if(HitIO() != nullptr)
71 HitIO()->SetVerboseLevel(m_verbose);
72 if(DigitIO() != nullptr)
73 DigitIO()->SetVerboseLevel(m_verbose);
74 if(TransactionManager() != nullptr)
75 TransactionManager()->SetVerboseLevel(m_verbose);
76
77 G4int i;
78
79 G4HCIOcatalog* hcio = G4HCIOcatalog::GetHCIOcatalog();
80 if(hcio != nullptr)
81 {
82 hcio->SetVerboseLevel(m_verbose);
83 for(i = 0; i < (G4int)hcio->NumberOfHCIOmanager(); ++i)
84 {
85 hcio->GetHCIOmanager(i)->SetVerboseLevel(m_verbose);
86 }
87 }
88 G4DCIOcatalog* dcio = G4DCIOcatalog::GetDCIOcatalog();
89 if(dcio != nullptr)
90 {
91 dcio->SetVerboseLevel(m_verbose);
92 for(i = 0; i < (G4int)dcio->NumberOfDCIOmanager(); ++i)
93 {
94 dcio->GetDCIOmanager(i)->SetVerboseLevel(m_verbose);
95 }
96 }
97 }
98
99 // --------------------------------------------------------------------
100 G4bool G4PersistencyManager::Store(const G4Event* evt)
101 {
102 if(m_verbose > 2)
103 {
104 G4cout << "G4PersistencyManager::Store() is called for event# "
105 << evt->GetEventID() << "." << G4endl;
106 }
107
108 if(TransactionManager() == nullptr)
109 return true;
110
111 G4bool is_store = f_pc->CurrentStoreMode("MCTruth") != kOff ||
112 f_pc->CurrentStoreMode("Hits") != kOff ||
113 f_pc->CurrentStoreMode("Digits") != kOff;
114
115 if(!is_store)
116 return true;
117
118 // Call package dependent Initialize()
119 //
120 if(!f_is_initialized)
121 {
122 f_is_initialized = true;
123 if(m_verbose > 1)
124 {
125 G4cout << "G4PersistencyManager:: Initializing Transaction ... "
126 << G4endl;
127 }
128 Initialize();
129 }
130
131 G4bool st1 = true, st2 = true;
132
133 // Start event IO transaction
134 //
135 if(TransactionManager()->StartUpdate())
136 {
137 if(m_verbose > 2)
138 {
139 G4cout << "G4PersistencyManager: Update transaction started for event#"
140 << evt->GetEventID() << "." << G4endl;
141 }
142 }
143 else
144 {
145 G4cerr << "TransactionManager::Store(G4Event) - StartUpdate() failed."
146 << G4endl;
147 return false;
148 }
149
150 G4String file;
151 G4String obj;
152
153 G4bool stmct = true, st3 = true;
154
155 // Store MCTruth event
156 //
157 obj = "MCTruth";
158 G4MCTEvent* mctevt = nullptr;
159 if(f_pc->CurrentStoreMode(obj) == kOn)
160 {
161 // Note: This part of code will not be activated until a method
162 // to obtain the current pointer of G4MCTEvent* become available.
163
164 // if ( (mctevt = f_MCTman->GetCurrentEvent()) != 0 ) {
165 if(mctevt != nullptr)
166 {
167 file = f_pc->CurrentWriteFile(obj);
168 if(TransactionManager()->SelectWriteFile(obj, file))
169 {
170 stmct = MCTruthIO()->Store(mctevt);
171 if(stmct && m_verbose > 1)
172 {
173 G4cout << " -- File : " << file << " -- Event# " << evt->GetEventID()
174 << " -- G4MCTEvent Stored." << G4endl;
175 }
176 }
177 else
178 {
179 stmct = false;
180 }
181 } // end of if ( mctevt != nullptr )
182 }
183
184 // Store hits collection
185 //
186 obj = "Hits";
187 if(f_pc->CurrentStoreMode(obj) == kOn)
188 {
189 if(G4HCofThisEvent* hc = evt->GetHCofThisEvent())
190 {
191 file = f_pc->CurrentWriteFile(obj);
192 if(TransactionManager()->SelectWriteFile(obj, file))
193 {
194 st1 = HitIO()->Store(hc);
195 if(st1 && m_verbose > 1)
196 {
197 G4cout << " -- File : " << file << " -- Event# " << evt->GetEventID()
198 << " -- Hit Collections Stored." << G4endl;
199 }
200 }
201 else
202 {
203 st1 = false;
204 }
205 }
206 }
207
208 // Store digits collection
209 //
210 obj = "Digits";
211 if(f_pc->CurrentStoreMode(obj) == kOn)
212 {
213 if(G4DCofThisEvent* dc = evt->GetDCofThisEvent())
214 {
215 file = f_pc->CurrentWriteFile(obj);
216 if(TransactionManager()->SelectWriteFile(obj, file))
217 {
218 st2 = DigitIO()->Store(dc);
219 if(st2 && m_verbose > 1)
220 {
221 G4cout << " -- File : " << file << " -- Event# " << evt->GetEventID()
222 << " -- Digit Collections Stored." << G4endl;
223 }
224 }
225 else
226 {
227 st2 = false;
228 }
229 }
230 }
231
232 // Store this G4EVENT
233 //
234 if(mctevt != 0 || evt != 0)
235 {
236 obj = "Hits";
237 file = f_pc->CurrentWriteFile(obj);
238 if(TransactionManager()->SelectWriteFile(obj, file))
239 {
240 st3 = EventIO()->Store(evt);
241 if(st3 && m_verbose > 1)
242 {
243 G4cout << " -- File name: " << f_pc->CurrentWriteFile("Hits")
244 << " -- Event# " << evt->GetEventID()
245 << " -- G4Pevent is Stored." << G4endl;
246 }
247 }
248 else
249 {
250 st3 = false;
251 }
252 }
253
254 G4bool st = stmct && st1 && st2 && st3;
255
256 if(st)
257 {
258 TransactionManager()->Commit();
259 if(m_verbose > 0)
260 G4cout << "G4PersistencyManager: event# " << evt->GetEventID()
261 << " is stored." << G4endl;
262 }
263 else
264 {
265 G4cerr << "G4PersistencyManager::Store(G4Event) - Transaction aborted."
266 << G4endl;
267 TransactionManager()->Abort();
268 }
269
270 return st;
271 }
272
273 // --------------------------------------------------------------------
274 G4bool G4PersistencyManager::Retrieve(G4Event*& evt)
275 {
276 if(m_verbose > 2)
277 {
278 G4cout << "G4PersistencyManager::Retrieve(G4Event*&) is called." << G4endl;
279 }
280
281 if(TransactionManager() == nullptr)
282 return true;
283
284 if(f_pc->CurrentRetrieveMode("MCTruth") == false &&
285 f_pc->CurrentRetrieveMode("Hits") == false &&
286 f_pc->CurrentRetrieveMode("Digits") == false)
287 {
288 return true;
289 }
290
291 // Call package dependent Initialize()
292 //
293 if(!f_is_initialized)
294 {
295 f_is_initialized = true;
296 if(m_verbose > 1)
297 {
298 G4cout << "G4PersistencyManager:: Initializing Transaction ... "
299 << G4endl;
300 }
301 Initialize();
302 }
303
304 // Start event IO transaction
305 //
306 if(TransactionManager()->StartRead())
307 {
308 if(m_verbose > 2)
309 {
310 G4cout << "G4PersistencyManager: Read transaction started." << G4endl;
311 }
312 }
313 else
314 {
315 G4cerr << "TransactionManager::Retrieve(G4Event) - StartRead() failed."
316 << G4endl;
317 return false;
318 }
319
320 G4bool st = false;
321 G4String file;
322
323 // Retrieve a G4EVENT
324 //
325 G4String obj = "Hits";
326 if(f_pc->CurrentRetrieveMode(obj) == true)
327 {
328 file = f_pc->CurrentReadFile(obj);
329 if(TransactionManager()->SelectReadFile(obj, file))
330 {
331 st = EventIO()->Retrieve(evt);
332 if(st && m_verbose > 1)
333 {
334 G4cout << " -- File : " << file << " -- Event# " << evt->GetEventID()
335 << " -- G4Event is Retrieved." << G4endl;
336 }
337 }
338 else
339 {
340 st = false;
341 }
342 }
343
344 if(st)
345 {
346 TransactionManager()->Commit();
347 }
348 else
349 {
350 G4cerr << "G4PersistencyManager::Retrieve() - Transaction aborted."
351 << G4endl;
352 TransactionManager()->Abort();
353 }
354
355 return st;
356 }
357