| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
27 // Author: Ivana Hrivnacova, 04/10/2016 (ivan 27 // Author: Ivana Hrivnacova, 04/10/2016 (ivana@ipno.in2p3.fr)
28 28
29 #include "G4NtupleBookingManager.hh" 29 #include "G4NtupleBookingManager.hh"
30 #include "G4RootPNtupleManager.hh" 30 #include "G4RootPNtupleManager.hh"
>> 31 #include "G4RootMainNtupleManager.hh"
31 #include "G4AnalysisUtilities.hh" 32 #include "G4AnalysisUtilities.hh"
32 33
33 #include "tools/wroot/file" 34 #include "tools/wroot/file"
34 #include "tools/wroot/ntuple" 35 #include "tools/wroot/ntuple"
35 36
36 using namespace G4Analysis; <<
37 using std::to_string; <<
38 <<
39 // mutex in a file scope 37 // mutex in a file scope
40 namespace { 38 namespace {
41 39
42 //Mutex to lock master manager when adding ntu 40 //Mutex to lock master manager when adding ntuple row and ending fill
43 G4Mutex pntupleMutex = G4MUTEX_INITIALIZER; 41 G4Mutex pntupleMutex = G4MUTEX_INITIALIZER;
44 //Mutex to lock master manager when createing <<
45 G4Mutex createMainMutex = G4MUTEX_INITIALIZER; <<
46 42
47 //____________________________________________ 43 //_____________________________________________________________________________
48 void NotExistWarning(const G4String& what, G4i << 44 void NotExistException(const G4String& what, G4int id, const G4String& functionName)
49 std::string_view classNam <<
50 std::string_view function <<
51 { 45 {
52 Warn(what + " id= " + to_string(id) + " does << 46 G4String inFunction = "G4RootPNtupleManager::";
53 className, functionName); << 47 inFunction += functionName;
54 << 48 G4ExceptionDescription description;
>> 49 description << what << " id= " << id << " does not exist.";
>> 50 G4Exception(inFunction, "Analysis_W011", JustWarning, description);
55 } 51 }
56 52
57 } 53 }
58 54
59 //____________________________________________ 55 //_____________________________________________________________________________
60 G4RootPNtupleManager::G4RootPNtupleManager(con 56 G4RootPNtupleManager::G4RootPNtupleManager(const G4AnalysisManagerState& state,
61 std::shared_ptr<G4Ntup 57 std::shared_ptr<G4NtupleBookingManager> bookingManger,
62 std::shared_ptr<G4Root 58 std::shared_ptr<G4RootMainNtupleManager> main,
63 G4bool rowWise, G4bool 59 G4bool rowWise, G4bool rowMode)
64 : G4BaseNtupleManager(state), 60 : G4BaseNtupleManager(state),
65 fBookingManager(std::move(bookingManger)), << 61 fBookingManager(bookingManger),
66 fMainNtupleManager(std::move(main)), << 62 fMainNtupleManager(main),
>> 63 fNtupleDescriptionVector(),
>> 64 fNtupleVector(),
67 fRowWise(rowWise), 65 fRowWise(rowWise),
68 fRowMode(rowMode) << 66 fRowMode(rowMode),
>> 67 fCreateNtuples(true)
69 {} 68 {}
70 69
71 //____________________________________________ 70 //_____________________________________________________________________________
72 G4RootPNtupleManager::~G4RootPNtupleManager() 71 G4RootPNtupleManager::~G4RootPNtupleManager()
73 { 72 {
74 for ( auto ntupleDescription : fNtupleDescri 73 for ( auto ntupleDescription : fNtupleDescriptionVector ) {
75 delete ntupleDescription; 74 delete ntupleDescription;
76 } << 75 }
77 } 76 }
78 77
79 // 78 //
80 // private functions 79 // private functions
81 // 80 //
82 81
83 //____________________________________________ 82 //_____________________________________________________________________________
84 G4RootPNtupleDescription* << 83 G4RootPNtupleDescription*
85 G4RootPNtupleManager::GetNtupleDescriptionInFu 84 G4RootPNtupleManager::GetNtupleDescriptionInFunction(
86 G4int id, std::string_view functionName, G4b << 85 G4int id, G4String functionName, G4bool warn) const
87 { << 86 {
88 auto index = id - fFirstId; 87 auto index = id - fFirstId;
89 if ( index < 0 || index >= G4int(fNtupleDesc 88 if ( index < 0 || index >= G4int(fNtupleDescriptionVector.size()) ) {
90 if ( warn) { 89 if ( warn) {
91 NotExistWarning("ntuple description", id << 90 NotExistException("ntuple description", id, functionName);
92 } 91 }
93 return nullptr; << 92 return nullptr;
94 } 93 }
95 << 94
96 return fNtupleDescriptionVector[index]; 95 return fNtupleDescriptionVector[index];
97 } 96 }
98 97
99 //____________________________________________ 98 //_____________________________________________________________________________
100 tools::wroot::base_pntuple* << 99 tools::wroot::base_pntuple*
101 G4RootPNtupleManager::GetNtupleInFunction( 100 G4RootPNtupleManager::GetNtupleInFunction(
102 G4int id, std::string_view functionName, G4b << 101 G4int id, G4String functionName, G4bool warn) const
103 { << 102 {
104 auto ntupleDescription = GetNtupleDescriptio 103 auto ntupleDescription = GetNtupleDescriptionInFunction(id, functionName);
105 if (ntupleDescription == nullptr) return nul << 104 if ( ! ntupleDescription ) return nullptr;
106 105
107 if (ntupleDescription->GetBasePNtuple() == n << 106 if ( ! ntupleDescription->fBasePNtuple ) {
108 if ( warn ) { 107 if ( warn ) {
109 NotExistWarning("ntuple", id, fkClass, f << 108 NotExistException("ntuple", id, functionName);
110 } 109 }
111 return nullptr; 110 return nullptr;
112 } << 111 }
113 return ntupleDescription->GetBasePNtuple(); << 112 return ntupleDescription->fBasePNtuple;
114 } 113 }
115 114
116 //____________________________________________ 115 //_____________________________________________________________________________
117 tools::wroot::ntuple* 116 tools::wroot::ntuple*
118 G4RootPNtupleManager::GetMainNtupleInFunction( 117 G4RootPNtupleManager::GetMainNtupleInFunction(
119 G4int id, std::string_view functionName, G4b << 118 G4int id, G4String functionName, G4bool warn) const
120 { << 119 {
121 auto& mainNtupleVector = fMainNtupleManager- 120 auto& mainNtupleVector = fMainNtupleManager->GetNtupleVector();
122 121
123 auto index = id - fFirstId; 122 auto index = id - fFirstId;
124 if ( index < 0 || index >= G4int(mainNtupleV 123 if ( index < 0 || index >= G4int(mainNtupleVector.size()) ) {
125 if ( warn) { 124 if ( warn) {
126 NotExistWarning("main ntuple", id, fkCla << 125 NotExistException("main ntuple", id, functionName);
127 } 126 }
128 return nullptr; << 127 return nullptr;
129 } 128 }
130 << 129
131 return mainNtupleVector[index]; 130 return mainNtupleVector[index];
132 } 131 }
133 132
134 // 133 //
135 // protected functions 134 // protected functions
136 // 135 //
137 136
138 //____________________________________________ 137 //_____________________________________________________________________________
139 void G4RootPNtupleManager::CreateNtupleFromMai 138 void G4RootPNtupleManager::CreateNtupleFromMain(
140 G4RootPNtupleDesc 139 G4RootPNtupleDescription* ntupleDescription,
141 tools::wroot::ntu 140 tools::wroot::ntuple* mainNtuple)
142 { 141 {
143 // Do not create pntuple if ntuple was delet << 142 #ifdef G4VERBOSE
144 if (mainNtuple == nullptr) { << 143 if ( fState.GetVerboseL4() ) {
145 ntupleDescription->SetNtuple(nullptr); << 144 fState.GetVerboseL4()
146 ntupleDescription->SetBasePNtuple(nullptr) << 145 ->Message("create from main", "pntuple", mainNtuple->name());
147 return; <<
148 } 146 }
>> 147 #endif
149 148
150 Message(kVL4, "create from main", "pntuple", << 149 auto file = fMainNtupleManager->GetNtupleFile(&ntupleDescription->fDescription);
151 <<
152 auto file = fMainNtupleManager->GetNtupleFil <<
153 if ( ! file ) { 150 if ( ! file ) {
154 Warn("Cannot create pntuple. Main ntuple f << 151 G4String inFunction = "G4RootPNtupleManager::::CreateNtupleFromMain";
155 fkClass, "CreateNtupleFromMain"); << 152 G4ExceptionDescription description;
>> 153 description
>> 154 << "Cannot create pntuple. Main ntuple file does not exist." << G4endl;
>> 155 G4Exception(inFunction, "Analysis_W002", JustWarning, description);
156 return; 156 return;
157 } 157 }
158 158
159 ntupleDescription->GetDescription().SetFile( << 159 ntupleDescription->fDescription.fFile = file;
160 160
161 // Get parameters from ntupleDescription 161 // Get parameters from ntupleDescription
162 mainNtuple->get_branches(ntupleDescription-> << 162 mainNtuple->get_branches(ntupleDescription->fMainBranches);
163 163
164 auto rfile = std::get<0>(*file); 164 auto rfile = std::get<0>(*file);
165 G4bool verbose = true; 165 G4bool verbose = true;
166 if ( fRowWise ) { 166 if ( fRowWise ) {
167 auto mainBranch = mainNtuple->get_row_wise 167 auto mainBranch = mainNtuple->get_row_wise_branch();
168 auto mtNtuple << 168 tools::wroot::mt_ntuple_row_wise* mtNtuple
169 = new tools::wroot::mt_ntuple_row_wise( 169 = new tools::wroot::mt_ntuple_row_wise(
170 G4cout, rfile->byte_swap(), rfil 170 G4cout, rfile->byte_swap(), rfile->compression(),
171 mainNtuple->dir().seek_directory 171 mainNtuple->dir().seek_directory(),
172 *mainBranch, mainBranch->basket_ << 172 *mainBranch, mainBranch->basket_size(),
173 ntupleDescription->GetDescriptio << 173 ntupleDescription->fDescription.fNtupleBooking, verbose);
174 174
175 ntupleDescription->SetNtuple( << 175 ntupleDescription->fNtuple
176 static_cast<tools::wroot::imt_ntuple*>(m << 176 = static_cast<tools::wroot::imt_ntuple*>(mtNtuple);
177 ntupleDescription->SetBasePNtuple( << 177 ntupleDescription->fBasePNtuple
178 static_cast<tools::wroot::base_pntuple*> << 178 = static_cast<tools::wroot::base_pntuple*>(mtNtuple);
179 } << 179 }
180 else { 180 else {
181 std::vector<tools::uint32> basketSizes; 181 std::vector<tools::uint32> basketSizes;
182 tools_vforcit(tools::wroot::branch*, ntupl << 182 tools_vforcit(tools::wroot::branch*, ntupleDescription->fMainBranches, it) {
183 basketSizes.push_back((*it)->basket_size 183 basketSizes.push_back((*it)->basket_size());
184 } 184 }
185 auto basketEntries = fMainNtupleManager->G 185 auto basketEntries = fMainNtupleManager->GetBasketEntries();
186 << 186
187 auto mtNtuple = << 187 tools::wroot::mt_ntuple_column_wise* mtNtuple =
188 new tools::wroot::mt_ntuple_column_wise( 188 new tools::wroot::mt_ntuple_column_wise(
189 G4cout, rfile->byte_swap(), rfile- 189 G4cout, rfile->byte_swap(), rfile->compression(),
190 mainNtuple->dir().seek_directory() 190 mainNtuple->dir().seek_directory(),
191 ntupleDescription->GetMainBranches << 191 ntupleDescription->fMainBranches, basketSizes,
192 ntupleDescription->GetDescription( << 192 ntupleDescription->fDescription.fNtupleBooking,
193 fRowMode, basketEntries, verbose); 193 fRowMode, basketEntries, verbose);
194 << 194
195 ntupleDescription->SetNtuple( << 195 ntupleDescription->fNtuple
196 static_cast<tools::wroot::imt_ntuple*>(m << 196 = static_cast<tools::wroot::imt_ntuple*>(mtNtuple);
197 ntupleDescription->SetBasePNtuple( << 197 ntupleDescription->fBasePNtuple
198 static_cast<tools::wroot::base_pntuple*> << 198 = static_cast<tools::wroot::base_pntuple*>(mtNtuple);
199 } 199 }
200 200
201 ntupleDescription->GetDescription().SetIsNtu << 201 ntupleDescription->fDescription.fIsNtupleOwner = true;
202 // // pntuple object is not deleted a 202 // // pntuple object is not deleted automatically
203 fNtupleVector.push_back(ntupleDescription->G << 203 fNtupleVector.push_back(ntupleDescription->fNtuple);
204 204
205 Message(kVL3, "create from main", "pntuple", << 205 #ifdef G4VERBOSE
>> 206 if ( fState.GetVerboseL3() ) {
>> 207 fState.GetVerboseL3()
>> 208 ->Message("create from main", "pntuple", mainNtuple->name());
>> 209 }
>> 210 #endif
206 } 211 }
207 212
208 //____________________________________________ 213 //_____________________________________________________________________________
209 void G4RootPNtupleManager::CreateNtupleDescrip << 214 void G4RootPNtupleManager::CreateNtuplesFromMain()
210 { 215 {
211 // Create ntuple descriptions from booking. << 216 // Create ntuple from booking (if not yet done) and main ntuple
212 // This function is called from the first Fill 217 // This function is called from the first Fill call.
213 218
214 // Create pntuple descriptions from ntuple b 219 // Create pntuple descriptions from ntuple booking.
215 auto g4NtupleBookings = fBookingManager->Get 220 auto g4NtupleBookings = fBookingManager->GetNtupleBookingVector();
216 <<
217 for ( auto g4NtupleBooking : g4NtupleBooking 221 for ( auto g4NtupleBooking : g4NtupleBookings ) {
218 auto ntupleDescription = new G4RootPNtuple 222 auto ntupleDescription = new G4RootPNtupleDescription(g4NtupleBooking);
219 // Save g4booking, activation in pntuple b 223 // Save g4booking, activation in pntuple booking
220 fNtupleDescriptionVector.push_back(ntupleD << 224 fNtupleDescriptionVector.push_back(ntupleDescription);
221 } 225 }
222 } <<
223 <<
224 //____________________________________________ <<
225 void G4RootPNtupleManager::CreateNtuplesFromMa <<
226 { <<
227 // Create slave ntuples from main ntuple. <<
228 // This function is called from the first Fill <<
229 226
230 auto& mainNtupleVector = fMainNtupleManager- 227 auto& mainNtupleVector = fMainNtupleManager->GetNtupleVector();
231 228
232 G4int lcounter = 0; 229 G4int lcounter = 0;
233 for ( auto mainNtuple : mainNtupleVector ) { << 230 for ( auto mainNtuple : mainNtupleVector ) {
234 auto& ntupleDescription = fNtupleDescripti 231 auto& ntupleDescription = fNtupleDescriptionVector[lcounter++];
235 CreateNtupleFromMain(ntupleDescription, ma 232 CreateNtupleFromMain(ntupleDescription, mainNtuple);
236 } 233 }
237 } <<
238 <<
239 //____________________________________________ <<
240 void G4RootPNtupleManager::CreateNtuplesIfNeed <<
241 { <<
242 // The ntuples on workers are created at first <<
243 // (if only columns of vector type) call. <<
244 // When writing multiple times in teh same fil <<
245 // to be recreated as well. <<
246 <<
247 // G4cout << "G4RootPNtupleManager::CreateNt <<
248 // << " fCreateNtuple: " << fCreateNtuples <<
249 // << " fNewCycle: " << fNewCycle <<
250 // << " fMainNtupleManager->GetNewCycle(): <<
251 // << " fNtupleDescriptionVector.size(): " <<
252 // << " fNtupleVector.size(): " << fNtuple <<
253 // << G4endl; <<
254 <<
255 if (fCreateNtuples) { <<
256 // create ntuple descriptions <<
257 CreateNtupleDescriptionsFromBooking(); <<
258 <<
259 // create main ntuples if needed <<
260 G4AutoLock lock(&createMainMutex); <<
261 if (fMainNtupleManager->GetNewCycle()) { <<
262 fMainNtupleManager->CreateNtuplesFromBoo <<
263 } <<
264 lock.unlock(); <<
265 234
266 // create slave ntuples << 235 fCreateNtuples = false;
267 CreateNtuplesFromMain(); <<
268 fCreateNtuples = false; <<
269 } <<
270 <<
271 if (fNewCycle) { <<
272 // create main ntuples if needed <<
273 G4AutoLock lock(&createMainMutex); <<
274 if (fMainNtupleManager->GetNewCycle()) { <<
275 fMainNtupleManager->CreateNtuplesFromBoo <<
276 } <<
277 lock.unlock(); <<
278 <<
279 // create slave ntuples <<
280 CreateNtuplesFromMain(); <<
281 fNewCycle = false; <<
282 } <<
283 } 236 }
284 237
285 //____________________________________________ 238 //_____________________________________________________________________________
286 G4int G4RootPNtupleManager::CreateNtuple(G4Ntu 239 G4int G4RootPNtupleManager::CreateNtuple(G4NtupleBooking* /*booking*/)
287 { 240 {
288 // Create pntuple from g4 ntuple booking. 241 // Create pntuple from g4 ntuple booking.
289 // Nothing to be done here. 242 // Nothing to be done here.
290 243
291 return G4Analysis::kInvalidId; 244 return G4Analysis::kInvalidId;
292 } << 245 }
293 246
294 //____________________________________________ 247 //_____________________________________________________________________________
295 G4bool G4RootPNtupleManager::FillNtupleIColumn 248 G4bool G4RootPNtupleManager::FillNtupleIColumn(
296 G4int ntupleId, G4int columnId, G4int value) 249 G4int ntupleId, G4int columnId, G4int value)
297 { 250 {
298 return FillNtupleTColumn<int>(ntupleId, colu 251 return FillNtupleTColumn<int>(ntupleId, columnId, value);
299 } << 252 }
300 253
301 //____________________________________________ 254 //_____________________________________________________________________________
302 G4bool G4RootPNtupleManager::FillNtupleFColumn 255 G4bool G4RootPNtupleManager::FillNtupleFColumn(
303 G4int ntupleId, G4int columnId, G4float valu 256 G4int ntupleId, G4int columnId, G4float value)
304 { 257 {
305 return FillNtupleTColumn<float>(ntupleId, co 258 return FillNtupleTColumn<float>(ntupleId, columnId, value);
306 } << 259 }
307 260
308 //____________________________________________ 261 //_____________________________________________________________________________
309 G4bool G4RootPNtupleManager::FillNtupleDColumn 262 G4bool G4RootPNtupleManager::FillNtupleDColumn(
310 G4int ntupleId, G4int columnId, G4double val 263 G4int ntupleId, G4int columnId, G4double value)
311 { 264 {
312 return FillNtupleTColumn<double>(ntupleId, c 265 return FillNtupleTColumn<double>(ntupleId, columnId, value);
313 } << 266 }
314 267
315 //____________________________________________ 268 //_____________________________________________________________________________
316 G4bool G4RootPNtupleManager::FillNtupleSColumn 269 G4bool G4RootPNtupleManager::FillNtupleSColumn(
317 G4int ntupleId, G4int columnId, const G4Stri 270 G4int ntupleId, G4int columnId, const G4String& value)
318 { 271 {
319 return FillNtupleTColumn<std::string>(ntuple 272 return FillNtupleTColumn<std::string>(ntupleId, columnId, value);
320 } << 273 }
321 274
322 //____________________________________________ 275 //_____________________________________________________________________________
323 G4bool G4RootPNtupleManager::AddNtupleRow(G4in 276 G4bool G4RootPNtupleManager::AddNtupleRow(G4int ntupleId)
324 { << 277 {
325 if ( fState.GetIsActivation() && ( ! GetActi << 278 if (fCreateNtuples) {
326 //G4cout << "Skipping AddNtupleRow for " < << 279 CreateNtuplesFromMain();
327 return false; <<
328 } <<
329 <<
330 if ( IsVerbose(kVL4) ) { <<
331 Message(kVL4, "add", "pntuple row", " ntup <<
332 } 280 }
333 281
334 // Creating ntuples on workers is triggered << 282 if ( fState.GetIsActivation() && ( ! GetActivation(ntupleId) ) ) {
335 // or AddRow (in only columns of vector type << 283 //G4cout << "Skipping AddNtupleRow for " << ntupleId << G4endl;
336 CreateNtuplesIfNeeded(); << 284 return false;
>> 285 }
>> 286
>> 287 #ifdef G4VERBOSE
>> 288 if ( fState.GetVerboseL4() ) {
>> 289 G4ExceptionDescription description;
>> 290 description << " ntupleId " << ntupleId;
>> 291 fState.GetVerboseL4()->Message("add", "pntuple row", description);
>> 292 }
>> 293 #endif
337 294
338 auto ntupleDescription = GetNtupleDescriptio 295 auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "AddNtupleRow");
339 if (ntupleDescription == nullptr) return fal << 296 if ( ! ntupleDescription ) return false;
340 297
341 auto rfile = std::get<0>(*ntupleDescription- << 298 auto rfile = std::get<0>(*ntupleDescription->fDescription.fFile);
342 299
343 G4AutoLock lock(&pntupleMutex); 300 G4AutoLock lock(&pntupleMutex);
344 lock.unlock(); 301 lock.unlock();
345 mutex toolsLock(lock); 302 mutex toolsLock(lock);
346 auto result << 303 auto result
347 = ntupleDescription->GetNtuple()->add_row( << 304 = ntupleDescription->fNtuple->add_row(toolsLock, *rfile);
348 305
349 if ( ! result ) { 306 if ( ! result ) {
350 Warn("NtupleId " + to_string(ntupleId) + " << 307 G4ExceptionDescription description;
351 fkClass, "AddNtupleRow"); << 308 description << " " << " ntupleId " << ntupleId
352 } << 309 << "adding row has failed.";
353 << 310 G4Exception("G4RootPNtupleManager::AddNtupleRow()",
354 ntupleDescription->GetDescription().SetHasFi << 311 "Analysis_W022", JustWarning, description);
355 << 312 }
356 if ( IsVerbose(kVL3) ) { << 313
357 Message(kVL3, "add", "pntuple row", " ntup << 314 ntupleDescription->fDescription.fHasFill = true;
358 } << 315
359 << 316 #ifdef G4VERBOSE
>> 317 if ( fState.GetVerboseL3() ) {
>> 318 G4ExceptionDescription description;
>> 319 description << " ntupleId " << ntupleId;
>> 320 fState.GetVerboseL3()->Message("add", "pntuple row", description);
>> 321 }
>> 322 #endif
360 323
361 return true; 324 return true;
362 } 325 }
363 326
364 //____________________________________________ 327 //_____________________________________________________________________________
365 G4bool G4RootPNtupleManager::Merge() 328 G4bool G4RootPNtupleManager::Merge()
366 { 329 {
367 for ( auto ntupleDescription : fNtupleDescri 330 for ( auto ntupleDescription : fNtupleDescriptionVector) {
368 331
369 // skip inactivated ntuples 332 // skip inactivated ntuples
370 if (! ntupleDescription->GetDescription(). << 333 if(!ntupleDescription->fDescription.fActivation || !ntupleDescription->fNtuple) {
371 (ntupleDescription->GetNtuple() == nul <<
372 // G4cout << "skipping inactive ntuple " 334 // G4cout << "skipping inactive ntuple " << G4endl;
373 continue; 335 continue;
374 } 336 }
375 337
376 if ( IsVerbose(kVL4) ) { << 338 #ifdef G4VERBOSE
377 Message(kVL4, "merge", "pntuple", << 339 if ( fState.GetVerboseL4() ) {
378 ntupleDescription->GetDescription().Ge << 340 fState.GetVerboseL4()
379 } << 341 ->Message("merge", "pntuple", ntupleDescription->fDescription.fNtupleBooking.name());
380 << 342 }
381 auto rfile = std::get<0>(*ntupleDescriptio << 343 #endif
>> 344
>> 345 auto rfile = std::get<0>(*ntupleDescription->fDescription.fFile);
382 346
383 G4AutoLock lock(&pntupleMutex); 347 G4AutoLock lock(&pntupleMutex);
384 lock.unlock(); 348 lock.unlock();
385 mutex toolsLock(lock); 349 mutex toolsLock(lock);
386 auto result << 350 auto result
387 = ntupleDescription->GetNtuple()->end_fi << 351 = ntupleDescription->fNtuple->end_fill(toolsLock, *rfile);
388 352
389 if ( ! result ) { 353 if ( ! result ) {
390 Warn("Ntuple " + ntupleDescription->GetD << 354 G4ExceptionDescription description;
391 "end fill has failed.", fkClass, "M << 355 description << " " << " ntuple " << ntupleDescription->fDescription.fNtupleBooking.name()
392 } << 356 << "end fill has failed.";
393 << 357 G4Exception("G4RootPNtupleManager::Merge()",
394 if ( IsVerbose(kVL3) ) { << 358 "Analysis_W031", JustWarning, description);
395 Message(kVL3, "merge", "pntuple", <<
396 ntupleDescription->GetDescription().Ge <<
397 } 359 }
398 360
>> 361 delete ntupleDescription->fNtuple;
>> 362 ntupleDescription->fNtuple = nullptr;
>> 363
>> 364 #ifdef G4VERBOSE
>> 365 if ( fState.GetVerboseL3() ) {
>> 366 fState.GetVerboseL3()
>> 367 ->Message("merge", "pntuple", ntupleDescription->fDescription.fNtupleBooking.name());
>> 368 }
>> 369 #endif
399 } 370 }
400 <<
401 // Set new cycle <<
402 fNewCycle = true; <<
403 <<
404 return true; 371 return true;
405 } <<
406 <<
407 //____________________________________________ <<
408 G4bool G4RootPNtupleManager::Reset() <<
409 { <<
410 // Reset ntuple description, this will delet <<
411 // we have its ownership. <<
412 // The ntuples will be recreated with new cy <<
413 <<
414 for ( auto ntupleDescription : fNtupleDescri <<
415 ntupleDescription->Reset(); <<
416 } <<
417 <<
418 fNtupleVector.clear(); <<
419 372
420 return true; <<
421 } 373 }
422 374
423 //____________________________________________ 375 //_____________________________________________________________________________
424 void G4RootPNtupleManager::Clear() << 376 G4bool G4RootPNtupleManager::Reset(G4bool deleteNtuple)
425 { 377 {
426 for ( auto ntupleDescription : fNtupleDescri 378 for ( auto ntupleDescription : fNtupleDescriptionVector ) {
427 delete ntupleDescription->GetNtuple(); << 379 if ( deleteNtuple ) {
428 } << 380 delete ntupleDescription->fNtuple;
429 << 381 }
430 fNtupleDescriptionVector.clear(); << 382 ntupleDescription->fNtuple = nullptr;
431 fNtupleVector.clear(); <<
432 <<
433 Message(kVL2, "clear", "pntuples"); <<
434 } <<
435 <<
436 //____________________________________________ <<
437 G4bool G4RootPNtupleManager::Delete(G4int id) <<
438 { <<
439 if ( IsVerbose(G4Analysis::kVL4) ) { <<
440 Message(G4Analysis::kVL4, "delete", "pntup <<
441 } 383 }
442 384
443 auto ntupleDescription = GetNtupleDescriptio << 385 fNtupleVector.clear();
444 << 386
445 if (ntupleDescription == nullptr) return fal <<
446 <<
447 // Delete/clear ntuple data <<
448 delete ntupleDescription->GetNtuple(); <<
449 ntupleDescription->SetNtuple(nullptr); <<
450 ntupleDescription->SetBasePNtuple(nullptr); <<
451 ntupleDescription->GetMainBranches().clear() <<
452 <<
453 // Update ntuple vector <<
454 auto index = id - GetFirstId(); <<
455 fNtupleVector[index] = nullptr; <<
456 <<
457 Message(G4Analysis::kVL2, "delete", "pntuple <<
458 <<
459 return true; 387 return true;
460 } << 388 }
461 389
462 //____________________________________________ 390 //_____________________________________________________________________________
463 391
464 void G4RootPNtupleManager::SetActivation( 392 void G4RootPNtupleManager::SetActivation(
465 G4bool activation) 393 G4bool activation)
466 { 394 {
467 for ( auto ntupleDescription : fNtupleDescri 395 for ( auto ntupleDescription : fNtupleDescriptionVector ) {
468 ntupleDescription->GetDescription().SetAct << 396 ntupleDescription->fDescription.fActivation = activation;
469 } << 397 }
470 } 398 }
471 399
472 //____________________________________________ 400 //_____________________________________________________________________________
473 401
474 void G4RootPNtupleManager::SetActivation( 402 void G4RootPNtupleManager::SetActivation(
475 G4int ntupleId, G4bool activation) 403 G4int ntupleId, G4bool activation)
476 { 404 {
477 auto ntupleDescription = GetNtupleDescriptio 405 auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetActivation");
478 if (ntupleDescription == nullptr) return; << 406 if ( ! ntupleDescription ) return;
479 407
480 ntupleDescription->GetDescription().SetActiv << 408 ntupleDescription->fDescription.fActivation = activation;
481 } 409 }
482 410
483 //____________________________________________ 411 //_____________________________________________________________________________
484 G4bool G4RootPNtupleManager::GetActivation( 412 G4bool G4RootPNtupleManager::GetActivation(
485 G4int ntupleId) const 413 G4int ntupleId) const
486 { 414 {
487 auto ntupleDescription = GetNtupleDescriptio 415 auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "GetActivation");
488 if (ntupleDescription == nullptr) return fal << 416 if ( ! ntupleDescription ) return false;
489 417
490 return ntupleDescription->GetDescription().G << 418 return ntupleDescription->fDescription.fActivation;
491 } 419 }
492 420
493 //____________________________________________ 421 //_____________________________________________________________________________
494 void G4RootPNtupleManager::SetNewCycle(G4bool << 422 G4int G4RootPNtupleManager::GetNofNtuples() const
495 { 423 {
496 fNewCycle = value; << 424 return fNtupleVector.size();
497 } <<
498 <<
499 //____________________________________________ <<
500 G4bool G4RootPNtupleManager::GetNewCycle() con <<
501 { <<
502 return fNewCycle; <<
503 } 425 }
504 426
505 //____________________________________________ 427 //_____________________________________________________________________________
506 void G4RootPNtupleManager::SetNtupleRowWise(G4 428 void G4RootPNtupleManager::SetNtupleRowWise(G4bool rowWise, G4bool rowMode)
507 { << 429 {
508 fRowWise = rowWise; 430 fRowWise = rowWise;
509 fRowMode = rowMode; 431 fRowMode = rowMode;
510 } 432 }
511 433