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