lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.1.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 12:08:39 +02:00
parent 286caacf06
commit c9b32a6c0a
5770 changed files with 1050949 additions and 367105 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/analysis/root/src/G4RootAnalysisManager.cc
+211 -17
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4RootAnalysisManager.cc 74257 2013-10-02 14:24:55Z gcosmo $
// $Id: G4RootAnalysisManager.cc 85317 2014-10-27 15:58:15Z gcosmo $
// Author: Ivana Hrivnacova, 18/06/2013 (ivana@ipno.in2p3.fr)
@@ -31,8 +31,12 @@
#include "G4RootFileManager.hh"
#include "G4H1ToolsManager.hh"
#include "G4H2ToolsManager.hh"
#include "G4H3ToolsManager.hh"
#include "G4P1ToolsManager.hh"
#include "G4P2ToolsManager.hh"
#include "G4RootNtupleManager.hh"
#include "G4AnalysisVerbose.hh"
#include "G4AnalysisManagerState.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
@@ -49,6 +53,12 @@ namespace {
G4Mutex mergeH1Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging H1 histograms
G4Mutex mergeH2Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging H1 histograms
G4Mutex mergeH3Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging P1 profiles
G4Mutex mergeP1Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging P2 profiles
G4Mutex mergeP2Mutex = G4MUTEX_INITIALIZER;
}
G4RootAnalysisManager* G4RootAnalysisManager::fgMasterInstance = 0;
@@ -70,6 +80,9 @@ G4RootAnalysisManager::G4RootAnalysisManager(G4bool isMaster)
: G4VAnalysisManager("Root", isMaster),
fH1Manager(0),
fH2Manager(0),
fH3Manager(0),
fP1Manager(0),
fP2Manager(0),
fNtupleManager(0),
fFileManager(0)
{
@@ -88,6 +101,9 @@ G4RootAnalysisManager::G4RootAnalysisManager(G4bool isMaster)
// Create managers
fH1Manager = new G4H1ToolsManager(fState);
fH2Manager = new G4H2ToolsManager(fState);
fH3Manager = new G4H3ToolsManager(fState);
fP1Manager = new G4P1ToolsManager(fState);
fP2Manager = new G4P2ToolsManager(fState);
fNtupleManager = new G4RootNtupleManager(fState);
fFileManager = new G4RootFileManager(fState);
// The managers will be deleted by the base class
@@ -95,6 +111,9 @@ G4RootAnalysisManager::G4RootAnalysisManager(G4bool isMaster)
// Set managers to base class
SetH1Manager(fH1Manager);
SetH2Manager(fH2Manager);
SetH3Manager(fH3Manager);
SetP1Manager(fP1Manager);
SetP2Manager(fP2Manager);
SetNtupleManager(fNtupleManager);
SetFileManager(fFileManager);
}
@@ -124,8 +143,8 @@ G4bool G4RootAnalysisManager::WriteH1()
for ( G4int i=0; i<G4int(h1Vector.size()); ++i ) {
G4HnInformation* info = hnVector[i];
G4bool activation = info->fActivation;
G4String name = info->fName;
G4bool activation = info->GetActivation();
G4String name = info->GetName();
// skip writing if activation is enabled and H1 is inactivated
if ( fState.GetIsActivation() && ( ! activation ) ) continue;
tools::histo::h1d* h1 = h1Vector[i];
@@ -141,7 +160,7 @@ G4bool G4RootAnalysisManager::WriteH1()
G4ExceptionDescription description;
description << " " << "saving histogram " << name << " failed";
G4Exception("G4RootAnalysisManager::Write()",
"Analysis_W003", JustWarning, description);
"Analysis_W022", JustWarning, description);
return false;
}
}
@@ -171,8 +190,8 @@ G4bool G4RootAnalysisManager::WriteH2()
for ( G4int i=0; i<G4int(h2Vector.size()); ++i ) {
G4HnInformation* info = hnVector[i];
G4bool activation = info->fActivation;
G4String name = info->fName;
G4bool activation = info->GetActivation();
G4String name = info->GetName();
// skip writing if inactivated
if ( fState.GetIsActivation() && ( ! activation ) ) continue;
tools::histo::h2d* h2 = h2Vector[i];
@@ -188,7 +207,7 @@ G4bool G4RootAnalysisManager::WriteH2()
G4ExceptionDescription description;
description << " " << "saving histogram " << name << " failed";
G4Exception("G4RootAnalysisManager::Write()",
"Analysis_W003", JustWarning, description);
"Analysis_W022", JustWarning, description);
return false;
}
}
@@ -204,6 +223,147 @@ G4bool G4RootAnalysisManager::WriteH2()
return true;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::WriteH3()
{
const std::vector<tools::histo::h3d*>& h3Vector
= fH3Manager->GetH3Vector();
const std::vector<G4HnInformation*>& hnVector
= fH3Manager->GetHnVector();
if ( ! h3Vector.size() ) return true;
if ( ! G4Threading::IsWorkerThread() ) {
for ( G4int i=0; i<G4int(h3Vector.size()); ++i ) {
G4HnInformation* info = hnVector[i];
G4bool activation = info->GetActivation();
G4String name = info->GetName();
// skip writing if inactivated
if ( fState.GetIsActivation() && ( ! activation ) ) continue;
tools::histo::h3d* h3 = h3Vector[i];
#ifdef G4VERBOSE
if ( fState.GetVerboseL3() )
fState.GetVerboseL3()->Message("write", "h3d", name);
#endif
tools::wroot::directory* histoDirectory
= fFileManager->GetHistoDirectory();
G4bool result
= to(*histoDirectory, *h3, name);
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "saving histogram " << name << " failed";
G4Exception("G4RootAnalysisManager::Write()",
"Analysis_W022", JustWarning, description);
return false;
}
}
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lH3(&mergeH3Mutex);
fgMasterInstance->fH3Manager->AddH3Vector(h3Vector);
lH3.unlock();
}
return true;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::WriteP1()
{
const std::vector<tools::histo::p1d*>& p1Vector
= fP1Manager->GetP1Vector();
const std::vector<G4HnInformation*>& hnVector
= fP1Manager->GetHnVector();
if ( ! p1Vector.size() ) return true;
if ( ! G4Threading::IsWorkerThread() ) {
for ( G4int i=0; i<G4int(p1Vector.size()); ++i ) {
G4HnInformation* info = hnVector[i];
G4bool activation = info->GetActivation();
G4String name = info->GetName();
// skip writing if activation is enabled and P1 is inactivated
if ( fState.GetIsActivation() && ( ! activation ) ) continue;
tools::histo::p1d* p1 = p1Vector[i];
#ifdef G4VERBOSE
if ( fState.GetVerboseL3() )
fState.GetVerboseL3()->Message("write", "p1d", name);
#endif
tools::wroot::directory* profileDirectory
= fFileManager->GetProfileDirectory();
G4bool result
= to(*profileDirectory, *p1, name);
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "saving profile " << name << " failed";
G4Exception("G4RootAnalysisManager::Write()",
"Analysis_W022", JustWarning, description);
return false;
}
}
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lP1(&mergeP1Mutex);
fgMasterInstance->fP1Manager->AddP1Vector(p1Vector);
lP1.unlock();
}
return true;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::WriteP2()
{
const std::vector<tools::histo::p2d*>& p2Vector
= fP2Manager->GetP2Vector();
const std::vector<G4HnInformation*>& hnVector
= fP2Manager->GetHnVector();
if ( ! p2Vector.size() ) return true;
if ( ! G4Threading::IsWorkerThread() ) {
for ( G4int i=0; i<G4int(p2Vector.size()); ++i ) {
G4HnInformation* info = hnVector[i];
G4bool activation = info->GetActivation();
G4String name = info->GetName();
// skip writing if activation is enabled and P2 is inactivated
if ( fState.GetIsActivation() && ( ! activation ) ) continue;
tools::histo::p2d* p2 = p2Vector[i];
#ifdef G4VERBOSE
if ( fState.GetVerboseL3() )
fState.GetVerboseL3()->Message("write", "p2d", name);
#endif
tools::wroot::directory* profileDirectory
= fFileManager->GetProfileDirectory();
G4bool result
= to(*profileDirectory, *p2, name);
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "saving profile " << name << " failed";
G4Exception("G4RootAnalysisManager::Write()",
"Analysis_W022", JustWarning, description);
return false;
}
}
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lP2(&mergeP2Mutex);
fgMasterInstance->fP2Manager->AddP2Vector(p2Vector);
lP2.unlock();
}
return true;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::Reset()
{
@@ -217,6 +377,15 @@ G4bool G4RootAnalysisManager::Reset()
result = fH2Manager->Reset();
finalResult = finalResult && result;
result = fH3Manager->Reset();
finalResult = finalResult && result;
result = fP1Manager->Reset();
finalResult = finalResult && result;
result = fP2Manager->Reset();
finalResult = finalResult && result;
result = fNtupleManager->Reset();
finalResult = finalResult && result;
@@ -261,14 +430,16 @@ G4bool G4RootAnalysisManager::WriteImpl()
G4bool finalResult = true;
if ( ! fgMasterInstance &&
( ( ! fH1Manager->IsEmpty() ) || ( ! fH2Manager->IsEmpty() ) ) ) {
( ( ! fH1Manager->IsEmpty() ) || ( ! fH2Manager->IsEmpty() ) ||
( ! fH3Manager->IsEmpty() ) || ( ! fP1Manager->IsEmpty() ) ||
( ! fP2Manager->IsEmpty() ) ) ) {
G4ExceptionDescription description;
description
<< " " << "No master G4RootAnalysisManager instance exists."
<< G4endl
<< " " << "Histogram data will not be merged.";
<< " " << "Histogram/profile data will not be merged.";
G4Exception("G4RootAnalysisManager::Write()",
"Analysis_W014", JustWarning, description);
"Analysis_W031", JustWarning, description);
}
// H1
@@ -279,6 +450,18 @@ G4bool G4RootAnalysisManager::WriteImpl()
result = WriteH2();
finalResult = finalResult && result;
// H3
result = WriteH3();
finalResult = finalResult && result;
// P1
result = WriteP1();
finalResult = finalResult && result;
// P2
result = WriteP2();
finalResult = finalResult && result;
// File
result = fFileManager->WriteFile();
finalResult = finalResult && result;
@@ -295,7 +478,7 @@ G4bool G4RootAnalysisManager::WriteImpl()
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::CloseFileImpl()
{
G4bool result = true;
G4bool finalResult = true;
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
@@ -304,25 +487,36 @@ G4bool G4RootAnalysisManager::CloseFileImpl()
#endif
// reset data
result = Reset();
G4bool result = Reset();
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4RootAnalysisManager::Write()",
"Analysis_W002", JustWarning, description);
"Analysis_W021", JustWarning, description);
}
finalResult = finalResult && result;
// close file
fFileManager->CloseFile();
// No files clean-up in sequential mode
if ( ! fState.IsMT() ) return result;
if ( ! G4Threading::IsMultithreadedApplication() ) return finalResult;
// Delete files if empty in MT mode
if ( ( fState.GetIsMaster() &&
fH1Manager->IsEmpty() && fH2Manager->IsEmpty() ) ||
fH1Manager->IsEmpty() && fH2Manager->IsEmpty() && fH3Manager->IsEmpty() &&
fP1Manager->IsEmpty() && fP2Manager->IsEmpty() ) ||
( ( ! fState.GetIsMaster() ) && fNtupleManager->IsEmpty() ) ) {
std::remove(fFileManager->GetFullFileName());
result = ! std::remove(fFileManager->GetFullFileName());
// std::remove returns 0 when success
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Removing file "
<< fFileManager->GetFullFileName() << " failed";
G4Exception("G4XmlAnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
}
finalResult = finalResult && result;
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
@@ -337,6 +531,6 @@ G4bool G4RootAnalysisManager::CloseFileImpl()
#endif
}
return result;
return finalResult;
}