| 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, 09/07/2013 (ivan 27 // Author: Ivana Hrivnacova, 09/07/2013 (ivana@ipno.in2p3.fr)
28 28
29 #include "G4VAnalysisReader.hh" 29 #include "G4VAnalysisReader.hh"
30 #include "G4AnalysisUtilities.hh" 30 #include "G4AnalysisUtilities.hh"
31 #include "G4HnManager.hh" 31 #include "G4HnManager.hh"
32 #include "G4VRNtupleManager.hh" 32 #include "G4VRNtupleManager.hh"
33 #include "G4VRFileManager.hh" 33 #include "G4VRFileManager.hh"
34 #include "G4Threading.hh" 34 #include "G4Threading.hh"
35 35
36 using namespace G4Analysis; 36 using namespace G4Analysis;
37 37
38 //____________________________________________ 38 //_____________________________________________________________________________
39 G4VAnalysisReader::G4VAnalysisReader(const G4S 39 G4VAnalysisReader::G4VAnalysisReader(const G4String& type)
40 : fState(type, ! G4Threading::IsWorkerThread( 40 : fState(type, ! G4Threading::IsWorkerThread())
41 {} 41 {}
42 42
43 //____________________________________________ 43 //_____________________________________________________________________________
44 G4VAnalysisReader::~G4VAnalysisReader() = defa 44 G4VAnalysisReader::~G4VAnalysisReader() = default;
45 45
46 // 46 //
47 // protected methods 47 // protected methods
48 // 48 //
49 49
50 //____________________________________________ 50 //_____________________________________________________________________________
51 void G4VAnalysisReader::SetH1Manager(G4VTBaseH 51 void G4VAnalysisReader::SetH1Manager(G4VTBaseHnManager<kDim1>* h1Manager)
52 { 52 {
53 fVH1Manager.reset(h1Manager); 53 fVH1Manager.reset(h1Manager);
54 } 54 }
55 55
56 //____________________________________________ 56 //_____________________________________________________________________________
57 void G4VAnalysisReader::SetH2Manager(G4VTBaseH 57 void G4VAnalysisReader::SetH2Manager(G4VTBaseHnManager<kDim2>* h2Manager)
58 { 58 {
59 fVH2Manager.reset(h2Manager); 59 fVH2Manager.reset(h2Manager);
60 } 60 }
61 61
62 //____________________________________________ 62 //_____________________________________________________________________________
63 void G4VAnalysisReader::SetH3Manager(G4VTBaseH 63 void G4VAnalysisReader::SetH3Manager(G4VTBaseHnManager<kDim3>* h3Manager)
64 { 64 {
65 fVH3Manager.reset(h3Manager); 65 fVH3Manager.reset(h3Manager);
66 } 66 }
67 67
68 //____________________________________________ 68 //_____________________________________________________________________________
69 void G4VAnalysisReader::SetP1Manager(G4VTBaseH 69 void G4VAnalysisReader::SetP1Manager(G4VTBaseHnManager<kDim2>* p1Manager)
70 { 70 {
71 fVP1Manager.reset(p1Manager); 71 fVP1Manager.reset(p1Manager);
72 } 72 }
73 73
74 //____________________________________________ 74 //_____________________________________________________________________________
75 void G4VAnalysisReader::SetP2Manager(G4VTBaseH 75 void G4VAnalysisReader::SetP2Manager(G4VTBaseHnManager<kDim3>* p2Manager)
76 { 76 {
77 fVP2Manager.reset(p2Manager); 77 fVP2Manager.reset(p2Manager);
78 } 78 }
79 79
80 //____________________________________________ 80 //_____________________________________________________________________________
81 void G4VAnalysisReader::SetNtupleManager(std:: 81 void G4VAnalysisReader::SetNtupleManager(std::shared_ptr<G4VRNtupleManager> ntupleManager)
82 { 82 {
83 fVNtupleManager = std::move(ntupleManager); 83 fVNtupleManager = std::move(ntupleManager);
84 } 84 }
85 85
86 //____________________________________________ 86 //_____________________________________________________________________________
87 void G4VAnalysisReader::SetFileManager(std::sh 87 void G4VAnalysisReader::SetFileManager(std::shared_ptr<G4VRFileManager> fileManager)
88 { 88 {
89 fVFileManager = std::move(fileManager); 89 fVFileManager = std::move(fileManager);
90 } 90 }
91 91
92 // 92 //
93 // public methods 93 // public methods
94 // 94 //
95 95
96 //____________________________________________ 96 //_____________________________________________________________________________
97 G4bool G4VAnalysisReader::CloseFiles(G4bool re 97 G4bool G4VAnalysisReader::CloseFiles(G4bool reset)
98 { 98 {
99 return CloseFilesImpl(reset); 99 return CloseFilesImpl(reset);
100 } 100 }
101 101
102 //____________________________________________ 102 //_____________________________________________________________________________
103 void G4VAnalysisReader::SetFileName(const G4St 103 void G4VAnalysisReader::SetFileName(const G4String& fileName)
104 { 104 {
105 fVFileManager->SetFileName(fileName); 105 fVFileManager->SetFileName(fileName);
106 } 106 }
107 107
108 //____________________________________________ 108 //_____________________________________________________________________________
109 G4String G4VAnalysisReader::GetFileName() cons 109 G4String G4VAnalysisReader::GetFileName() const
110 { 110 {
111 return fVFileManager->GetFileName(); 111 return fVFileManager->GetFileName();
112 } 112 }
113 113
114 //____________________________________________ 114 //_____________________________________________________________________________
115 G4int G4VAnalysisReader::ReadH1(const G4String 115 G4int G4VAnalysisReader::ReadH1(const G4String& h1Name,
116 const G4String 116 const G4String& fileName,
117 const G4String 117 const G4String& dirName)
118 { 118 {
119 if ( fileName != "" ) { 119 if ( fileName != "" ) {
120 return ReadH1Impl(h1Name, fileName, dirNam 120 return ReadH1Impl(h1Name, fileName, dirName, true);
121 } 121 }
122 if (fVFileManager->GetFileName() == "") { 122 if (fVFileManager->GetFileName() == "") {
123 Warn("Cannot get H1 " + h1Name + ". File n 123 Warn("Cannot get H1 " + h1Name + ". File name has to be set first.", fkClass, "ReadH1");
124 return kInvalidId; 124 return kInvalidId;
125 } 125 }
126 return ReadH1Impl(h1Name, fVFileManager->Get 126 return ReadH1Impl(h1Name, fVFileManager->GetFileName(), dirName, false);
127 } 127 }
128 128
129 //____________________________________________ 129 //_____________________________________________________________________________
130 G4int G4VAnalysisReader::ReadH2(const G4String 130 G4int G4VAnalysisReader::ReadH2(const G4String& h2Name,
131 const G4String 131 const G4String& fileName,
132 const G4String 132 const G4String& dirName)
133 { 133 {
134 if ( fileName != "" ) { 134 if ( fileName != "" ) {
135 return ReadH2Impl(h2Name, fileName, dirNam 135 return ReadH2Impl(h2Name, fileName, dirName, true);
136 } 136 }
137 if (fVFileManager->GetFileName() == "") { 137 if (fVFileManager->GetFileName() == "") {
138 Warn("Cannot get H2 " + h2Name + ". File n 138 Warn("Cannot get H2 " + h2Name + ". File name has to be set first.", fkClass, "ReadH2");
139 return kInvalidId; 139 return kInvalidId;
140 } 140 }
141 return ReadH2Impl(h2Name, fVFileManager->Get 141 return ReadH2Impl(h2Name, fVFileManager->GetFileName(), dirName, false);
142 } 142 }
143 143
144 //____________________________________________ 144 //_____________________________________________________________________________
145 G4int G4VAnalysisReader::ReadH3(const G4String 145 G4int G4VAnalysisReader::ReadH3(const G4String& h3Name,
146 const G4String 146 const G4String& fileName,
147 const G4String 147 const G4String& dirName)
148 { 148 {
149 if ( fileName != "" ) { 149 if ( fileName != "" ) {
150 return ReadH3Impl(h3Name, fileName, dirNam 150 return ReadH3Impl(h3Name, fileName, dirName, true);
151 } 151 }
152 if (fVFileManager->GetFileName() == "") { 152 if (fVFileManager->GetFileName() == "") {
153 Warn("Cannot get H3 " + h3Name + ". File n 153 Warn("Cannot get H3 " + h3Name + ". File name has to be set first.", fkClass, "ReadH3");
154 return kInvalidId; 154 return kInvalidId;
155 } 155 }
156 return ReadH3Impl(h3Name, fVFileManager->Get 156 return ReadH3Impl(h3Name, fVFileManager->GetFileName(), dirName, false);
157 } 157 }
158 158
159 //____________________________________________ 159 //_____________________________________________________________________________
160 G4int G4VAnalysisReader::ReadP1(const G4String 160 G4int G4VAnalysisReader::ReadP1(const G4String& p1Name,
161 const G4String 161 const G4String& fileName,
162 const G4String 162 const G4String& dirName)
163 { 163 {
164 if ( fileName != "" ) { 164 if ( fileName != "" ) {
165 return ReadP1Impl(p1Name, fileName, dirNam 165 return ReadP1Impl(p1Name, fileName, dirName, true);
166 } 166 }
167 if (fVFileManager->GetFileName() == "") { 167 if (fVFileManager->GetFileName() == "") {
168 Warn("Cannot get P1 " + p1Name + ". File n 168 Warn("Cannot get P1 " + p1Name + ". File name has to be set first.", fkClass, "ReadP1");
169 return kInvalidId; 169 return kInvalidId;
170 } 170 }
171 return ReadP1Impl(p1Name, fVFileManager->Get 171 return ReadP1Impl(p1Name, fVFileManager->GetFileName(), dirName, false);
172 } 172 }
173 173
174 //____________________________________________ 174 //_____________________________________________________________________________
175 G4int G4VAnalysisReader::ReadP2(const G4String 175 G4int G4VAnalysisReader::ReadP2(const G4String& p2Name,
176 const G4String 176 const G4String& fileName,
177 const G4String 177 const G4String& dirName)
178 { 178 {
179 if ( fileName != "" ) { 179 if ( fileName != "" ) {
180 return ReadP2Impl(p2Name, fileName, dirNam 180 return ReadP2Impl(p2Name, fileName, dirName, true);
181 } 181 }
182 if (fVFileManager->GetFileName() == "") { 182 if (fVFileManager->GetFileName() == "") {
183 Warn("Cannot get P2 " + p2Name + ". File n 183 Warn("Cannot get P2 " + p2Name + ". File name has to be set first.", fkClass, "ReadP2");
184 return kInvalidId; 184 return kInvalidId;
185 } 185 }
186 return ReadP2Impl(p2Name, fVFileManager->Get 186 return ReadP2Impl(p2Name, fVFileManager->GetFileName(), dirName, false);
187 } 187 }
188 188
189 //____________________________________________ 189 //_____________________________________________________________________________
190 G4bool G4VAnalysisReader::SetFirstHistoId(G4in 190 G4bool G4VAnalysisReader::SetFirstHistoId(G4int firstId)
191 { 191 {
192 auto result = true; 192 auto result = true;
193 193
194 result &= SetFirstH1Id(firstId); 194 result &= SetFirstH1Id(firstId);
195 result &= SetFirstH2Id(firstId); 195 result &= SetFirstH2Id(firstId);
196 result &= SetFirstH3Id(firstId); 196 result &= SetFirstH3Id(firstId);
197 197
198 return result; 198 return result;
199 } 199 }
200 200
201 //____________________________________________ 201 //_____________________________________________________________________________
202 G4bool G4VAnalysisReader::SetFirstH1Id(G4int f 202 G4bool G4VAnalysisReader::SetFirstH1Id(G4int firstId)
203 { 203 {
204 return fVH1Manager->GetHnManager()->SetFirst 204 return fVH1Manager->GetHnManager()->SetFirstId(firstId);
205 } 205 }
206 206
207 //____________________________________________ 207 //_____________________________________________________________________________
208 G4bool G4VAnalysisReader::SetFirstH2Id(G4int f 208 G4bool G4VAnalysisReader::SetFirstH2Id(G4int firstId)
209 { 209 {
210 return fVH2Manager->GetHnManager()->SetFirst 210 return fVH2Manager->GetHnManager()->SetFirstId(firstId);
211 } 211 }
212 212
213 //____________________________________________ 213 //_____________________________________________________________________________
214 G4bool G4VAnalysisReader::SetFirstH3Id(G4int f 214 G4bool G4VAnalysisReader::SetFirstH3Id(G4int firstId)
215 { 215 {
216 return fVH3Manager->GetHnManager()->SetFirst 216 return fVH3Manager->GetHnManager()->SetFirstId(firstId);
217 } 217 }
218 218
219 //____________________________________________ 219 //_____________________________________________________________________________
220 G4bool G4VAnalysisReader::SetFirstProfileId(G4 220 G4bool G4VAnalysisReader::SetFirstProfileId(G4int firstId)
221 { 221 {
222 auto result = true; 222 auto result = true;
223 223
224 result &= SetFirstP1Id(firstId); 224 result &= SetFirstP1Id(firstId);
225 result &= SetFirstP2Id(firstId); 225 result &= SetFirstP2Id(firstId);
226 226
227 return result; 227 return result;
228 } 228 }
229 229
230 //____________________________________________ 230 //_____________________________________________________________________________
231 G4bool G4VAnalysisReader::SetFirstP1Id(G4int f 231 G4bool G4VAnalysisReader::SetFirstP1Id(G4int firstId)
232 { 232 {
233 return fVP1Manager->GetHnManager()->SetFirst 233 return fVP1Manager->GetHnManager()->SetFirstId(firstId);
234 } 234 }
235 235
236 //____________________________________________ 236 //_____________________________________________________________________________
237 G4bool G4VAnalysisReader::SetFirstP2Id(G4int f 237 G4bool G4VAnalysisReader::SetFirstP2Id(G4int firstId)
238 { 238 {
239 return fVP2Manager->GetHnManager()->SetFirst 239 return fVP2Manager->GetHnManager()->SetFirstId(firstId);
240 } 240 }
241 241
242 //____________________________________________ 242 //_____________________________________________________________________________
243 G4bool G4VAnalysisReader::SetFirstNtupleId(G4i 243 G4bool G4VAnalysisReader::SetFirstNtupleId(G4int firstId)
244 { 244 {
245 return fVNtupleManager->SetFirstId(firstId); 245 return fVNtupleManager->SetFirstId(firstId);
246 } 246 }
247 247
248 //____________________________________________ 248 //_____________________________________________________________________________
249 G4int G4VAnalysisReader::GetNtuple(const G4Str 249 G4int G4VAnalysisReader::GetNtuple(const G4String& ntupleName,
250 const G4Str 250 const G4String& fileName,
251 const G4Str 251 const G4String& dirName)
252 { 252 {
253 if ( fileName != "" ) { 253 if ( fileName != "" ) {
254 return fVNtupleManager->ReadNtupleImpl(ntu 254 return fVNtupleManager->ReadNtupleImpl(ntupleName, fileName, dirName, true);
255 } 255 }
256 // Check if fileName was set 256 // Check if fileName was set
257 if (fVFileManager->GetFileName() == "") { 257 if (fVFileManager->GetFileName() == "") {
258 Warn("Cannot read Ntuple " + ntupleName += 258 Warn("Cannot read Ntuple " + ntupleName += ". File name has to be set first.", fkClass,
259 "ReadNtuple"); 259 "ReadNtuple");
260 return kInvalidId; 260 return kInvalidId;
261 } 261 }
262 return fVNtupleManager->ReadNtupleImpl(ntupl 262 return fVNtupleManager->ReadNtupleImpl(ntupleName, fVFileManager->GetFileName(), dirName, false);
263 } 263 }
264 264
265 //____________________________________________ 265 //_____________________________________________________________________________
266 G4bool G4VAnalysisReader::SetNtupleIColumn(con 266 G4bool G4VAnalysisReader::SetNtupleIColumn(const G4String& columnName,
267 G4 267 G4int& value)
268 { 268 {
269 return fVNtupleManager->SetNtupleIColumn(col 269 return fVNtupleManager->SetNtupleIColumn(columnName, value);
270 } 270 }
271 271
272 //____________________________________________ 272 //_____________________________________________________________________________
273 G4bool G4VAnalysisReader::SetNtupleFColumn(con 273 G4bool G4VAnalysisReader::SetNtupleFColumn(const G4String& columnName,
274 G4 274 G4float& value)
275 { 275 {
276 return fVNtupleManager->SetNtupleFColumn(col 276 return fVNtupleManager->SetNtupleFColumn(columnName, value);
277 } 277 }
278 278
279 //____________________________________________ 279 //_____________________________________________________________________________
280 G4bool G4VAnalysisReader::SetNtupleDColumn(con 280 G4bool G4VAnalysisReader::SetNtupleDColumn(const G4String& columnName,
281 G4 281 G4double& value)
282 { 282 {
283 return fVNtupleManager->SetNtupleDColumn(col 283 return fVNtupleManager->SetNtupleDColumn(columnName, value);
284 } 284 }
285 285
286 //____________________________________________ 286 //_____________________________________________________________________________
287 G4bool G4VAnalysisReader::SetNtupleSColumn(con 287 G4bool G4VAnalysisReader::SetNtupleSColumn(const G4String& columnName,
288 G4 288 G4String& value)
289 { 289 {
290 return fVNtupleManager->SetNtupleSColumn(col 290 return fVNtupleManager->SetNtupleSColumn(columnName, value);
291 } 291 }
292 292
293 //____________________________________________ 293 //_____________________________________________________________________________
294 G4bool G4VAnalysisReader::SetNtupleIColumn(con 294 G4bool G4VAnalysisReader::SetNtupleIColumn(const G4String& columnName,
295 st 295 std::vector<int>& vector)
296 { 296 {
297 return fVNtupleManager->SetNtupleIColumn(col 297 return fVNtupleManager->SetNtupleIColumn(columnName, vector);
298 } 298 }
299 299
300 //____________________________________________ 300 //_____________________________________________________________________________
301 G4bool G4VAnalysisReader::SetNtupleFColumn(con 301 G4bool G4VAnalysisReader::SetNtupleFColumn(const G4String& columnName,
302 st 302 std::vector<float>& vector)
303 { 303 {
304 return fVNtupleManager->SetNtupleFColumn(col 304 return fVNtupleManager->SetNtupleFColumn(columnName, vector);
305 } 305 }
306 306
307 //____________________________________________ 307 //_____________________________________________________________________________
308 G4bool G4VAnalysisReader::SetNtupleDColumn(con 308 G4bool G4VAnalysisReader::SetNtupleDColumn(const G4String& columnName,
309 st 309 std::vector<double>& vector)
310 { 310 {
311 return fVNtupleManager->SetNtupleDColumn(col 311 return fVNtupleManager->SetNtupleDColumn(columnName, vector);
312 } 312 }
313 313
314 //____________________________________________ 314 //_____________________________________________________________________________
315 G4bool G4VAnalysisReader::SetNtupleSColumn(con 315 G4bool G4VAnalysisReader::SetNtupleSColumn(const G4String& columnName,
316 st 316 std::vector<std::string>& vector)
317 { 317 {
318 return fVNtupleManager->SetNtupleSColumn(col 318 return fVNtupleManager->SetNtupleSColumn(columnName, vector);
319 } 319 }
320 320
321 //____________________________________________ 321 //_____________________________________________________________________________
322 G4bool G4VAnalysisReader::SetNtupleIColumn(G4i 322 G4bool G4VAnalysisReader::SetNtupleIColumn(G4int ntupleId,
323 co 323 const G4String& columnName,
324 G4 324 G4int& value)
325 { 325 {
326 return fVNtupleManager->SetNtupleIColumn(ntu 326 return fVNtupleManager->SetNtupleIColumn(ntupleId, columnName, value);
327 } 327 }
328 328
329 //____________________________________________ 329 //_____________________________________________________________________________
330 G4bool G4VAnalysisReader::SetNtupleFColumn(G4i 330 G4bool G4VAnalysisReader::SetNtupleFColumn(G4int ntupleId,
331 co 331 const G4String& columnName,
332 G4 332 G4float& value)
333 { 333 {
334 return fVNtupleManager->SetNtupleFColumn(ntu 334 return fVNtupleManager->SetNtupleFColumn(ntupleId, columnName, value);
335 } 335 }
336 336
337 //____________________________________________ 337 //_____________________________________________________________________________
338 G4bool G4VAnalysisReader::SetNtupleDColumn(G4i 338 G4bool G4VAnalysisReader::SetNtupleDColumn(G4int ntupleId,
339 co 339 const G4String& columnName,
340 G4 340 G4double& value)
341 { 341 {
342 return fVNtupleManager->SetNtupleDColumn(ntu 342 return fVNtupleManager->SetNtupleDColumn(ntupleId, columnName, value);
343 } 343 }
344 344
345 //____________________________________________ 345 //_____________________________________________________________________________
346 G4bool G4VAnalysisReader::SetNtupleSColumn(G4i 346 G4bool G4VAnalysisReader::SetNtupleSColumn(G4int ntupleId,
347 co 347 const G4String& columnName,
348 G4 348 G4String& value)
349 { 349 {
350 return fVNtupleManager->SetNtupleSColumn(ntu 350 return fVNtupleManager->SetNtupleSColumn(ntupleId, columnName, value);
351 } 351 }
352 352
353 //____________________________________________ 353 //_____________________________________________________________________________
354 G4bool G4VAnalysisReader::SetNtupleIColumn(G4i 354 G4bool G4VAnalysisReader::SetNtupleIColumn(G4int ntupleId,
355 co 355 const G4String& columnName,
356 st 356 std::vector<int>& vector)
357 { 357 {
358 return fVNtupleManager->SetNtupleIColumn(ntu 358 return fVNtupleManager->SetNtupleIColumn(ntupleId, columnName, vector);
359 } 359 }
360 360
361 //____________________________________________ 361 //_____________________________________________________________________________
362 G4bool G4VAnalysisReader::SetNtupleFColumn(G4i 362 G4bool G4VAnalysisReader::SetNtupleFColumn(G4int ntupleId,
363 co 363 const G4String& columnName,
364 st 364 std::vector<float>& vector)
365 { 365 {
366 return fVNtupleManager->SetNtupleFColumn(ntu 366 return fVNtupleManager->SetNtupleFColumn(ntupleId, columnName, vector);
367 } 367 }
368 368
369 //____________________________________________ 369 //_____________________________________________________________________________
370 G4bool G4VAnalysisReader::SetNtupleDColumn(G4i 370 G4bool G4VAnalysisReader::SetNtupleDColumn(G4int ntupleId,
371 co 371 const G4String& columnName,
372 st 372 std::vector<double>& vector)
373 { 373 {
374 return fVNtupleManager->SetNtupleDColumn(ntu 374 return fVNtupleManager->SetNtupleDColumn(ntupleId, columnName, vector);
375 } 375 }
376 376
377 //____________________________________________ 377 //_____________________________________________________________________________
378 G4bool G4VAnalysisReader::SetNtupleSColumn(G4i 378 G4bool G4VAnalysisReader::SetNtupleSColumn(G4int ntupleId,
379 co 379 const G4String& columnName,
380 st 380 std::vector<std::string>& vector)
381 { 381 {
382 return fVNtupleManager->SetNtupleSColumn(ntu 382 return fVNtupleManager->SetNtupleSColumn(ntupleId, columnName, vector);
383 } 383 }
384 384
385 //____________________________________________ 385 //_____________________________________________________________________________
386 G4bool G4VAnalysisReader::GetNtupleRow() 386 G4bool G4VAnalysisReader::GetNtupleRow()
387 { 387 {
388 return fVNtupleManager->GetNtupleRow(); 388 return fVNtupleManager->GetNtupleRow();
389 } 389 }
390 390
391 391
392 //____________________________________________ 392 //_____________________________________________________________________________
393 G4bool G4VAnalysisReader::GetNtupleRow(G4int n 393 G4bool G4VAnalysisReader::GetNtupleRow(G4int ntupleId)
394 { 394 {
395 return fVNtupleManager->GetNtupleRow(ntupleI 395 return fVNtupleManager->GetNtupleRow(ntupleId);
396 } 396 }
397 397
398 //____________________________________________ 398 //_____________________________________________________________________________
399 G4int G4VAnalysisReader::GetNofH1s(G4bool only 399 G4int G4VAnalysisReader::GetNofH1s(G4bool onlyIfExist) const
400 { 400 {
401 return fVH1Manager->GetNofHns(onlyIfExist); 401 return fVH1Manager->GetNofHns(onlyIfExist);
402 } 402 }
403 403
404 //____________________________________________ 404 //_____________________________________________________________________________
405 G4int G4VAnalysisReader::GetNofH2s(G4bool only 405 G4int G4VAnalysisReader::GetNofH2s(G4bool onlyIfExist) const
406 { 406 {
407 return fVH2Manager->GetNofHns(onlyIfExist); 407 return fVH2Manager->GetNofHns(onlyIfExist);
408 } 408 }
409 409
410 //____________________________________________ 410 //_____________________________________________________________________________
411 G4int G4VAnalysisReader::GetNofH3s(G4bool only 411 G4int G4VAnalysisReader::GetNofH3s(G4bool onlyIfExist) const
412 { 412 {
413 return fVH3Manager->GetNofHns(onlyIfExist); 413 return fVH3Manager->GetNofHns(onlyIfExist);
414 } 414 }
415 415
416 //____________________________________________ 416 //_____________________________________________________________________________
417 G4int G4VAnalysisReader::GetNofP1s(G4bool only 417 G4int G4VAnalysisReader::GetNofP1s(G4bool onlyIfExist) const
418 { 418 {
419 return fVP1Manager->GetNofHns(onlyIfExist); 419 return fVP1Manager->GetNofHns(onlyIfExist);
420 } 420 }
421 421
422 //____________________________________________ 422 //_____________________________________________________________________________
423 G4int G4VAnalysisReader::GetNofP2s(G4bool only 423 G4int G4VAnalysisReader::GetNofP2s(G4bool onlyIfExist) const
424 { 424 {
425 return fVP2Manager->GetNofHns(onlyIfExist); 425 return fVP2Manager->GetNofHns(onlyIfExist);
426 } 426 }
427 427
428 //____________________________________________ 428 //_____________________________________________________________________________
429 G4int G4VAnalysisReader::GetNofNtuples() const 429 G4int G4VAnalysisReader::GetNofNtuples() const
430 { 430 {
431 return fVNtupleManager->GetNofNtuples(); 431 return fVNtupleManager->GetNofNtuples();
432 } 432 }
433 433
434 // GetH1Id(), GetH2Id in .icc 434 // GetH1Id(), GetH2Id in .icc
435 435
436 // Access methods in .icc 436 // Access methods in .icc
437 437
438 //____________________________________________ 438 //_____________________________________________________________________________
439 void G4VAnalysisReader::SetVerboseLevel(G4int 439 void G4VAnalysisReader::SetVerboseLevel(G4int verboseLevel)
440 { 440 {
441 fState.SetVerboseLevel(verboseLevel); 441 fState.SetVerboseLevel(verboseLevel);
442 } 442 }
443 443
444 // GetVerboseLevel() in .icc 444 // GetVerboseLevel() in .icc
445 445