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