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