| 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 // $Id: G4VAnalysisManager.hh 70604 2013-06-03 11:27:06Z ihrivnac $
26 27
27 #include "G4HnManager.hh" 28 #include "G4HnManager.hh"
28 #include "G4NtupleBookingManager.hh" << 29 #include "G4VH1Manager.hh"
>> 30 #include "G4VH2Manager.hh"
29 #include "G4VNtupleManager.hh" 31 #include "G4VNtupleManager.hh"
30 #include "G4VFileManager.hh" 32 #include "G4VFileManager.hh"
31 33
32 //____________________________________________ 34 //_____________________________________________________________________________
33 inline << 35 inline
34 void G4VAnalysisManager::Message( <<
35 G4int level, const G4String& action, const G <<
36 const G4String& objectName, G4bool success) <<
37 { <<
38 fState.Message(level, action, objectType, ob <<
39 } <<
40 <<
41 //____________________________________________ <<
42 inline <<
43 G4bool G4VAnalysisManager::FillH1(G4int id, G4 36 G4bool G4VAnalysisManager::FillH1(G4int id, G4double value, G4double weight)
44 { 37 {
45 return fVH1Manager->Fill(id, {{value}}, weig << 38 return fVH1Manager->FillH1(id, value, weight);
46 } <<
47 <<
48 //____________________________________________ <<
49 inline <<
50 G4bool G4VAnalysisManager::FillH2(G4int id, <<
51 G4double xva <<
52 G4double wei <<
53 { <<
54 return fVH2Manager->Fill(id, {{xvalue, yvalu <<
55 } <<
56 <<
57 //____________________________________________ <<
58 inline <<
59 G4bool G4VAnalysisManager::FillH3(G4int id, <<
60 G4double xvalue, <<
61 G4double weight) <<
62 { <<
63 return fVH3Manager->Fill(id, { {xvalue, yval <<
64 } <<
65 <<
66 //____________________________________________ <<
67 inline <<
68 G4bool G4VAnalysisManager::FillP1(G4int id, G4 <<
69 G4double wei <<
70 { <<
71 return fVP1Manager->Fill(id, {{xvalue, yvalu <<
72 } 39 }
73 40
74 //____________________________________________ 41 //_____________________________________________________________________________
75 inline << 42 inline
76 G4bool G4VAnalysisManager::FillP2(G4int id, << 43 G4bool G4VAnalysisManager::FillH2(G4int id,
77 G4double xvalue, << 44 G4double xvalue, G4double yvalue,
78 G4double weight) << 45 G4double weight)
79 { 46 {
80 return fVP2Manager->Fill(id, {{xvalue, yvalu << 47 return fVH2Manager->FillH2(id, xvalue, yvalue, weight);
81 } 48 }
82 49
83 //____________________________________________ 50 //_____________________________________________________________________________
84 inline << 51 inline
85 G4bool G4VAnalysisManager::FillNtupleIColumn(G 52 G4bool G4VAnalysisManager::FillNtupleIColumn(G4int columnId, G4int value)
86 { 53 {
87 return fVNtupleManager->FillNtupleIColumn(co 54 return fVNtupleManager->FillNtupleIColumn(columnId, value);
88 } << 55 }
89 56
90 //____________________________________________ 57 //_____________________________________________________________________________
91 inline << 58 inline
92 G4bool G4VAnalysisManager::FillNtupleFColumn(G 59 G4bool G4VAnalysisManager::FillNtupleFColumn(G4int columnId, G4float value)
93 { 60 {
94 return fVNtupleManager->FillNtupleFColumn(co 61 return fVNtupleManager->FillNtupleFColumn(columnId, value);
95 } << 62 }
96 63
97 //____________________________________________ 64 //_____________________________________________________________________________
98 inline << 65 inline
99 G4bool G4VAnalysisManager::FillNtupleDColumn(G 66 G4bool G4VAnalysisManager::FillNtupleDColumn(G4int columnId, G4double value)
100 { 67 {
101 return fVNtupleManager->FillNtupleDColumn(co 68 return fVNtupleManager->FillNtupleDColumn(columnId, value);
102 } << 69 }
103 70
104 //____________________________________________ 71 //_____________________________________________________________________________
105 inline << 72 inline
106 G4bool G4VAnalysisManager::FillNtupleSColumn(G <<
107 { <<
108 return fVNtupleManager->FillNtupleSColumn(co <<
109 } <<
110 <<
111 //____________________________________________ <<
112 inline <<
113 G4bool G4VAnalysisManager::AddNtupleRow() 73 G4bool G4VAnalysisManager::AddNtupleRow()
114 { << 74 {
115 return fVNtupleManager->AddNtupleRow(); 75 return fVNtupleManager->AddNtupleRow();
116 } << 76 }
117 77
118 //____________________________________________ 78 //_____________________________________________________________________________
119 inline << 79 inline
120 G4bool G4VAnalysisManager::FillNtupleIColumn(G << 80 G4bool G4VAnalysisManager::FillNtupleIColumn(G4int ntupleId, G4int columnId,
121 G4 << 81 G4int value)
122 { 82 {
123 return fVNtupleManager->FillNtupleIColumn(nt 83 return fVNtupleManager->FillNtupleIColumn(ntupleId, columnId, value);
124 } << 84 }
125 //____________________________________________ 85 //_____________________________________________________________________________
126 inline << 86 inline
127 G4bool G4VAnalysisManager::FillNtupleFColumn(G << 87 G4bool G4VAnalysisManager::FillNtupleFColumn(G4int ntupleId, G4int columnId,
128 G4 << 88 G4float value)
129 { 89 {
130 return fVNtupleManager->FillNtupleFColumn(nt 90 return fVNtupleManager->FillNtupleFColumn(ntupleId, columnId, value);
131 } << 91 }
132 92
133 //____________________________________________ 93 //_____________________________________________________________________________
134 inline << 94 inline
135 G4bool G4VAnalysisManager::FillNtupleDColumn(G << 95 G4bool G4VAnalysisManager::FillNtupleDColumn(G4int ntupleId, G4int columnId,
136 G4 << 96 G4double value)
137 { 97 {
138 return fVNtupleManager->FillNtupleDColumn(nt 98 return fVNtupleManager->FillNtupleDColumn(ntupleId, columnId, value);
139 } << 99 }
140 100
141 //____________________________________________ 101 //_____________________________________________________________________________
142 inline << 102 inline
143 G4bool G4VAnalysisManager::FillNtupleSColumn(G <<
144 co <<
145 { <<
146 return fVNtupleManager->FillNtupleSColumn(nt <<
147 } <<
148 <<
149 //____________________________________________ <<
150 inline <<
151 G4bool G4VAnalysisManager::AddNtupleRow(G4int 103 G4bool G4VAnalysisManager::AddNtupleRow(G4int ntupleId)
152 { << 104 {
153 return fVNtupleManager->AddNtupleRow(ntupleI 105 return fVNtupleManager->AddNtupleRow(ntupleId);
154 } 106 }
155 107
156 //____________________________________________ 108 //_____________________________________________________________________________
157 inline << 109 inline
158 G4bool G4VAnalysisManager::GetActivation() con << 110 G4bool G4VAnalysisManager::GetActivation() const
159 { 111 {
160 return fState.GetIsActivation(); 112 return fState.GetIsActivation();
161 } << 113 }
162 114
163 //____________________________________________ 115 //_____________________________________________________________________________
164 inline << 116 inline
165 G4int G4VAnalysisManager::GetH1Id(const G4Stri 117 G4int G4VAnalysisManager::GetH1Id(const G4String& name, G4bool warn) const
166 { 118 {
167 return fVH1Manager->GetId(name, warn); << 119 return fVH1Manager->GetH1Id(name, warn);
168 } << 120 }
169 121
170 //____________________________________________ 122 //_____________________________________________________________________________
171 inline << 123 inline
172 G4int G4VAnalysisManager::GetH2Id(const G4Stri 124 G4int G4VAnalysisManager::GetH2Id(const G4String& name, G4bool warn) const
173 { 125 {
174 return fVH2Manager->GetId(name, warn); << 126 return fVH2Manager->GetH2Id(name, warn);
175 } << 127 }
176 <<
177 //____________________________________________ <<
178 inline <<
179 G4int G4VAnalysisManager::GetH3Id(const G4Stri <<
180 { <<
181 return fVH3Manager->GetId(name, warn); <<
182 } <<
183 128
184 //____________________________________________ 129 //_____________________________________________________________________________
185 inline << 130 inline
186 G4int G4VAnalysisManager::GetP1Id(const G4Stri <<
187 { <<
188 return fVP1Manager->GetId(name, warn); <<
189 } <<
190 <<
191 //____________________________________________ <<
192 inline <<
193 G4int G4VAnalysisManager::GetP2Id(const G4Stri <<
194 { <<
195 return fVP2Manager->GetId(name, warn); <<
196 } <<
197 <<
198 //____________________________________________ <<
199 inline <<
200 G4int G4VAnalysisManager::GetH1Nbins(G4int id) 131 G4int G4VAnalysisManager::GetH1Nbins(G4int id) const
201 { 132 {
202 return fVH1Manager->GetNbins(G4Analysis::kX, << 133 return fVH1Manager->GetH1Nbins(id);
203 } << 134 }
204 135
205 //____________________________________________ 136 //_____________________________________________________________________________
206 inline << 137 inline
207 G4double G4VAnalysisManager::GetH1Xmin(G4int i 138 G4double G4VAnalysisManager::GetH1Xmin(G4int id) const
208 { 139 {
209 // Returns xmin value with applied unit and hi 140 // Returns xmin value with applied unit and histogram function
210 141
211 return fVH1Manager->GetMinValue(G4Analysis:: << 142 return fVH1Manager->GetH1Xmin(id);
212 } << 143 }
213 144
214 //____________________________________________ 145 //_____________________________________________________________________________
215 inline << 146 inline
216 G4double G4VAnalysisManager::GetH1Xmax(G4int i 147 G4double G4VAnalysisManager::GetH1Xmax(G4int id) const
217 { 148 {
218 return fVH1Manager->GetMaxValue(G4Analysis:: << 149 return fVH1Manager->GetH1Xmax(id);
219 } << 150 }
220 151
221 //____________________________________________ 152 //_____________________________________________________________________________
222 inline << 153 inline
223 G4double G4VAnalysisManager::GetH1Width(G4int 154 G4double G4VAnalysisManager::GetH1Width(G4int id) const
224 { 155 {
225 return fVH1Manager->GetWidth(G4Analysis::kX, << 156 return fVH1Manager->GetH1Width(id);
226 } << 157 }
227 158
228 //____________________________________________ 159 //_____________________________________________________________________________
229 inline << 160 inline
230 G4int G4VAnalysisManager::GetH2Nxbins(G4int id 161 G4int G4VAnalysisManager::GetH2Nxbins(G4int id) const
231 { << 162 {
232 return fVH2Manager->GetNbins(G4Analysis::kX, << 163 return fVH2Manager->GetH2Nxbins(id);
233 } << 164 }
234 165
235 //____________________________________________ 166 //_____________________________________________________________________________
236 inline << 167 inline
237 G4double G4VAnalysisManager::GetH2Xmin(G4int i 168 G4double G4VAnalysisManager::GetH2Xmin(G4int id) const
238 { 169 {
239 // Returns xmin value with applied unit and hi 170 // Returns xmin value with applied unit and histogram function
240 171
241 return fVH2Manager->GetMinValue(G4Analysis:: << 172 return fVH2Manager->GetH2Xmin(id);
242 } << 173 }
243 174
244 //____________________________________________ 175 //_____________________________________________________________________________
245 inline << 176 inline
246 G4double G4VAnalysisManager::GetH2Xmax(G4int i 177 G4double G4VAnalysisManager::GetH2Xmax(G4int id) const
247 { 178 {
248 return fVH2Manager->GetMaxValue(G4Analysis:: << 179 return fVH2Manager->GetH2Xmax(id);
249 } << 180 }
250 181
251 //____________________________________________ 182 //_____________________________________________________________________________
252 inline << 183 inline
253 G4double G4VAnalysisManager::GetH2XWidth(G4int 184 G4double G4VAnalysisManager::GetH2XWidth(G4int id) const
254 { 185 {
255 return fVH2Manager->GetWidth(G4Analysis::kX, << 186 return fVH2Manager->GetH2XWidth(id);
256 } << 187 }
257 188
258 //____________________________________________ 189 //_____________________________________________________________________________
259 inline << 190 inline
260 G4int G4VAnalysisManager::GetH2Nybins(G4int id 191 G4int G4VAnalysisManager::GetH2Nybins(G4int id) const
261 { 192 {
262 return fVH2Manager->GetNbins(G4Analysis::kY, << 193 return fVH2Manager->GetH2Nybins(id);
263 } << 194 }
264 195
265 //____________________________________________ 196 //_____________________________________________________________________________
266 inline << 197 inline
267 G4double G4VAnalysisManager::GetH2Ymin(G4int i 198 G4double G4VAnalysisManager::GetH2Ymin(G4int id) const
268 { 199 {
269 // Returns xmin value with applied unit and hi 200 // Returns xmin value with applied unit and histogram function
270 201
271 return fVH2Manager->GetMinValue(G4Analysis:: << 202 return fVH2Manager->GetH2Ymin(id);
272 } << 203 }
273 204
274 //____________________________________________ 205 //_____________________________________________________________________________
275 inline << 206 inline
276 G4double G4VAnalysisManager::GetH2Ymax(G4int i 207 G4double G4VAnalysisManager::GetH2Ymax(G4int id) const
277 { 208 {
278 return fVH2Manager->GetMaxValue(G4Analysis:: << 209 return fVH2Manager->GetH2Ymax(id);
279 } << 210 }
280 211
281 //____________________________________________ 212 //_____________________________________________________________________________
282 inline << 213 inline
283 G4double G4VAnalysisManager::GetH2YWidth(G4int 214 G4double G4VAnalysisManager::GetH2YWidth(G4int id) const
284 { 215 {
285 return fVH2Manager->GetWidth(G4Analysis::kY, << 216 return fVH2Manager->GetH2YWidth(id);
286 } << 217 }
287 <<
288 //____________________________________________ <<
289 inline <<
290 G4int G4VAnalysisManager::GetH3Nxbins(G4int id <<
291 { <<
292 return fVH3Manager->GetNbins(G4Analysis::kX, <<
293 } <<
294 <<
295 //____________________________________________ <<
296 inline <<
297 G4double G4VAnalysisManager::GetH3Xmin(G4int i <<
298 { <<
299 // Returns xmin value with applied unit and hi <<
300 <<
301 return fVH3Manager->GetMinValue(G4Analysis:: <<
302 } <<
303 <<
304 //____________________________________________ <<
305 inline <<
306 G4double G4VAnalysisManager::GetH3Xmax(G4int i <<
307 { <<
308 return fVH3Manager->GetMaxValue(G4Analysis:: <<
309 } <<
310 <<
311 //____________________________________________ <<
312 inline <<
313 G4double G4VAnalysisManager::GetH3XWidth(G4int <<
314 { <<
315 return fVH3Manager->GetWidth(G4Analysis::kX, <<
316 } <<
317 <<
318 //____________________________________________ <<
319 inline <<
320 G4int G4VAnalysisManager::GetH3Nybins(G4int id <<
321 { <<
322 return fVH3Manager->GetNbins(G4Analysis::kY, <<
323 } <<
324 <<
325 //____________________________________________ <<
326 inline <<
327 G4double G4VAnalysisManager::GetH3Ymin(G4int i <<
328 { <<
329 // Returns xmin value with applied unit and hi <<
330 <<
331 return fVH3Manager->GetMinValue(G4Analysis:: <<
332 } <<
333 218
334 //____________________________________________ 219 //_____________________________________________________________________________
335 inline << 220 inline
336 G4double G4VAnalysisManager::GetH3Ymax(G4int i <<
337 { <<
338 return fVH3Manager->GetMaxValue(G4Analysis:: <<
339 } <<
340 <<
341 //____________________________________________ <<
342 inline <<
343 G4double G4VAnalysisManager::GetH3YWidth(G4int <<
344 { <<
345 return fVH3Manager->GetWidth(G4Analysis::kY, <<
346 } <<
347 <<
348 //____________________________________________ <<
349 inline <<
350 G4int G4VAnalysisManager::GetH3Nzbins(G4int id <<
351 { <<
352 return fVH3Manager->GetNbins(G4Analysis::kZ, <<
353 } <<
354 <<
355 //____________________________________________ <<
356 inline <<
357 G4double G4VAnalysisManager::GetH3Zmin(G4int i <<
358 { <<
359 // Returns xmin value with applied unit and hi <<
360 <<
361 return fVH3Manager->GetMinValue(G4Analysis:: <<
362 } <<
363 <<
364 //____________________________________________ <<
365 inline <<
366 G4double G4VAnalysisManager::GetH3Zmax(G4int i <<
367 { <<
368 return fVH3Manager->GetMaxValue(G4Analysis:: <<
369 } <<
370 <<
371 //____________________________________________ <<
372 inline <<
373 G4double G4VAnalysisManager::GetH3ZWidth(G4int <<
374 { <<
375 return fVH3Manager->GetWidth(G4Analysis::kZ, <<
376 } <<
377 <<
378 //____________________________________________ <<
379 inline <<
380 G4int G4VAnalysisManager::GetP1Nbins(G4int id) <<
381 { <<
382 return fVP1Manager->GetNbins(G4Analysis::kX, <<
383 } <<
384 <<
385 //____________________________________________ <<
386 inline <<
387 G4double G4VAnalysisManager::GetP1Xmin(G4int i <<
388 { <<
389 // Returns xmin value with applied unit and hi <<
390 <<
391 return fVP1Manager->GetMinValue(G4Analysis:: <<
392 } <<
393 <<
394 //____________________________________________ <<
395 inline <<
396 G4double G4VAnalysisManager::GetP1Xmax(G4int i <<
397 { <<
398 return fVP1Manager->GetMaxValue(G4Analysis:: <<
399 } <<
400 <<
401 //____________________________________________ <<
402 inline <<
403 G4double G4VAnalysisManager::GetP1XWidth(G4int <<
404 { <<
405 return fVP1Manager->GetWidth(G4Analysis::kX, <<
406 } <<
407 <<
408 //____________________________________________ <<
409 inline <<
410 G4double G4VAnalysisManager::GetP1Ymin(G4int i <<
411 { <<
412 // Returns xmin value with applied unit and hi <<
413 <<
414 return fVP1Manager->GetMinValue(G4Analysis:: <<
415 } <<
416 <<
417 //____________________________________________ <<
418 inline <<
419 G4double G4VAnalysisManager::GetP1Ymax(G4int i <<
420 { <<
421 return fVP1Manager->GetMaxValue(G4Analysis:: <<
422 } <<
423 <<
424 //____________________________________________ <<
425 inline <<
426 G4int G4VAnalysisManager::GetP2Nxbins(G4int id <<
427 { <<
428 return fVP2Manager->GetNbins(G4Analysis::kX, <<
429 } <<
430 <<
431 //____________________________________________ <<
432 inline <<
433 G4double G4VAnalysisManager::GetP2Xmin(G4int i <<
434 { <<
435 // Returns xmin value with applied unit and hi <<
436 <<
437 return fVP2Manager->GetMinValue(G4Analysis:: <<
438 } <<
439 <<
440 //____________________________________________ <<
441 inline <<
442 G4double G4VAnalysisManager::GetP2Xmax(G4int i <<
443 { <<
444 return fVP2Manager->GetMaxValue(G4Analysis:: <<
445 } <<
446 <<
447 //____________________________________________ <<
448 inline <<
449 G4double G4VAnalysisManager::GetP2XWidth(G4int <<
450 { <<
451 return fVP2Manager->GetWidth(G4Analysis::kX, <<
452 } <<
453 <<
454 //____________________________________________ <<
455 inline <<
456 G4int G4VAnalysisManager::GetP2Nybins(G4int id <<
457 { <<
458 return fVP2Manager->GetNbins(G4Analysis::kY, <<
459 } <<
460 <<
461 //____________________________________________ <<
462 inline <<
463 G4double G4VAnalysisManager::GetP2Ymin(G4int i <<
464 { <<
465 // Returns xmin value with applied unit and hi <<
466 <<
467 return fVP2Manager->GetMinValue(G4Analysis:: <<
468 } <<
469 <<
470 //____________________________________________ <<
471 inline <<
472 G4double G4VAnalysisManager::GetP2Ymax(G4int i <<
473 { <<
474 return fVP2Manager->GetMaxValue(G4Analysis:: <<
475 } <<
476 <<
477 //____________________________________________ <<
478 inline <<
479 G4double G4VAnalysisManager::GetP2YWidth(G4int <<
480 { <<
481 return fVP2Manager->GetWidth(G4Analysis::kY, <<
482 } <<
483 <<
484 //____________________________________________ <<
485 inline <<
486 G4double G4VAnalysisManager::GetP2Zmin(G4int i <<
487 { <<
488 // Returns xmin value with applied unit and hi <<
489 <<
490 return fVP2Manager->GetMinValue(G4Analysis:: <<
491 } <<
492 <<
493 //____________________________________________ <<
494 inline <<
495 G4double G4VAnalysisManager::GetP2Zmax(G4int i <<
496 { <<
497 return fVP2Manager->GetMaxValue(G4Analysis:: <<
498 } <<
499 <<
500 //____________________________________________ <<
501 inline <<
502 G4String G4VAnalysisManager::GetH1Name(G4int i 221 G4String G4VAnalysisManager::GetH1Name(G4int id) const
503 { 222 {
504 return fH1HnManager->GetName(id); 223 return fH1HnManager->GetName(id);
505 } << 224 }
506 225
507 //____________________________________________ 226 //_____________________________________________________________________________
508 inline << 227 inline
509 G4double G4VAnalysisManager::GetH1Unit(G4int i 228 G4double G4VAnalysisManager::GetH1Unit(G4int id) const
510 { 229 {
511 return fH1HnManager->GetUnit(G4Analysis::kX, << 230 return fH1HnManager->GetXUnit(id);
512 } << 231 }
513 232
514 //____________________________________________ 233 //_____________________________________________________________________________
515 inline << 234 inline
516 G4bool G4VAnalysisManager::GetH1Activation(G4i 235 G4bool G4VAnalysisManager::GetH1Activation(G4int id) const
517 { 236 {
518 return fH1HnManager->GetActivation(id); 237 return fH1HnManager->GetActivation(id);
519 } << 238 }
520 239
521 //____________________________________________ 240 //_____________________________________________________________________________
522 inline << 241 inline
523 G4bool G4VAnalysisManager::GetH1Ascii(G4int id 242 G4bool G4VAnalysisManager::GetH1Ascii(G4int id) const
524 { 243 {
525 return fH1HnManager->GetAscii(id); 244 return fH1HnManager->GetAscii(id);
526 } << 245 }
527 <<
528 //____________________________________________ <<
529 inline <<
530 G4bool G4VAnalysisManager::GetH1Plotting(G4int <<
531 { <<
532 return fH1HnManager->GetPlotting(id); <<
533 } <<
534 246
535 //____________________________________________ 247 //_____________________________________________________________________________
536 inline << 248 inline
537 G4String G4VAnalysisManager::GetH2Name(G4int i 249 G4String G4VAnalysisManager::GetH2Name(G4int id) const
538 { 250 {
539 return fH2HnManager->GetName(id); 251 return fH2HnManager->GetName(id);
540 } << 252 }
541 253
542 //____________________________________________ 254 //_____________________________________________________________________________
543 inline << 255 inline
544 G4double G4VAnalysisManager::GetH2XUnit(G4int 256 G4double G4VAnalysisManager::GetH2XUnit(G4int id) const
545 { 257 {
546 return fH2HnManager->GetUnit(G4Analysis::kX, << 258 return fH2HnManager->GetXUnit(id);
547 } << 259 }
548 260
549 //____________________________________________ 261 //_____________________________________________________________________________
550 inline << 262 inline
551 G4double G4VAnalysisManager::GetH2YUnit(G4int 263 G4double G4VAnalysisManager::GetH2YUnit(G4int id) const
552 { 264 {
553 return fH2HnManager->GetUnit(G4Analysis::kY, << 265 return fH2HnManager->GetYUnit(id);
554 } << 266 }
555 267
556 //____________________________________________ 268 //_____________________________________________________________________________
557 inline << 269 inline
558 G4bool G4VAnalysisManager::GetH2Activation(G4i 270 G4bool G4VAnalysisManager::GetH2Activation(G4int id) const
559 { 271 {
560 return fH2HnManager->GetActivation(id); 272 return fH2HnManager->GetActivation(id);
561 } << 273 }
562 274
563 //____________________________________________ 275 //_____________________________________________________________________________
564 inline << 276 inline
565 G4bool G4VAnalysisManager::GetH2Ascii(G4int id 277 G4bool G4VAnalysisManager::GetH2Ascii(G4int id) const
566 { 278 {
567 return fH2HnManager->GetAscii(id); 279 return fH2HnManager->GetAscii(id);
568 } << 280 }
569 <<
570 //____________________________________________ <<
571 inline <<
572 G4bool G4VAnalysisManager::GetH2Plotting(G4int <<
573 { <<
574 return fH2HnManager->GetPlotting(id); <<
575 } <<
576 <<
577 //____________________________________________ <<
578 inline <<
579 G4String G4VAnalysisManager::GetH3Name(G4int i <<
580 { <<
581 return fH3HnManager->GetName(id); <<
582 } <<
583 <<
584 //____________________________________________ <<
585 inline <<
586 G4double G4VAnalysisManager::GetH3XUnit(G4int <<
587 { <<
588 return fH3HnManager->GetUnit(G4Analysis::kX, <<
589 } <<
590 281
591 //____________________________________________ <<
592 inline <<
593 G4double G4VAnalysisManager::GetH3YUnit(G4int <<
594 { <<
595 return fH3HnManager->GetUnit(G4Analysis::kY, <<
596 } <<
597 282
598 //____________________________________________ 283 //_____________________________________________________________________________
599 inline << 284 inline
600 G4double G4VAnalysisManager::GetH3ZUnit(G4int <<
601 { <<
602 return fH3HnManager->GetUnit(G4Analysis::kZ, <<
603 } <<
604 <<
605 //____________________________________________ <<
606 inline <<
607 G4bool G4VAnalysisManager::GetH3Activation(G4i <<
608 { <<
609 return fH3HnManager->GetActivation(id); <<
610 } <<
611 <<
612 //____________________________________________ <<
613 inline <<
614 G4bool G4VAnalysisManager::GetH3Ascii(G4int id <<
615 { <<
616 return fH3HnManager->GetAscii(id); <<
617 } <<
618 <<
619 //____________________________________________ <<
620 inline <<
621 G4bool G4VAnalysisManager::GetH3Plotting(G4int <<
622 { <<
623 return fH3HnManager->GetPlotting(id); <<
624 } <<
625 <<
626 //____________________________________________ <<
627 inline <<
628 G4String G4VAnalysisManager::GetP1Name(G4int i <<
629 { <<
630 return fP1HnManager->GetName(id); <<
631 } <<
632 <<
633 //____________________________________________ <<
634 inline <<
635 G4double G4VAnalysisManager::GetP1XUnit(G4int <<
636 { <<
637 return fP1HnManager->GetUnit(G4Analysis::kX, <<
638 } <<
639 <<
640 //____________________________________________ <<
641 inline <<
642 G4double G4VAnalysisManager::GetP1YUnit(G4int <<
643 { <<
644 return fP1HnManager->GetUnit(G4Analysis::kY, <<
645 } <<
646 <<
647 //____________________________________________ <<
648 inline <<
649 G4bool G4VAnalysisManager::GetP1Activation(G4i <<
650 { <<
651 return fP1HnManager->GetActivation(id); <<
652 } <<
653 <<
654 //____________________________________________ <<
655 inline <<
656 G4bool G4VAnalysisManager::GetP1Ascii(G4int id <<
657 { <<
658 return fP1HnManager->GetAscii(id); <<
659 } <<
660 <<
661 //____________________________________________ <<
662 inline <<
663 G4bool G4VAnalysisManager::GetP1Plotting(G4int <<
664 { <<
665 return fP1HnManager->GetPlotting(id); <<
666 } <<
667 <<
668 //____________________________________________ <<
669 inline <<
670 G4String G4VAnalysisManager::GetP2Name(G4int i <<
671 { <<
672 return fP2HnManager->GetName(id); <<
673 } <<
674 <<
675 //____________________________________________ <<
676 inline <<
677 G4double G4VAnalysisManager::GetP2XUnit(G4int <<
678 { <<
679 return fP2HnManager->GetUnit(G4Analysis::kX, <<
680 } <<
681 <<
682 //____________________________________________ <<
683 inline <<
684 G4double G4VAnalysisManager::GetP2YUnit(G4int <<
685 { <<
686 return fP2HnManager->GetUnit(G4Analysis::kY, <<
687 } <<
688 <<
689 //____________________________________________ <<
690 inline <<
691 G4double G4VAnalysisManager::GetP2ZUnit(G4int <<
692 { <<
693 return fP2HnManager->GetUnit(G4Analysis::kZ, <<
694 } <<
695 <<
696 //____________________________________________ <<
697 inline <<
698 G4bool G4VAnalysisManager::GetP2Activation(G4i <<
699 { <<
700 return fP2HnManager->GetActivation(id); <<
701 } <<
702 <<
703 //____________________________________________ <<
704 inline <<
705 G4bool G4VAnalysisManager::GetP2Ascii(G4int id <<
706 { <<
707 return fP2HnManager->GetAscii(id); <<
708 } <<
709 <<
710 //____________________________________________ <<
711 inline <<
712 G4bool G4VAnalysisManager::GetP2Plotting(G4int <<
713 { <<
714 return fP2HnManager->GetPlotting(id); <<
715 } <<
716 <<
717 //____________________________________________ <<
718 inline <<
719 G4bool G4VAnalysisManager::GetNtupleActivation <<
720 { <<
721 if ( fVNtupleManager ) { <<
722 return fVNtupleManager->GetActivation(id); <<
723 } <<
724 return fNtupleBookingManager->GetActivation( <<
725 } <<
726 <<
727 //____________________________________________ <<
728 inline <<
729 G4bool G4VAnalysisManager::SetH1Title(G4int id 285 G4bool G4VAnalysisManager::SetH1Title(G4int id, const G4String& title)
730 { 286 {
731 return fVH1Manager->SetTitle(id, title); << 287 return fVH1Manager->SetH1Title(id, title);
732 } << 288 }
733 289
734 //____________________________________________ 290 //_____________________________________________________________________________
735 inline << 291 inline
736 G4bool G4VAnalysisManager::SetH1XAxisTitle(G4i 292 G4bool G4VAnalysisManager::SetH1XAxisTitle(G4int id, const G4String& title)
737 { 293 {
738 return fVH1Manager->SetAxisTitle(G4Analysis: << 294 return fVH1Manager->SetH1XAxisTitle(id, title);
739 } << 295 }
740 296
741 //____________________________________________ 297 //_____________________________________________________________________________
742 inline << 298 inline
743 G4bool G4VAnalysisManager::SetH1YAxisTitle(G4i 299 G4bool G4VAnalysisManager::SetH1YAxisTitle(G4int id, const G4String& title)
744 { 300 {
745 return fVH1Manager->SetAxisTitle(G4Analysis: << 301 return fVH1Manager->SetH1YAxisTitle(id, title);
746 } << 302 }
747 303
748 //____________________________________________ 304 //_____________________________________________________________________________
749 inline << 305 inline
750 G4bool G4VAnalysisManager::SetH1XAxisIsLog(G4i <<
751 { <<
752 return fH1HnManager->SetAxisIsLog(G4Analysis <<
753 } <<
754 <<
755 //____________________________________________ <<
756 inline <<
757 G4bool G4VAnalysisManager::SetH1YAxisIsLog(G4i <<
758 { <<
759 return fH1HnManager->SetAxisIsLog(G4Analysis <<
760 } <<
761 <<
762 //____________________________________________ <<
763 inline <<
764 G4bool G4VAnalysisManager::SetH2Title(G4int id 306 G4bool G4VAnalysisManager::SetH2Title(G4int id, const G4String& title)
765 { 307 {
766 return fVH2Manager->SetTitle(id, title); << 308 return fVH2Manager->SetH2Title(id, title);
767 } << 309 }
768 310
769 //____________________________________________ 311 //_____________________________________________________________________________
770 inline << 312 inline
771 G4bool G4VAnalysisManager::SetH2XAxisTitle(G4i 313 G4bool G4VAnalysisManager::SetH2XAxisTitle(G4int id, const G4String& title)
772 { 314 {
773 return fVH2Manager->SetAxisTitle(G4Analysis: << 315 return fVH2Manager->SetH2XAxisTitle(id, title);
774 } << 316 }
775 317
776 //____________________________________________ 318 //_____________________________________________________________________________
777 inline << 319 inline
778 G4bool G4VAnalysisManager::SetH2YAxisTitle(G4i 320 G4bool G4VAnalysisManager::SetH2YAxisTitle(G4int id, const G4String& title)
779 { 321 {
780 return fVH2Manager->SetAxisTitle(G4Analysis: << 322 return fVH2Manager->SetH2YAxisTitle(id, title);
781 } << 323 }
782 324
783 //____________________________________________ 325 //_____________________________________________________________________________
784 inline << 326 inline
785 G4bool G4VAnalysisManager::SetH2ZAxisTitle(G4i 327 G4bool G4VAnalysisManager::SetH2ZAxisTitle(G4int id, const G4String& title)
786 { 328 {
787 return fVH2Manager->SetAxisTitle(G4Analysis: << 329 return fVH2Manager->SetH2ZAxisTitle(id, title);
788 } << 330 }
789 <<
790 //____________________________________________ <<
791 inline <<
792 G4bool G4VAnalysisManager::SetH2XAxisIsLog(G4i <<
793 { <<
794 return fH2HnManager->SetAxisIsLog(G4Analysis <<
795 } <<
796 <<
797 //____________________________________________ <<
798 inline <<
799 G4bool G4VAnalysisManager::SetH2YAxisIsLog(G4i <<
800 { <<
801 return fH2HnManager->SetAxisIsLog(G4Analysis <<
802 } <<
803 <<
804 //____________________________________________ <<
805 inline <<
806 G4bool G4VAnalysisManager::SetH2ZAxisIsLog(G4i <<
807 { <<
808 return fH2HnManager->SetAxisIsLog(G4Analysis <<
809 } <<
810 <<
811 //____________________________________________ <<
812 inline <<
813 G4bool G4VAnalysisManager::SetH3Title(G4int id <<
814 { <<
815 return fVH3Manager->SetTitle(id, title); <<
816 } <<
817 <<
818 //____________________________________________ <<
819 inline <<
820 G4bool G4VAnalysisManager::SetH3XAxisTitle(G4i <<
821 { <<
822 return fVH3Manager->SetAxisTitle(G4Analysis: <<
823 } <<
824 <<
825 //____________________________________________ <<
826 inline <<
827 G4bool G4VAnalysisManager::SetH3YAxisTitle(G4i <<
828 { <<
829 return fVH3Manager->SetAxisTitle(G4Analysis: <<
830 } <<
831 <<
832 //____________________________________________ <<
833 inline <<
834 G4bool G4VAnalysisManager::SetH3ZAxisTitle(G4i <<
835 { <<
836 return fVH3Manager->SetAxisTitle(G4Analysis: <<
837 } <<
838 <<
839 //____________________________________________ <<
840 inline <<
841 G4bool G4VAnalysisManager::SetH3XAxisIsLog(G4i <<
842 { <<
843 return fH3HnManager->SetAxisIsLog(G4Analysis <<
844 } <<
845 <<
846 //____________________________________________ <<
847 inline <<
848 G4bool G4VAnalysisManager::SetH3YAxisIsLog(G4i <<
849 { <<
850 return fH3HnManager->SetAxisIsLog(G4Analysis <<
851 } <<
852 <<
853 //____________________________________________ <<
854 inline <<
855 G4bool G4VAnalysisManager::SetH3ZAxisIsLog(G4i <<
856 { <<
857 return fH3HnManager->SetAxisIsLog(G4Analysis <<
858 } <<
859 <<
860 //____________________________________________ <<
861 inline <<
862 G4bool G4VAnalysisManager::SetP1Title(G4int id <<
863 { <<
864 return fVP1Manager->SetTitle(id, title); <<
865 } <<
866 <<
867 //____________________________________________ <<
868 inline <<
869 G4bool G4VAnalysisManager::SetP1XAxisTitle(G4i <<
870 { <<
871 return fVP1Manager->SetAxisTitle(G4Analysis: <<
872 } <<
873 <<
874 //____________________________________________ <<
875 inline <<
876 G4bool G4VAnalysisManager::SetP1YAxisTitle(G4i <<
877 { <<
878 return fVP1Manager->SetAxisTitle(G4Analysis: <<
879 } <<
880 <<
881 //____________________________________________ <<
882 inline <<
883 G4bool G4VAnalysisManager::SetP1XAxisIsLog(G4i <<
884 { <<
885 return fP1HnManager->SetAxisIsLog(G4Analysis <<
886 } <<
887 <<
888 //____________________________________________ <<
889 inline <<
890 G4bool G4VAnalysisManager::SetP1YAxisIsLog(G4i <<
891 { <<
892 return fP1HnManager->SetAxisIsLog(G4Analysis <<
893 } <<
894 <<
895 //____________________________________________ <<
896 inline <<
897 G4bool G4VAnalysisManager::SetP2Title(G4int id <<
898 { <<
899 return fVP2Manager->SetTitle(id, title); <<
900 } <<
901 <<
902 //____________________________________________ <<
903 inline <<
904 G4bool G4VAnalysisManager::SetP2XAxisTitle(G4i <<
905 { <<
906 return fVP2Manager->SetAxisTitle(G4Analysis: <<
907 } <<
908 <<
909 //____________________________________________ <<
910 inline <<
911 G4bool G4VAnalysisManager::SetP2YAxisTitle(G4i <<
912 { <<
913 return fVP2Manager->SetAxisTitle(G4Analysis: <<
914 } <<
915 331
916 //____________________________________________ 332 //_____________________________________________________________________________
917 inline << 333 inline
918 G4bool G4VAnalysisManager::SetP2ZAxisTitle(G4i <<
919 { <<
920 return fVP2Manager->SetAxisTitle(G4Analysis: <<
921 } <<
922 <<
923 //____________________________________________ <<
924 inline <<
925 G4bool G4VAnalysisManager::SetP2XAxisIsLog(G4i <<
926 { <<
927 return fP2HnManager->SetAxisIsLog(G4Analysis <<
928 } <<
929 <<
930 //____________________________________________ <<
931 inline <<
932 G4bool G4VAnalysisManager::SetP2YAxisIsLog(G4i <<
933 { <<
934 return fP2HnManager->SetAxisIsLog(G4Analysis <<
935 } <<
936 <<
937 //____________________________________________ <<
938 inline <<
939 G4bool G4VAnalysisManager::SetP2ZAxisIsLog(G4i <<
940 { <<
941 return fP2HnManager->SetAxisIsLog(G4Analysis <<
942 } <<
943 <<
944 //____________________________________________ <<
945 inline <<
946 G4String G4VAnalysisManager::GetH1Title(G4int 334 G4String G4VAnalysisManager::GetH1Title(G4int id) const
947 { 335 {
948 return fVH1Manager->GetTitle(id); << 336 return fVH1Manager->GetH1Title(id);
949 } << 337 }
950 <<
951 //____________________________________________ <<
952 inline <<
953 G4String G4VAnalysisManager::GetH1XAxisTitle(G <<
954 { <<
955 return fVH1Manager->GetAxisTitle(G4Analysis: <<
956 } <<
957 <<
958 //____________________________________________ <<
959 inline <<
960 G4String G4VAnalysisManager::GetH1YAxisTitle(G <<
961 { <<
962 return fVH1Manager->GetAxisTitle(G4Analysis: <<
963 } <<
964 338
965 //____________________________________________ 339 //_____________________________________________________________________________
966 inline << 340 inline
967 G4bool G4VAnalysisManager::GetH1XAxisIsLog(G4i << 341 G4String G4VAnalysisManager::GetH1XAxisTitle(G4int id) const
968 { 342 {
969 return fH1HnManager->GetAxisIsLog(G4Analysis << 343 return fVH1Manager->GetH1XAxisTitle(id);
970 } << 344 }
971 345
972 //____________________________________________ 346 //_____________________________________________________________________________
973 inline << 347 inline
974 G4bool G4VAnalysisManager::GetH1YAxisIsLog(G4i << 348 G4String G4VAnalysisManager::GetH1YAxisTitle(G4int id) const
975 { 349 {
976 return fH1HnManager->GetAxisIsLog(G4Analysis << 350 return fVH1Manager->GetH1YAxisTitle(id);
977 } << 351 }
978 352
979 //____________________________________________ 353 //_____________________________________________________________________________
980 inline << 354 inline
981 G4String G4VAnalysisManager::GetH2Title(G4int 355 G4String G4VAnalysisManager::GetH2Title(G4int id) const
982 { 356 {
983 return fVH2Manager->GetTitle(id); << 357 return fVH2Manager->GetH2Title(id);
984 } << 358 }
985 <<
986 //____________________________________________ <<
987 inline <<
988 G4String G4VAnalysisManager::GetH2XAxisTitle(G <<
989 { <<
990 return fVH2Manager->GetAxisTitle(G4Analysis: <<
991 } <<
992 <<
993 //____________________________________________ <<
994 inline <<
995 G4String G4VAnalysisManager::GetH2YAxisTitle(G <<
996 { <<
997 return fVH2Manager->GetAxisTitle(G4Analysis: <<
998 } <<
999 <<
1000 //___________________________________________ <<
1001 inline <<
1002 G4String G4VAnalysisManager::GetH2ZAxisTitle( <<
1003 { <<
1004 return fVH2Manager->GetAxisTitle(G4Analysis <<
1005 } <<
1006 <<
1007 //___________________________________________ <<
1008 inline <<
1009 G4bool G4VAnalysisManager::GetH2XAxisIsLog(G4 <<
1010 { <<
1011 return fH2HnManager->GetAxisIsLog(G4Analysi <<
1012 } <<
1013 <<
1014 //___________________________________________ <<
1015 inline <<
1016 G4bool G4VAnalysisManager::GetH2YAxisIsLog(G4 <<
1017 { <<
1018 return fH2HnManager->GetAxisIsLog(G4Analysi <<
1019 } <<
1020 <<
1021 //___________________________________________ <<
1022 inline <<
1023 G4bool G4VAnalysisManager::GetH2ZAxisIsLog(G4 <<
1024 { <<
1025 return fH2HnManager->GetAxisIsLog(G4Analysi <<
1026 } <<
1027 <<
1028 //___________________________________________ <<
1029 inline <<
1030 G4String G4VAnalysisManager::GetH3Title(G4int <<
1031 { <<
1032 return fVH3Manager->GetTitle(id); <<
1033 } <<
1034 <<
1035 //___________________________________________ <<
1036 inline <<
1037 G4String G4VAnalysisManager::GetH3XAxisTitle( <<
1038 { <<
1039 return fVH3Manager->GetAxisTitle(G4Analysis <<
1040 } <<
1041 <<
1042 //___________________________________________ <<
1043 inline <<
1044 G4String G4VAnalysisManager::GetH3YAxisTitle( <<
1045 { <<
1046 return fVH3Manager->GetAxisTitle(G4Analysis <<
1047 } <<
1048 <<
1049 //___________________________________________ <<
1050 inline <<
1051 G4String G4VAnalysisManager::GetH3ZAxisTitle( <<
1052 { <<
1053 return fVH3Manager->GetAxisTitle(G4Analysis <<
1054 } <<
1055 <<
1056 //___________________________________________ <<
1057 inline <<
1058 G4bool G4VAnalysisManager::GetH3XAxisIsLog(G4 <<
1059 { <<
1060 return fH3HnManager->GetAxisIsLog(G4Analysi <<
1061 } <<
1062 <<
1063 //___________________________________________ <<
1064 inline <<
1065 G4bool G4VAnalysisManager::GetH3YAxisIsLog(G4 <<
1066 { <<
1067 return fH3HnManager->GetAxisIsLog(G4Analysi <<
1068 } <<
1069 <<
1070 //___________________________________________ <<
1071 inline <<
1072 G4bool G4VAnalysisManager::GetH3ZAxisIsLog(G4 <<
1073 { <<
1074 return fH3HnManager->GetAxisIsLog(G4Analysi <<
1075 } <<
1076 <<
1077 //___________________________________________ <<
1078 inline <<
1079 G4String G4VAnalysisManager::GetP1Title(G4int <<
1080 { <<
1081 return fVP1Manager->GetTitle(id); <<
1082 } <<
1083 <<
1084 //___________________________________________ <<
1085 inline <<
1086 G4String G4VAnalysisManager::GetP1XAxisTitle( <<
1087 { <<
1088 return fVP1Manager->GetAxisTitle(G4Analysis <<
1089 } <<
1090 <<
1091 //___________________________________________ <<
1092 inline <<
1093 G4String G4VAnalysisManager::GetP1YAxisTitle( <<
1094 { <<
1095 return fVP1Manager->GetAxisTitle(G4Analysis <<
1096 } <<
1097 <<
1098 //___________________________________________ <<
1099 inline <<
1100 G4bool G4VAnalysisManager::GetP1XAxisIsLog(G4 <<
1101 { <<
1102 return fP1HnManager->GetAxisIsLog(G4Analysi <<
1103 } <<
1104 359
1105 //___________________________________________ 360 //_____________________________________________________________________________
1106 inline << 361 inline
1107 G4bool G4VAnalysisManager::GetP1YAxisIsLog(G4 << 362 G4String G4VAnalysisManager::GetH2XAxisTitle(G4int id) const
1108 { 363 {
1109 return fP1HnManager->GetAxisIsLog(G4Analysi << 364 return fVH2Manager->GetH2XAxisTitle(id);
1110 } << 365 }
1111 366
1112 //___________________________________________ 367 //_____________________________________________________________________________
1113 inline << 368 inline
1114 G4String G4VAnalysisManager::GetP2Title(G4int << 369 G4String G4VAnalysisManager::GetH2YAxisTitle(G4int id) const
1115 { 370 {
1116 return fVP2Manager->GetTitle(id); << 371 return fVH2Manager->GetH2YAxisTitle(id);
1117 } << 372 }
1118 373
1119 //___________________________________________ 374 //_____________________________________________________________________________
1120 inline << 375 inline
1121 G4String G4VAnalysisManager::GetP2XAxisTitle( << 376 G4String G4VAnalysisManager::GetH2ZAxisTitle(G4int id) const
1122 { 377 {
1123 return fVP2Manager->GetAxisTitle(G4Analysis << 378 return fVH2Manager->GetH2ZAxisTitle(id);
1124 } << 379 }
1125 380
1126 //___________________________________________ 381 //_____________________________________________________________________________
1127 inline << 382 inline
1128 G4String G4VAnalysisManager::GetP2YAxisTitle( << 383 G4int G4VAnalysisManager::GetVerboseLevel() const
1129 { <<
1130 return fVP2Manager->GetAxisTitle(G4Analysis <<
1131 } <<
1132 <<
1133 //___________________________________________ <<
1134 inline <<
1135 G4String G4VAnalysisManager::GetP2ZAxisTitle( <<
1136 { <<
1137 return fVP2Manager->GetAxisTitle(G4Analysis <<
1138 } <<
1139 <<
1140 //___________________________________________ <<
1141 inline <<
1142 G4bool G4VAnalysisManager::GetP2XAxisIsLog(G4 <<
1143 { <<
1144 return fP2HnManager->GetAxisIsLog(G4Analysi <<
1145 } <<
1146 <<
1147 //___________________________________________ <<
1148 inline <<
1149 G4bool G4VAnalysisManager::GetP2YAxisIsLog(G4 <<
1150 { <<
1151 return fP2HnManager->GetAxisIsLog(G4Analysi <<
1152 } <<
1153 <<
1154 //___________________________________________ <<
1155 inline <<
1156 G4bool G4VAnalysisManager::GetP2ZAxisIsLog(G4 <<
1157 { <<
1158 return fP2HnManager->GetAxisIsLog(G4Analysi <<
1159 } <<
1160 <<
1161 <<
1162 //___________________________________________ <<
1163 inline <<
1164 G4int G4VAnalysisManager::GetVerboseLevel() c <<
1165 { 384 {
1166 return fState.GetVerboseLevel(); 385 return fState.GetVerboseLevel();
1167 } << 386 }
1168 << 387
1169 //___________________________________________ 388 //_____________________________________________________________________________
1170 inline 389 inline
1171 G4String G4VAnalysisManager::GetType() const << 390 G4String G4VAnalysisManager::GetType() const
1172 { 391 {
1173 return fState.GetType(); 392 return fState.GetType();
1174 } << 393 }
1175 394
1176 //___________________________________________ 395 //_____________________________________________________________________________
1177 inline 396 inline
1178 G4String G4VAnalysisManager::GetFileType() co << 397 G4String G4VAnalysisManager::GetFileType() const
1179 { 398 {
1180 return fState.GetFileType(); << 399 return fVFileManager->GetFileType();
1181 } << 400 }
1182 401