Geant4  10.03.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4P1ToolsManager.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // $Id$
27 
28 // Author: Ivana Hrivnacova, 24/07/2014 (ivana@ipno.in2p3.fr)
29 
30 #include "G4P1ToolsManager.hh"
32 #include "G4BaseHistoUtilities.hh"
33 #include "G4AnalysisUtilities.hh"
34 
35 #include "tools/histo/p1d"
36 
37 #include <fstream>
38 
39 using namespace G4Analysis;
40 
41 // static definitions
42 const G4int G4P1ToolsManager::kDimension = 1;
43 
44 //
45 // Constructors, destructor
46 //
47 
48 //_____________________________________________________________________________
50  : G4VP1Manager(),
51  G4THnManager<tools::histo::p1d>(state, "P1")
52 {}
53 
54 //_____________________________________________________________________________
56 {}
57 
58 //
59 // Utility functions
60 //
61 
62 namespace {
63 
64 //_____________________________________________________________________________
65 void UpdateP1Information(G4HnInformation* hnInformation,
66  const G4String& xunitName,
67  const G4String& yunitName,
68  const G4String& xfcnName,
69  const G4String& yfcnName,
70  G4BinScheme xbinScheme)
71 {
72  hnInformation->SetDimension(kX, xunitName, xfcnName, xbinScheme);
73  hnInformation->SetDimension(kY, yunitName, yfcnName, G4BinScheme::kLinear);
74 }
75 
76 //_____________________________________________________________________________
77 void AddP1Annotation(tools::histo::p1d* p1d,
78  const G4String& xunitName,
79  const G4String& yunitName,
80  const G4String& xfcnName,
81  const G4String& yfcnName)
82 {
83  G4String xaxisTitle;
84  G4String yaxisTitle;
85  UpdateTitle(xaxisTitle, xunitName, xfcnName);
86  UpdateTitle(yaxisTitle, yunitName, yfcnName);
87  p1d->add_annotation(tools::histo::key_axis_x_title(), xaxisTitle);
88  p1d->add_annotation(tools::histo::key_axis_y_title(), yaxisTitle);
89 }
90 
91 //_____________________________________________________________________________
92 tools::histo::p1d* CreateToolsP1(const G4String& title,
93  G4int nbins, G4double xmin, G4double xmax,
94  G4double ymin, G4double ymax,
95  const G4String& xunitName,
96  const G4String& yunitName,
97  const G4String& xfcnName,
98  const G4String& yfcnName,
99  const G4String& xbinSchemeName)
100 {
101  auto xunit = GetUnitValue(xunitName);
102  auto yunit = GetUnitValue(yunitName);
103  auto xfcn = GetFunction(xfcnName);
104  auto yfcn = GetFunction(yfcnName);
105  auto xbinScheme = GetBinScheme(xbinSchemeName);
106 
107  if ( xbinScheme != G4BinScheme::kLog ) {
108  if ( xbinScheme == G4BinScheme::kUser ) {
109  // This should never happen, but let's make sure about it
110  // by issuing a warning
111  G4ExceptionDescription description;
112  description
113  << " User binning scheme setting was ignored." << G4endl
114  << " Linear binning will be applied with given (nbins, xmin, xmax) values";
115  G4Exception("G4P1ToolsManager::CreateP1",
116  "Analysis_W013", JustWarning, description);
117  }
118  if ( ymin == 0. && ymax == 0.) {
119  return new tools::histo::p1d(title,
120  nbins, xfcn(xmin/xunit), xfcn(xmax/xunit));
121  } else {
122  return new tools::histo::p1d(title,
123  nbins, xfcn(xmin/xunit), xfcn(xmax/xunit),
124  yfcn(ymin/yunit), yfcn(ymax/yunit));
125  }
126  }
127  else {
128  // Compute edges
129  std::vector<G4double> edges;
130  ComputeEdges(nbins, xmin, xmax, xunit, xfcn, xbinScheme, edges);
131  if ( ymin == 0. && ymax == 0.) {
132  return new tools::histo::p1d(title, edges);
133  } else {
134  return new tools::histo::p1d(title, edges, yfcn(ymin/yunit), yfcn(ymax/yunit));
135  }
136  }
137 }
138 
139 //_____________________________________________________________________________
140 tools::histo::p1d* CreateToolsP1(const G4String& title,
141  const std::vector<G4double>& edges,
142  G4double ymin, G4double ymax,
143  const G4String& xunitName,
144  const G4String& yunitName,
145  const G4String& xfcnName,
146  const G4String& yfcnName)
147 {
148  auto xunit = GetUnitValue(xunitName);
149  auto yunit = GetUnitValue(yunitName);
150  auto xfcn = GetFunction(xfcnName);
151  auto yfcn = GetFunction(yfcnName);
152 
153  // Apply function
154  std::vector<G4double> newEdges;
155  ComputeEdges(edges, xunit, xfcn, newEdges);
156 
157  return new tools::histo::p1d(title, newEdges, yfcn(ymin/yunit), yfcn(ymax/yunit));
158 }
159 
160 //_____________________________________________________________________________
161 void ConfigureToolsP1(tools::histo::p1d* p1d,
162  G4int nbins, G4double xmin, G4double xmax,
163  G4double ymin, G4double ymax,
164  const G4String& xunitName,
165  const G4String& yunitName,
166  const G4String& xfcnName,
167  const G4String& yfcnName,
168  const G4String& xbinSchemeName)
169 {
170  auto xunit = GetUnitValue(xunitName);
171  auto yunit = GetUnitValue(yunitName);
172  auto xfcn = GetFunction(xfcnName);
173  auto yfcn = GetFunction(yfcnName);
174  auto xbinScheme = GetBinScheme(xbinSchemeName);
175 
176  if ( xbinScheme != G4BinScheme::kLog ) {
177  if ( xbinScheme == G4BinScheme::kUser ) {
178  // This should never happen, but let's make sure about it
179  // by issuing a warning
180  G4ExceptionDescription description;
181  description
182  << " User binning scheme setting was ignored." << G4endl
183  << " Linear binning will be applied with given (nbins, xmin, xmax) values";
184  G4Exception("G4P1ToolsManager::SetP1",
185  "Analysis_W013", JustWarning, description);
186  }
187  if ( ymin == 0. && ymax == 0. ) {
188  p1d->configure(nbins, xfcn(xmin/xunit), xfcn(xmax/xunit));
189  } else {
190  p1d->configure(nbins, xfcn(xmin/xunit), xfcn(xmax/xunit),
191  yfcn(ymin/yunit), yfcn(ymax/yunit));
192  }
193  }
194  else {
195  // Compute bins
196  std::vector<G4double> edges;
197  ComputeEdges(nbins, xmin, xmax, xunit, xfcn, xbinScheme, edges);
198  if ( ymin == 0. && ymax == 0. ) {
199  p1d->configure(edges);
200  } else {
201  p1d->configure(edges, yfcn(ymin/yunit), yfcn(ymax/yunit));
202  }
203  }
204 }
205 
206 //_____________________________________________________________________________
207 void ConfigureToolsP1(tools::histo::p1d* p1d,
208  const std::vector<G4double>& edges,
209  G4double ymin, G4double ymax,
210  const G4String& xunitName,
211  const G4String& yunitName,
212  const G4String& xfcnName,
213  const G4String& yfcnName)
214 {
215  // Apply function to edges
216  auto xunit = GetUnitValue(xunitName);
217  auto yunit = GetUnitValue(yunitName);
218  auto xfcn = GetFunction(xfcnName);
219  auto yfcn = GetFunction(yfcnName);
220  std::vector<G4double> newEdges;
221  ComputeEdges(edges, xunit, xfcn, newEdges);
222 
223  if ( ymin == 0. && ymax == 0. ) {
224  p1d->configure(newEdges);
225  } else {
226  p1d->configure(newEdges, yfcn(ymin/yunit), yfcn(ymax/yunit));
227  }
228 }
229 
230 }
231 
232 //
233 // private methods
234 //
235 
236 //_____________________________________________________________________________
237 void G4P1ToolsManager::AddP1Information(const G4String& name,
238  const G4String& xunitName,
239  const G4String& yunitName,
240  const G4String& xfcnName,
241  const G4String& yfcnName,
242  G4BinScheme xbinScheme) const
243 {
244  auto hnInformation = fHnManager->AddHnInformation(name, 2);
245  hnInformation->AddDimension(xunitName, xfcnName, xbinScheme);
246  hnInformation->AddDimension(yunitName, yfcnName, G4BinScheme::kLinear);
247 }
248 
249 //
250 // protected methods
251 //
252 
253 //_____________________________________________________________________________
255  G4int nbins, G4double xmin, G4double xmax,
256  G4double ymin, G4double ymax,
257  const G4String& xunitName, const G4String& yunitName,
258  const G4String& xfcnName, const G4String& yfcnName,
259  const G4String& xbinSchemeName)
260 {
261 #ifdef G4VERBOSE
262  if ( fState.GetVerboseL4() )
263  fState.GetVerboseL4()->Message("create", "P1", name);
264 #endif
265  tools::histo::p1d* p1d
266  = CreateToolsP1(title, nbins, xmin, xmax, ymin, ymax,
267  xunitName, yunitName, xfcnName, yfcnName,
268  xbinSchemeName);
269 
270  // Add annotation
271  AddP1Annotation(p1d, xunitName, yunitName, xfcnName, yfcnName);
272 
273  // Save P1 information
274  auto xbinScheme = GetBinScheme(xbinSchemeName);
275  AddP1Information(
276  name, xunitName, yunitName, xfcnName, yfcnName, xbinScheme);
277 
278  // Register profile
279  G4int id = RegisterT(p1d, name);
280 
281 #ifdef G4VERBOSE
282  if ( fState.GetVerboseL2() )
283  fState.GetVerboseL2()->Message("create", "P1", name);
284 #endif
285  return id;
286 }
287 
288 //_____________________________________________________________________________
290  const std::vector<G4double>& edges,
291  G4double ymin, G4double ymax,
292  const G4String& xunitName, const G4String& yunitName,
293  const G4String& xfcnName, const G4String& yfcnName)
294 {
295 #ifdef G4VERBOSE
296  if ( fState.GetVerboseL4() )
297  fState.GetVerboseL4()->Message("create", "P1", name);
298 #endif
299  tools::histo::p1d* p1d
300  = CreateToolsP1(title, edges, ymin, ymax,
301  xunitName, yunitName, xfcnName, yfcnName);
302 
303  // Add annotation
304  AddP1Annotation(p1d, xunitName, yunitName, xfcnName, yfcnName);
305 
306  // Save P1 information
307  AddP1Information(
308  name, xunitName, yunitName, xfcnName, yfcnName, G4BinScheme::kUser);
309 
310  // Register profile
311  G4int id = RegisterT(p1d, name);
312 
313 #ifdef G4VERBOSE
314  if ( fState.GetVerboseL2() )
315  fState.GetVerboseL2()->Message("create", "P1", name);
316 #endif
317  return id;
318 }
319 
320 //_____________________________________________________________________________
322  G4int nbins, G4double xmin, G4double xmax,
323  G4double ymin, G4double ymax,
324  const G4String& xunitName, const G4String& yunitName,
325  const G4String& xfcnName, const G4String& yfcnName,
326  const G4String& xbinSchemeName)
327 {
328  auto p1d = GetTInFunction(id, "SetP1", false, false);
329  if ( ! p1d ) return false;
330 
331  auto info = fHnManager->GetHnInformation(id,"SetP1");
332 #ifdef G4VERBOSE
333  if ( fState.GetVerboseL4() )
334  fState.GetVerboseL4()->Message("configure", "P1", info->GetName());
335 #endif
336 
337  // Configure tools p1
338  ConfigureToolsP1(
339  p1d, nbins, xmin, xmax, ymin, ymax,
340  xunitName, yunitName, xfcnName, yfcnName, xbinSchemeName);
341 
342  // Add annotation
343  AddP1Annotation(p1d, xunitName, yunitName, xfcnName, yfcnName);
344 
345  // Update information
346  auto xbinScheme = GetBinScheme(xbinSchemeName);
347  UpdateP1Information(
348  info, xunitName, yunitName, xfcnName, yfcnName, xbinScheme);
349 
350  // Set activation
351  fHnManager->SetActivation(id, true);
352 
353  return true;
354 }
355 
356 //_____________________________________________________________________________
358  const std::vector<G4double>& edges,
359  G4double ymin, G4double ymax,
360  const G4String& xunitName, const G4String& yunitName,
361  const G4String& xfcnName, const G4String& yfcnName)
362 {
363  auto p1d = GetTInFunction(id, "SetP1", false, false);
364  if ( ! p1d ) return false;
365 
366  auto info = fHnManager->GetHnInformation(id,"SetP1");
367 #ifdef G4VERBOSE
368  if ( fState.GetVerboseL4() )
369  fState.GetVerboseL4()->Message("configure", "P1", info->GetName());
370 #endif
371 
372  // Configure tools p1
373  ConfigureToolsP1(p1d, edges, ymin, ymax,
374  xunitName, yunitName, xfcnName, yfcnName);
375 
376  // Add annotation
377  AddP1Annotation(p1d, xunitName, yunitName, xfcnName, yfcnName);
378 
379  // Update information
380  UpdateP1Information(
381  info, xunitName, yunitName, xfcnName, yfcnName, G4BinScheme::kUser);
382 
383  // Set activation
384  fHnManager->SetActivation(id, true);
385 
386  return true;
387 }
388 
389 
390 //_____________________________________________________________________________
392 {
393  auto p1d = GetTInFunction(id, "ScaleP1", false, false);
394  if ( ! p1d ) return false;
395 
396  return p1d->scale(factor);
397 }
398 
399 //_____________________________________________________________________________
401  G4double weight)
402 {
403  auto p1d = GetTInFunction(id, "FillP1", true, false);
404  if ( ! p1d ) return false;
405 
406  if ( fState.GetIsActivation() && ( ! fHnManager->GetActivation(id) ) ) {
407  //G4cout << "Skipping FillP1 for " << id << G4endl;
408  return false;
409  }
410 
411  auto xInfo
412  = fHnManager->GetHnDimensionInformation(id, kX, "FillP1");
413  auto yInfo
414  = fHnManager->GetHnDimensionInformation(id, kY, "FillP1");
415 
416  p1d->fill(xInfo->fFcn(xvalue/xInfo->fUnit),
417  yInfo->fFcn(yvalue/yInfo->fUnit), weight);
418 
419 #ifdef G4VERBOSE
420  if ( fState.GetVerboseL4() ) {
421  G4ExceptionDescription description;
422  description << " id " << id
423  << " xvalue " << xvalue
424  << " xfcn(xvalue/xunit) " << xInfo->fFcn(xvalue/xInfo->fUnit)
425  << " yvalue " << yvalue
426  << " yfcn(yvalue/yunit) " << yInfo->fFcn(yvalue/yInfo->fUnit)
427  << " weight " << weight;
428  fState.GetVerboseL4()->Message("fill", "P1", description);
429  }
430 #endif
431  return true;
432 }
433 
434 //_____________________________________________________________________________
436 {
437  return GetTId(name, warn);
438 }
439 
440 //_____________________________________________________________________________
442 {
443  auto p1d = GetTInFunction(id, "GetP1Nbins");
444  if ( ! p1d ) return 0;
445 
446  return GetNbins(*p1d, kX);
447 }
448 
449 //_____________________________________________________________________________
451 {
452 // Returns xmin value with applied unit and profile function
453 
454  auto p1d = GetTInFunction(id, "GetP1Xmin");
455  if ( ! p1d ) return 0.;
456 
457  return GetMin(*p1d, kX);
458 }
459 
460 //_____________________________________________________________________________
462 {
463  auto p1d = GetTInFunction(id, "GetP1Xmax");
464  if ( ! p1d ) return 0.;
465 
466  return GetMax(*p1d, kX);
467 }
468 
469 //_____________________________________________________________________________
471 {
472  auto p1d = GetTInFunction(id, "GetP1XWidth", true, false);
473  if ( ! p1d ) return 0.;
474 
475  return GetWidth(*p1d, kX, fHnManager->GetHnType());
476 }
477 
478 //_____________________________________________________________________________
480 {
481 // Returns xmin value with applied unit and profile function
482 
483  auto p1d = GetTInFunction(id, "GetP1Ymin");
484  if ( ! p1d ) return 0.;
485 
486  return p1d->min_v();
487 }
488 
489 //_____________________________________________________________________________
491 {
492  auto p1d = GetTInFunction(id, "GetP1Ymax");
493  if ( ! p1d ) return 0.;
494 
495  return p1d->max_v();
496 }
497 
498 //_____________________________________________________________________________
500 {
501  auto p1d = GetTInFunction(id, "SetP1Title");
502  if ( ! p1d ) return false;
503 
504  return SetTitle(*p1d, title);
505 }
506 
507 //_____________________________________________________________________________
509 {
510  auto p1d = GetTInFunction(id, "SetP1XAxisTitle");
511  if ( ! p1d ) return false;
512 
513  return SetAxisTitle(*p1d, kX, title);
514 }
515 
516 //_____________________________________________________________________________
518 {
519  auto p1d = GetTInFunction(id, "SetP1YAxisTitle");
520  if ( ! p1d ) return false;
521 
522  return SetAxisTitle(*p1d, kY, title);
523 }
524 
525 //_____________________________________________________________________________
527 {
528  auto p1d = GetTInFunction(id, "GetP1Title");
529  if ( ! p1d ) return "";
530 
531  return GetTitle(*p1d);
532 }
533 
534 
535 //_____________________________________________________________________________
537 {
538  auto p1d = GetTInFunction(id, "GetP1XAxisTitle");
539  if ( ! p1d ) return "";
540 
541  return GetAxisTitle(*p1d, kX, fHnManager->GetHnType());
542 }
543 
544 //_____________________________________________________________________________
546 {
547  auto p1d = GetTInFunction(id, "GetP1YAxisTitle");
548  if ( ! p1d ) return "";
549 
550  return GetAxisTitle(*p1d, kY, fHnManager->GetHnType());
551 }
552 
553 //
554 // public methods
555 //
556 
557 //_____________________________________________________________________________
558 G4int G4P1ToolsManager::AddP1(const G4String& name, tools::histo::p1d* p1d)
559 {
560 #ifdef G4VERBOSE
561  if ( fState.GetVerboseL4() )
562  fState.GetVerboseL4()->Message("add", "P1", name);
563 #endif
564 
565  // Add annotation
566  AddP1Annotation(p1d, "none", "none", "none", "none");
567  // Add information
568  AddP1Information(name, "none", "none", "none", "none", G4BinScheme::kLinear);
569 
570  // Register profile
571  auto id = RegisterT(p1d, name);
572 
573 #ifdef G4VERBOSE
574  if ( fState.GetVerboseL2() )
575  fState.GetVerboseL2()->Message("add", "P1", name);
576 #endif
577  return id;
578 }
579 
580 //_____________________________________________________________________________
582  const std::vector<tools::histo::p1d*>& p1Vector)
583 {
584  AddTVector(p1Vector);
585 }
586 
587 //_____________________________________________________________________________
588 tools::histo::p1d* G4P1ToolsManager::GetP1(G4int id, G4bool warn,
589  G4bool onlyIfActive) const
590 {
591  return GetTInFunction(id, "GetP1", warn, onlyIfActive);
592 }
593 
G4double GetWidth(const G4ToolsBaseHisto &baseHisto, G4int dimension, const G4String &hnType)
virtual ~G4P1ToolsManager()
const XML_Char XML_Encoding * info
Definition: expat.h:530
void Message(const G4String &action, const G4String &object, const G4String &objectName, G4bool success=true) const
const XML_Char * name
Definition: expat.h:151
G4String GetTitle(const G4ToolsBaseHisto &baseHisto)
G4String GetAxisTitle(const G4ToolsBaseHisto &baseHisto, G4int dimension, const G4String &hnType)
virtual G4double GetP1Xmin(G4int id) const final
G4double GetMin(const G4ToolsBaseHisto &baseHisto, G4int dimension)
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
void ComputeEdges(G4int nbins, G4double xmin, G4double xmax, G4double unit, G4Fcn fcn, G4BinScheme, std::vector< G4double > &edges)
Definition: G4BinScheme.cc:56
virtual G4int GetP1Id(const G4String &name, G4bool warn=true) const final
virtual G4String GetP1Title(G4int id) const final
virtual G4bool ScaleP1(G4int id, G4double factor) final
void AddP1Vector(const std::vector< tools::histo::p1d * > &p1Vector)
virtual G4bool FillP1(G4int id, G4double xvalue, G4double yvalue, G4double weight=1.0) final
virtual G4bool SetP1XAxisTitle(G4int id, const G4String &title) final
G4bool SetAxisTitle(G4ToolsBaseHisto &baseHisto, G4int dimension, const G4String &title)
virtual G4double GetP1Xmax(G4int id) const final
int G4int
Definition: G4Types.hh:78
std::shared_ptr< G4HnManager > fHnManager
Definition: G4THnManager.hh:83
virtual G4double GetP1Ymax(G4int id) const final
G4int RegisterT(tools::histo::p1d *t, const G4String &name)
const G4AnalysisVerbose * GetVerboseL2() const
void UpdateTitle(G4String &title, const G4String &unitName, const G4String &fcnName)
virtual G4bool SetP1YAxisTitle(G4int id, const G4String &title) final
const G4AnalysisManagerState & fState
Definition: G4THnManager.hh:80
G4int GetTId(const G4String &name, G4bool warn=true) const
const G4AnalysisVerbose * GetVerboseL4() const
bool G4bool
Definition: G4Types.hh:79
const G4int kX
tools::histo::p1d * GetTInFunction(G4int id, G4String functionName, G4bool warn=true, G4bool onlyIfActive=true) const
virtual G4bool SetP1Title(G4int id, const G4String &title) final
G4double GetUnitValue(const G4String &unit)
virtual G4double GetP1XWidth(G4int id) const final
G4bool SetTitle(G4ToolsBaseHisto &baseHisto, const G4String &title)
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4int AddP1(const G4String &name, tools::histo::p1d *p1d)
virtual G4bool SetP1(G4int id, G4int nbins, G4double xmin, G4double xmax, G4double ymin=0, G4double ymax=0, const G4String &xunitName="none", const G4String &yunitName="none", const G4String &xfcnName="none", const G4String &yfcnName="none", const G4String &xbinScheme="linear") final
G4Fcn GetFunction(const G4String &fcnName)
Definition: G4Fcn.cc:36
virtual G4int GetP1Nbins(G4int id) const final
void AddTVector(const std::vector< tools::histo::p1d * > &tVector)
G4BinScheme GetBinScheme(const G4String &binSchemeName)
Definition: G4BinScheme.cc:36
virtual G4String GetP1XAxisTitle(G4int id) const final
#define G4endl
Definition: G4ios.hh:61
G4double GetMax(const G4ToolsBaseHisto &baseHisto, G4int dimension)
G4BinScheme
Definition: G4BinScheme.hh:40
G4int GetNbins(const G4ToolsBaseHisto &baseHisto, G4int dimension)
double G4double
Definition: G4Types.hh:76
void AddDimension(const G4String &unitName, const G4String &fcnName, G4BinScheme binScheme)
const G4int kY
virtual G4String GetP1YAxisTitle(G4int id) const final
subroutine title
Definition: hijing1.383.f:5980
G4P1ToolsManager(const G4AnalysisManagerState &state)
virtual G4double GetP1Ymin(G4int id) const final
virtual G4int CreateP1(const G4String &name, const G4String &title, G4int nbins, G4double xmin, G4double xmax, G4double ymin=0, G4double ymax=0, const G4String &xunitName="none", const G4String &yunitName="none", const G4String &xfcnName="none", const G4String &yfcnName="none", const G4String &xbinScheme="linear") final
void SetDimension(G4int dimension, const G4String &unitName, const G4String &fcnName, G4BinScheme binScheme)
tools::histo::p1d * GetP1(G4int id, G4bool warn=true, G4bool onlyIfActive=true) const