G4TScoreNtupleWriter.icc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
// Author: Ivana Hrivnacova, 30/10/2018  (ivana@ipno.in2p3.fr)
// ---------------------------------------------------------------------
 
#include "G4TScoreNtupleWriterMessenger.hh"
#include "G4THitsMap.hh"
#include "G4Threading.hh"
 
//_____________________________________________________________________________
//
// ctor, dtor
//
 
//_____________________________________________________________________________
template <typename T>
G4TScoreNtupleWriter<T>::G4TScoreNtupleWriter()
  : G4VScoreNtupleWriter()
  , fMessenger(nullptr)
  , fHCIds()
  , fAnalysisManager(nullptr)
  , fDefaultFileType("root")
  , fFileName("scoring")
  , fVerboseLevel(1)
  , fHasAnalysisFile(false)
  , fIsBooked(false)
  , fIsInitialized(false)
  , fFirstNtupleId(0)
{
  if(G4Threading::IsMasterThread())
  {
    fMessenger = new G4TScoreNtupleWriterMessenger<T>(this);
  }
}
 
//_____________________________________________________________________________
template <typename T>
G4TScoreNtupleWriter<T>::~G4TScoreNtupleWriter()
{
  delete fMessenger;
}
 
//
// private methods
//
 
//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::CreateAnalysisManager()
{
  if(fAnalysisManager)
    return;
 
  // create/get analysis manager
  fAnalysisManager = T::Instance();
 
  fAnalysisManager->SetDefaultFileType(fDefaultFileType);
  fAnalysisManager->SetVerboseLevel(fVerboseLevel);
}
 
//
// protected methods
//
 
//_____________________________________________________________________________
template <typename T>
G4VScoreNtupleWriter* G4TScoreNtupleWriter<T>::CreateInstance() const
{
  auto instance = new G4TScoreNtupleWriter();
  instance->SetFileName(fFileName);
  instance->SetVerboseLevel(fVerboseLevel);
 
  return instance;
}
 
//
// public methods
//
 
//_____________________________________________________________________________
template <typename T>
G4bool G4TScoreNtupleWriter<T>::Book(G4HCofThisEvent* hce)
{
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- G4TScoreNtupleWriter<T>::Book" << G4endl;
  }
#endif
  if(!hce)
    return false;
 
  // book collection ID if DoubleHitsMap
  if(fHCIds.size() == 0)
  {
#ifdef G4VERBOSE
    if(fVerboseLevel > 1)
    {
      G4cout << "--- going to fill fHCIds " << G4endl;
    }
#endif
    for(G4int i = 0; i < hce->GetNumberOfCollections(); ++i)
    {
      auto hitsMap = dynamic_cast<G4THitsMap<G4double>*>(hce->GetHC(i));
 
      if(hitsMap)
      {
#ifdef G4VERBOSE
        if(fVerboseLevel > 1)
        {
          G4cout << "--- adding hcID = " << i << G4endl;
        }
#endif
        fHCIds.push_back(i);
      }
    }
  }
 
  // Create analysis manager
  if(fHCIds.size())
  {
    CreateAnalysisManager();
  }
 
  // Create ntuples (only once)
  if(!fIsInitialized)
  {
#ifdef G4VERBOSE
    if(fVerboseLevel > 1)
    {
      G4cout << "-- going to create ntuples " << G4endl;
    }
#endif
    auto first = true;
    for(auto id : fHCIds)
    {
      auto hitsMap = static_cast<G4THitsMap<G4double>*>(hce->GetHC(id));
 
      // Create ntuple for this primitive
      G4String ntupleName(hitsMap->GetSDname());
      ntupleName.append("_");
      ntupleName.append(hitsMap->GetName());
 
      G4int ntupleId = fAnalysisManager->CreateNtuple(ntupleName, ntupleName);
      if(first)
      {
        fFirstNtupleId = ntupleId;
#ifdef G4VERBOSE
        if(fVerboseLevel > 1)
        {
          G4cout << "-- set first ntuple Id " << fFirstNtupleId << G4endl;
        }
#endif
        first = false;
      }
 
      G4String colName(ntupleName);
      colName.append("_eventId");
      fAnalysisManager->CreateNtupleIColumn(colName);
      colName = ntupleName;
      colName.append("_cell");
      fAnalysisManager->CreateNtupleIColumn(colName);
      colName = ntupleName;
      colName.append("_score");
      fAnalysisManager->CreateNtupleDColumn(colName);
      fAnalysisManager->FinishNtuple();
      fIsBooked = true;
    }
    fIsInitialized = true;
  }
 
  return fIsBooked;
}
 
