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