Geant4  10.02.p01
G4XmlAnalysisReader.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: G4XmlAnalysisReader.cc 74257 2013-10-02 14:24:55Z gcosmo $
27 
28 // Author: Ivana Hrivnacova, 25/07/2014 (ivana@ipno.in2p3.fr)
29 
30 #include "G4XmlAnalysisReader.hh"
31 #include "G4XmlRFileManager.hh"
32 #include "G4H1ToolsManager.hh"
33 #include "G4H2ToolsManager.hh"
34 #include "G4H3ToolsManager.hh"
35 #include "G4P1ToolsManager.hh"
36 #include "G4P2ToolsManager.hh"
37 #include "G4XmlRNtupleManager.hh"
39 #include "G4AnalysisVerbose.hh"
40 #include "G4AnalysisUtilities.hh"
41 #include "G4Threading.hh"
42 
43 #include <iostream>
44 #include <cstdio>
45 
46 using namespace G4Analysis;
47 
50 
51 //_____________________________________________________________________________
53 {
54  if ( fgInstance == nullptr ) {
55  G4bool isMaster = ! G4Threading::IsWorkerThread();
56  fgInstance = new G4XmlAnalysisReader(isMaster);
57  }
58 
59  return fgInstance;
60 }
61 
62 //_____________________________________________________________________________
64  : G4ToolsAnalysisReader("Xml", isMaster),
65  fNtupleManager(nullptr),
66  fFileManager(nullptr)
67 {
68  if ( ( isMaster && fgMasterInstance ) || ( fgInstance ) ) {
69  G4ExceptionDescription description;
70  description
71  << " "
72  << "G4XmlAnalysisReader already exists."
73  << "Cannot create another instance.";
74  G4Exception("G4XmlAnalysisReader::G4XmlAnalysisReader()",
75  "Analysis_F001", FatalException, description);
76  }
77  if ( isMaster ) fgMasterInstance = this;
78  fgInstance = this;
79 
80  // Create managers
83  // The managers will be deleted by the base class
84 
85  // Set managers to base class
88 }
89 
90 //_____________________________________________________________________________
92 {
93  if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
94  fgInstance = nullptr;
95 }
96 
97 //
98 // private methods
99 //
100 
101 //_____________________________________________________________________________
103  const G4String& fileName,
104  const G4String& objectName,
105  const G4String& objectType,
106  const G4String& inFunction)
107 {
108 // Get buffer for reading object specified by objectName and objectType
109 // for a file specified by fileName;
110 // open the file if it was not yet open
111 
112  // Histograms and profiles are not saved per thread
113  // and ntuple file name is already updated
114  auto rfile = fFileManager->GetRFile(fileName);
115  if ( ! rfile ) {
116  if ( ! fFileManager->OpenRFile(fileName) ) return nullptr;
117  rfile = fFileManager->GetRFile(fileName);
118  }
119 
120  tools::raxml_out* handler = nullptr;
121  if ( rfile ) {
122  std::vector<tools::raxml_out>& objects = rfile->objects();
123  std::vector<tools::raxml_out>::iterator it;
124  for (it = objects.begin(); it!=objects.end(); ++it) {
125  tools::raxml_out& object = *it;
126  if ( object.cls() == objectType && object.name() == objectName ) {
127  handler = &object;
128  break;
129  }
130  }
131  }
132 
133  if ( ! handler ) {
134  G4ExceptionDescription description;
135  description
136  << " "
137  << "Cannot get "<< objectName << " in file " << fileName;
138  G4String inFunctionFull = "G4XmlAnalysisReader::";
139  inFunctionFull.append(inFunction);
140  G4Exception(inFunctionFull, "Analysis_WR011", JustWarning, description);
141  return nullptr;
142  }
143 
144  return handler;
145 }
146 
147 //_____________________________________________________________________________
149 {
150 // Reset histograms and ntuple
151 
152  auto finalResult = true;
153 
154  auto result = G4ToolsAnalysisReader::Reset();
155  finalResult = finalResult && result;
156 
157  result = fNtupleManager->Reset();
158  finalResult = finalResult && result;
159 
160  return finalResult;
161 }
162 
163 //
164 // protected methods
165 //
166 
167 //_____________________________________________________________________________
169  const G4String& fileName,
170  G4bool /*isUserFileName*/)
171 {
172 #ifdef G4VERBOSE
173  if ( fState.GetVerboseL4() )
174  fState.GetVerboseL4()->Message("read", "h1", h1Name);
175 #endif
176 
177  tools::raxml_out* handler
178  = GetHandler(fileName, h1Name, tools::histo::h1d::s_class(), "ReadH1Impl");
179  if ( ! handler ) return kInvalidId;
180 
181  auto h1 = static_cast<tools::histo::h1d*>(handler->object());
182  auto id = fH1Manager->AddH1(h1Name, h1);
183 
184 #ifdef G4VERBOSE
185  if ( fState.GetVerboseL2() )
186  fState.GetVerboseL2()->Message("read", "h1", h1Name, id > kInvalidId);
187 #endif
188 
189  return id;
190 }
191 
192 //_____________________________________________________________________________
194  const G4String& fileName,
195  G4bool /*isUserFileName*/)
196 {
197 #ifdef G4VERBOSE
198  if ( fState.GetVerboseL4() )
199  fState.GetVerboseL4()->Message("read", "h2", h2Name);
200 #endif
201 
202  auto handler
203  = GetHandler(fileName, h2Name, tools::histo::h2d::s_class(), "ReadH2Impl");
204  if ( ! handler ) return kInvalidId;
205 
206  auto h2 = static_cast<tools::histo::h2d*>(handler->object());
207  auto id = fH2Manager->AddH2(h2Name, h2);
208 
209 #ifdef G4VERBOSE
210  if ( fState.GetVerboseL2() )
211  fState.GetVerboseL2()->Message("read", "h2", h2Name, id > kInvalidId);
212 #endif
213 
214  return id;
215 }
216 
217 //_____________________________________________________________________________
219  const G4String& fileName,
220  G4bool /*isUserFileName*/)
221 {
222 #ifdef G4VERBOSE
223  if ( fState.GetVerboseL4() )
224  fState.GetVerboseL4()->Message("read", "h3", h3Name);
225 #endif
226 
227  auto handler
228  = GetHandler(fileName, h3Name, tools::histo::h3d::s_class(), "ReadH3Impl");
229  if ( ! handler ) return kInvalidId;
230 
231  auto h3 = static_cast<tools::histo::h3d*>(handler->object());
232  auto id = fH3Manager->AddH3(h3Name, h3);
233 
234 #ifdef G4VERBOSE
235  if ( fState.GetVerboseL2() )
236  fState.GetVerboseL2()->Message("read", "h3", h3Name, id > kInvalidId);
237 #endif
238 
239  return id;
240 }
241 
242 //_____________________________________________________________________________
244  const G4String& fileName,
245  G4bool /*isUserFileName*/)
246 {
247 #ifdef G4VERBOSE
248  if ( fState.GetVerboseL4() )
249  fState.GetVerboseL4()->Message("read", "p1", p1Name);
250 #endif
251 
252  auto handler
253  = GetHandler(fileName, p1Name, tools::histo::p1d::s_class(), "ReadP1Impl");
254  if ( ! handler ) return kInvalidId;
255 
256  auto p1 = static_cast<tools::histo::p1d*>(handler->object());
257  auto id = fP1Manager->AddP1(p1Name, p1);
258 
259 #ifdef G4VERBOSE
260  if ( fState.GetVerboseL2() )
261  fState.GetVerboseL2()->Message("read", "p1", p1Name, id > kInvalidId);
262 #endif
263 
264  return id;
265 }
266 
267 //_____________________________________________________________________________
269  const G4String& fileName,
270  G4bool /*isUserFileName*/)
271 {
272 #ifdef G4VERBOSE
273  if ( fState.GetVerboseL4() )
274  fState.GetVerboseL4()->Message("read", "p2", p2Name);
275 #endif
276 
277  auto handler
278  = GetHandler(fileName, p2Name, tools::histo::p2d::s_class(), "ReadP2Impl");
279  if ( ! handler ) return kInvalidId;
280 
281  auto p2 = static_cast<tools::histo::p2d*>(handler->object());
282  auto id = fP2Manager->AddP2(p2Name, p2);
283 
284 #ifdef G4VERBOSE
285  if ( fState.GetVerboseL2() )
286  fState.GetVerboseL2()->Message("read", "p2", p2Name, id > kInvalidId);
287 #endif
288 
289  return id;
290 }
291 
292 //_____________________________________________________________________________
294  const G4String& fileName,
295  G4bool isUserFileName)
296 {
297 #ifdef G4VERBOSE
298  if ( fState.GetVerboseL4() )
299  fState.GetVerboseL4()->Message("read", "ntuple", ntupleName);
300 #endif
301 
302  // Ntuples are saved per object and per thread
303  // but apply the ntuple name and the thread suffixes
304  // only if fileName is not provided explicitly
305  auto fullFileName = fileName;
306  if ( ! isUserFileName ) {
307  fullFileName = fFileManager->GetNtupleFileName(ntupleName);
308  }
309 
310  auto handler
311  = GetHandler(fullFileName, ntupleName, tools::aida::ntuple::s_class(),
312  "ReadNtupleImpl");
313  if ( ! handler ) return kInvalidId;
314 
315  auto rntuple = static_cast<tools::aida::ntuple*>(handler->object());
316  auto id = fNtupleManager->SetNtuple(new G4XmlRNtupleDescription(rntuple));
317 
318 #ifdef G4VERBOSE
319  if ( fState.GetVerboseL2() )
320  fState.GetVerboseL2()->Message("read", "ntuple", ntupleName, id > kInvalidId);
321 #endif
322 
323  return id;
324 }
void Message(const G4String &action, const G4String &object, const G4String &objectName, G4bool success=true) const
G4int AddH3(const G4String &name, tools::histo::h3d *h3d)
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
G4String GetNtupleFileName(const G4String &ntupleName) const
G4P1ToolsManager * fP1Manager
G4H1ToolsManager * fH1Manager
G4XmlRFileManager * fFileManager
G4XmlRNtupleManager * fNtupleManager
#define G4ThreadLocal
Definition: tls.hh:89
G4AnalysisManagerState fState
int G4int
Definition: G4Types.hh:78
G4H3ToolsManager * fH3Manager
G4int AddP2(const G4String &name, tools::histo::p2d *p2d)
const G4AnalysisVerbose * GetVerboseL2() const
static G4ThreadLocal G4XmlAnalysisReader * fgInstance
virtual G4int ReadP2Impl(const G4String &h1Name, const G4String &fileName, G4bool isUserFileName) final
tools::raxml_out * GetHandler(const G4String &fileName, const G4String &objectName, const G4String &objectType, const G4String &inFunction)
const G4AnalysisVerbose * GetVerboseL4() const
G4H2ToolsManager * fH2Manager
bool G4bool
Definition: G4Types.hh:79
void SetNtupleManager(G4VRNtupleManager *ntupleManager)
static G4XmlAnalysisReader * fgMasterInstance
tools::raxml * GetRFile(const G4String &fileName) const
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4P2ToolsManager * fP2Manager
G4bool IsWorkerThread()
Definition: G4Threading.cc:129
G4int AddP1(const G4String &name, tools::histo::p1d *p1d)
virtual G4int ReadH3Impl(const G4String &h1Name, const G4String &fileName, G4bool isUserFileName) final
virtual G4int ReadH1Impl(const G4String &h1Name, const G4String &fileName, G4bool isUserFileName) final
virtual G4int ReadH2Impl(const G4String &h1Name, const G4String &fileName, G4bool isUserFileName) final
G4String & append(const G4String &)
G4int AddH2(const G4String &name, tools::histo::h2d *h2d)
G4int AddH1(const G4String &name, tools::histo::h1d *h1d)
G4XmlAnalysisReader(G4bool isMaster=true)
virtual G4int ReadNtupleImpl(const G4String &ntupleName, const G4String &fileName, G4bool isUserFileName) final
G4int SetNtuple(G4XmlRNtupleDescription *rntupleDescription)
virtual G4bool OpenRFile(const G4String &fileName)
static G4XmlAnalysisReader * Instance()
const G4int kInvalidId
virtual G4int ReadP1Impl(const G4String &h1Name, const G4String &fileName, G4bool isUserFileName) final
void SetFileManager(G4BaseFileManager *fileManager)