G4XmlAnalysisManager Class Reference

#include <G4XmlAnalysisManager.hh>

Inheritance diagram for G4XmlAnalysisManager:

G4VAnalysisManager

Public Member Functions

 G4XmlAnalysisManager ()
 ~G4XmlAnalysisManager ()
virtual G4bool OpenFile (const G4String &fileName)
virtual G4bool Write ()
virtual G4bool CloseFile ()
virtual G4int CreateH1 (const G4String &name, const G4String &title, G4int nbins, G4double xmin, G4double xmax, const G4String &unitName="none", const G4String &fcnName="none")
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")
virtual G4bool SetH1 (G4int id, G4int nbins, G4double xmin, G4double xmax, const G4String &unitName="none", const G4String &fcnName="none")
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")
virtual G4bool ScaleH1 (G4int id, G4double factor)
virtual G4bool ScaleH2 (G4int id, G4double factor)
virtual void CreateNtuple (const G4String &name, const G4String &title)
virtual G4int CreateNtupleIColumn (const G4String &name)
virtual G4int CreateNtupleFColumn (const G4String &name)
virtual G4int CreateNtupleDColumn (const G4String &name)
virtual void FinishNtuple ()
virtual G4bool FillH1 (G4int id, G4double value, G4double weight=1.0)
virtual G4bool FillH2 (G4int id, G4double xvalue, G4double yvalue, G4double weight=1.0)
virtual G4bool FillNtupleIColumn (G4int id, G4int value)
virtual G4bool FillNtupleFColumn (G4int id, G4float value)
virtual G4bool FillNtupleDColumn (G4int id, G4double value)
virtual G4bool AddNtupleRow ()
virtual tools::histo::h1d * GetH1 (G4int id, G4bool warn=true, G4bool onlyIfActive=true) const
virtual tools::histo::h2d * GetH2 (G4int id, G4bool warn=true, G4bool onlyIfActive=true) const
virtual tools::waxml::ntuple * GetNtuple () const
virtual G4int GetH1Id (const G4String &name, G4bool warn=true) const
virtual G4int GetH2Id (const G4String &name, G4bool warn=true) const
virtual G4int GetH1Nbins (G4int id) const
virtual G4double GetH1Xmin (G4int id) const
virtual G4double GetH1Xmax (G4int id) const
virtual G4double GetH1Width (G4int id) const
virtual G4int GetH2Nxbins (G4int id) const
virtual G4double GetH2Xmin (G4int id) const
virtual G4double GetH2Xmax (G4int id) const
virtual G4double GetH2XWidth (G4int id) const
virtual G4int GetH2Nybins (G4int id) const
virtual G4double GetH2Ymin (G4int id) const
virtual G4double GetH2Ymax (G4int id) const
virtual G4double GetH2YWidth (G4int id) const
virtual G4bool SetH1Title (G4int id, const G4String &title)
virtual G4bool SetH1XAxisTitle (G4int id, const G4String &title)
virtual G4bool SetH1YAxisTitle (G4int id, const G4String &title)
virtual G4bool SetH2Title (G4int id, const G4String &title)
virtual G4bool SetH2XAxisTitle (G4int id, const G4String &title)
virtual G4bool SetH2YAxisTitle (G4int id, const G4String &title)
virtual G4bool SetH2ZAxisTitle (G4int id, const G4String &title)
virtual G4String GetH1Title (G4int id) const
virtual G4String GetH1XAxisTitle (G4int id) const
virtual G4String GetH1YAxisTitle (G4int id) const
virtual G4String GetH2Title (G4int id) const
virtual G4String GetH2XAxisTitle (G4int id) const
virtual G4String GetH2YAxisTitle (G4int id) const
virtual G4String GetH2ZAxisTitle (G4int id) const

Static Public Member Functions

static G4XmlAnalysisManagerInstance ()

Protected Member Functions

virtual G4bool WriteOnAscii (std::ofstream &output)

Detailed Description

Definition at line 45 of file G4XmlAnalysisManager.hh.


Constructor & Destructor Documentation

G4XmlAnalysisManager::G4XmlAnalysisManager (  ) 

Definition at line 51 of file G4XmlAnalysisManager.cc.

References FatalException, and G4Exception().

Referenced by Instance().

00052  : G4VAnalysisManager("Xml"),
00053    fFile(0),
00054    fH1Vector(),   
00055    fH2Vector(),   
00056    fH1NameIdMap(),  
00057    fH2NameIdMap(),  
00058    fNtuple(0),
00059    fNtupleBooking(0),
00060    fNtupleIColumnMap(),
00061    fNtupleFColumnMap(),
00062    fNtupleDColumnMap()
00063 {
00064   if ( fgInstance ) {
00065     G4ExceptionDescription description;
00066     description << "G4XmlAnalysisManager already exists." 
00067                 << "Cannot create another instance.";
00068     G4Exception("G4XmlAnalysisManager::G4XmlAnalysisManager",
00069                 "Analysis_F001", FatalException, description);
00070   }              
00071    
00072   fgInstance = this;
00073 }

G4XmlAnalysisManager::~G4XmlAnalysisManager (  ) 

Definition at line 76 of file G4XmlAnalysisManager.cc.

00077 {  
00078   std::vector<tools::histo::h1d*>::iterator it;
00079   for ( it = fH1Vector.begin(); it != fH1Vector.end(); it++ ) {
00080     delete *it;
00081   } 
00082    
00083   std::vector<tools::histo::h2d*>::iterator it2;
00084   for ( it2 = fH2Vector.begin(); it2 != fH2Vector.end(); it2++ ) {
00085     delete *it2;
00086   }
00087     
00088   delete fNtuple;
00089   delete fNtupleBooking;
00090   delete fFile;  
00091 
00092   fgInstance = 0;
00093 }


Member Function Documentation

G4bool G4XmlAnalysisManager::AddNtupleRow (  )  [virtual]

Implements G4VAnalysisManager.

Definition at line 923 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fpVerboseL4, G4Exception(), JustWarning, and G4AnalysisVerbose::Message().

00924 { 
00925 #ifdef G4VERBOSE
00926   if ( fpVerboseL4 )
00927     fpVerboseL4->Message("add", "ntuple row", "");
00928 #endif
00929 
00930   if ( ! fNtuple ) {
00931     G4ExceptionDescription description;
00932     description << "      " << "ntuple does not exist. ";
00933     G4Exception("G4XmlAnalysisManager::AddNtupleRow()",
00934                 "Analysis_W008", JustWarning, description);
00935     return false;
00936   }  
00937   
00938   fNtuple->add_row();
00939 #ifdef G4VERBOSE
00940   if ( fpVerboseL4 )
00941     fpVerboseL4->Message("add", "ntuple row", "");
00942 #endif
00943 
00944   return true;
00945 }

G4bool G4XmlAnalysisManager::CloseFile (  )  [virtual]

