| 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, 01/09/2020 (ivan 27 // Author: Ivana Hrivnacova, 01/09/2020 (ivana@ipno.in2p3.fr)
28 28
29 #include "G4NtupleBookingManager.hh" 29 #include "G4NtupleBookingManager.hh"
30 #include "G4AnalysisManagerState.hh" 30 #include "G4AnalysisManagerState.hh"
31 #include "G4AnalysisUtilities.hh" 31 #include "G4AnalysisUtilities.hh"
32 32
33 using namespace G4Analysis; 33 using namespace G4Analysis;
34 using std::to_string; 34 using std::to_string;
35 35
36 // 36 //
37 // private template functions 37 // private template functions
38 // 38 //
39 39
40 //____________________________________________ 40 //_____________________________________________________________________________
41 G4NtupleBookingManager::G4NtupleBookingManager 41 G4NtupleBookingManager::G4NtupleBookingManager(
42 const G4AnalysisManagerState& state) 42 const G4AnalysisManagerState& state)
43 : G4BaseAnalysisManager(state) 43 : G4BaseAnalysisManager(state)
44 {} 44 {}
45 45
46 //____________________________________________ 46 //_____________________________________________________________________________
47 G4NtupleBookingManager::~G4NtupleBookingManage 47 G4NtupleBookingManager::~G4NtupleBookingManager()
48 { 48 {
49 for ( auto ntupleBooking : fNtupleBookingVec 49 for ( auto ntupleBooking : fNtupleBookingVector ) {
50 delete ntupleBooking; 50 delete ntupleBooking;
51 } 51 }
52 } 52 }
53 53
54 //____________________________________________ 54 //_____________________________________________________________________________
55 G4NtupleBooking* 55 G4NtupleBooking*
56 G4NtupleBookingManager::GetNtupleBookingInFunc 56 G4NtupleBookingManager::GetNtupleBookingInFunction(
57 G4int id, std::string_view functionName, G4b 57 G4int id, std::string_view functionName, G4bool warn) const
58 { 58 {
59 auto index = id - fFirstId; 59 auto index = id - fFirstId;
60 if ( index < 0 || index >= G4int(fNtupleBook 60 if ( index < 0 || index >= G4int(fNtupleBookingVector.size()) ) {
61 if ( warn) { 61 if ( warn) {
62 Warn("Ntuple booking " + to_string(id) + 62 Warn("Ntuple booking " + to_string(id) + " does not exist.",
63 fkClass, functionName); 63 fkClass, functionName);
64 } 64 }
65 return nullptr; 65 return nullptr;
66 } 66 }
67 67
68 return fNtupleBookingVector[index]; 68 return fNtupleBookingVector[index];
69 } 69 }
70 70
71 //____________________________________________ 71 //_____________________________________________________________________________
72 G4bool G4NtupleBookingManager::CheckName( 72 G4bool G4NtupleBookingManager::CheckName(
73 const G4String& name, const G4String& object 73 const G4String& name, const G4String& objectType) const
74 { 74 {
75 if (name.size() == 0u) { 75 if (name.size() == 0u) {
76 Warn("Empty " + objectType + " name is not 76 Warn("Empty " + objectType + " name is not allowed.\n" +
77 objectType + " was not created.", fkCla 77 objectType + " was not created.", fkClass, "CheckName");
78 return false; 78 return false;
79 } 79 }
80 return true; 80 return true;
81 } 81 }
82 82
83 // 83 //
84 // protected functions 84 // protected functions
85 // 85 //
86 86
87 //____________________________________________ 87 //_____________________________________________________________________________
88 G4bool G4NtupleBookingManager::IsEmpty() const 88 G4bool G4NtupleBookingManager::IsEmpty() const
89 { 89 {
90 return fNtupleBookingVector.size() == 0u; 90 return fNtupleBookingVector.size() == 0u;
91 } 91 }
92 92
93 //____________________________________________ 93 //_____________________________________________________________________________
94 G4int G4NtupleBookingManager::CreateNtuple( 94 G4int G4NtupleBookingManager::CreateNtuple(
95 const G4String& name, const G4String& title) 95 const G4String& name, const G4String& title)
96 { 96 {
97 if ( ! CheckName(name, "Ntuple") ) return kI 97 if ( ! CheckName(name, "Ntuple") ) return kInvalidId;
98 98
99 Message(kVL4, "create", "ntuple booking", na 99 Message(kVL4, "create", "ntuple booking", name);
100 100
101 G4int index = 0; 101 G4int index = 0;
102 G4NtupleBooking* ntupleBooking = nullptr; 102 G4NtupleBooking* ntupleBooking = nullptr;
103 if (fFreeIds.empty()) { 103 if (fFreeIds.empty()) {
104 index = (G4int)fNtupleBookingVector.size() 104 index = (G4int)fNtupleBookingVector.size();
105 ntupleBooking = new G4NtupleBooking(); 105 ntupleBooking = new G4NtupleBooking();
106 fNtupleBookingVector.push_back(ntupleBooki 106 fNtupleBookingVector.push_back(ntupleBooking);
107 ntupleBooking->fNtupleId = G4int(index + f 107 ntupleBooking->fNtupleId = G4int(index + fFirstId);
108 } 108 }
109 else { 109 else {
110 // Get the first freed Id 110 // Get the first freed Id
111 index = *(fFreeIds.begin()) - GetFirstId() 111 index = *(fFreeIds.begin()) - GetFirstId();
112 ntupleBooking = fNtupleBookingVector[index 112 ntupleBooking = fNtupleBookingVector[index];
113 ntupleBooking->fNtupleBooking = tools::ntu 113 ntupleBooking->fNtupleBooking = tools::ntuple_booking();
114 ntupleBooking->Reset(); 114 ntupleBooking->Reset();
115 115
116 // Remove the id from the set 116 // Remove the id from the set
117 fFreeIds.erase(fFreeIds.begin()); 117 fFreeIds.erase(fFreeIds.begin());
118 } 118 }
119 119
120 // Save name & title in ntuple booking 120 // Save name & title in ntuple booking
121 ntupleBooking->fNtupleBooking.set_name(name) 121 ntupleBooking->fNtupleBooking.set_name(name);
122 ntupleBooking->fNtupleBooking.set_title(titl 122 ntupleBooking->fNtupleBooking.set_title(title);
123 123
124 // Update related data 124 // Update related data
125 fLockFirstId = true; 125 fLockFirstId = true;
126 fCurrentNtupleId = ntupleBooking->fNtupleId; 126 fCurrentNtupleId = ntupleBooking->fNtupleId;
127 127
128 Message(kVL2, "create", "ntuple booking", 128 Message(kVL2, "create", "ntuple booking",
129 name + " ntupleId " + to_string(ntupleBoo 129 name + " ntupleId " + to_string(ntupleBooking->fNtupleId));
130 130
131 return fCurrentNtupleId; 131 return fCurrentNtupleId;
132 } 132 }
133 133
134 //____________________________________________ 134 //_____________________________________________________________________________
135 G4int G4NtupleBookingManager::CreateNtupleICol 135 G4int G4NtupleBookingManager::CreateNtupleIColumn(const G4String& name,
136 136 std::vector<int>* vector)
137 { 137 {
138 return CreateNtupleIColumn(GetCurrentNtupleI 138 return CreateNtupleIColumn(GetCurrentNtupleId(), name, vector);
139 } 139 }
140 140
141 //____________________________________________ 141 //_____________________________________________________________________________
142 G4int G4NtupleBookingManager::CreateNtupleFCol 142 G4int G4NtupleBookingManager::CreateNtupleFColumn(const G4String& name,
143 143 std::vector<float>* vector)
144 { 144 {
145 return CreateNtupleFColumn(GetCurrentNtupleI 145 return CreateNtupleFColumn(GetCurrentNtupleId(), name, vector);
146 } 146 }
147 147
148 //____________________________________________ 148 //_____________________________________________________________________________
149 G4int G4NtupleBookingManager::CreateNtupleDCol 149 G4int G4NtupleBookingManager::CreateNtupleDColumn(const G4String& name,
150 150 std::vector<double>* vector)
151 { 151 {
152 return CreateNtupleDColumn(GetCurrentNtupleI 152 return CreateNtupleDColumn(GetCurrentNtupleId(), name, vector);
153 } 153 }
154 154
155 //____________________________________________ 155 //_____________________________________________________________________________
156 G4int G4NtupleBookingManager::CreateNtupleSCol 156 G4int G4NtupleBookingManager::CreateNtupleSColumn(const G4String& name,
157 157 std::vector<std::string>* vector)
158 { 158 {
159 return CreateNtupleSColumn(GetCurrentNtupleI 159 return CreateNtupleSColumn(GetCurrentNtupleId(), name, vector);
160 } 160 }
161 161
162 //____________________________________________ 162 //_____________________________________________________________________________
163 G4NtupleBooking* G4NtupleBookingManager::Fini 163 G4NtupleBooking* G4NtupleBookingManager::FinishNtuple()
164 { 164 {
165 return FinishNtuple(GetCurrentNtupleId()); 165 return FinishNtuple(GetCurrentNtupleId());
166 } 166 }
167 167
168 //____________________________________________ 168 //_____________________________________________________________________________
169 G4int G4NtupleBookingManager::CreateNtupleICol 169 G4int G4NtupleBookingManager::CreateNtupleIColumn(
170 G4int ntupleId, const G4String& name, std::v 170 G4int ntupleId, const G4String& name, std::vector<int>* vector)
171 { 171 {
172 return CreateNtupleTColumn<int>(ntupleId, na 172 return CreateNtupleTColumn<int>(ntupleId, name, vector);
173 } 173 }
174 174
175 //____________________________________________ 175 //_____________________________________________________________________________
176 G4int G4NtupleBookingManager::CreateNtupleFCol 176 G4int G4NtupleBookingManager::CreateNtupleFColumn(
177 G4int ntupleId, const G4String& name, std::v 177 G4int ntupleId, const G4String& name, std::vector<float>* vector)
178 { 178 {
179 return CreateNtupleTColumn<float>(ntupleId, 179 return CreateNtupleTColumn<float>(ntupleId, name, vector);
180 } 180 }
181 181
182 //____________________________________________ 182 //_____________________________________________________________________________
183 G4int G4NtupleBookingManager::CreateNtupleDCol 183 G4int G4NtupleBookingManager::CreateNtupleDColumn(
184 G4int ntupleId, const G4String& name, std::v 184 G4int ntupleId, const G4String& name, std::vector<double>* vector)
185 { 185 {
186 return CreateNtupleTColumn<double>(ntupleId, 186 return CreateNtupleTColumn<double>(ntupleId, name, vector);
187 } 187 }
188 188
189 //____________________________________________ 189 //_____________________________________________________________________________
190 G4int G4NtupleBookingManager::CreateNtupleSCol 190 G4int G4NtupleBookingManager::CreateNtupleSColumn(
191 G4int ntupleId, const G4String& name, std::v 191 G4int ntupleId, const G4String& name, std::vector<std::string>* vector)
192 { 192 {
193 return CreateNtupleTColumn<std::string>(ntup 193 return CreateNtupleTColumn<std::string>(ntupleId, name, vector);
194 } 194 }
195 195
196 //____________________________________________ 196 //_____________________________________________________________________________
197 G4NtupleBooking* G4NtupleBookingManager::Fini 197 G4NtupleBooking* G4NtupleBookingManager::FinishNtuple(
198 G4int ntupleId) 198 G4int ntupleId)
199 { 199 {
200 // Nothing to be done for booking, 200 // Nothing to be done for booking,
201 return GetNtupleBookingInFunction(ntupleId, 201 return GetNtupleBookingInFunction(ntupleId, "FinishNtuple");
202 } 202 }
203 203
204 //____________________________________________ 204 //_____________________________________________________________________________
205 G4bool G4NtupleBookingManager::SetFirstNtupleC 205 G4bool G4NtupleBookingManager::SetFirstNtupleColumnId(G4int firstId)
206 { 206 {
207 if ( fLockFirstNtupleColumnId ) { 207 if ( fLockFirstNtupleColumnId ) {
208 Warn("Cannot set FirstNtupleColumnId as it 208 Warn("Cannot set FirstNtupleColumnId as its value was already used.",
209 fkClass, "SetFirstNtupleColumnId"); 209 fkClass, "SetFirstNtupleColumnId");
210 return false; 210 return false;
211 } 211 }
212 212
213 fFirstNtupleColumnId = firstId; 213 fFirstNtupleColumnId = firstId;
214 return true; 214 return true;
215 } 215 }
216 216
217 //____________________________________________ 217 //_____________________________________________________________________________
218 void G4NtupleBookingManager::SetActivation( 218 void G4NtupleBookingManager::SetActivation(
219 G4bool activation) 219 G4bool activation)
220 { 220 {
221 for ( auto ntupleBooking : fNtupleBookingVec 221 for ( auto ntupleBooking : fNtupleBookingVector ) {
222 ntupleBooking->fActivation = activation; 222 ntupleBooking->fActivation = activation;
223 } 223 }
224 } 224 }
225 225
226 //____________________________________________ 226 //_____________________________________________________________________________
227 void G4NtupleBookingManager::SetActivation( 227 void G4NtupleBookingManager::SetActivation(
228 G4int ntupleId, G4bool activation) 228 G4int ntupleId, G4bool activation)
229 { 229 {
230 auto ntupleBooking 230 auto ntupleBooking
231 = GetNtupleBookingInFunction(ntupleId, "Se 231 = GetNtupleBookingInFunction(ntupleId, "SetActivation");
232 if (ntupleBooking == nullptr) return; 232 if (ntupleBooking == nullptr) return;
233 233
234 ntupleBooking->fActivation = activation; 234 ntupleBooking->fActivation = activation;
235 } 235 }
236 236
237 //____________________________________________ 237 //_____________________________________________________________________________
238 G4bool G4NtupleBookingManager::GetActivation( 238 G4bool G4NtupleBookingManager::GetActivation(
239 G4int ntupleId) const 239 G4int ntupleId) const
240 { 240 {
241 auto ntupleBooking 241 auto ntupleBooking
242 = GetNtupleBookingInFunction(ntupleId, "Ge 242 = GetNtupleBookingInFunction(ntupleId, "GetActivation");
243 if (ntupleBooking == nullptr) return false; 243 if (ntupleBooking == nullptr) return false;
244 244
245 return ntupleBooking->fActivation; 245 return ntupleBooking->fActivation;
246 } 246 }
247 247
248 //____________________________________________ 248 //_____________________________________________________________________________
249 void G4NtupleBookingManager::SetFileName( 249 void G4NtupleBookingManager::SetFileName(
250 const G4String& fileName) 250 const G4String& fileName)
251 { 251 {
252 for ( auto ntupleBooking : fNtupleBookingVec 252 for ( auto ntupleBooking : fNtupleBookingVector ) {
253 ntupleBooking->fFileName = fileName; 253 ntupleBooking->fFileName = fileName;
254 } 254 }
255 } 255 }
256 256
257 //____________________________________________ 257 //_____________________________________________________________________________
258 void G4NtupleBookingManager::SetFileName( 258 void G4NtupleBookingManager::SetFileName(
259 G4int ntupleId, const G4String& fileName) 259 G4int ntupleId, const G4String& fileName)
260 { 260 {
261 auto ntupleBooking 261 auto ntupleBooking
262 = GetNtupleBookingInFunction(ntupleId, "Se 262 = GetNtupleBookingInFunction(ntupleId, "SetFileName");
263 if (ntupleBooking == nullptr) return; 263 if (ntupleBooking == nullptr) return;
264 264
265 // Do nothing if file name does not change 265 // Do nothing if file name does not change
266 if ( ntupleBooking->fFileName == fileName ) 266 if ( ntupleBooking->fFileName == fileName ) return;
267 267
268 auto ntupleFileName = fileName; 268 auto ntupleFileName = fileName;
269 auto extension = GetExtension(fileName); 269 auto extension = GetExtension(fileName);
270 if (extension.size() != 0u) { 270 if (extension.size() != 0u) {
271 // Check if valid extension (if present) 271 // Check if valid extension (if present)
272 auto output = G4Analysis::GetOutput(extens 272 auto output = G4Analysis::GetOutput(extension);
273 if ( output == G4AnalysisOutput::kNone ) { 273 if ( output == G4AnalysisOutput::kNone ) {
274 Warn("The file extension " + extension + 274 Warn("The file extension " + extension + " is not supported.",
275 fkClass, "SetFileName"); 275 fkClass, "SetFileName");
276 return; 276 return;
277 } 277 }
278 } 278 }
279 else { 279 else {
280 if (fFileType.size() != 0u) { 280 if (fFileType.size() != 0u) {
281 //add extension if missing and file type 281 //add extension if missing and file type is defined
282 ntupleFileName = fileName + "." + fFileT 282 ntupleFileName = fileName + "." + fFileType;
283 } 283 }
284 } 284 }
285 285
286 // Save the fileName in booking 286 // Save the fileName in booking
287 // If extension is still missing (possible w 287 // If extension is still missing (possible with generic manager),
288 // it will be completed with the default one 288 // it will be completed with the default one at OpenFile
289 ntupleBooking->fFileName = std::move(ntupleF << 289 ntupleBooking->fFileName = ntupleFileName;
290 } 290 }
291 291
292 //____________________________________________ 292 //_____________________________________________________________________________
293 G4String G4NtupleBookingManager::GetFileName( 293 G4String G4NtupleBookingManager::GetFileName(
294 G4int ntupleId) const 294 G4int ntupleId) const
295 { 295 {
296 auto ntupleBooking 296 auto ntupleBooking
297 = GetNtupleBookingInFunction(ntupleId, "Ge 297 = GetNtupleBookingInFunction(ntupleId, "GetFileName");
298 if (ntupleBooking == nullptr) return ""; 298 if (ntupleBooking == nullptr) return "";
299 299
300 return ntupleBooking->fFileName; 300 return ntupleBooking->fFileName;
301 } 301 }
302 302
303 //____________________________________________ 303 //_____________________________________________________________________________
304 void G4NtupleBookingManager::ClearData() 304 void G4NtupleBookingManager::ClearData()
305 { 305 {
306 for ( auto ntupleBooking : fNtupleBookingVec 306 for ( auto ntupleBooking : fNtupleBookingVector ) {
307 delete ntupleBooking; 307 delete ntupleBooking;
308 } 308 }
309 fNtupleBookingVector.clear(); 309 fNtupleBookingVector.clear();
310 fLockFirstNtupleColumnId = false; 310 fLockFirstNtupleColumnId = false;
311 311
312 Message(G4Analysis::kVL2, "clear", "ntupleBo 312 Message(G4Analysis::kVL2, "clear", "ntupleBookings");
313 } 313 }
314 314
315 //____________________________________________ 315 //_____________________________________________________________________________
316 G4bool G4NtupleBookingManager::Delete(G4int id 316 G4bool G4NtupleBookingManager::Delete(G4int id, G4bool keepSetting)
317 { 317 {
318 Message(kVL4, "delete", "ntuple booking ntup 318 Message(kVL4, "delete", "ntuple booking ntupleId " + to_string(id));
319 319
320 auto ntupleBooking = GetNtupleBookingInFunct 320 auto ntupleBooking = GetNtupleBookingInFunction(id, "Delete", true);
321 321
322 if (ntupleBooking == nullptr) return false; 322 if (ntupleBooking == nullptr) return false;
323 323
324 // Update ntuple booking 324 // Update ntuple booking
325 ntupleBooking->SetDeleted(true, keepSetting) 325 ntupleBooking->SetDeleted(true, keepSetting);
326 326
327 // Register freed Id 327 // Register freed Id
328 fFreeIds.insert(id); 328 fFreeIds.insert(id);
329 329
330 Message(G4Analysis::kVL2, "delete", "ntuple 330 Message(G4Analysis::kVL2, "delete", "ntuple booking ntupleId " + to_string(id));
331 331
332 return true; 332 return true;
333 } 333 }
334 334
335 //____________________________________________ 335 //_____________________________________________________________________________
336 G4bool G4NtupleBookingManager::List(std::ostre 336 G4bool G4NtupleBookingManager::List(std::ostream& output, G4bool onlyIfActive)
337 { 337 {
338 // Save current output stream formatting 338 // Save current output stream formatting
339 std::ios_base::fmtflags outputFlags(output.f 339 std::ios_base::fmtflags outputFlags(output.flags() );
340 340
341 // Define optimal field widths 341 // Define optimal field widths
342 size_t maxNameLength = 0; 342 size_t maxNameLength = 0;
343 size_t maxTitleLength = 0; 343 size_t maxTitleLength = 0;
344 // size_t maxEntries = 0; 344 // size_t maxEntries = 0;
345 size_t nofActive = 0; 345 size_t nofActive = 0;
346 for (auto g4NtupleBooking : fNtupleBookingVe 346 for (auto g4NtupleBooking : fNtupleBookingVector) {
347 const auto& ntupleBooking = g4NtupleBookin 347 const auto& ntupleBooking = g4NtupleBooking->fNtupleBooking;
348 if (ntupleBooking.name().length() > maxNam 348 if (ntupleBooking.name().length() > maxNameLength) {
349 maxNameLength = ntupleBooking.name().len 349 maxNameLength = ntupleBooking.name().length();
350 } 350 }
351 if (ntupleBooking.title().length() > maxTi 351 if (ntupleBooking.title().length() > maxTitleLength) {
352 maxTitleLength = ntupleBooking.title().l 352 maxTitleLength = ntupleBooking.title().length();
353 } 353 }
354 // if (ntuple->entries() > maxEntries) { 354 // if (ntuple->entries() > maxEntries) {
355 // maxEntries = ntuple->entries(); 355 // maxEntries = ntuple->entries();
356 // } 356 // }
357 if (g4NtupleBooking->fActivation) { 357 if (g4NtupleBooking->fActivation) {
358 ++nofActive; 358 ++nofActive;
359 } 359 }
360 } 360 }
361 size_t maxIdWidth = std::to_string(fNtupleBo 361 size_t maxIdWidth = std::to_string(fNtupleBookingVector.size() + GetFirstId()).length();
362 // update strings width for added double quo 362 // update strings width for added double quotas
363 maxNameLength += 2; 363 maxNameLength += 2;
364 maxTitleLength += 2; 364 maxTitleLength += 2;
365 365
366 // List general info 366 // List general info
367 output << "Ntuple: " << nofActive << " activ 367 output << "Ntuple: " << nofActive << " active ";
368 if (! onlyIfActive) { 368 if (! onlyIfActive) {
369 output << " of " << GetNofNtuples(true) < 369 output << " of " << GetNofNtuples(true) << " defined ";
370 } 370 }
371 output << G4endl; 371 output << G4endl;
372 372
373 // List objects 373 // List objects
374 G4int counter = 0; 374 G4int counter = 0;
375 for (auto g4NtupleBooking : fNtupleBookingVe 375 for (auto g4NtupleBooking : fNtupleBookingVector) {
376 const auto& ntupleBooking = g4NtupleBookin 376 const auto& ntupleBooking = g4NtupleBooking->fNtupleBooking;
377 377
378 // skip inactivated objcets 378 // skip inactivated objcets
379 if (fState.GetIsActivation() && onlyIfActi 379 if (fState.GetIsActivation() && onlyIfActive && (! g4NtupleBooking->fActivation)) continue;
380 380
381 // print selected info 381 // print selected info
382 output << " id: " << std::setw((G4int)ma 382 output << " id: " << std::setw((G4int)maxIdWidth) << GetFirstId() + counter++
383 << " name: \"" << std::setw((G4int)maxNa 383 << " name: \"" << std::setw((G4int)maxNameLength) << std::left << ntupleBooking.name() + "\""
384 << " title: \"" << std::setw((G4int)maxT 384 << " title: \"" << std::setw((G4int)maxTitleLength) << std::left << ntupleBooking.title() + "\"";
385 // << " entries: " << std::setw((G4int)m 385 // << " entries: " << std::setw((G4int)maxEntriesWidth) << ntuple->entries();
386 if (! onlyIfActive) { 386 if (! onlyIfActive) {
387 output << " active: " << std::boolalpha 387 output << " active: " << std::boolalpha << g4NtupleBooking->fActivation;
388 } 388 }
389 output << G4endl; 389 output << G4endl;
390 } 390 }
391 391
392 // Restore the output stream formatting 392 // Restore the output stream formatting
393 output.flags(outputFlags); 393 output.flags(outputFlags);
394 394
395 return output.good(); 395 return output.good();
396 } 396 }
397 397
398 // 398 //
399 // public methods 399 // public methods
400 // 400 //
401 401
402 //____________________________________________ 402 //_____________________________________________________________________________
403 void G4NtupleBookingManager::SetFileType(const 403 void G4NtupleBookingManager::SetFileType(const G4String& fileType)
404 { 404 {
405 // do nothing if file type is defined and is 405 // do nothing if file type is defined and is same
406 if ( fFileType == fileType ) return; 406 if ( fFileType == fileType ) return;
407 407
408 // save the type 408 // save the type
409 fFileType = fileType; 409 fFileType = fileType;
410 410
411 // Give warning and redefine file extension 411 // Give warning and redefine file extension in bookings
412 // with file name of different fileTypes 412 // with file name of different fileTypes
413 for ( auto ntupleBooking : fNtupleBookingVec 413 for ( auto ntupleBooking : fNtupleBookingVector ) {
414 if ((ntupleBooking->fFileName).size() == 0 414 if ((ntupleBooking->fFileName).size() == 0u) continue;
415 415
416 auto extension = GetExtension(ntupleBookin 416 auto extension = GetExtension(ntupleBooking->fFileName);
417 if ( fFileType == extension ) continue; 417 if ( fFileType == extension ) continue;
418 418
419 // multiple file types are not suported 419 // multiple file types are not suported
420 auto baseFileName = GetBaseName(ntupleBook 420 auto baseFileName = GetBaseName(ntupleBooking->fFileName);
421 auto ntupleFileName = baseFileName + "." + 421 auto ntupleFileName = baseFileName + "." + fFileType;
422 if (extension.size() != 0u) { 422 if (extension.size() != 0u) {
423 Warn("Writing ntuples in files of differ 423 Warn("Writing ntuples in files of different output types " +
424 fFileType + ", " + extension + " is 424 fFileType + ", " + extension + " is not supported.",
425 fkClass, "SetFileType"); 425 fkClass, "SetFileType");
426 } 426 }
427 427
428 // Save the info in ntuple description 428 // Save the info in ntuple description
429 ntupleBooking->fFileName = std::move(ntupl << 429 ntupleBooking->fFileName = ntupleFileName;
430 } 430 }
431 } 431 }
432 432
433 //____________________________________________ 433 //_____________________________________________________________________________
434 tools::ntuple_booking* G4NtupleBookingManager: 434 tools::ntuple_booking* G4NtupleBookingManager::GetNtuple(
435 G4bool warn, G4bool onlyIfActive) const 435 G4bool warn, G4bool onlyIfActive) const
436 { 436 {
437 return GetNtuple(fFirstId, warn, onlyIfActiv 437 return GetNtuple(fFirstId, warn, onlyIfActive);
438 } 438 }
439 439
440 //____________________________________________ 440 //_____________________________________________________________________________
441 tools::ntuple_booking* G4NtupleBookingManager: 441 tools::ntuple_booking* G4NtupleBookingManager::GetNtuple(
442 G4int ntupleId, G4bool warn, G4bool onlyIfAc 442 G4int ntupleId, G4bool warn, G4bool onlyIfActive) const
443 { 443 {
444 auto g4Booking = GetNtupleBookingInFunction( 444 auto g4Booking = GetNtupleBookingInFunction(ntupleId, "GetNtuple", warn);
445 445
446 if (g4Booking == nullptr) return nullptr; 446 if (g4Booking == nullptr) return nullptr;
447 447
448 if ( ( g4Booking->GetDeleted() ) || 448 if ( ( g4Booking->GetDeleted() ) ||
449 ( onlyIfActive && (! g4Booking->fActiva 449 ( onlyIfActive && (! g4Booking->fActivation) ) ) return nullptr;
450 450
451 return &(g4Booking->fNtupleBooking); 451 return &(g4Booking->fNtupleBooking);
452 } 452 }
453 453