| 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 "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 if ( fVNtupleManager ) {
722 return fVNtupleManager->GetActivation(id); 718 return fVNtupleManager->GetActivation(id);
>> 719 } else {
>> 720 return fNtupleBookingManager->GetActivation(id);
>> 721
723 } 722 }
724 return fNtupleBookingManager->GetActivation( <<
725 } 723 }
726 724
727 //____________________________________________ 725 //_____________________________________________________________________________
728 inline << 726 inline
729 G4bool G4VAnalysisManager::SetH1Title(G4int id 727 G4bool G4VAnalysisManager::SetH1Title(G4int id, const G4String& title)
730 { 728 {
731 return fVH1Manager->SetTitle(id, title); << 729 return fVH1Manager->SetH1Title(id, title);
732 } << 730 }
733 731
734 //____________________________________________ 732 //_____________________________________________________________________________
735 inline << 733 inline
736 G4bool G4VAnalysisManager::SetH1XAxisTitle(G4i 734 G4bool G4VAnalysisManager::SetH1XAxisTitle(G4int id, const G4String& title)
737 { 735 {
738 return fVH1Manager->SetAxisTitle(G4Analysis: << 736 return fVH1Manager->SetH1XAxisTitle(id, title);
739 } << 737 }
740 738
741 //____________________________________________ 739 //_____________________________________________________________________________
742 inline << 740 inline
743 G4bool G4VAnalysisManager::SetH1YAxisTitle(G4i 741 G4bool G4VAnalysisManager::SetH1YAxisTitle(G4int id, const G4String& title)
744 { 742 {
745 return fVH1Manager->SetAxisTitle(G4Analysis: << 743 return fVH1Manager->SetH1YAxisTitle(id, title);
746 } << 744 }
747 745
748 //____________________________________________ 746 //_____________________________________________________________________________
749 inline << 747 inline
750 G4bool G4VAnalysisManager::SetH1XAxisIsLog(G4i 748 G4bool G4VAnalysisManager::SetH1XAxisIsLog(G4int id, G4bool isLog)
751 { 749 {
752 return fH1HnManager->SetAxisIsLog(G4Analysis << 750 return fH1HnManager->SetXAxisIsLog(id, isLog);
753 } 751 }
754 752
755 //____________________________________________ 753 //_____________________________________________________________________________
756 inline << 754 inline
757 G4bool G4VAnalysisManager::SetH1YAxisIsLog(G4i 755 G4bool G4VAnalysisManager::SetH1YAxisIsLog(G4int id, G4bool isLog)
758 { 756 {
759 return fH1HnManager->SetAxisIsLog(G4Analysis << 757 return fH1HnManager->SetYAxisIsLog(id, isLog);
760 } 758 }
761 759
762 //____________________________________________ 760 //_____________________________________________________________________________
763 inline << 761 inline
764 G4bool G4VAnalysisManager::SetH2Title(G4int id 762 G4bool G4VAnalysisManager::SetH2Title(G4int id, const G4String& title)
765 { 763 {
766 return fVH2Manager->SetTitle(id, title); << 764 return fVH2Manager->SetH2Title(id, title);
767 } << 765 }
768 766
769 //____________________________________________ 767 //_____________________________________________________________________________
770 inline << 768 inline
771 G4bool G4VAnalysisManager::SetH2XAxisTitle(G4i 769 G4bool G4VAnalysisManager::SetH2XAxisTitle(G4int id, const G4String& title)
772 { 770 {
773 return fVH2Manager->SetAxisTitle(G4Analysis: << 771 return fVH2Manager->SetH2XAxisTitle(id, title);
774 } << 772 }
775 773
776 //____________________________________________ 774 //_____________________________________________________________________________
777 inline << 775 inline
778 G4bool G4VAnalysisManager::SetH2YAxisTitle(G4i 776 G4bool G4VAnalysisManager::SetH2YAxisTitle(G4int id, const G4String& title)
779 { 777 {
780 return fVH2Manager->SetAxisTitle(G4Analysis: << 778 return fVH2Manager->SetH2YAxisTitle(id, title);
781 } << 779 }
782 780
783 //____________________________________________ 781 //_____________________________________________________________________________
784 inline << 782 inline
785 G4bool G4VAnalysisManager::SetH2ZAxisTitle(G4i 783 G4bool G4VAnalysisManager::SetH2ZAxisTitle(G4int id, const G4String& title)
786 { 784 {
787 return fVH2Manager->SetAxisTitle(G4Analysis: << 785 return fVH2Manager->SetH2ZAxisTitle(id, title);
788 } << 786 }
789 787
790 //____________________________________________ 788 //_____________________________________________________________________________
791 inline << 789 inline
792 G4bool G4VAnalysisManager::SetH2XAxisIsLog(G4i 790 G4bool G4VAnalysisManager::SetH2XAxisIsLog(G4int id, G4bool isLog)
793 { 791 {
794 return fH2HnManager->SetAxisIsLog(G4Analysis << 792 return fH2HnManager->SetXAxisIsLog(id, isLog);
795 } 793 }
796 794
797 //____________________________________________ 795 //_____________________________________________________________________________
798 inline << 796 inline
799 G4bool G4VAnalysisManager::SetH2YAxisIsLog(G4i 797 G4bool G4VAnalysisManager::SetH2YAxisIsLog(G4int id, G4bool isLog)
800 { 798 {
801 return fH2HnManager->SetAxisIsLog(G4Analysis << 799 return fH2HnManager->SetYAxisIsLog(id, isLog);
802 } 800 }
803 801
804 //____________________________________________ 802 //_____________________________________________________________________________
805 inline << 803 inline
806 G4bool G4VAnalysisManager::SetH2ZAxisIsLog(G4i 804 G4bool G4VAnalysisManager::SetH2ZAxisIsLog(G4int id, G4bool isLog)
807 { 805 {
808 return fH2HnManager->SetAxisIsLog(G4Analysis << 806 return fH2HnManager->SetZAxisIsLog(id, isLog);
809 } 807 }
810 808
811 //____________________________________________ 809 //_____________________________________________________________________________
812 inline << 810 inline
813 G4bool G4VAnalysisManager::SetH3Title(G4int id 811 G4bool G4VAnalysisManager::SetH3Title(G4int id, const G4String& title)
814 { 812 {
815 return fVH3Manager->SetTitle(id, title); << 813 return fVH3Manager->SetH3Title(id, title);
816 } << 814 }
817 815
818 //____________________________________________ 816 //_____________________________________________________________________________
819 inline << 817 inline
820 G4bool G4VAnalysisManager::SetH3XAxisTitle(G4i 818 G4bool G4VAnalysisManager::SetH3XAxisTitle(G4int id, const G4String& title)
821 { 819 {
822 return fVH3Manager->SetAxisTitle(G4Analysis: << 820 return fVH3Manager->SetH3XAxisTitle(id, title);
823 } << 821 }
824 822
825 //____________________________________________ 823 //_____________________________________________________________________________
826 inline << 824 inline
827 G4bool G4VAnalysisManager::SetH3YAxisTitle(G4i 825 G4bool G4VAnalysisManager::SetH3YAxisTitle(G4int id, const G4String& title)
828 { 826 {
829 return fVH3Manager->SetAxisTitle(G4Analysis: << 827 return fVH3Manager->SetH3YAxisTitle(id, title);
830 } << 828 }
831 829
832 //____________________________________________ 830 //_____________________________________________________________________________
833 inline << 831 inline
834 G4bool G4VAnalysisManager::SetH3ZAxisTitle(G4i 832 G4bool G4VAnalysisManager::SetH3ZAxisTitle(G4int id, const G4String& title)
835 { 833 {
836 return fVH3Manager->SetAxisTitle(G4Analysis: << 834 return fVH3Manager->SetH3ZAxisTitle(id, title);
837 } << 835 }
838 836
839 //____________________________________________ 837 //_____________________________________________________________________________
840 inline << 838 inline
841 G4bool G4VAnalysisManager::SetH3XAxisIsLog(G4i 839 G4bool G4VAnalysisManager::SetH3XAxisIsLog(G4int id, G4bool isLog)
842 { 840 {
843 return fH3HnManager->SetAxisIsLog(G4Analysis << 841 return fH3HnManager->SetXAxisIsLog(id, isLog);
844 } 842 }
845 843
846 //____________________________________________ 844 //_____________________________________________________________________________
847 inline << 845 inline
848 G4bool G4VAnalysisManager::SetH3YAxisIsLog(G4i 846 G4bool G4VAnalysisManager::SetH3YAxisIsLog(G4int id, G4bool isLog)
849 { 847 {
850 return fH3HnManager->SetAxisIsLog(G4Analysis << 848 return fH3HnManager->SetYAxisIsLog(id, isLog);
851 } 849 }
852 850
853 //____________________________________________ 851 //_____________________________________________________________________________
854 inline << 852 inline
855 G4bool G4VAnalysisManager::SetH3ZAxisIsLog(G4i 853 G4bool G4VAnalysisManager::SetH3ZAxisIsLog(G4int id, G4bool isLog)
856 { 854 {
857 return fH3HnManager->SetAxisIsLog(G4Analysis << 855 return fH3HnManager->SetZAxisIsLog(id, isLog);
858 } 856 }
859 857
860 //____________________________________________ 858 //_____________________________________________________________________________
861 inline << 859 inline
862 G4bool G4VAnalysisManager::SetP1Title(G4int id 860 G4bool G4VAnalysisManager::SetP1Title(G4int id, const G4String& title)
863 { 861 {
864 return fVP1Manager->SetTitle(id, title); << 862 return fVP1Manager->SetP1Title(id, title);
865 } << 863 }
866 864
867 //____________________________________________ 865 //_____________________________________________________________________________
868 inline << 866 inline
869 G4bool G4VAnalysisManager::SetP1XAxisTitle(G4i 867 G4bool G4VAnalysisManager::SetP1XAxisTitle(G4int id, const G4String& title)
870 { 868 {
871 return fVP1Manager->SetAxisTitle(G4Analysis: << 869 return fVP1Manager->SetP1XAxisTitle(id, title);
872 } << 870 }
873 871
874 //____________________________________________ 872 //_____________________________________________________________________________
875 inline << 873 inline
876 G4bool G4VAnalysisManager::SetP1YAxisTitle(G4i 874 G4bool G4VAnalysisManager::SetP1YAxisTitle(G4int id, const G4String& title)
877 { 875 {
878 return fVP1Manager->SetAxisTitle(G4Analysis: << 876 return fVP1Manager->SetP1YAxisTitle(id, title);
879 } << 877 }
880 878
881 //____________________________________________ 879 //_____________________________________________________________________________
882 inline << 880 inline
883 G4bool G4VAnalysisManager::SetP1XAxisIsLog(G4i 881 G4bool G4VAnalysisManager::SetP1XAxisIsLog(G4int id, G4bool isLog)
884 { 882 {
885 return fP1HnManager->SetAxisIsLog(G4Analysis << 883 return fP1HnManager->SetXAxisIsLog(id, isLog);
886 } 884 }
887 885
888 //____________________________________________ 886 //_____________________________________________________________________________
889 inline << 887 inline
890 G4bool G4VAnalysisManager::SetP1YAxisIsLog(G4i 888 G4bool G4VAnalysisManager::SetP1YAxisIsLog(G4int id, G4bool isLog)
891 { 889 {
892 return fP1HnManager->SetAxisIsLog(G4Analysis << 890 return fP1HnManager->SetYAxisIsLog(id, isLog);
893 } 891 }
894 892
895 //____________________________________________ 893 //_____________________________________________________________________________
896 inline << 894 inline
897 G4bool G4VAnalysisManager::SetP2Title(G4int id 895 G4bool G4VAnalysisManager::SetP2Title(G4int id, const G4String& title)
898 { 896 {
899 return fVP2Manager->SetTitle(id, title); << 897 return fVP2Manager->SetP2Title(id, title);
900 } << 898 }
901 899
902 //____________________________________________ 900 //_____________________________________________________________________________
903 inline << 901 inline
904 G4bool G4VAnalysisManager::SetP2XAxisTitle(G4i 902 G4bool G4VAnalysisManager::SetP2XAxisTitle(G4int id, const G4String& title)
905 { 903 {
906 return fVP2Manager->SetAxisTitle(G4Analysis: << 904 return fVP2Manager->SetP2XAxisTitle(id, title);
907 } << 905 }
908 906
909 //____________________________________________ 907 //_____________________________________________________________________________
910 inline << 908 inline
911 G4bool G4VAnalysisManager::SetP2YAxisTitle(G4i 909 G4bool G4VAnalysisManager::SetP2YAxisTitle(G4int id, const G4String& title)
912 { 910 {
913 return fVP2Manager->SetAxisTitle(G4Analysis: << 911 return fVP2Manager->SetP2YAxisTitle(id, title);
914 } << 912 }
915 913
916 //____________________________________________ 914 //_____________________________________________________________________________
917 inline << 915 inline
918 G4bool G4VAnalysisManager::SetP2ZAxisTitle(G4i 916 G4bool G4VAnalysisManager::SetP2ZAxisTitle(G4int id, const G4String& title)
919 { 917 {
920 return fVP2Manager->SetAxisTitle(G4Analysis: << 918 return fVP2Manager->SetP2ZAxisTitle(id, title);
921 } << 919 }
922 920
923 //____________________________________________ 921 //_____________________________________________________________________________
924 inline << 922 inline
925 G4bool G4VAnalysisManager::SetP2XAxisIsLog(G4i 923 G4bool G4VAnalysisManager::SetP2XAxisIsLog(G4int id, G4bool isLog)
926 { 924 {
927 return fP2HnManager->SetAxisIsLog(G4Analysis << 925 return fP2HnManager->SetXAxisIsLog(id, isLog);
928 } 926 }
929 927
930 //____________________________________________ 928 //_____________________________________________________________________________
931 inline << 929 inline
932 G4bool G4VAnalysisManager::SetP2YAxisIsLog(G4i 930 G4bool G4VAnalysisManager::SetP2YAxisIsLog(G4int id, G4bool isLog)
933 { 931 {
934 return fP2HnManager->SetAxisIsLog(G4Analysis << 932 return fP2HnManager->SetYAxisIsLog(id, isLog);
935 } 933 }
936 934
937 //____________________________________________ 935 //_____________________________________________________________________________
938 inline << 936 inline
939 G4bool G4VAnalysisManager::SetP2ZAxisIsLog(G4i 937 G4bool G4VAnalysisManager::SetP2ZAxisIsLog(G4int id, G4bool isLog)
940 { 938 {
941 return fP2HnManager->SetAxisIsLog(G4Analysis << 939 return fP2HnManager->SetZAxisIsLog(id, isLog);
942 } 940 }
943 941
944 //____________________________________________ 942 //_____________________________________________________________________________
945 inline << 943 inline
946 G4String G4VAnalysisManager::GetH1Title(G4int 944 G4String G4VAnalysisManager::GetH1Title(G4int id) const
947 { 945 {
948 return fVH1Manager->GetTitle(id); << 946 return fVH1Manager->GetH1Title(id);
949 } << 947 }
950 948
951 //____________________________________________ 949 //_____________________________________________________________________________
952 inline << 950 inline
953 G4String G4VAnalysisManager::GetH1XAxisTitle(G << 951 G4String G4VAnalysisManager::GetH1XAxisTitle(G4int id) const
954 { 952 {
955 return fVH1Manager->GetAxisTitle(G4Analysis: << 953 return fVH1Manager->GetH1XAxisTitle(id);
956 } << 954 }
957 955
958 //____________________________________________ 956 //_____________________________________________________________________________
959 inline << 957 inline
960 G4String G4VAnalysisManager::GetH1YAxisTitle(G << 958 G4String G4VAnalysisManager::GetH1YAxisTitle(G4int id) const
961 { 959 {
962 return fVH1Manager->GetAxisTitle(G4Analysis: << 960 return fVH1Manager->GetH1YAxisTitle(id);
963 } << 961 }
964 962
965 //____________________________________________ 963 //_____________________________________________________________________________
966 inline << 964 inline
967 G4bool G4VAnalysisManager::GetH1XAxisIsLog(G4i 965 G4bool G4VAnalysisManager::GetH1XAxisIsLog(G4int id) const
968 { 966 {
969 return fH1HnManager->GetAxisIsLog(G4Analysis << 967 return fH1HnManager->GetXAxisIsLog(id);
970 } 968 }
971 969
972 //____________________________________________ 970 //_____________________________________________________________________________
973 inline << 971 inline
974 G4bool G4VAnalysisManager::GetH1YAxisIsLog(G4i 972 G4bool G4VAnalysisManager::GetH1YAxisIsLog(G4int id) const
975 { 973 {
976 return fH1HnManager->GetAxisIsLog(G4Analysis << 974 return fH1HnManager->GetYAxisIsLog(id);
977 } 975 }
978 976
979 //____________________________________________ 977 //_____________________________________________________________________________
980 inline << 978 inline
981 G4String G4VAnalysisManager::GetH2Title(G4int 979 G4String G4VAnalysisManager::GetH2Title(G4int id) const
982 { 980 {
983 return fVH2Manager->GetTitle(id); << 981 return fVH2Manager->GetH2Title(id);
984 } << 982 }
985 983
986 //____________________________________________ 984 //_____________________________________________________________________________
987 inline << 985 inline
988 G4String G4VAnalysisManager::GetH2XAxisTitle(G << 986 G4String G4VAnalysisManager::GetH2XAxisTitle(G4int id) const
989 { 987 {
990 return fVH2Manager->GetAxisTitle(G4Analysis: << 988 return fVH2Manager->GetH2XAxisTitle(id);
991 } << 989 }
992 990
993 //____________________________________________ 991 //_____________________________________________________________________________
994 inline << 992 inline
995 G4String G4VAnalysisManager::GetH2YAxisTitle(G << 993 G4String G4VAnalysisManager::GetH2YAxisTitle(G4int id) const
996 { 994 {
997 return fVH2Manager->GetAxisTitle(G4Analysis: << 995 return fVH2Manager->GetH2YAxisTitle(id);
998 } << 996 }
999 997
1000 //___________________________________________ 998 //_____________________________________________________________________________
1001 inline << 999 inline
1002 G4String G4VAnalysisManager::GetH2ZAxisTitle( << 1000 G4String G4VAnalysisManager::GetH2ZAxisTitle(G4int id) const
1003 { 1001 {
1004 return fVH2Manager->GetAxisTitle(G4Analysis << 1002 return fVH2Manager->GetH2ZAxisTitle(id);
1005 } << 1003 }
1006 1004
1007 //___________________________________________ 1005 //_____________________________________________________________________________
1008 inline << 1006 inline
1009 G4bool G4VAnalysisManager::GetH2XAxisIsLog(G4 1007 G4bool G4VAnalysisManager::GetH2XAxisIsLog(G4int id) const
1010 { 1008 {
1011 return fH2HnManager->GetAxisIsLog(G4Analysi << 1009 return fH2HnManager->GetXAxisIsLog(id);
1012 } 1010 }
1013 1011
1014 //___________________________________________ 1012 //_____________________________________________________________________________
1015 inline << 1013 inline
1016 G4bool G4VAnalysisManager::GetH2YAxisIsLog(G4 1014 G4bool G4VAnalysisManager::GetH2YAxisIsLog(G4int id) const
1017 { 1015 {
1018 return fH2HnManager->GetAxisIsLog(G4Analysi << 1016 return fH2HnManager->GetYAxisIsLog(id);
1019 } 1017 }
1020 1018
1021 //___________________________________________ 1019 //_____________________________________________________________________________
1022 inline << 1020 inline
1023 G4bool G4VAnalysisManager::GetH2ZAxisIsLog(G4 1021 G4bool G4VAnalysisManager::GetH2ZAxisIsLog(G4int id) const
1024 { 1022 {
1025 return fH2HnManager->GetAxisIsLog(G4Analysi << 1023 return fH2HnManager->GetZAxisIsLog(id);
1026 } 1024 }
1027 1025
1028 //___________________________________________ 1026 //_____________________________________________________________________________
1029 inline << 1027 inline
1030 G4String G4VAnalysisManager::GetH3Title(G4int 1028 G4String G4VAnalysisManager::GetH3Title(G4int id) const
1031 { 1029 {
1032 return fVH3Manager->GetTitle(id); << 1030 return fVH3Manager->GetH3Title(id);
1033 } << 1031 }
1034 1032
1035 //___________________________________________ 1033 //_____________________________________________________________________________
1036 inline << 1034 inline
1037 G4String G4VAnalysisManager::GetH3XAxisTitle( << 1035 G4String G4VAnalysisManager::GetH3XAxisTitle(G4int id) const
1038 { 1036 {
1039 return fVH3Manager->GetAxisTitle(G4Analysis << 1037 return fVH3Manager->GetH3XAxisTitle(id);
1040 } << 1038 }
1041 1039
1042 //___________________________________________ 1040 //_____________________________________________________________________________
1043 inline << 1041 inline
1044 G4String G4VAnalysisManager::GetH3YAxisTitle( << 1042 G4String G4VAnalysisManager::GetH3YAxisTitle(G4int id) const
1045 { 1043 {
1046 return fVH3Manager->GetAxisTitle(G4Analysis << 1044 return fVH3Manager->GetH3YAxisTitle(id);
1047 } << 1045 }
1048 1046
1049 //___________________________________________ 1047 //_____________________________________________________________________________
1050 inline << 1048 inline
1051 G4String G4VAnalysisManager::GetH3ZAxisTitle( << 1049 G4String G4VAnalysisManager::GetH3ZAxisTitle(G4int id) const
1052 { 1050 {
1053 return fVH3Manager->GetAxisTitle(G4Analysis << 1051 return fVH3Manager->GetH3ZAxisTitle(id);
1054 } << 1052 }
1055 1053
1056 //___________________________________________ 1054 //_____________________________________________________________________________
1057 inline << 1055 inline
1058 G4bool G4VAnalysisManager::GetH3XAxisIsLog(G4 1056 G4bool G4VAnalysisManager::GetH3XAxisIsLog(G4int id) const
1059 { 1057 {
1060 return fH3HnManager->GetAxisIsLog(G4Analysi << 1058 return fH3HnManager->GetXAxisIsLog(id);
1061 } 1059 }
1062 1060
1063 //___________________________________________ 1061 //_____________________________________________________________________________
1064 inline << 1062 inline
1065 G4bool G4VAnalysisManager::GetH3YAxisIsLog(G4 1063 G4bool G4VAnalysisManager::GetH3YAxisIsLog(G4int id) const
1066 { 1064 {
1067 return fH3HnManager->GetAxisIsLog(G4Analysi << 1065 return fH3HnManager->GetYAxisIsLog(id);
1068 } 1066 }
1069 1067
1070 //___________________________________________ 1068 //_____________________________________________________________________________
1071 inline << 1069 inline
1072 G4bool G4VAnalysisManager::GetH3ZAxisIsLog(G4 1070 G4bool G4VAnalysisManager::GetH3ZAxisIsLog(G4int id) const
1073 { 1071 {
1074 return fH3HnManager->GetAxisIsLog(G4Analysi << 1072 return fH3HnManager->GetZAxisIsLog(id);
1075 } 1073 }
1076 1074
1077 //___________________________________________ 1075 //_____________________________________________________________________________
1078 inline << 1076 inline
1079 G4String G4VAnalysisManager::GetP1Title(G4int 1077 G4String G4VAnalysisManager::GetP1Title(G4int id) const
1080 { 1078 {
1081 return fVP1Manager->GetTitle(id); << 1079 return fVP1Manager->GetP1Title(id);
1082 } << 1080 }
1083 1081
1084 //___________________________________________ 1082 //_____________________________________________________________________________
1085 inline << 1083 inline
1086 G4String G4VAnalysisManager::GetP1XAxisTitle( << 1084 G4String G4VAnalysisManager::GetP1XAxisTitle(G4int id) const
1087 { 1085 {
1088 return fVP1Manager->GetAxisTitle(G4Analysis << 1086 return fVP1Manager->GetP1XAxisTitle(id);
1089 } << 1087 }
1090 1088
1091 //___________________________________________ 1089 //_____________________________________________________________________________
1092 inline << 1090 inline
1093 G4String G4VAnalysisManager::GetP1YAxisTitle( << 1091 G4String G4VAnalysisManager::GetP1YAxisTitle(G4int id) const
1094 { 1092 {
1095 return fVP1Manager->GetAxisTitle(G4Analysis << 1093 return fVP1Manager->GetP1YAxisTitle(id);
1096 } << 1094 }
1097 1095
1098 //___________________________________________ 1096 //_____________________________________________________________________________
1099 inline << 1097 inline
1100 G4bool G4VAnalysisManager::GetP1XAxisIsLog(G4 1098 G4bool G4VAnalysisManager::GetP1XAxisIsLog(G4int id) const
1101 { 1099 {
1102 return fP1HnManager->GetAxisIsLog(G4Analysi << 1100 return fP1HnManager->GetXAxisIsLog(id);
1103 } 1101 }
1104 1102
1105 //___________________________________________ 1103 //_____________________________________________________________________________
1106 inline << 1104 inline
1107 G4bool G4VAnalysisManager::GetP1YAxisIsLog(G4 1105 G4bool G4VAnalysisManager::GetP1YAxisIsLog(G4int id) const
1108 { 1106 {
1109 return fP1HnManager->GetAxisIsLog(G4Analysi << 1107 return fP1HnManager->GetYAxisIsLog(id);
1110 } 1108 }
1111 1109
1112 //___________________________________________ 1110 //_____________________________________________________________________________
1113 inline << 1111 inline
1114 G4String G4VAnalysisManager::GetP2Title(G4int 1112 G4String G4VAnalysisManager::GetP2Title(G4int id) const
1115 { 1113 {
1116 return fVP2Manager->GetTitle(id); << 1114 return fVP2Manager->GetP2Title(id);
1117 } << 1115 }
1118 1116
1119 //___________________________________________ 1117 //_____________________________________________________________________________
1120 inline << 1118 inline
1121 G4String G4VAnalysisManager::GetP2XAxisTitle( << 1119 G4String G4VAnalysisManager::GetP2XAxisTitle(G4int id) const
1122 { 1120 {
1123 return fVP2Manager->GetAxisTitle(G4Analysis << 1121 return fVP2Manager->GetP2XAxisTitle(id);
1124 } << 1122 }
1125 1123
1126 //___________________________________________ 1124 //_____________________________________________________________________________
1127 inline << 1125 inline
1128 G4String G4VAnalysisManager::GetP2YAxisTitle( << 1126 G4String G4VAnalysisManager::GetP2YAxisTitle(G4int id) const
1129 { 1127 {
1130 return fVP2Manager->GetAxisTitle(G4Analysis << 1128 return fVP2Manager->GetP2YAxisTitle(id);
1131 } << 1129 }
1132 1130
1133 //___________________________________________ 1131 //_____________________________________________________________________________
1134 inline << 1132 inline
1135 G4String G4VAnalysisManager::GetP2ZAxisTitle( << 1133 G4String G4VAnalysisManager::GetP2ZAxisTitle(G4int id) const
1136 { 1134 {
1137 return fVP2Manager->GetAxisTitle(G4Analysis << 1135 return fVP2Manager->GetP2ZAxisTitle(id);
1138 } << 1136 }
1139 1137
1140 //___________________________________________ 1138 //_____________________________________________________________________________
1141 inline << 1139 inline
1142 G4bool G4VAnalysisManager::GetP2XAxisIsLog(G4 1140 G4bool G4VAnalysisManager::GetP2XAxisIsLog(G4int id) const
1143 { 1141 {
1144 return fP2HnManager->GetAxisIsLog(G4Analysi << 1142 return fP2HnManager->GetXAxisIsLog(id);
1145 } 1143 }
1146 1144
1147 //___________________________________________ 1145 //_____________________________________________________________________________
1148 inline << 1146 inline
1149 G4bool G4VAnalysisManager::GetP2YAxisIsLog(G4 1147 G4bool G4VAnalysisManager::GetP2YAxisIsLog(G4int id) const
1150 { 1148 {
1151 return fP2HnManager->GetAxisIsLog(G4Analysi << 1149 return fP2HnManager->GetYAxisIsLog(id);
1152 } 1150 }
1153 1151
1154 //___________________________________________ 1152 //_____________________________________________________________________________
1155 inline << 1153 inline
1156 G4bool G4VAnalysisManager::GetP2ZAxisIsLog(G4 1154 G4bool G4VAnalysisManager::GetP2ZAxisIsLog(G4int id) const
1157 { 1155 {
1158 return fP2HnManager->GetAxisIsLog(G4Analysi << 1156 return fP2HnManager->GetZAxisIsLog(id);
1159 } 1157 }
1160 1158
1161 1159
1162 //___________________________________________ 1160 //_____________________________________________________________________________
1163 inline << 1161 inline
1164 G4int G4VAnalysisManager::GetVerboseLevel() c << 1162 G4int G4VAnalysisManager::GetVerboseLevel() const
1165 { 1163 {
1166 return fState.GetVerboseLevel(); 1164 return fState.GetVerboseLevel();
1167 } << 1165 }
1168 << 1166
1169 //___________________________________________ 1167 //_____________________________________________________________________________
1170 inline 1168 inline
1171 G4String G4VAnalysisManager::GetType() const << 1169 G4String G4VAnalysisManager::GetType() const
1172 { 1170 {
1173 return fState.GetType(); 1171 return fState.GetType();
1174 } << 1172 }
1175 1173
1176 //___________________________________________ 1174 //_____________________________________________________________________________
1177 inline 1175 inline
1178 G4String G4VAnalysisManager::GetFileType() co << 1176 G4String G4VAnalysisManager::GetFileType() const
1179 { 1177 {
1180 return fState.GetFileType(); << 1178 return fVFileManager->GetFileType();
1181 } << 1179 }
1182 1180