geant4/source/digits_hits/utils/include/G4TScoreNtupleWriter.icc

//
// ********************************************************************
// * 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),
   fFileName("scoring"),
   fVerboseLevel(1),
   fHasAnalysisManager(false),
   fHasAnalysisFile(false),
   fIsBooked(false),
   fIsInitialized(false),
   fFirstNtupleId(0)
{
  if ( G4Threading::IsMasterThread() ) {
    fMessenger = new G4TScoreNtupleWriterMessenger<T>(this);
  }
}

//_____________________________________________________________________________
template <typename T>
G4TScoreNtupleWriter<T>::~G4TScoreNtupleWriter()
{
  if ( fHasAnalysisManager ) {
    delete fAnalysisManager;
  }

  delete fMessenger;
}

//
// private methods
//

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::CreateAnalysisManager()
{
  if ( fAnalysisManager ) return;

  // create analysis manager
  if ( ! T::IsInstance() ) fHasAnalysisManager = true;
  fAnalysisManager = T::Instance();
 
  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>::SetVerboseLevel(G4int value)
{ 
  fVerboseLevel = value; 
  if ( fAnalysisManager ) {
    fAnalysisManager->SetVerboseLevel(value);
  }
}

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::SetFileName(const G4String& fileName)
{ 
  fFileName = fileName; 
}