Geant4  10.00.p02
G4H2ToolsManager.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: G4H2ToolsManager.cc 70604 2013-06-03 11:27:06Z ihrivnac $
27 
28 // Author: Ivana Hrivnacova, 18/06/2013 (ivana@ipno.in2p3.fr)
29 
30 #include "G4H2ToolsManager.hh"
31 #include "G4HnManager.hh"
32 #include "G4AnalysisManagerState.hh"
33 #include "G4AnalysisUtilities.hh"
34 
35 #include "tools/histo/h2d"
36 
37 #include <fstream>
38 
39 using namespace G4Analysis;
40 
41 //_____________________________________________________________________________
42 G4H2ToolsManager::G4H2ToolsManager(const G4AnalysisManagerState& state)
43  : G4VH2Manager(state),
44  fH2Vector(),
45  fH2NameIdMap()
46 {
47 }
48 
49 //_____________________________________________________________________________
50 G4H2ToolsManager::~G4H2ToolsManager()
51 {
52  std::vector<tools::histo::h2d*>::iterator it;
53  for (it = fH2Vector.begin(); it != fH2Vector.end(); it++ ) {
54  delete (*it);
55  }
56 }
57 
58 //
59 // Utility functions
60 //
61 
62 namespace {
63 
64 //_____________________________________________________________________________
65 void UpdateH2Information(G4HnInformation* information,
66  const G4String& xunitName,
67  const G4String& yunitName,
68  const G4String& xfcnName,
69  const G4String& yfcnName,
70  G4BinScheme xbinScheme,
71  G4BinScheme ybinScheme)
72 {
73  G4double xunit = GetUnitValue(xunitName);
74  G4double yunit = GetUnitValue(yunitName);
75  G4Fcn xfcn = GetFunction(xfcnName);
76  G4Fcn yfcn = GetFunction(yfcnName);
77  information->fXUnitName = xunitName;
78  information->fYUnitName = yunitName;
79  information->fXFcnName = xfcnName;
80  information->fYFcnName = yfcnName;
81  information->fXUnit = xunit;
82  information->fYUnit = yunit;
83  information->fXFcn = xfcn;
84  information->fYFcn = yfcn;
85  information->fXBinScheme = xbinScheme;
86  information->fYBinScheme = ybinScheme;
87 }
88 
89 //_____________________________________________________________________________
90 void AddH2Annotation(tools::histo::h2d* h2d,
91  const G4String& xunitName,
92  const G4String& yunitName,
93  const G4String& xfcnName,
94  const G4String& yfcnName)
95 {
96  G4String xaxisTitle;
97  G4String yaxisTitle;
98  UpdateTitle(xaxisTitle, xunitName, xfcnName);
99  UpdateTitle(yaxisTitle, yunitName, yfcnName);
100  h2d->add_annotation(tools::histo::key_axis_x_title(), xaxisTitle);
101  h2d->add_annotation(tools::histo::key_axis_y_title(), yaxisTitle);
102 }
103 
104 //_____________________________________________________________________________
105 tools::histo::h2d* CreateToolsH2(
106  const G4String& title,
107  G4int nxbins, G4double xmin, G4double xmax,
108  G4int nybins, G4double ymin, G4double ymax,
109  const G4String& xfcnName,
110  const G4String& yfcnName,
111  const G4String& xbinSchemeName,
112  const G4String& ybinSchemeName)
113 {
114  G4Fcn xfcn = GetFunction(xfcnName);
115  G4Fcn yfcn = GetFunction(yfcnName);
116  G4BinScheme xbinScheme = GetBinScheme(xbinSchemeName);
117  G4BinScheme ybinScheme = GetBinScheme(ybinSchemeName);
118 
119  if ( xbinScheme != kLogBinScheme && ybinScheme != kLogBinScheme) {
120  if ( xbinScheme == kUserBinScheme || ybinScheme == kUserBinScheme) {
121  // This should never happen, but let's make sure about it
122  // by issuing a warning
123  G4ExceptionDescription description;
124  description
125  << " User binning scheme setting was ignored." << G4endl
126  << " Linear binning will be applied with given (nbins, xmin, xmax) values";
127  G4Exception("G4H2ToolsManager::CreateH2",
128  "Analysis_W013", JustWarning, description);
129  }
130  return new tools::histo::h2d(title,
131  nxbins, xfcn(xmin), xfcn(xmax),
132  nybins, yfcn(ymin), yfcn(ymax));
133  // h2 objects are deleted in destructor and reset when
134  // closing a file.
135  }
136  else {
137  // Compute edges
138  std::vector<G4double> xedges;
139  ComputeEdges(nxbins, xmin, xmax, xfcn, xbinScheme, xedges);
140  std::vector<G4double> yedges;
141  ComputeEdges(nybins, ymin, ymax, yfcn, ybinScheme, yedges);
142  return new tools::histo::h2d(title, xedges, yedges);
143  }
144 }
145 
146 //_____________________________________________________________________________
147 tools::histo::h2d* CreateToolsH2(
148  const G4String& title,
149  const std::vector<G4double>& xedges,
150  const std::vector<G4double>& yedges,
151  const G4String& xfcnName,
152  const G4String& yfcnName)
153 {
154  G4Fcn xfcn = GetFunction(xfcnName);
155  G4Fcn yfcn = GetFunction(yfcnName);
156 
157  // Apply function
158  std::vector<G4double> xnewEdges;
159  ComputeEdges(xedges, xfcn, xnewEdges);
160  std::vector<G4double> ynewEdges;
161  ComputeEdges(yedges, yfcn, ynewEdges);
162 
163  return new tools::histo::h2d(title, xnewEdges, ynewEdges);
164  // h2 objects are deleted in destructor and reset when
165  // closing a file.
166 }
167 
168 //_____________________________________________________________________________
169 void ConfigureToolsH2(tools::histo::h2d* h2d,
170  G4int nxbins, G4double xmin, G4double xmax,
171  G4int nybins, G4double ymin, G4double ymax,
172  const G4String& xfcnName,
173  const G4String& yfcnName,
174  const G4String& xbinSchemeName,
175  const G4String& ybinSchemeName)
176 {
177  G4Fcn xfcn = GetFunction(xfcnName);
178  G4Fcn yfcn = GetFunction(yfcnName);
179  G4BinScheme xbinScheme = GetBinScheme(xbinSchemeName);
180  G4BinScheme ybinScheme = GetBinScheme(ybinSchemeName);
181 
182  if ( xbinScheme != kLogBinScheme && ybinScheme != kLogBinScheme) {
183  if ( xbinScheme == kUserBinScheme || ybinScheme == kUserBinScheme) {
184  // This should never happen, but let's make sure about it
185  // by issuing a warning
186  G4ExceptionDescription description;
187  description
188  << " User binning scheme setting was ignored." << G4endl
189  << " Linear binning will be applied with given (nbins, xmin, xmax) values";
190  G4Exception("G4H2ToolsManager::CreateH2",
191  "Analysis_W013", JustWarning, description);
192  }
193  h2d->configure(nxbins, xfcn(xmin), xfcn(xmax),
194  nybins, yfcn(ymin), yfcn(ymax));
195  }
196  else {
197  // Compute bins
198  std::vector<G4double> xedges;
199  ComputeEdges(nxbins, xmin, xmax, xfcn, xbinScheme, xedges);
200  std::vector<G4double> yedges;
201  ComputeEdges(nybins, ymin, ymax, yfcn, ybinScheme, yedges);
202  h2d->configure(xedges, yedges);
203  }
204 }
205 
206 //_____________________________________________________________________________
207 void ConfigureToolsH2(tools::histo::h2d* h2d,
208  const std::vector<G4double>& xedges,
209  const std::vector<G4double>& yedges,
210  const G4String& xfcnName,
211  const G4String& yfcnName)
212 {
213  G4Fcn xfcn = GetFunction(xfcnName);
214  std::vector<G4double> xnewEdges;
215  ComputeEdges(xedges, xfcn, xnewEdges);
216 
217  G4Fcn yfcn = GetFunction(yfcnName);
218  std::vector<G4double> ynewEdges;
219  ComputeEdges(yedges, yfcn, ynewEdges);
220 
221  h2d->configure(xnewEdges, ynewEdges);
222 }
223 
224 }
225 
226 
227 //
228 // private methods
229 //
230 
231 //_____________________________________________________________________________
232 tools::histo::h2d* G4H2ToolsManager::GetH2InFunction(G4int id,
233  G4String functionName, G4bool warn,
234  G4bool onlyIfActive) const
235 {
236  G4int index = id - fFirstId;
237  if ( index < 0 || index >= G4int(fH2Vector.size()) ) {
238  if ( warn) {
239  G4String inFunction = "G4H2ToolsManager::";
240  inFunction += functionName;
241  G4ExceptionDescription description;
242  description << " " << "histogram " << id << " does not exist.";
243  G4Exception(inFunction, "Analysis_W007", JustWarning, description);
244  }
245  return 0;
246  }
247 
248  // Do not return histogram if inactive
249  if ( fState.GetIsActivation() && onlyIfActive &&
250  ( ! fHnManager->GetActivation(id) ) ) {
251  return 0;
252  }
253 
254  return fH2Vector[index];
255 }
256 
257 
258 //_____________________________________________________________________________
259 void G4H2ToolsManager::AddH2Information(const G4String& name,
260  const G4String& xunitName,
261  const G4String& yunitName,
262  const G4String& xfcnName,
263  const G4String& yfcnName,
264  G4BinScheme xbinScheme,
265  G4BinScheme ybinScheme) const
266 {
267  G4double xunit = GetUnitValue(xunitName);
268  G4double yunit = GetUnitValue(yunitName);
269  G4Fcn xfcn = GetFunction(xfcnName);
270  G4Fcn yfcn = GetFunction(yfcnName);
271  fHnManager
272  ->AddH2Information(name, xunitName, yunitName, xfcnName, yfcnName,
273  xunit, yunit, xfcn, yfcn,
274  xbinScheme, ybinScheme);
275 }
276 
277 //_____________________________________________________________________________
278 G4int G4H2ToolsManager::RegisterToolsH2(tools::histo::h2d* h2d,
279  const G4String& name)
280 {
281  G4int index = fH2Vector.size();
282  fH2Vector.push_back(h2d);
283 
284  fLockFirstId = true;
285  fH2NameIdMap[name] = index + fFirstId;
286  return index + fFirstId;
287 }
288 
289 //
290 // protected methods
291 //
292 
293 //_____________________________________________________________________________
294 G4int G4H2ToolsManager::CreateH2(const G4String& name, const G4String& title,
295  G4int nxbins, G4double xmin, G4double xmax,
296  G4int nybins, G4double ymin, G4double ymax,
297  const G4String& xunitName, const G4String& yunitName,
298  const G4String& xfcnName, const G4String& yfcnName,
299  const G4String& xbinSchemeName,
300  const G4String& ybinSchemeName)
301 
302 {
303 #ifdef G4VERBOSE
304  if ( fState.GetVerboseL4() )
305  fState.GetVerboseL4()->Message("create", "H2", name);
306 #endif
307  tools::histo::h2d* h2d
308  = CreateToolsH2(title, nxbins, xmin, xmax, nybins, ymin, ymax,
309  xfcnName, yfcnName, xbinSchemeName, ybinSchemeName);
310 
311  // Add annotation
312  AddH2Annotation(h2d, xunitName, yunitName, xfcnName, yfcnName);
313 
314  // Save H2 information
315  G4BinScheme xbinScheme = GetBinScheme(xbinSchemeName);
316  G4BinScheme ybinScheme = GetBinScheme(ybinSchemeName);
317  AddH2Information(
318  name, xunitName, yunitName, xfcnName, yfcnName, xbinScheme, ybinScheme);
319 
320  // Register histogram
321  G4int id = RegisterToolsH2(h2d, name);
322 
323 #ifdef G4VERBOSE
324  if ( fState.GetVerboseL2() )
325  fState.GetVerboseL2()->Message("create", "H2", name);
326 #endif
327 
328  return id;
329 }
330 
331 //_____________________________________________________________________________
332 G4int G4H2ToolsManager::CreateH2(const G4String& name, const G4String& title,
333  const std::vector<G4double>& xedges,
334  const std::vector<G4double>& yedges,
335  const G4String& xunitName, const G4String& yunitName,
336  const G4String& xfcnName, const G4String& yfcnName)
337 
338 {
339 #ifdef G4VERBOSE
340  if ( fState.GetVerboseL4() )
341  fState.GetVerboseL4()->Message("create", "H2", name);
342 #endif
343  tools::histo::h2d* h2d
344  = CreateToolsH2(title, xedges, yedges, xfcnName, yfcnName);
345 
346  // Add annotation
347  AddH2Annotation(h2d, xunitName, yunitName, xfcnName, yfcnName);
348 
349  // Save H2 information
350  AddH2Information(
351  name, xunitName, yunitName, xfcnName, yfcnName, kUserBinScheme, kUserBinScheme);
352 
353  // Register histogram
354  G4int id = RegisterToolsH2(h2d, name);
355 
356 #ifdef G4VERBOSE
357  if ( fState.GetVerboseL2() )
358  fState.GetVerboseL2()->Message("create", "H2", name);
359 #endif
360 
361  return id;
362 }
363 
364 //_____________________________________________________________________________
365 G4bool G4H2ToolsManager::SetH2(G4int id,
366  G4int nxbins, G4double xmin, G4double xmax,
367  G4int nybins, G4double ymin, G4double ymax,
368  const G4String& xunitName, const G4String& yunitName,
369  const G4String& xfcnName, const G4String& yfcnName,
370  const G4String& xbinSchemeName,
371  const G4String& ybinSchemeName)
372 {
373  tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2", false, false);
374  if ( ! h2d ) return false;
375 
376  G4HnInformation* info = fHnManager->GetHnInformation(id, "SetH2");
377 #ifdef G4VERBOSE
378  if ( fState.GetVerboseL4() )
379  fState.GetVerboseL4()->Message("configure", "H2", info->fName);
380 #endif
381 
382  // Configure tools h2
383  ConfigureToolsH2(
384  h2d, nxbins, xmin, xmax, nybins, ymin, ymax, xfcnName, yfcnName,
385  xbinSchemeName, xbinSchemeName);
386 
387  // Add annotation
388  AddH2Annotation(h2d, xunitName, yunitName, xfcnName, yfcnName);
389 
390  // Update information
391  G4BinScheme xbinScheme = GetBinScheme(xbinSchemeName);
392  G4BinScheme ybinScheme = GetBinScheme(ybinSchemeName);
393  UpdateH2Information(
394  info, xunitName, yunitName, xfcnName, yfcnName, xbinScheme, ybinScheme);
395 
396  // Set activation
397  fHnManager->SetActivation(id, true);
398 
399  return true;
400 }
401 
402 //_____________________________________________________________________________
403 G4bool G4H2ToolsManager::SetH2(G4int id,
404  const std::vector<G4double>& xedges,
405  const std::vector<G4double>& yedges,
406  const G4String& xunitName, const G4String& yunitName,
407  const G4String& xfcnName, const G4String& yfcnName)
408 {
409  tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2", false, false);
410  if ( ! h2d ) return false;
411 
412  G4HnInformation* info = fHnManager->GetHnInformation(id, "SetH2");
413 #ifdef G4VERBOSE
414  if ( fState.GetVerboseL4() )
415  fState.GetVerboseL4()->Message("configure", "H2", info->fName);
416 #endif
417 
418  // Configure tools h2
419  ConfigureToolsH2(h2d, xedges, yedges, xfcnName, yfcnName);
420 
421  // Add annotation
422  AddH2Annotation(h2d, xunitName, yunitName, xfcnName, yfcnName);
423 
424  // Update information
425  UpdateH2Information(
426  info, xunitName, yunitName, xfcnName, yfcnName, kUserBinScheme, kUserBinScheme);
427 
428  // Set activation
429  fHnManager->SetActivation(id, true);
430 
431  return true;
432 }
433 
434 //_____________________________________________________________________________
435 G4bool G4H2ToolsManager::ScaleH2(G4int id, G4double factor)
436 {
437  tools::histo::h2d* h2d = GetH2InFunction(id, "ScaleH2", false, false);
438  if ( ! h2d ) return false;
439 
440  return h2d->scale(factor);
441 }
442 
443 //_____________________________________________________________________________
444 G4bool G4H2ToolsManager::FillH2(G4int id,
445  G4double xvalue, G4double yvalue,
446  G4double weight)
447 {
448  tools::histo::h2d* h2d = GetH2InFunction(id, "FillH2", true, false);
449  if ( ! h2d ) return false;
450 
451  if ( fState.GetIsActivation() && ( ! fHnManager->GetActivation(id) ) ) {
452  return false;
453  }
454 
455  G4HnInformation* info = fHnManager->GetHnInformation(id, "FillH2");
456  h2d->fill(info->fXFcn(xvalue/info->fXUnit),
457  info->fYFcn(yvalue/info->fYUnit), weight);
458 #ifdef G4VERBOSE
459  if ( fState.GetVerboseL4() ) {
460  G4ExceptionDescription description;
461  description << " id " << id
462  << " xvalue " << xvalue << " yvalue " << yvalue;
463  fState.GetVerboseL4()->Message("fill", "H2", description);
464  }
465 #endif
466  return true;
467 }
468 
469 //_____________________________________________________________________________
470 G4int G4H2ToolsManager::GetH2Id(const G4String& name, G4bool warn) const
471 {
472  std::map<G4String, G4int>::const_iterator it = fH2NameIdMap.find(name);
473  if ( it == fH2NameIdMap.end() ) {
474  if ( warn) {
475  G4String inFunction = "G4H2ToolsManager::GetH2Id";
476  G4ExceptionDescription description;
477  description << " " << "histogram " << name << " does not exist.";
478  G4Exception(inFunction, "Analysis_W007", JustWarning, description);
479  }
480  return -1;
481  }
482  return it->second;
483 }
484 
485 //_____________________________________________________________________________
486 G4int G4H2ToolsManager::GetH2Nxbins(G4int id) const
487 {
488  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2NXbins");
489  if ( ! h2d ) return 0;
490 
491  return h2d->axis_x().bins();
492 }
493 
494 //_____________________________________________________________________________
495 G4double G4H2ToolsManager::GetH2Xmin(G4int id) const
496 {
497 // Returns xmin value with applied unit and histogram function
498 
499  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Xmin");
500  if ( ! h2d ) return 0;
501 
502  return h2d->axis_x().lower_edge();
503 }
504 
505 //_____________________________________________________________________________
506 G4double G4H2ToolsManager::GetH2Xmax(G4int id) const
507 {
508  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Xmax");
509  if ( ! h2d ) return 0;
510 
511  return h2d->axis_x().upper_edge();
512 }
513 
514 //_____________________________________________________________________________
515 G4double G4H2ToolsManager::GetH2XWidth(G4int id) const
516 {
517  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2XWidth", true, false);
518  if ( ! h2d ) return 0;
519 
520  G4int nbins = h2d->axis_x().bins();
521  if ( ! nbins ) {
522  G4ExceptionDescription description;
523  description << " nbins = 0 (for h2 id = " << id << ").";
524  G4Exception("G4H2ToolsManager::GetH2Width",
525  "Analysis_W014", JustWarning, description);
526  return 0;
527  }
528 
529  return ( h2d->axis_x().upper_edge() - h2d->axis_x().lower_edge())/nbins;
530 }
531 
532 //_____________________________________________________________________________
533 G4int G4H2ToolsManager::GetH2Nybins(G4int id) const
534 {
535  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2NYbins");
536  if ( ! h2d ) return 0;
537 
538  return h2d->axis_y().bins();
539 }
540 
541 //_____________________________________________________________________________
542 G4double G4H2ToolsManager::GetH2Ymin(G4int id) const
543 {
544 // Returns xmin value with applied unit and histogram function
545 
546  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Ymin");
547  if ( ! h2d ) return 0;
548 
549  return h2d->axis_y().lower_edge();
550 }
551 
552 //_____________________________________________________________________________
553 G4double G4H2ToolsManager::GetH2Ymax(G4int id) const
554 {
555  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Ymax");
556  if ( ! h2d ) return 0;
557 
558  return h2d->axis_y().upper_edge();
559 }
560 
561 //_____________________________________________________________________________
562 G4double G4H2ToolsManager::GetH2YWidth(G4int id) const
563 {
564  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2YWidth", true, false);
565  if ( ! h2d ) return 0;
566 
567  G4int nbins = h2d->axis_y().bins();
568  if ( ! nbins ) {
569  G4ExceptionDescription description;
570  description << " nbins = 0 (for h2 id = " << id << ").";
571  G4Exception("G4H2ToolsManager::GetH2Width",
572  "Analysis_W014", JustWarning, description);
573  return 0;
574  }
575 
576  return ( h2d->axis_y().upper_edge() - h2d->axis_y().lower_edge())/nbins;
577 }
578 
579 //_____________________________________________________________________________
580 G4bool G4H2ToolsManager::SetH2Title(G4int id, const G4String& title)
581 {
582  tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2Title");
583  if ( ! h2d ) return false;
584 
585  return h2d->set_title(title);
586 }
587 
588 //_____________________________________________________________________________
589 G4bool G4H2ToolsManager::SetH2XAxisTitle(G4int id, const G4String& title)
590 {
591  tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2XAxisTitle");
592  if ( ! h2d ) return false;
593 
594  h2d->add_annotation(tools::histo::key_axis_x_title(), title);
595  return true;
596 }
597 
598 //_____________________________________________________________________________
599 G4bool G4H2ToolsManager::SetH2YAxisTitle(G4int id, const G4String& title)
600 {
601  tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2YAxisTitle");
602  if ( ! h2d ) return false;
603 
604  h2d->add_annotation(tools::histo::key_axis_y_title(), title);
605  return true;
606 }
607 
608 //_____________________________________________________________________________
609 G4bool G4H2ToolsManager::SetH2ZAxisTitle(G4int id, const G4String& title)
610 {
611  tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2ZAxisTitle");
612  if ( ! h2d ) return false;
613 
614  h2d->add_annotation(tools::histo::key_axis_z_title(), title);
615  return true;
616 }
617 
618 //_____________________________________________________________________________
619 G4String G4H2ToolsManager::GetH2Title(G4int id) const
620 {
621  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Title");
622  if ( ! h2d ) return "";
623 
624  return h2d->title();
625 }
626 
627 //_____________________________________________________________________________
628 G4String G4H2ToolsManager::GetH2XAxisTitle(G4int id) const
629 {
630  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2XAxisTitle");
631  if ( ! h2d ) return "";
632 
633  G4String title;
634  G4bool result = h2d->annotation(tools::histo::key_axis_x_title(), title);
635  if ( ! result ) {
636  G4ExceptionDescription description;
637  description << " Failed to get x_axis title for h2 id = " << id << ").";
638  G4Exception("G4H2ToolsManager::GetH2XAxisTitle",
639  "Analysis_W014", JustWarning, description);
640  return "";
641  }
642 
643  return title;
644 }
645 
646 //_____________________________________________________________________________
647 G4String G4H2ToolsManager::GetH2YAxisTitle(G4int id) const
648 {
649  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2YAxisTitle");
650  if ( ! h2d ) return "";
651 
652  G4String title;
653  G4bool result = h2d->annotation(tools::histo::key_axis_y_title(), title);
654  if ( ! result ) {
655  G4ExceptionDescription description;
656  description << " Failed to get y_axis title for h2 id = " << id << ").";
657  G4Exception("G4H2ToolsManager::GetH2YAxisTitle",
658  "Analysis_W014", JustWarning, description);
659  return "";
660  }
661 
662  return title;
663 }
664 
665 //_____________________________________________________________________________
666 G4String G4H2ToolsManager::GetH2ZAxisTitle(G4int id) const
667 {
668  tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2ZAxisTitle");
669  if ( ! h2d ) return "";
670 
671  G4String title;
672  G4bool result = h2d->annotation(tools::histo::key_axis_z_title(), title);
673  if ( ! result ) {
674  G4ExceptionDescription description;
675  description << " Failed to get z_axis title for h2 id = " << id << ").";
676  G4Exception("G4H2ToolsManager::GetH2ZAxisTitle",
677  "Analysis_W014", JustWarning, description);
678  return "";
679  }
680 
681  return title;
682 }
683 
684 //_____________________________________________________________________________
685 G4bool G4H2ToolsManager::WriteOnAscii(std::ofstream& /*output*/)
686 {
687 // Write selected objects on ASCII file
688 // According to the implementation by Michel Maire, originally in
689 // extended examples.
690 // Not yet available for H2
691 
692  return ! fHnManager->IsAscii();
693 }
694 
695 //
696 // public methods
697 //
698 
699 //_____________________________________________________________________________
700 void G4H2ToolsManager::AddH2Vector(
701  const std::vector<tools::histo::h2d*>& h2Vector)
702 {
703 #ifdef G4VERBOSE
704  if ( fState.GetVerboseL4() )
705  fState.GetVerboseL4()->Message("merge", "all h2", "");
706 #endif
707  std::vector<tools::histo::h2d*>::const_iterator itw = h2Vector.begin();
708  std::vector<tools::histo::h2d*>::iterator it;
709  for (it = fH2Vector.begin(); it != fH2Vector.end(); it++ ) {
710  (*it)->add(*(*itw++));
711  }
712 #ifdef G4VERBOSE
713  if ( fState.GetVerboseL1() )
714  fState.GetVerboseL1()->Message("merge", "all h2", "");
715 #endif
716 }
717 
718 //_____________________________________________________________________________
719 G4bool G4H2ToolsManager::Reset()
720 {
721 // Reset histograms and ntuple
722 
723  G4bool finalResult = true;
724 
725  std::vector<tools::histo::h2d*>::iterator it;
726  for (it = fH2Vector.begin(); it != fH2Vector.end(); it++ ) {
727  G4bool result = (*it)->reset();
728  if ( ! result ) finalResult = false;
729  }
730 
731  return finalResult;
732 }
733 
734 //_____________________________________________________________________________
735 G4bool G4H2ToolsManager::IsEmpty() const
736 {
737  return ! fH2Vector.size();
738 }
739 
740 //_____________________________________________________________________________
741 tools::histo::h2d* G4H2ToolsManager::GetH2(G4int id, G4bool warn,
742  G4bool onlyIfActive) const
743 {
744  return GetH2InFunction(id, "GetH2", warn, onlyIfActive);
745 }
746 
G4H2ToolsManager::GetH2Nybins
virtual G4int GetH2Nybins(G4int id) const
Definition: G4H2ToolsManager.cc:533
kLogBinScheme
Definition: G4BinScheme.hh:42
G4AnalysisVerbose::Message
void Message(const G4String &action, const G4String &object, const G4String &objectName, G4bool success=true) const
Definition: G4AnalysisVerbose.cc:59
G4HnManager::IsAscii
G4bool IsAscii() const
Definition: G4HnManager.cc:114
G4VH2Manager::fHnManager
G4HnManager * fHnManager
Definition: G4VH2Manager.hh:122
G4H2ToolsManager::GetH2YAxisTitle
virtual G4String GetH2YAxisTitle(G4int id) const
Definition: G4H2ToolsManager.cc:647
G4H2ToolsManager::SetH2YAxisTitle
virtual G4bool SetH2YAxisTitle(G4int id, const G4String &title)
Definition: G4H2ToolsManager.cc:599
G4H2ToolsManager::GetH2XAxisTitle
virtual G4String GetH2XAxisTitle(G4int id) const
Definition: G4H2ToolsManager.cc:628
G4AnalysisManagerState.hh
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
G4H2ToolsManager::AddH2Information
void AddH2Information(const G4String &name, const G4String &xunitName, const G4String &yunitName, const G4String &xfcnName, const G4String &yfcnName, G4BinScheme xbinScheme, G4BinScheme ybinScheme) const
Definition: G4H2ToolsManager.cc:259
G4H2ToolsManager::~G4H2ToolsManager
virtual ~G4H2ToolsManager()
Definition: G4H2ToolsManager.cc:50
G4H2ToolsManager::GetH2Ymax
virtual G4double GetH2Ymax(G4int id) const
Definition: G4H2ToolsManager.cc:553
name
G4String name
Definition: TRTMaterials.hh:40
G4Fcn
G4double(* G4Fcn)(G4double)
Definition: G4Fcn.hh:36
G4H2ToolsManager::IsEmpty
G4bool IsEmpty() const
Definition: G4H2ToolsManager.cc:735
G4H2ToolsManager::GetH2Xmin
virtual G4double GetH2Xmin(G4int id) const
Definition: G4H2ToolsManager.cc:495
G4H2ToolsManager::GetH2InFunction
virtual tools::histo::h2d * GetH2InFunction(G4int id, G4String function, G4bool warn=true, G4bool onlyIfActive=true) const
Definition: G4H2ToolsManager.cc:232
G4H2ToolsManager::GetH2Nxbins
virtual G4int GetH2Nxbins(G4int id) const
Definition: G4H2ToolsManager.cc:486
G4H2ToolsManager::SetH2ZAxisTitle
virtual G4bool SetH2ZAxisTitle(G4int id, const G4String &title)
Definition: G4H2ToolsManager.cc:609
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4int
int G4int
Definition: G4Types.hh:78
kUserBinScheme
Definition: G4BinScheme.hh:43
G4H2ToolsManager::RegisterToolsH2
G4int RegisterToolsH2(tools::histo::h2d *h2d, const G4String &name)
Definition: G4H2ToolsManager.cc:278
G4H2ToolsManager::GetH2Title
virtual G4String GetH2Title(G4int id) const
Definition: G4H2ToolsManager.cc:619
G4HnManager::GetHnInformation
G4HnInformation * GetHnInformation(G4int id, G4String functionName="", G4bool warn=true) const
Definition: G4HnManager.cc:86
G4HnManager::GetActivation
G4bool GetActivation(G4int id) const
Definition: G4HnManager.cc:209
G4AnalysisManagerState::GetVerboseL2
const G4AnalysisVerbose * GetVerboseL2() const
Definition: G4AnalysisManagerState.hh:108
G4HnManager.hh
G4Analysis::UpdateTitle
void UpdateTitle(G4String &title, const G4String &unitName, const G4String &fcnName)
Definition: G4AnalysisUtilities.cc:149
G4H2ToolsManager::fH2Vector
std::vector< tools::histo::h2d * > fH2Vector
Definition: G4H2ToolsManager.hh:171
G4H2ToolsManager::AddH2Vector
void AddH2Vector(const std::vector< tools::histo::h2d * > &h2Vector)
Definition: G4H2ToolsManager.cc:700
G4H2ToolsManager::GetH2YWidth
virtual G4double GetH2YWidth(G4int id) const
Definition: G4H2ToolsManager.cc:562
G4H2ToolsManager::WriteOnAscii
virtual G4bool WriteOnAscii(std::ofstream &output)
Definition: G4H2ToolsManager.cc:685
G4AnalysisManagerState::GetVerboseL4
const G4AnalysisVerbose * GetVerboseL4() const
Definition: G4AnalysisManagerState.hh:114
G4bool
bool G4bool
Definition: G4Types.hh:79
G4H2ToolsManager::SetH2
virtual G4bool SetH2(G4int id, G4int nxbins, G4double xmin, G4double xmax, G4int nybins, G4double ymin, G4double ymax, const G4String &xunitName="none", const G4String &yunitName="none", const G4String &xfcnName="none", const G4String &yfcnName="none", const G4String &xbinScheme="linear", const G4String &ybinScheme="linear")
Definition: G4H2ToolsManager.cc:365
G4H2ToolsManager::SetH2XAxisTitle
virtual G4bool SetH2XAxisTitle(G4int id, const G4String &title)
Definition: G4H2ToolsManager.cc:589
G4Analysis::GetUnitValue
G4double GetUnitValue(const G4String &unit)
Definition: G4AnalysisUtilities.cc:138
G4HnInformation::fXBinScheme
G4BinScheme fXBinScheme
Definition: G4HnInformation.hh:69
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4H2ToolsManager::GetH2
tools::histo::h2d * GetH2(G4int id, G4bool warn=true, G4bool onlyIfActive=true) const
Definition: G4H2ToolsManager.cc:741
G4H2ToolsManager::GetH2ZAxisTitle
virtual G4String GetH2ZAxisTitle(G4int id) const
Definition: G4H2ToolsManager.cc:666
G4HnInformation::fYBinScheme
G4BinScheme fYBinScheme
Definition: G4HnInformation.hh:70
G4Analysis::GetFunction
G4Fcn GetFunction(const G4String &fcnName)
Definition: G4Fcn.cc:36
G4H2ToolsManager::GetH2Ymin
virtual G4double GetH2Ymin(G4int id) const
Definition: G4H2ToolsManager.cc:542
G4H2ToolsManager::CreateH2
virtual G4int CreateH2(const G4String &name, const G4String &title, G4int nxbins, G4double xmin, G4double xmax, G4int nybins, G4double ymin, G4double ymax, const G4String &xunitName="none", const G4String &yunitName="none", const G4String &xfcnName="none", const G4String &yfcnName="none", const G4String &xbinScheme="linear", const G4String &ybinScheme="linear")
Definition: G4H2ToolsManager.cc:294
G4H2ToolsManager::GetH2Xmax
virtual G4double GetH2Xmax(G4int id) const
Definition: G4H2ToolsManager.cc:506
G4H2ToolsManager::GetH2XWidth
virtual G4double GetH2XWidth(G4int id) const
Definition: G4H2ToolsManager.cc:515
G4AnalysisUtilities.hh
G4Analysis::GetBinScheme
G4BinScheme GetBinScheme(const G4String &binSchemeName)
Definition: G4BinScheme.cc:36
G4H2ToolsManager::GetH2Id
virtual G4int GetH2Id(const G4String &name, G4bool warn=true) const
Definition: G4H2ToolsManager.cc:470
G4endl
#define G4endl
Definition: G4ios.hh:61
G4Analysis::ComputeEdges
void ComputeEdges(G4int nbins, G4double xmin, G4double xmax, G4Fcn fcn, G4BinScheme, std::vector< G4double > &edges)
Definition: G4BinScheme.cc:56
G4BinScheme
G4BinScheme
Definition: G4BinScheme.hh:40
G4HnManager::AddH2Information
void AddH2Information(const G4String &name, const G4String &xunitName, const G4String &yunitName, const G4String &xfcnName, const G4String &yfcnName, G4double xunit, G4double yunit, G4Fcn fx, G4Fcn fy, G4BinScheme xBinScheme, G4BinScheme yBinScheme)
Definition: G4HnManager.cc:70
G4H2ToolsManager::fH2NameIdMap
std::map< G4String, G4int > fH2NameIdMap
Definition: G4H2ToolsManager.hh:172
G4double
double G4double
Definition: G4Types.hh:76
G4H2ToolsManager::FillH2
virtual G4bool FillH2(G4int id, G4double xvalue, G4double yvalue, G4double weight=1.0)
Definition: G4H2ToolsManager.cc:444
G4H2ToolsManager::SetH2Title
virtual G4bool SetH2Title(G4int id, const G4String &title)
Definition: G4H2ToolsManager.cc:580
G4H2ToolsManager::ScaleH2
virtual G4bool ScaleH2(G4int id, G4double factor)
Definition: G4H2ToolsManager.cc:435
G4AnalysisManagerState::GetVerboseL1
const G4AnalysisVerbose * GetVerboseL1() const
Definition: G4AnalysisManagerState.hh:105
G4HnManager::SetActivation
void SetActivation(G4bool activation)
Definition: G4HnManager.cc:140
G4BaseAnalysisManager::fState
const G4AnalysisManagerState & fState
Definition: G4BaseAnalysisManager.hh:58
G4H2ToolsManager.hh
G4H2ToolsManager::G4H2ToolsManager
G4H2ToolsManager(const G4AnalysisManagerState &state)
Definition: G4H2ToolsManager.cc:42