Geant4  10.01.p01
G4H1ToolsManager.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: G4H1ToolsManager.cc 70604 2013-06-03 11:27:06Z ihrivnac $
27 
28 // Author: Ivana Hrivnacova, 18/06/2013 (ivana@ipno.in2p3.fr)
29 
30 #include "G4H1ToolsManager.hh"
31 #include "G4BaseToolsManager.hh"
32 #include "G4HnManager.hh"
34 #include "G4AnalysisUtilities.hh"
35 
36 #include "tools/histo/h1d"
37 
38 #include <fstream>
39 
40 using namespace G4Analysis;
41 
42 //
43 // Constructors, destructor
44 //
45 
46 //_____________________________________________________________________________
48  : G4VH1Manager(state),
49  fBaseToolsManager("H1"),
50  fH1Vector(),
51  fH1NameIdMap()
52 {
53 }
54 
55 //_____________________________________________________________________________
57 {
58  std::vector<tools::histo::h1d*>::iterator it;
59  for (it = fH1Vector.begin(); it != fH1Vector.end(); it++ ) {
60  delete (*it);
61  }
62 }
63 
64 //
65 // Utility functions
66 //
67 
68 namespace {
69 
70 //_____________________________________________________________________________
71 void UpdateH1Information(G4HnInformation* hnInformation,
72  const G4String& unitName,
73  const G4String& fcnName,
74  G4BinScheme binScheme)
75 {
76  G4double unit = GetUnitValue(unitName);
77  G4Fcn fcn = GetFunction(fcnName);
78  G4HnDimensionInformation* information
80  information->fUnitName = unitName;
81  information->fFcnName = fcnName;
82  information->fUnit = unit;
83  information->fFcn = fcn;
84  information->fBinScheme = binScheme;
85 }
86 
87 //_____________________________________________________________________________
88 void AddH1Annotation(tools::histo::h1d* h1d,
89  const G4String& unitName,
90  const G4String& fcnName)
91 {
92  G4String axisTitle;
93  UpdateTitle(axisTitle, unitName, fcnName);
94  h1d->add_annotation(tools::histo::key_axis_x_title(), axisTitle);
95 }
96 
97 //_____________________________________________________________________________
98 tools::histo::h1d* CreateToolsH1(const G4String& title,
99  G4int nbins, G4double xmin, G4double xmax,
100  const G4String& unitName,
101  const G4String& fcnName,
102  const G4String& binSchemeName)
103 {
104  G4double unit = GetUnitValue(unitName);
105  G4Fcn fcn = GetFunction(fcnName);
106  G4BinScheme binScheme = GetBinScheme(binSchemeName);
107 
108  if ( binScheme != kLogBinScheme ) {
109  if ( binScheme == kUserBinScheme ) {
110  // This should never happen, but let's make sure about it
111  // by issuing a warning
112  G4ExceptionDescription description;
113  description
114  << " User binning scheme setting was ignored." << G4endl
115  << " Linear binning will be applied with given (nbins, xmin, xmax) values";
116  G4Exception("G4H1ToolsManager::CreateH1",
117  "Analysis_W013", JustWarning, description);
118  }
119  return new tools::histo::h1d(title, nbins, fcn(xmin/unit), fcn(xmax/unit));
120  }
121  else {
122  // Compute edges
123  std::vector<G4double> edges;
124  ComputeEdges(nbins, xmin, xmax, unit, fcn, binScheme, edges);
125  return new tools::histo::h1d(title, edges);
126  }
127 }
128 
129 //_____________________________________________________________________________
130 tools::histo::h1d* CreateToolsH1(const G4String& title,
131  const std::vector<G4double>& edges,
132  const G4String& unitName,
133  const G4String& fcnName)
134 {
135  G4double unit = GetUnitValue(unitName);
136  G4Fcn fcn = GetFunction(fcnName);
137 
138  // Apply function
139  std::vector<G4double> newEdges;
140  ComputeEdges(edges, unit, fcn, newEdges);
141 
142  return new tools::histo::h1d(title, newEdges);
143 }
144 
145 //_____________________________________________________________________________
146 void ConfigureToolsH1(tools::histo::h1d* h1d,
147  G4int nbins, G4double xmin, G4double xmax,
148  const G4String& unitName,
149  const G4String& fcnName,
150  const G4String& binSchemeName)
151 {
152  G4double unit = GetUnitValue(unitName);
153  G4Fcn fcn = GetFunction(fcnName);
154  G4BinScheme binScheme = GetBinScheme(binSchemeName);
155 
156  if ( binScheme != kLogBinScheme ) {
157  if ( binScheme == kUserBinScheme ) {
158  // This should never happen, but let's make sure about it
159  // by issuing a warning
160  G4ExceptionDescription description;
161  description
162  << " User binning scheme setting was ignored." << G4endl
163  << " Linear binning will be applied with given (nbins, xmin, xmax) values";
164  G4Exception("G4H1ToolsManager::SetH1",
165  "Analysis_W013", JustWarning, description);
166  }
167  h1d->configure(nbins, fcn(xmin/unit), fcn(xmax/unit));
168  }
169  else {
170  // Compute bins
171  std::vector<G4double> edges;
172  ComputeEdges(nbins, xmin, xmax, unit, fcn, binScheme, edges);
173  h1d->configure(edges);
174  }
175 }
176 
177 //_____________________________________________________________________________
178 void ConfigureToolsH1(tools::histo::h1d* h1d,
179  const std::vector<G4double>& edges,
180  const G4String& unitName,
181  const G4String& fcnName)
182 {
183  // Apply function to edges
184  G4double unit = GetUnitValue(unitName);
185  G4Fcn fcn = GetFunction(fcnName);
186  std::vector<G4double> newEdges;
187  ComputeEdges(edges, unit, fcn, newEdges);
188 
189  h1d->configure(newEdges);
190 }
191 
192 }
193 
194 //
195 // private methods
196 //
197 
198 //_____________________________________________________________________________
200  G4String functionName, G4bool warn,
201  G4bool onlyIfActive) const
202 {
203  G4int index = id - fFirstId;
204  if ( index < 0 || index >= G4int(fH1Vector.size()) ) {
205  if ( warn) {
206  G4String inFunction = "G4H1ToolsManager::";
207  inFunction += functionName;
208  G4ExceptionDescription description;
209  description << " " << "histogram " << id << " does not exist.";
210  G4Exception(inFunction, "Analysis_W011", JustWarning, description);
211  }
212  return 0;
213  }
214 
215  // Do not return histogram if inactive
216  if ( fState.GetIsActivation() && onlyIfActive && ( ! fHnManager->GetActivation(id) ) ) {
217  return 0;
218  }
219 
220  return fH1Vector[index];
221 }
222 
223 //_____________________________________________________________________________
225  const G4String& unitName,
226  const G4String& fcnName,
227  G4BinScheme binScheme) const
228 {
229  G4double unit = GetUnitValue(unitName);
230  G4Fcn fcn = GetFunction(fcnName);
231  fHnManager->AddH1Information(name, unitName, fcnName, unit, fcn, binScheme);
232 }
233 
234 //_____________________________________________________________________________
235 G4int G4H1ToolsManager::RegisterToolsH1(tools::histo::h1d* h1d,
236  const G4String& name)
237 {
238  G4int index = fH1Vector.size();
239  fH1Vector.push_back(h1d);
240 
241  fLockFirstId = true;
242  fH1NameIdMap[name] = index + fFirstId;
243  return index + fFirstId;
244 }
245 
246 //
247 // protected methods
248 //
249 
250 //_____________________________________________________________________________
252  G4int nbins, G4double xmin, G4double xmax,
253  const G4String& unitName, const G4String& fcnName,
254  const G4String& binSchemeName)
255 {
256 #ifdef G4VERBOSE
257  if ( fState.GetVerboseL4() )
258  fState.GetVerboseL4()->Message("create", "H1", name);
259 #endif
260 
261  // Create H1
262  tools::histo::h1d* h1d
263  = CreateToolsH1(title, nbins, xmin, xmax, unitName, fcnName, binSchemeName);
264 
265  // Add annotation
266  AddH1Annotation(h1d, unitName, fcnName);
267 
268  // Save H1 information
269  G4BinScheme binScheme = GetBinScheme(binSchemeName);
270  AddH1Information(name, unitName, fcnName, binScheme);
271 
272  // Register histogram
273  G4int id = RegisterToolsH1(h1d, name);
274 
275 #ifdef G4VERBOSE
276  if ( fState.GetVerboseL2() )
277  fState.GetVerboseL2()->Message("create", "H1", name);
278 #endif
279  return id;
280 }
281 
282 //_____________________________________________________________________________
284  const std::vector<G4double>& edges,
285  const G4String& unitName, const G4String& fcnName)
286 {
287 #ifdef G4VERBOSE
288  if ( fState.GetVerboseL4() )
289  fState.GetVerboseL4()->Message("create", "H1", name);
290 #endif
291  tools::histo::h1d* h1d
292  = CreateToolsH1(title, edges, unitName, fcnName);
293 
294  // Add annotation
295  AddH1Annotation(h1d, unitName, fcnName);
296 
297  // Save H1 information
298  AddH1Information(name, unitName, fcnName, kUserBinScheme);
299 
300  // Register histogram
301  G4int id = RegisterToolsH1(h1d, name);
302 
303 #ifdef G4VERBOSE
304  if ( fState.GetVerboseL2() )
305  fState.GetVerboseL2()->Message("create", "H1", name);
306 #endif
307  return id;
308 }
309 
310 //_____________________________________________________________________________
312  G4int nbins, G4double xmin, G4double xmax,
313  const G4String& unitName, const G4String& fcnName,
314  const G4String& binSchemeName)
315 {
316  tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1", false, false);
317  if ( ! h1d ) return false;
318 
319  G4HnInformation* info = fHnManager->GetHnInformation(id,"SetH1");
320 #ifdef G4VERBOSE
321  if ( fState.GetVerboseL4() )
322  fState.GetVerboseL4()->Message("configure", "H1", info->GetName());
323 #endif
324 
325  // Configure tools h1
326  ConfigureToolsH1(h1d, nbins, xmin, xmax, unitName, fcnName, binSchemeName);
327 
328  // Add annotation
329  AddH1Annotation(h1d, unitName, fcnName);
330 
331  // Update information
332  G4BinScheme binScheme = GetBinScheme(binSchemeName);
333  UpdateH1Information(info, unitName, fcnName, binScheme);
334 
335  // Set activation
336  fHnManager->SetActivation(id, true);
337 
338  return true;
339 }
340 
341 //_____________________________________________________________________________
343  const std::vector<G4double>& edges,
344  const G4String& unitName,
345  const G4String& fcnName)
346 {
347  tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1", false, false);
348  if ( ! h1d ) return false;
349 
350  G4HnInformation* info = fHnManager->GetHnInformation(id,"SetH1");
351 #ifdef G4VERBOSE
352  if ( fState.GetVerboseL4() )
353  fState.GetVerboseL4()->Message("configure", "H1", info->GetName());
354 #endif
355 
356  // Configure tools h1
357  ConfigureToolsH1(h1d, edges, unitName, fcnName);
358 
359  // Add annotation
360  AddH1Annotation(h1d, unitName, fcnName);
361 
362  // Update information
363  UpdateH1Information(info, unitName, fcnName, kUserBinScheme);
364 
365  // Set activation
366  fHnManager->SetActivation(id, true);
367 
368  return true;
369 }
370 
371 
372 //_____________________________________________________________________________
374 {
375  tools::histo::h1d* h1d = GetH1InFunction(id, "ScaleH1", false, false);
376  if ( ! h1d ) return false;
377 
378  return h1d->scale(factor);
379 }
380 
381 //_____________________________________________________________________________
383 {
384  tools::histo::h1d* h1d = GetH1InFunction(id, "FillH1", true, false);
385  if ( ! h1d ) return false;
386 
387  if ( fState.GetIsActivation() && ( ! fHnManager->GetActivation(id) ) ) {
388  //G4cout << "Skipping FillH1 for " << id << G4endl;
389  return false;
390  }
391 
394  h1d->fill(info->fFcn(value/info->fUnit), weight);
395 #ifdef G4VERBOSE
396  if ( fState.GetVerboseL4() ) {
397  G4ExceptionDescription description;
398  description << " id " << id << " value " << value
399  << " fcn(value/unit) " << info->fFcn(value/info->fUnit)
400  << " weight " << weight;
401  fState.GetVerboseL4()->Message("fill", "H1", description);
402  }
403 #endif
404  return true;
405 }
406 
407 //_____________________________________________________________________________
409 {
410  std::map<G4String, G4int>::const_iterator it = fH1NameIdMap.find(name);
411  if ( it == fH1NameIdMap.end() ) {
412  if ( warn) {
413  G4String inFunction = "G4H1ToolsManager::GetH1Id";
414  G4ExceptionDescription description;
415  description << " " << "histogram " << name << " does not exist.";
416  G4Exception(inFunction, "Analysis_W011", JustWarning, description);
417  }
418  return kInvalidId;
419  }
420  return it->second;
421 }
422 
423 //_____________________________________________________________________________
425 {
426  tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1Nbins");
427  if ( ! h1d ) return 0;
428 
430 }
431 
432 //_____________________________________________________________________________
434 {
435 // Returns xmin value with applied unit and histogram function
436 
437  tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1Xmin");
438  if ( ! h1d ) return 0;
439 
441 }
442 
443 //_____________________________________________________________________________
445 {
446  tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1Xmax");
447  if ( ! h1d ) return 0;
448 
450 }
451 
452 //_____________________________________________________________________________
454 {
455  tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1XWidth", true, false);
456  if ( ! h1d ) return 0;
457 
459 }
460 
461 //_____________________________________________________________________________
463 {
464  tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1Title");
465  if ( ! h1d ) return false;
466 
467  return fBaseToolsManager.SetTitle(*h1d, title);
468 }
469 
470 //_____________________________________________________________________________
472 {
473  tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1XAxisTitle");
474  if ( ! h1d ) return false;
475 
477 }
478 
479 //_____________________________________________________________________________
481 {
482  tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1YAxisTitle");
483  if ( ! h1d ) return false;
484 
486 }
487 
488 //_____________________________________________________________________________
490 {
491  tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1Title");
492  if ( ! h1d ) return "";
493 
494  return fBaseToolsManager.GetTitle(*h1d);
495 }
496 
497 
498 //_____________________________________________________________________________
500 {
501  tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1XAxisTitle");
502  if ( ! h1d ) return "";
503 
505 }
506 
507 //_____________________________________________________________________________
509 {
510  tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1YAxisTitle");
511  if ( ! h1d ) return "";
512 
514 }
515 
516 //_____________________________________________________________________________
518 {
519 // Write selected objects on ASCII file
520 // According to the implementation by Michel Maire, originally in
521 // extended examples.
522 
523  // h1 histograms
524  for ( G4int i=0; i<G4int(fH1Vector.size()); ++i ) {
525  G4int id = i + fFirstId;
526  G4HnInformation* info = fHnManager->GetHnInformation(id,"WriteOnAscii");
527  // skip writing if activation is enabled and H1 is inactivated
528  if ( ! info->GetAscii() ) continue;
529  tools::histo::h1d* h1 = fH1Vector[i];
530 
531 #ifdef G4VERBOSE
532  if ( fState.GetVerboseL3() )
533  fState.GetVerboseL3()->Message("write on ascii", "h1d", info->GetName());
534 #endif
535 
536  output << "\n 1D histogram " << id << ": " << h1->title()
537  << "\n \n \t X \t\t Y" << G4endl;
538 
539  for (G4int j=0; j< G4int(h1->axis().bins()); ++j) {
540  output << " " << j << "\t"
541  << h1->axis().bin_center(j) << "\t"
542  << h1->bin_height(j) << G4endl;
543  }
544  }
545 
546  return true;
547 }
548 
549 //
550 // public methods
551 //
552 
553 //_____________________________________________________________________________
554 G4int G4H1ToolsManager::AddH1(const G4String& name, tools::histo::h1d* h1d)
555 {
556 #ifdef G4VERBOSE
557  if ( fState.GetVerboseL4() )
558  fState.GetVerboseL4()->Message("add", "H1", name);
559 #endif
560 
561  // Add annotation
562  AddH1Annotation(h1d, "none", "none");
563  // Add information
564  AddH1Information(name, "none", "none", kLinearBinScheme);
565 
566  // Register histogram
567  G4int id = RegisterToolsH1(h1d, name);
568 
569 #ifdef G4VERBOSE
570  if ( fState.GetVerboseL2() )
571  fState.GetVerboseL2()->Message("add", "H1", name);
572 #endif
573  return id;
574 }
575 
576 //_____________________________________________________________________________
578  const std::vector<tools::histo::h1d*>& h1Vector)
579 {
580 #ifdef G4VERBOSE
581  if ( fState.GetVerboseL4() )
582  fState.GetVerboseL4()->Message("merge", "all h1", "");
583 #endif
584  std::vector<tools::histo::h1d*>::const_iterator itw = h1Vector.begin();
585  std::vector<tools::histo::h1d*>::iterator it;
586  for (it = fH1Vector.begin(); it != fH1Vector.end(); it++ ) {
587  (*it)->add(*(*itw++));
588  }
589 #ifdef G4VERBOSE
590  if ( fState.GetVerboseL1() )
591  fState.GetVerboseL1()->Message("merge", "all h1", "");
592 #endif
593 }
594 
595 //_____________________________________________________________________________
597 {
598 // Reset histograms and ntuple
599 
600  G4bool finalResult = true;
601 
602  std::vector<tools::histo::h1d*>::iterator it;
603  for (it = fH1Vector.begin(); it != fH1Vector.end(); it++ ) {
604  G4bool result = (*it)->reset();
605  if ( ! result ) finalResult = false;
606  }
607 
608  return finalResult;
609 }
610 
611 //_____________________________________________________________________________
613 {
614  return ! fH1Vector.size();
615 }
616 
617 //_____________________________________________________________________________
618 tools::histo::h1d* G4H1ToolsManager::GetH1(G4int id, G4bool warn,
619  G4bool onlyIfActive) const
620 {
621  return GetH1InFunction(id, "GetH1", warn, onlyIfActive);
622 }
623 
void Message(const G4String &action, const G4String &object, const G4String &objectName, G4bool success=true) const
virtual G4bool SetH1YAxisTitle(G4int id, const G4String &title)
G4BaseToolsManager fBaseToolsManager
virtual G4bool SetH1XAxisTitle(G4int id, const G4String &title)
virtual ~G4H1ToolsManager()
G4bool SetTitle(G4ToolsBaseHisto &baseHisto, const G4String &title)
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
G4String GetTitle(const G4ToolsBaseHisto &baseHisto) const
virtual G4bool SetH1(G4int id, G4int nbins, G4double xmin, G4double xmax, const G4String &unitName="none", const G4String &fcnName="none", const G4String &binSchemeName="linear")
void ComputeEdges(G4int nbins, G4double xmin, G4double xmax, G4double unit, G4Fcn fcn, G4BinScheme, std::vector< G4double > &edges)
Definition: G4BinScheme.cc:56
static const G4int kY
G4String name
Definition: TRTMaterials.hh:40
virtual G4double GetH1Xmin(G4int id) const
void AddH1Information(const G4String &name, const G4String &unitName, const G4String &fcnName, G4double unit, G4Fcn fx, G4BinScheme binScheme)
Definition: G4HnManager.cc:57
tools::histo::h1d * GetH1(G4int id, G4bool warn=true, G4bool onlyIfActive=true) const
G4double(* G4Fcn)(G4double)
Definition: G4Fcn.hh:36
virtual G4bool SetH1Title(G4int id, const G4String &title)
int G4int
Definition: G4Types.hh:78
G4String GetAxisTitle(const G4ToolsBaseHisto &baseHisto, G4int dimension) const
G4HnInformation * GetHnInformation(G4int id, G4String functionName="", G4bool warn=true) const
Definition: G4HnManager.cc:123
G4bool GetActivation(G4int id) const
Definition: G4HnManager.cc:270
const G4AnalysisVerbose * GetVerboseL2() const
void UpdateTitle(G4String &title, const G4String &unitName, const G4String &fcnName)
std::vector< tools::histo::h1d * > fH1Vector
virtual G4String GetH1XAxisTitle(G4int id) const
const G4AnalysisVerbose * GetVerboseL3() const
G4int GetNbins(const G4ToolsBaseHisto &baseHisto, G4int dimension) const
void AddH1Information(const G4String &name, const G4String &unitName, const G4String &fcnName, G4BinScheme binScheme) const
virtual G4int GetH1Nbins(G4int id) const
const G4AnalysisVerbose * GetVerboseL4() const
bool G4bool
Definition: G4Types.hh:79
virtual G4int GetH1Id(const G4String &name, G4bool warn=true) const
G4double GetWidth(const G4ToolsBaseHisto &baseHisto, G4int dimension) const
virtual G4bool WriteOnAscii(std::ofstream &output)
virtual tools::histo::h1d * GetH1InFunction(G4int id, G4String functionName, G4bool warn=true, G4bool onlyIfActive=true) const
G4double GetUnitValue(const G4String &unit)
virtual G4int CreateH1(const G4String &name, const G4String &title, G4int nbins, G4double xmin, G4double xmax, const G4String &unitName="none", const G4String &fcnName="none", const G4String &binScheme="linear")
std::map< G4String, G4int > fH1NameIdMap
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4HnManager * fHnManager
static const G4double factor
virtual G4double GetH1Width(G4int id) const
G4Fcn GetFunction(const G4String &fcnName)
Definition: G4Fcn.cc:36
virtual G4String GetH1YAxisTitle(G4int id) const
G4double GetMax(const G4ToolsBaseHisto &baseHisto, G4int dimension) const
G4int AddH1(const G4String &name, tools::histo::h1d *h1d)
G4H1ToolsManager(const G4AnalysisManagerState &state)
G4HnDimensionInformation * GetHnDimensionInformation(G4int dimension)
G4BinScheme GetBinScheme(const G4String &binSchemeName)
Definition: G4BinScheme.cc:36
G4bool GetAscii() const
#define G4endl
Definition: G4ios.hh:61
G4String GetName() const
G4BinScheme
Definition: G4BinScheme.hh:40
void AddH1Vector(const std::vector< tools::histo::h1d * > &h1Vector)
virtual G4double GetH1Xmax(G4int id) const
G4int RegisterToolsH1(tools::histo::h1d *h1d, const G4String &name)
double G4double
Definition: G4Types.hh:76
G4double GetMin(const G4ToolsBaseHisto &baseHisto, G4int dimension) const
virtual G4bool ScaleH1(G4int id, G4double factor)
const G4int kInvalidId
virtual G4String GetH1Title(G4int id) const
virtual G4bool FillH1(G4int id, G4double value, G4double weight=1.0)
const G4AnalysisVerbose * GetVerboseL1() const
void SetActivation(G4bool activation)
Definition: G4HnManager.cc:188
G4bool IsEmpty() const
const G4AnalysisManagerState & fState
G4bool SetAxisTitle(G4ToolsBaseHisto &baseHisto, G4int dimension, const G4String &title)
static const G4int kX
G4HnDimensionInformation * GetHnDimensionInformation(G4int id, G4int dimension, G4String functionName="", G4bool warn=true) const
Definition: G4HnManager.cc:145