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