Implements G4VAnalysisManager.

Definition at line 430 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fLockFileName, G4VAnalysisManager::fpVerboseL1, G4VAnalysisManager::fpVerboseL4, G4Exception(), G4VAnalysisManager::GetFullFileName(), JustWarning, and G4AnalysisVerbose::Message().

00431 {
00432   G4bool result = true;
00433 
00434 #ifdef G4VERBOSE
00435   if ( fpVerboseL4 ) 
00436     fpVerboseL4->Message("close", "file", GetFullFileName());
00437 #endif
00438 
00439   // reset data
00440   result = Reset();
00441   if ( ! result ) {
00442       G4ExceptionDescription description;
00443       description << "      " << "Resetting data failed";
00444       G4Exception("G4XmlAnalysisManager::CloseFile()",
00445                 "Analysis_W002", JustWarning, description);
00446       result = false;       
00447   } 
00448 
00449   // close file
00450   tools::waxml::end(*fFile);
00451   fFile->close(); 
00452   fLockFileName = false;
00453 
00454 #ifdef G4VERBOSE
00455   if ( fpVerboseL1 ) 
00456     fpVerboseL1->Message("close", "file", GetFullFileName());
00457 #endif
00458 
00459   return result; 
00460 } 

G4int G4XmlAnalysisManager::CreateH1 ( const G4String name,
const G4String title,
G4int  nbins,
G4double  xmin,
G4double  xmax,
const G4String unitName = "none",
const G4String fcnName = "none" 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 463 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::AddH1Information(), G4VAnalysisManager::fLockFirstHistoId, G4VAnalysisManager::fpVerboseL2, G4VAnalysisManager::fpVerboseL4, G4VAnalysisManager::GetFunction(), G4VAnalysisManager::GetUnitValue(), and G4AnalysisVerbose::Message().

00466 {
00467 #ifdef G4VERBOSE
00468   if ( fpVerboseL4 ) 
00469     fpVerboseL4->Message("create", "H1", name);
00470 #endif
00471   G4int index = fH1Vector.size();
00472   G4double unit = GetUnitValue(unitName);
00473   G4Fcn fcn = GetFunction(fcnName);
00474   tools::histo::h1d* h1 
00475     = new tools::histo::h1d(title, nbins, fcn(xmin), fcn(xmax));
00476             // h1 objects are deleted in destructor and reset when 
00477             // closing a file.
00478 
00479   G4String axisTitle;
00480   UpdateTitle(axisTitle,unitName, fcnName);        
00481   h1->add_annotation(tools::histo::key_axis_x_title(), axisTitle);
00482              
00483   fH1Vector.push_back(h1);
00484   AddH1Information(name, unitName, fcnName, unit, fcn);
00485 
00486   fLockFirstHistoId = true;
00487 #ifdef G4VERBOSE
00488   if ( fpVerboseL2 ) 
00489     fpVerboseL2->Message("create", "H1", name);
00490 #endif
00491   fH1NameIdMap[name] = index + fFirstHistoId;
00492   return index + fFirstHistoId;
00493 }                                         

G4int G4XmlAnalysisManager::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" 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 496 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::AddH2Information(), G4VAnalysisManager::fLockFirstHistoId, G4VAnalysisManager::fpVerboseL2, G4VAnalysisManager::fpVerboseL4, G4VAnalysisManager::GetFunction(), G4VAnalysisManager::GetUnitValue(), and G4AnalysisVerbose::Message().

00501 {
00502 #ifdef G4VERBOSE
00503   if ( fpVerboseL4 ) 
00504     fpVerboseL4->Message("create", "H2", name);
00505 #endif
00506   G4int index = fH2Vector.size();
00507   G4double xunit = GetUnitValue(xunitName);
00508   G4double yunit = GetUnitValue(yunitName);
00509   G4Fcn xfcn = GetFunction(xfcnName);
00510   G4Fcn yfcn = GetFunction(yfcnName);
00511   tools::histo::h2d* h2 
00512     = new tools::histo::h2d(title, 
00513                             nxbins, xfcn(xmin), xfcn(xmax), 
00514                             nybins, yfcn(ymin), yfcn(ymax));
00515             // h1 objects are deleted in destructor and reset when 
00516             // closing a file.
00517 
00518   G4String xaxisTitle;
00519   G4String yaxisTitle;
00520   UpdateTitle(xaxisTitle, xunitName, xfcnName);        
00521   UpdateTitle(yaxisTitle, yunitName, yfcnName);        
00522   h2->add_annotation(tools::histo::key_axis_x_title(), xaxisTitle);
00523   h2->add_annotation(tools::histo::key_axis_y_title(), yaxisTitle);
00524              
00525   fH2Vector.push_back(h2);
00526   AddH2Information(name, xunitName, yunitName, xfcnName, yfcnName, 
00527                    xunit, yunit, xfcn, yfcn);
00528 
00529   fLockFirstHistoId = true;
00530 #ifdef G4VERBOSE
00531   if ( fpVerboseL2 ) 
00532     fpVerboseL2->Message("create", "H2", name);
00533 #endif
00534   fH2NameIdMap[name] = index + fFirstHistoId;
00535   return index + fFirstHistoId;
00536 }                                         

void G4XmlAnalysisManager::CreateNtuple ( const G4String name,
const G4String title 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 634 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fpVerboseL2, G4VAnalysisManager::fpVerboseL4, G4Exception(), JustWarning, and G4AnalysisVerbose::Message().

00636 {
00637   if ( fNtupleBooking ) {
00638     G4ExceptionDescription description;
00639     description << "      " 
00640                 << "Ntuple already exists. "
00641                 << "(Only one ntuple is currently supported.)";
00642     G4Exception("G4XmlAnalysisManager::CreateNtuple()",
00643                 "Analysis_W006", JustWarning, description);
00644     return;       
00645   }
00646 
00647 #ifdef G4VERBOSE
00648   if ( fpVerboseL4 ) 
00649     fpVerboseL4->Message("create", "ntuple", name);
00650 #endif
00651 
00652   // Create ntuple booking
00653   fNtupleBooking = new tools::ntuple_booking();
00654   fNtupleBooking->m_name = name;
00655   fNtupleBooking->m_title = title;
00656 
00657   // Create ntuple if the file is open
00658   if ( fFile ) {
00659     fNtuple = new tools::waxml::ntuple(*fFile);
00660            // ntuple object is deleted when closing a file
00661   }
00662 
00663 #ifdef G4VERBOSE
00664   if ( fpVerboseL2 ) 
00665     fpVerboseL2->Message("create", "ntuple", name);
00666 #endif
00667 }                                         

G4int G4XmlAnalysisManager::CreateNtupleDColumn ( const G4String name  )  [virtual]

Implements G4VAnalysisManager.

Definition at line 746 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fFirstNtupleColumnId, G4VAnalysisManager::fLockFirstNtupleColumnId, G4VAnalysisManager::fpVerboseL2, G4VAnalysisManager::fpVerboseL4, G4Exception(), JustWarning, and G4AnalysisVerbose::Message().

00747 {
00748 #ifdef G4VERBOSE
00749   if ( fpVerboseL4 ) 
00750     fpVerboseL4->Message("create", "ntuple D column", name);
00751 #endif
00752 
00753   if ( ! fNtupleBooking ) {
00754     G4ExceptionDescription description;
00755     description << "      " 
00756                 << "Ntuple has to be created first. ";
00757     G4Exception("G4XmlAnalysisManager::CreateNtupleDColumn()",
00758                 "Analysis_W005", JustWarning, description);
00759     return -1;       
00760   }
00761 
00762   // Save column info in booking
00763   G4int index = fNtupleBooking->m_columns.size();
00764   fNtupleBooking->add_column<double>(name);  
00765  
00766   // Create column if ntuple already exists
00767   if ( fNtuple ) {
00768     tools::waxml::ntuple::column<double>* column 
00769       = fNtuple->create_column<double>(name);  
00770     fNtupleDColumnMap[index] = column;
00771   }
00772     
00773   fLockFirstNtupleColumnId = true;
00774 
00775 #ifdef G4VERBOSE
00776   if ( fpVerboseL2 ) 
00777     fpVerboseL2->Message("create", "ntuple D column", name);
00778 #endif
00779 
00780   return index + fFirstNtupleColumnId;       
00781 }                                         

G4int G4XmlAnalysisManager::CreateNtupleFColumn ( const G4String name  )  [virtual]

Implements G4VAnalysisManager.

Definition at line 708 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fFirstNtupleColumnId, G4VAnalysisManager::fLockFirstNtupleColumnId, G4VAnalysisManager::fpVerboseL2, G4VAnalysisManager::fpVerboseL4, G4Exception(), JustWarning, and G4AnalysisVerbose::Message().

00709 {
00710 #ifdef G4VERBOSE
00711   if ( fpVerboseL4 ) 
00712     fpVerboseL4->Message("create", "ntuple F column", name);
00713 #endif
00714 
00715   if ( ! fNtupleBooking )  {
00716     G4ExceptionDescription description;
00717     description << "      " 
00718                 << "Ntuple has to be created first. ";
00719     G4Exception("G4XmlAnalysisManager::CreateNtupleFColumn()",
00720                 "Analysis_W005", JustWarning, description);
00721     return -1;       
00722   }
00723 
00724   // Save column info in booking
00725   G4int index = fNtupleBooking->m_columns.size();
00726   fNtupleBooking->add_column<float>(name);  
00727  
00728   // Create column if ntuple already exists
00729   if ( fNtuple ) {
00730     tools::waxml::ntuple::column<float>* column 
00731       = fNtuple->create_column<float>(name);  
00732     fNtupleFColumnMap[index] = column;
00733   }
00734     
00735   fLockFirstNtupleColumnId = true;
00736 
00737 #ifdef G4VERBOSE
00738   if ( fpVerboseL2 ) 
00739     fpVerboseL2->Message("create", "ntuple F column", name);
00740 #endif
00741 
00742   return index + fFirstNtupleColumnId;       
00743 }                                         

G4int G4XmlAnalysisManager::CreateNtupleIColumn ( const G4String name  )  [virtual]

Implements G4VAnalysisManager.

Definition at line 670 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fFirstNtupleColumnId, G4VAnalysisManager::fLockFirstNtupleColumnId, G4VAnalysisManager::fpVerboseL2, G4VAnalysisManager::fpVerboseL4, G4Exception(), JustWarning, and G4AnalysisVerbose::Message().

00671 {
00672 #ifdef G4VERBOSE
00673   if ( fpVerboseL4 ) 
00674     fpVerboseL4->Message("create", "ntuple I column", name);
00675 #endif
00676 
00677   if ( ! fNtupleBooking ) {
00678     G4ExceptionDescription description;
00679     description << "      " 
00680                 << "Ntuple has to be created first. ";
00681     G4Exception("G4XmlAnalysisManager::CreateNtupleIColumn()",
00682                 "Analysis_W005", JustWarning, description);
00683     return -1;       
00684   }
00685 
00686   // Save column info in booking
00687   G4int index = fNtupleBooking->m_columns.size();
00688   fNtupleBooking->add_column<int>(name);  
00689  
00690   // Create column if ntuple already exists
00691   if ( fNtuple ) {
00692     tools::waxml::ntuple::column<int>* column 
00693       = fNtuple->create_column<int>(name);  
00694     fNtupleIColumnMap[index] = column;
00695   }
00696     
00697   fLockFirstNtupleColumnId = true;
00698 
00699 #ifdef G4VERBOSE
00700   if ( fpVerboseL2 ) 
00701     fpVerboseL2->Message("create", "ntuple I column", name);
00702 #endif
00703 
00704   return index + fFirstNtupleColumnId;       
00705 }                                         

G4bool G4XmlAnalysisManager::FillH1 ( G4int  id,
G4double  value,
G4double  weight = 1.0 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 807 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fActivation, G4VAnalysisManager::fpVerboseL4, G4HnInformation::fXFcn, G4HnInformation::fXUnit, G4VAnalysisManager::GetActivation(), G4VAnalysisManager::GetInformation(), G4VAnalysisManager::GetXUnit(), G4VAnalysisManager::kH1, and G4AnalysisVerbose::Message().

00808 {
00809   tools::histo::h1d* h1d = GetH1InFunction(id, "FillH1", true, false);
00810   if ( ! h1d ) return false;
00811 
00812   if ( fActivation && ( ! GetActivation(kH1, id) ) ) {
00813     //G4cout << "Skipping FillH1 for " << id << G4endl; 
00814     return false; 
00815   }  
00816 
00817   G4HnInformation* info = GetInformation(kH1, id);
00818   h1d->fill(info->fXFcn(value/info->fXUnit), weight);
00819 #ifdef G4VERBOSE
00820   if ( fpVerboseL4 ) {
00821     G4ExceptionDescription description;
00822     description << " id " << id << " value " << value/GetXUnit(kH1, id);
00823     fpVerboseL4->Message("fill", "H1", description);
00824   }  
00825 #endif
00826   return true;
00827 }

G4bool G4XmlAnalysisManager::FillH2 ( G4int  id,
G4double  xvalue,
G4double  yvalue,
G4double  weight = 1.0 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 830 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fActivation, G4VAnalysisManager::fpVerboseL4, G4HnInformation::fXFcn, G4HnInformation::fXUnit, G4HnInformation::fYFcn, G4HnInformation::fYUnit, G4VAnalysisManager::GetActivation(), G4VAnalysisManager::GetInformation(), G4VAnalysisManager::GetXUnit(), G4VAnalysisManager::GetYUnit(), G4VAnalysisManager::kH2, and G4AnalysisVerbose::Message().

00833 {
00834   tools::histo::h2d* h2d = GetH2InFunction(id, "FillH2", true, false);
00835   if ( ! h2d ) return false;
00836 
00837   if ( fActivation && ( ! GetActivation(kH2, id) ) ) return false; 
00838 
00839   G4HnInformation* info = GetInformation(kH2, id);
00840   h2d->fill(info->fXFcn(xvalue/info->fXUnit), 
00841             info->fYFcn(yvalue/info->fYUnit), weight);
00842 #ifdef G4VERBOSE
00843   if ( fpVerboseL4 ) {
00844     G4ExceptionDescription description;
00845     description << " id " << id 
00846                 << " xvalue " << xvalue/GetXUnit(kH2, id) 
00847                 << " yvalue " << yvalue/GetYUnit(kH2, id);
00848     fpVerboseL4->Message("fill", "H2", description);
00849   }  
00850 #endif
00851   return true;
00852 }

G4bool G4XmlAnalysisManager::FillNtupleDColumn ( G4int  id,
G4double  value 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 900 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fpVerboseL4, G4Exception(), JustWarning, and G4AnalysisVerbose::Message().

00901 {
00902   tools::waxml::ntuple::column<double>* column = GetNtupleDColumn(id);
00903   if ( ! column ) {
00904     G4ExceptionDescription description;
00905     description << "      " << "column " << id << " does not exist.";
00906     G4Exception("G4XmlAnalysisManager::FillNtupleDColumn()",
00907                 "Analysis_W009", JustWarning, description);
00908     return false;
00909   }  
00910   
00911   column->fill(value);
00912 #ifdef G4VERBOSE
00913   if ( fpVerboseL4 ) {
00914     G4ExceptionDescription description;
00915     description << " id " << id << " value " << value;
00916     fpVerboseL4->Message("fill", "ntuple D column", description);
00917   }  
00918 #endif
00919   return true;       
00920 }                                         

G4bool G4XmlAnalysisManager::FillNtupleFColumn ( G4int  id,
G4float  value 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 877 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fpVerboseL4, G4Exception(), JustWarning, and G4AnalysisVerbose::Message().

00878 {
00879   tools::waxml::ntuple::column<float>* column = GetNtupleFColumn(id);
00880   if ( ! column ) {
00881     G4ExceptionDescription description;
00882     description << "      " << "column " << id << " does not exist.";
00883     G4Exception("G4XmlAnalysisManager::FillNtupleFColumn()",
00884                 "Analysis_W009", JustWarning, description);
00885     return false;
00886   }  
00887   
00888   column->fill(value);
00889 #ifdef G4VERBOSE
00890   if ( fpVerboseL4 ) {
00891     G4ExceptionDescription description;
00892     description << " id " << id << " value " << value;
00893     fpVerboseL4->Message("fill", "ntuple F column", description);
00894   }  
00895 #endif
00896   return true;       
00897 }                                         

G4bool G4XmlAnalysisManager::FillNtupleIColumn ( G4int  id,
G4int  value 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 855 of file G4XmlAnalysisManager.cc.

References G4VAnalysisManager::fpVerboseL4, G4Exception(), JustWarning, and G4AnalysisVerbose::Message().

00856 {
00857   tools::waxml::ntuple::column<int>* column = GetNtupleIColumn(id);
00858   if ( ! column ) {
00859     G4ExceptionDescription description;
00860     description << "      " << "column " << id << " does not exist.";
00861     G4Exception("G4XmlAnalysisManager::FillNtupleIColumn()",
00862                 "Analysis_W009", JustWarning, description);
00863     return false;
00864   }  
00865   
00866   column->fill(value);
00867 #ifdef G4VERBOSE
00868   if ( fpVerboseL4 ) {
00869     G4ExceptionDescription description;
00870     description << " id " << id << " value " << value;
00871     fpVerboseL4->Message("fill", "ntuple I column", description);
00872   }  
00873 #endif
00874   return true;       
00875 }                                         

void G4XmlAnalysisManager::FinishNtuple (  )  [virtual]

Implements G4VAnalysisManager.

Definition at line 784 of file G4XmlAnalysisManager.cc.

References G4String::append(), G4VAnalysisManager::fLockNtupleDirectoryName, G4VAnalysisManager::fNtupleDirectoryName, G4VAnalysisManager::fpVerboseL2, G4VAnalysisManager::fpVerboseL4, and G4AnalysisVerbose::Message().

00785 { 
00786   if ( ! fNtuple ) return;
00787 
00788 #ifdef G4VERBOSE
00789   if ( fpVerboseL4 ) 
00790     fpVerboseL4->Message("finish", "ntuple", fNtupleBooking->m_name);
00791 #endif
00792 
00793   G4String path = "/";
00794   path.append(fNtupleDirectoryName);
00795   fNtuple->write_header(path, fNtupleBooking->m_name, fNtupleBooking->m_title);  
00796 
00797   fLockNtupleDirectoryName = true;
00798 
00799 #ifdef G4VERBOSE
00800   if ( fpVerboseL2 ) 
00801     fpVerboseL2->Message("finish", "ntuple", fNtupleBooking->m_name);
00802 #endif
00803 }

tools::histo::h1d * G4XmlAnalysisManager::GetH1 ( G4int  id,
G4bool  warn = true,
G4bool  onlyIfActive = true 
) const [virtual]

Definition at line 948 of file G4XmlAnalysisManager.cc.

00950 {
00951   return GetH1InFunction(id, "GetH1", warn, onlyIfActive);
00952 }

G4int G4XmlAnalysisManager::GetH1Id ( const G4String name,
G4bool  warn = true 
) const [virtual]

Definition at line 962 of file G4XmlAnalysisManager.cc.

References G4Exception(), and JustWarning.

00963 {
00964   std::map<G4String, G4int>::const_iterator it = fH1NameIdMap.find(name);
00965   if ( it ==  fH1NameIdMap.end() ) {  
00966     if ( warn) {
00967       G4String inFunction = "G4RootAnalysisManager::GetH1Id";
00968       G4ExceptionDescription description;
00969       description << "      " << "histogram " << name << " does not exist.";
00970       G4Exception(inFunction, "Analysis_W007", JustWarning, description);
00971     }
00972     return -1;         
00973   }
00974   return it->second;
00975 }  

G4int G4XmlAnalysisManager::GetH1Nbins ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1000 of file G4XmlAnalysisManager.cc.

01001 {
01002   tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1Nbins");
01003   if ( ! h1d ) return 0;
01004   
01005   return h1d->axis().bins();
01006 }  

G4String G4XmlAnalysisManager::GetH1Title ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1221 of file G4XmlAnalysisManager.cc.

01222 {
01223   tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1Title");
01224   if ( ! h1d ) return "";
01225   
01226   return h1d->title();
01227 }  

G4double G4XmlAnalysisManager::GetH1Width ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1031 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fXFcn, G4HnInformation::fXUnit, G4Exception(), G4VAnalysisManager::GetInformation(), JustWarning, and G4VAnalysisManager::kH1.

01032 {
01033   tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1XWidth", true, false);
01034   if ( ! h1d ) return 0;
01035   
01036   G4int nbins = h1d->axis().bins();
01037   if ( ! nbins ) {
01038     G4ExceptionDescription description;
01039     description << "    nbins = 0 (for h1 id = " << id << ").";
01040     G4Exception("G4XmlAnalysisManager::GetH1Width",
01041                 "Analysis_W014", JustWarning, description);
01042     return 0;
01043   }              
01044   
01045   G4HnInformation* info = GetInformation(kH1, id);
01046   return ( info->fXFcn(h1d->axis().upper_edge()) 
01047            - info->fXFcn(h1d->axis().lower_edge()))*info->fXUnit/nbins;
01048 }  

G4String G4XmlAnalysisManager::GetH1XAxisTitle ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1230 of file G4XmlAnalysisManager.cc.

References G4Exception(), and JustWarning.

01231 {
01232   tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1XAxisTitle");
01233   if ( ! h1d ) return "";
01234   
01235   G4String title;
01236   G4bool result = h1d->annotation(tools::histo::key_axis_x_title(), title);
01237   if ( ! result ) {
01238     G4ExceptionDescription description;
01239     description << "    Failed to get x_axis title for h1 id = " << id << ").";
01240     G4Exception("G4XmlAnalysisManager::GetH1XAxisTitle",
01241                 "Analysis_W014", JustWarning, description);
01242     return "";
01243   }
01244   
01245   return title;              
01246 }  

G4double G4XmlAnalysisManager::GetH1Xmax ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1021 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fXFcn, G4HnInformation::fXUnit, G4VAnalysisManager::GetInformation(), and G4VAnalysisManager::kH1.

01022 {
01023   tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1Xmax");
01024   if ( ! h1d ) return 0;
01025   
01026   G4HnInformation* info = GetInformation(kH1, id);
01027   return info->fXFcn(h1d->axis().upper_edge()*info->fXUnit);
01028 }  

G4double G4XmlAnalysisManager::GetH1Xmin ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1009 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fXFcn, G4HnInformation::fXUnit, G4VAnalysisManager::GetInformation(), and G4VAnalysisManager::kH1.

01010 {
01011 // Returns xmin value with applied unit and histogram function
01012 
01013   tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1Xmin");
01014   if ( ! h1d ) return 0;
01015   
01016   G4HnInformation* info = GetInformation(kH1, id);
01017   return info->fXFcn(h1d->axis().lower_edge()*info->fXUnit);
01018 }  

G4String G4XmlAnalysisManager::GetH1YAxisTitle ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1249 of file G4XmlAnalysisManager.cc.

References G4Exception(), and JustWarning.

01250 {
01251   tools::histo::h1d* h1d = GetH1InFunction(id, "GetH1YAxisTitle");
01252   if ( ! h1d ) return "";
01253   
01254   G4String title;
01255   G4bool result = h1d->annotation(tools::histo::key_axis_y_title(), title);
01256   if ( ! result ) {
01257     G4ExceptionDescription description;
01258     description << "    Failed to get y_axis title for h1 id = " << id << ").";
01259     G4Exception("G4XmlAnalysisManager::GetH1YAxisTitle",
01260                 "Analysis_W014", JustWarning, description);
01261     return "";
01262   }
01263   
01264   return title;              
01265 }  

tools::histo::h2d * G4XmlAnalysisManager::GetH2 ( G4int  id,
G4bool  warn = true,
G4bool  onlyIfActive = true 
) const [virtual]

Definition at line 955 of file G4XmlAnalysisManager.cc.

00957 {
00958   return GetH2InFunction(id, "GetH2", warn, onlyIfActive);
00959 }

G4int G4XmlAnalysisManager::GetH2Id ( const G4String name,
G4bool  warn = true 
) const [virtual]

Definition at line 978 of file G4XmlAnalysisManager.cc.

References G4Exception(), and JustWarning.

00979 {
00980   std::map<G4String, G4int>::const_iterator it = fH2NameIdMap.find(name);
00981   if ( it ==  fH2NameIdMap.end() ) {  
00982     if ( warn) {
00983       G4String inFunction = "G4RootAnalysisManager::GetH2Id";
00984       G4ExceptionDescription description;
00985       description << "      " << "histogram " << name << " does not exist.";
00986       G4Exception(inFunction, "Analysis_W007", JustWarning, description);
00987     }
00988     return -1;         
00989   }
00990   return it->second;
00991 }  

G4int G4XmlAnalysisManager::GetH2Nxbins ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1051 of file G4XmlAnalysisManager.cc.

01052 {
01053   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2NXbins");
01054   if ( ! h2d ) return 0;
01055   
01056   return h2d->axis_x().bins();
01057 }  

G4int G4XmlAnalysisManager::GetH2Nybins ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1102 of file G4XmlAnalysisManager.cc.

01103 {
01104   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2NYbins");
01105   if ( ! h2d ) return 0;
01106   
01107   return h2d->axis_y().bins();
01108 }  

G4String G4XmlAnalysisManager::GetH2Title ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1268 of file G4XmlAnalysisManager.cc.

01269 {
01270   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Title");
01271   if ( ! h2d ) return "";
01272   
01273   return h2d->title();
01274 }  

G4String G4XmlAnalysisManager::GetH2XAxisTitle ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1278 of file G4XmlAnalysisManager.cc.

References G4Exception(), and JustWarning.

01279 {
01280   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2XAxisTitle");
01281   if ( ! h2d ) return "";
01282   
01283   G4String title;
01284   G4bool result = h2d->annotation(tools::histo::key_axis_x_title(), title);
01285   if ( ! result ) {
01286     G4ExceptionDescription description;
01287     description << "    Failed to get x_axis title for h2 id = " << id << ").";
01288     G4Exception("G4XmlAnalysisManager::GetH2XAxisTitle",
01289                 "Analysis_W014", JustWarning, description);
01290     return "";
01291   }
01292   
01293   return title;              
01294 } 

G4double G4XmlAnalysisManager::GetH2Xmax ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1072 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fXFcn, G4HnInformation::fXUnit, G4VAnalysisManager::GetInformation(), and G4VAnalysisManager::kH2.

01073 {
01074   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Xmax");
01075   if ( ! h2d ) return 0;
01076   
01077   G4HnInformation* info = GetInformation(kH2, id);
01078   return info->fXFcn(h2d->axis_x().upper_edge()*info->fXUnit);
01079 }  

G4double G4XmlAnalysisManager::GetH2Xmin ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1060 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fXFcn, G4HnInformation::fXUnit, G4VAnalysisManager::GetInformation(), and G4VAnalysisManager::kH2.

01061 {
01062 // Returns xmin value with applied unit and histogram function
01063 
01064   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Xmin");
01065   if ( ! h2d ) return 0;
01066   
01067   G4HnInformation* info = GetInformation(kH2, id);
01068   return info->fXFcn(h2d->axis_x().lower_edge()*info->fXUnit);
01069 }  

G4double G4XmlAnalysisManager::GetH2XWidth ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1082 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fXFcn, G4HnInformation::fXUnit, G4Exception(), G4VAnalysisManager::GetInformation(), JustWarning, and G4VAnalysisManager::kH2.

01083 {
01084   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2XWidth", true, false);
01085   if ( ! h2d ) return 0;
01086   
01087   G4int nbins = h2d->axis_x().bins();
01088   if ( ! nbins ) {
01089     G4ExceptionDescription description;
01090     description << "    nbins = 0 (for h1 id = " << id << ").";
01091     G4Exception("G4XmlAnalysisManager::GetH2Width",
01092                 "Analysis_W014", JustWarning, description);
01093     return 0;
01094   }              
01095   
01096   G4HnInformation* info = GetInformation(kH2, id);
01097   return ( info->fXFcn(h2d->axis_x().upper_edge()) 
01098            - info->fXFcn(h2d->axis_x().lower_edge()))*info->fXUnit/nbins;
01099 }  

G4String G4XmlAnalysisManager::GetH2YAxisTitle ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1297 of file G4XmlAnalysisManager.cc.

References G4Exception(), and JustWarning.

01298 {
01299   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2YAxisTitle");
01300   if ( ! h2d ) return "";
01301   
01302   G4String title;
01303   G4bool result = h2d->annotation(tools::histo::key_axis_y_title(), title);
01304   if ( ! result ) {
01305     G4ExceptionDescription description;
01306     description << "    Failed to get y_axis title for h2 id = " << id << ").";
01307     G4Exception("G4XmlAnalysisManager::GetH2YAxisTitle",
01308                 "Analysis_W014", JustWarning, description);
01309     return "";
01310   }
01311   
01312   return title;              
01313 }  

G4double G4XmlAnalysisManager::GetH2Ymax ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1123 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fYFcn, G4HnInformation::fYUnit, G4VAnalysisManager::GetInformation(), and G4VAnalysisManager::kH2.

01124 {
01125   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Ymax");
01126   if ( ! h2d ) return 0;
01127   
01128   G4HnInformation* info = GetInformation(kH2, id);
01129   return info->fYFcn(h2d->axis_y().upper_edge()*info->fYUnit);
01130 }  

G4double G4XmlAnalysisManager::GetH2Ymin ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1111 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fYFcn, G4HnInformation::fYUnit, G4VAnalysisManager::GetInformation(), and G4VAnalysisManager::kH2.

01112 {
01113 // Returns xmin value with applied unit and histogram function
01114 
01115   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2Ymin");
01116   if ( ! h2d ) return 0;
01117   
01118   G4HnInformation* info = GetInformation(kH2, id);
01119   return info->fYFcn(h2d->axis_y().lower_edge()*info->fYUnit);
01120 }  

G4double G4XmlAnalysisManager::GetH2YWidth ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1133 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fYFcn, G4HnInformation::fYUnit, G4Exception(), G4VAnalysisManager::GetInformation(), JustWarning, and G4VAnalysisManager::kH2.

01134 {
01135   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2YWidth", true, false);
01136   if ( ! h2d ) return 0;
01137   
01138   G4int nbins = h2d->axis_y().bins();
01139   if ( ! nbins ) {
01140     G4ExceptionDescription description;
01141     description << "    nbins = 0 (for h1 id = " << id << ").";
01142     G4Exception("G4XmlAnalysisManager::GetH2Width",
01143                 "Analysis_W014", JustWarning, description);
01144     return 0;
01145   }              
01146   
01147   G4HnInformation* info = GetInformation(kH2, id);
01148   return ( info->fYFcn(h2d->axis_y().upper_edge()) 
01149            - info->fYFcn(h2d->axis_y().lower_edge()))*info->fYUnit/nbins;
01150 }  

G4String G4XmlAnalysisManager::GetH2ZAxisTitle ( G4int  id  )  const [virtual]

Implements G4VAnalysisManager.

Definition at line 1316 of file G4XmlAnalysisManager.cc.

References G4Exception(), and JustWarning.

01317 {
01318   tools::histo::h2d* h2d = GetH2InFunction(id, "GetH2ZAxisTitle");
01319   if ( ! h2d ) return "";
01320   
01321   G4String title;
01322   G4bool result = h2d->annotation(tools::histo::key_axis_z_title(), title);
01323   if ( ! result ) {
01324     G4ExceptionDescription description;
01325     description << "    Failed to get z_axis title for h2 id = " << id << ").";
01326     G4Exception("G4XmlAnalysisManager::GetH2ZAxisTitle",
01327                 "Analysis_W014", JustWarning, description);
01328     return "";
01329   }
01330   
01331   return title;              
01332 }  

tools::waxml::ntuple * G4XmlAnalysisManager::GetNtuple (  )  const [virtual]

Definition at line 994 of file G4XmlAnalysisManager.cc.

00995 {
00996   return fNtuple;
00997 }  

G4XmlAnalysisManager * G4XmlAnalysisManager::Instance (  )  [static]

Definition at line 41 of file G4XmlAnalysisManager.cc.

References G4XmlAnalysisManager().

00042 {
00043   if ( fgInstance == 0 ) {
00044     fgInstance = new G4XmlAnalysisManager();
00045   }
00046   
00047   return fgInstance;
00048 }    

G4bool G4XmlAnalysisManager::OpenFile ( const G4String fileName  )  [virtual]

Implements G4VAnalysisManager.

Definition at line 319 of file G4XmlAnalysisManager.cc.

References G4String::append(), G4VAnalysisManager::fLockFileName, G4VAnalysisManager::fpVerboseL1, G4VAnalysisManager::fpVerboseL4, G4Exception(), G4VAnalysisManager::GetFileType(), JustWarning, and G4AnalysisVerbose::Message().

00320 {
00321   // Add file extension .Xml if no extension is given
00322   G4String name(fileName);
00323   if ( name.find(".") == std::string::npos ) { 
00324     name.append(".");
00325     name.append(GetFileType());
00326   }  
00327 
00328  #ifdef G4VERBOSE
00329   if ( fpVerboseL4 ) 
00330     fpVerboseL4->Message("open", "analysis file", name);
00331 #endif
00332   
00333   // delete a previous file if it exists
00334   if ( fFile ) delete fFile; 
00335   
00336   fFile = new std::ofstream(name);
00337   if ( fFile->fail() ) {
00338     G4ExceptionDescription description;
00339     description << "      " << "Cannot open file " << name;
00340     G4Exception("G4XmlAnalysisManager::OpenFile()",
00341               "Analysis_W001", JustWarning, description);
00342     return false;
00343   }
00344 
00345   tools::waxml::begin(*fFile);
00346 #ifdef G4VERBOSE
00347   if ( fpVerboseL1 ) 
00348     fpVerboseL1->Message("open", "analysis file", name);
00349 #endif
00350 
00351   // Create ntuple if it is booked
00352   if ( fNtupleBooking && ( ! fNtuple ) )
00353     CreateNtupleFromBooking();
00354 
00355   fLockFileName = true;
00356   return true;
00357 }  

G4bool G4XmlAnalysisManager::ScaleH1 ( G4int  id,
G4double  factor 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 616 of file G4XmlAnalysisManager.cc.

00617 {
00618   tools::histo::h1d* h1d = GetH1InFunction(id, "ScaleH1", false, false);
00619   if ( ! h1d ) return false;
00620 
00621   return h1d->scale(factor);
00622 }  

G4bool G4XmlAnalysisManager::ScaleH2 ( G4int  id,
G4double  factor 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 625 of file G4XmlAnalysisManager.cc.

00626 {
00627   tools::histo::h2d* h2d = GetH2InFunction(id, "ScaleH2", false, false);
00628   if ( ! h2d ) return false;
00629   
00630   return h2d->scale(factor);
00631 }  

G4bool G4XmlAnalysisManager::SetH1 ( G4int  id,
G4int  nbins,
G4double  xmin,
G4double  xmax,
const G4String unitName = "none",
const G4String fcnName = "none" 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 539 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fName, G4VAnalysisManager::fpVerboseL4, G4HnInformation::fXFcn, G4HnInformation::fXFcnName, G4HnInformation::fXUnit, G4HnInformation::fXUnitName, G4HnInformation::fYFcn, G4HnInformation::fYFcnName, G4HnInformation::fYUnit, G4HnInformation::fYUnitName, G4VAnalysisManager::GetFunction(), G4VAnalysisManager::GetH1Information(), G4VAnalysisManager::GetUnitValue(), G4VAnalysisManager::kH1, G4AnalysisVerbose::Message(), and G4VAnalysisManager::SetActivation().

00542 {                                
00543 
00544   tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1", false, false);
00545   if ( ! h1d ) return false;
00546 
00547   G4HnInformation* info = GetH1Information(id);
00548 #ifdef G4VERBOSE
00549   if ( fpVerboseL4 ) 
00550     fpVerboseL4->Message("configure", "H1", info->fName);
00551 #endif
00552 
00553   G4double unit = GetUnitValue(unitName);
00554   G4Fcn fcn = GetFunction(fcnName);
00555   h1d->configure(nbins, fcn(xmin), fcn(xmax));
00556   info->fXUnitName = unitName;
00557   info->fYUnitName = unitName;
00558   info->fXFcnName = fcnName;
00559   info->fYFcnName = fcnName;
00560   info->fXUnit = unit;
00561   info->fYUnit = unit;
00562   info->fXFcn = fcn;
00563   info->fYFcn = fcn;
00564   SetActivation(kH1, id, true); 
00565 
00566   G4String axisTitle;
00567   UpdateTitle(axisTitle,unitName, fcnName);        
00568   h1d->add_annotation(tools::histo::key_axis_x_title(), axisTitle);
00569 
00570   return true;
00571 }

G4bool G4XmlAnalysisManager::SetH1Title ( G4int  id,
const G4String title 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 1153 of file G4XmlAnalysisManager.cc.

01154 {
01155   tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1Title");
01156   if ( ! h1d ) return false;
01157   
01158   return h1d->set_title(title);
01159 }  

G4bool G4XmlAnalysisManager::SetH1XAxisTitle ( G4int  id,
const G4String title 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 1162 of file G4XmlAnalysisManager.cc.

01163 {
01164   tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1XAxisTitle");
01165   if ( ! h1d ) return false;
01166   
01167   h1d->add_annotation(tools::histo::key_axis_x_title(), title);
01168   return true;
01169 }  

G4bool G4XmlAnalysisManager::SetH1YAxisTitle ( G4int  id,
const G4String title 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 1172 of file G4XmlAnalysisManager.cc.

01173 {
01174   tools::histo::h1d* h1d = GetH1InFunction(id, "SetH1YAxisTitle");
01175   if ( ! h1d ) return false;
01176   
01177   h1d->add_annotation(tools::histo::key_axis_y_title(), title);
01178   return true;
01179 }  

G4bool G4XmlAnalysisManager::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" 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 574 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fName, G4VAnalysisManager::fpVerboseL4, G4HnInformation::fXFcn, G4HnInformation::fXFcnName, G4HnInformation::fXUnit, G4HnInformation::fXUnitName, G4HnInformation::fYFcn, G4HnInformation::fYFcnName, G4HnInformation::fYUnit, G4HnInformation::fYUnitName, G4VAnalysisManager::GetFunction(), G4VAnalysisManager::GetH2Information(), G4VAnalysisManager::GetUnitValue(), G4VAnalysisManager::kH2, G4AnalysisVerbose::Message(), and G4VAnalysisManager::SetActivation().

00579 {                                
00580   tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2", false, false);
00581   if ( ! h2d ) return false;
00582 
00583   G4HnInformation* info = GetH2Information(id);
00584 #ifdef G4VERBOSE
00585   if ( fpVerboseL4 ) 
00586     fpVerboseL4->Message("configure", "H2", info->fName);
00587 #endif
00588 
00589   G4double xunit = GetUnitValue(xunitName);
00590   G4double yunit = GetUnitValue(yunitName);
00591   G4Fcn xfcn = GetFunction(xfcnName);
00592   G4Fcn yfcn = GetFunction(yfcnName);
00593   h2d->configure(nxbins, xfcn(xmin), xfcn(xmax), 
00594                  nybins, yfcn(ymin), yfcn(ymax));
00595   info->fXUnitName = xunitName;
00596   info->fYUnitName = yunitName;
00597   info->fXFcnName = xfcnName;
00598   info->fYFcnName = yfcnName;
00599   info->fXUnit = xunit;
00600   info->fYUnit = yunit;
00601   info->fXFcn = xfcn;
00602   info->fYFcn = yfcn;
00603   SetActivation(kH2, id, true); 
00604   
00605   G4String xaxisTitle;
00606   G4String yaxisTitle;
00607   UpdateTitle(xaxisTitle, xunitName, xfcnName);        
00608   UpdateTitle(yaxisTitle, yunitName, yfcnName);        
00609   h2d->add_annotation(tools::histo::key_axis_x_title(), xaxisTitle);
00610   h2d->add_annotation(tools::histo::key_axis_y_title(), yaxisTitle);
00611   
00612   return true;
00613 }

G4bool G4XmlAnalysisManager::SetH2Title ( G4int  id,
const G4String title 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 1182 of file G4XmlAnalysisManager.cc.

01183 {
01184   tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2Title");
01185   if ( ! h2d ) return false;
01186   
01187   return h2d->set_title(title);
01188 }  

G4bool G4XmlAnalysisManager::SetH2XAxisTitle ( G4int  id,
const G4String title 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 1191 of file G4XmlAnalysisManager.cc.

01192 {
01193   tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2XAxisTitle");
01194   if ( ! h2d ) return false;
01195   
01196   h2d->add_annotation(tools::histo::key_axis_x_title(), title);
01197   return true;
01198 }  

G4bool G4XmlAnalysisManager::SetH2YAxisTitle ( G4int  id,
const G4String title 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 1201 of file G4XmlAnalysisManager.cc.

01202 {
01203   tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2YAxisTitle");
01204   if ( ! h2d ) return false;
01205   
01206   h2d->add_annotation(tools::histo::key_axis_x_title(), title);
01207   return true;  
01208 }  

G4bool G4XmlAnalysisManager::SetH2ZAxisTitle ( G4int  id,
const G4String title 
) [virtual]

Implements G4VAnalysisManager.

Definition at line 1211 of file G4XmlAnalysisManager.cc.

01212 {
01213   tools::histo::h2d* h2d = GetH2InFunction(id, "SetH2ZAxisTitle");
01214   if ( ! h2d ) return false;
01215   
01216   h2d->add_annotation(tools::histo::key_axis_z_title(), title);
01217   return true;  
01218 }  

G4bool G4XmlAnalysisManager::Write (  )  [virtual]

Implements G4VAnalysisManager.

Definition at line 360 of file G4XmlAnalysisManager.cc.

References G4String::append(), G4HnInformation::fActivation, G4VAnalysisManager::fActivation, G4VAnalysisManager::fHistoDirectoryName, G4VAnalysisManager::fLockHistoDirectoryName, G4HnInformation::fName, G4VAnalysisManager::fpVerboseL1, G4VAnalysisManager::fpVerboseL3, G4Exception(), G4VAnalysisManager::GetFullFileName(), G4VAnalysisManager::GetH1Information(), G4VAnalysisManager::GetH2Information(), G4VAnalysisManager::IsAscii(), JustWarning, G4AnalysisVerbose::Message(), and G4VAnalysisManager::WriteAscii().

00361 {
00362   // ntuple 
00363   if ( fNtuple ) fNtuple->write_trailer();
00364 
00365   // h1 histograms
00366   for ( G4int i=0; i<G4int(fH1Vector.size()); ++i ) {
00367     G4int id = i + fFirstHistoId;
00368     G4HnInformation* info = GetH1Information(id); 
00369     // skip writing if activation is enabled and H1 is inactivated
00370     if ( fActivation && ( ! info->fActivation ) ) continue; 
00371     tools::histo::h1d* h1 = fH1Vector[i];
00372 #ifdef G4VERBOSE
00373     if ( fpVerboseL3 ) 
00374       fpVerboseL3->Message("write", "h1d", info->fName);
00375 #endif
00376     G4String path = "/";
00377     path.append(fHistoDirectoryName);
00378     G4bool result
00379       = tools::waxml::write(*fFile, *h1, path, info->fName);
00380     if ( ! result ) {
00381       G4ExceptionDescription description;
00382       description << "      " << "saving histogram " << info->fName << " failed";
00383       G4Exception("G4XmlAnalysisManager::Write()",
00384                 "Analysis_W003", JustWarning, description);
00385       return false;       
00386     } 
00387     fLockHistoDirectoryName = true;
00388   }
00389  
00390   // h2 histograms
00391   for ( G4int i=0; i<G4int(fH2Vector.size()); ++i ) {
00392     G4int id = i + fFirstHistoId;
00393     G4HnInformation* info = GetH2Information(id); 
00394     // skip writing if inactivated
00395     if ( fActivation && ( ! info->fActivation ) ) continue;
00396     tools::histo::h2d* h2 = fH2Vector[i];
00397  #ifdef G4VERBOSE
00398     if ( fpVerboseL3 ) 
00399       fpVerboseL3->Message("write", "h2d", info->fName);
00400 #endif
00401     G4String path = "/";
00402     path.append(fHistoDirectoryName);
00403     G4bool result
00404       = tools::waxml::write(*fFile, *h2, path, info->fName);
00405     if ( ! result ) {
00406       G4ExceptionDescription description;
00407       description << "      " << "saving histogram " << info->fName << " failed";
00408       G4Exception("G4XmlAnalysisManager::Write()",
00409                 "Analysis_W003", JustWarning, description);
00410       return false;       
00411     } 
00412     fLockHistoDirectoryName = true;
00413   }
00414   G4bool result = true;
00415 
00416 #ifdef G4VERBOSE
00417   if ( fpVerboseL1 ) 
00418     fpVerboseL1->Message("write", "file", GetFullFileName(), result);
00419 #endif
00420 
00421   // Write ASCII if activated
00422   if ( IsAscii() ) {
00423     result = WriteAscii();
00424   }   
00425 
00426   return result;
00427 }

G4bool G4XmlAnalysisManager::WriteOnAscii ( std::ofstream &  output  )  [protected, virtual]

Implements G4VAnalysisManager.

Definition at line 280 of file G4XmlAnalysisManager.cc.

References G4HnInformation::fAscii, G4HnInformation::fName, G4VAnalysisManager::fpVerboseL3, G4endl, G4VAnalysisManager::GetH1Information(), and G4AnalysisVerbose::Message().

00281 {
00282 // Write selected objects on ASCII file
00283 // (Only H1 implemented by now)
00284 // According to the implementation by Michel Maire, originally in
00285 // extended examples.
00286 
00287   // h1 histograms
00288   for ( G4int i=0; i<G4int(fH1Vector.size()); ++i ) {
00289     G4int id = i + fFirstHistoId;
00290     G4HnInformation* info = GetH1Information(id); 
00291     // skip writing if activation is enabled and H1 is inactivated
00292     if ( ! info->fAscii ) continue; 
00293     tools::histo::h1d* h1 = fH1Vector[i];
00294 
00295 #ifdef G4VERBOSE
00296     if ( fpVerboseL3 ) 
00297       fpVerboseL3->Message("write on ascii", "h1d", info->fName);
00298 #endif
00299   
00300     output << "\n  1D histogram " << id << ": " << h1->title() 
00301            << "\n \n \t     X \t\t     Y" << G4endl;
00302     
00303     for (G4int j=0; j< G4int(h1->axis().bins()); ++j) {
00304        output << "  " << j << "\t" 
00305               << h1->axis().bin_center(j) << "\t"
00306               << h1->bin_height(j) << G4endl;
00307     } 
00308   }
00309   
00310   return true;
00311 }  


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:54:00 2013 for Geant4 by  doxygen 1.4.7