//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::OpenFile()
{
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- G4TScoreNtupleWriter<T>::OpenFile" << G4endl;
  }
#endif
 
  if(fAnalysisManager->IsOpenFile())
    return;
 
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- G4TScoreNtupleWriter<T>::OpenFile executing" << G4endl;
  }
#endif
 
  if(fAnalysisManager->GetFileName() == "")
  {
    fAnalysisManager->SetFileName(fFileName);
  }
  fAnalysisManager->OpenFile();
 
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- G4TScoreNtupleWriter<T>::OpenFile isOpenFile: "
           << fAnalysisManager->IsOpenFile() << G4endl;
  }
#endif
 
  fHasAnalysisFile = fAnalysisManager->IsOpenFile();
}
 
//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::Fill(G4HCofThisEvent* hce, G4int eventNumber)
{
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- start G4TScoreNtupleWriter<T>::Fill" << G4endl;
  }
#endif
 
  auto counter = 0;
  for(auto id : fHCIds)
  {
#ifdef G4VERBOSE
    if(fVerboseLevel > 1)
    {
      G4cout << "in loop over fHCIds, counter " << counter << G4endl;
    }
#endif
    auto hitsMap = static_cast<G4THitsMap<G4double>*>(hce->GetHC(id));
 
    // G4cout << eventNumber << ".. go to fill ntuple " << counter +
    // fFirstNtupleId << G4endl;
 
    // fill hits in ntuple
    std::map<G4int, G4double*>::iterator it;
    for(it = hitsMap->GetMap()->begin(); it != hitsMap->GetMap()->end(); it++)
    {
      fAnalysisManager->FillNtupleIColumn(counter + fFirstNtupleId, 0,
                                          eventNumber);
      fAnalysisManager->FillNtupleIColumn(counter + fFirstNtupleId, 1,
                                          it->first);
      fAnalysisManager->FillNtupleDColumn(counter + fFirstNtupleId, 2,
                                          *(it->second));
      fAnalysisManager->AddNtupleRow(counter + fFirstNtupleId);
    }
    counter++;
  }
 
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- done G4TScoreNtupleWriter<T>::Fill" << G4endl;
  }
#endif
}
 
//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::Write()
{
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- start G4TScoreNtupleWriter<T>::Write" << G4endl;
  }
#endif
 
  if(fHasAnalysisFile)
  {
#ifdef G4VERBOSE
    if(fVerboseLevel > 1)
    {
      G4cout << "--- G4TScoreNtupleWriter<T>::Write - has file" << G4endl;
    }
#endif
    fAnalysisManager->Write();
    fAnalysisManager->CloseFile();
    fAnalysisManager->SetFileName("");
  }
 
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- done G4TScoreNtupleWriter<T>::Write" << G4endl;
  }
#endif
}
 
//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::SetDefaultFileType(const G4String& value)
{
  fDefaultFileType = value;
  if(fAnalysisManager)
  {
    fAnalysisManager->SetDefaultFileType(value);
  }
}
 
//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::SetFileName(const G4String& fileName)
{
  fFileName = fileName;
}
 
//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::SetVerboseLevel(G4int value)
{
  fVerboseLevel = value;
  if(fAnalysisManager)
  {
    fAnalysisManager->SetVerboseLevel(value);
  }
}