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