TestActionTimer.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

//                                                              //
//                       TestActionTimer                        //
//       Code for text output (into the athena.out files)       //
//       of information about the time spent simulating         //
//       various pieces of the detector and particles.          //
//                                                              //
//       Written by      Zachary Marshall                       //
//                       Caltech                                //
//                       zmarshal@caltech.edu                   //
//                                                              //
//       Last update    08.07.08                                //
//                                                              //
 
 
#include "TestActionTimer.h"
 
#include "G4Version.hh"
#include "G4Run.hh"
#include "G4Event.hh"
#include "G4Step.hh"
 
#include "G4String.hh"
#include "G4Timer.hh"
#include "G4Track.hh"
#include "G4Electron.hh"
#include "G4Gamma.hh"
#include "G4Positron.hh"
#include "G4Neutron.hh"
 
// For file output
#include "GaudiKernel/ITHistSvc.h"
#include "TH1D.h"
#include <string_view>
 
// #define _myDebug
 
 
namespace G4UA
{
  // Helper for G4String changes
  bool G4StrContains(const G4String& s, const char* v)
  {
#if G4VERSION_NUMBER < 1100
    return s.contains(v);
#else
    return G4StrUtil::contains(s, v);
#endif
  }
 
  bool G4StrContains(const std::string_view& s, const char* v)
  {
    return s.find(v) != std::string_view::npos;
  }
 
  TestActionTimer::TestActionTimer()
  {
    m_report.timeName.resize(eMax);
    m_report.timeName[eEMB]   = "EMB";
    m_report.timeName[eEMEC]  = "EMEC";
    m_report.timeName[eFC1]   = "FC1";
    m_report.timeName[eFC23]  = "FC23";
    m_report.timeName[eFCO]   = "FCO";
    m_report.timeName[eHEC]   = "HEC";
    m_report.timeName[eCry]   = "Cry";
    m_report.timeName[eLAr]   = "LAr";
    m_report.timeName[eHCB]   = "HCB";
    m_report.timeName[eITkPix]   = "ITkPixel";
    m_report.timeName[eITkStrip] = "ITkStrip";
    m_report.timeName[ePre]   = "Pre";
    m_report.timeName[eMu]    = "Mu";
    m_report.timeName[ePx]    = "Px";
    m_report.timeName[eTrt]    = "TRT";
    m_report.timeName[eHGTD] = "HGTD";
    m_report.timeName[eSev]   = "IDServ";
    m_report.timeName[eSct]   = "SCT";
    m_report.timeName[eOther] = "Other";
 
    m_report.timeName[eElec]  = "Elec";
    m_report.timeName[ePos]   = "Pos";
    m_report.timeName[eGam]   = "Gam";
    m_report.timeName[eNeut]  = "Neut";
 
    G4cout<< "TestActionTimer::Constructor: Labels "
          <<" Run Event ";
    for (int i(0); i < eMax; ++i) G4cout << m_report.timeName[i] << " ";
    G4cout << "Particle Dead" << G4endl;
 
    // init timers
 
    m_runTimer = new G4Timer();
    m_runTimer->Start();
 
    // create all timers, start and stop, init counters
    for (int i(0); i < eMax; ++i) {
      G4Timer* timer = new G4Timer();
      timer->Start();
 
      m_timer.push_back(timer);
      m_report.time.push_back(0.);
    }
 
    PPanic();
    VPanic();
 
#ifdef _myDebug
    G4cout << "TestActionTimer::Constructor done" << G4endl;
#endif
  }
 
  void TestActionTimer::BeginOfEventAction(const G4Event*)
  {
    m_report.nev++;
 
    if (m_eventTimer != 0) {
      delete m_eventTimer;
      m_eventTimer = 0;
    }
    m_eventTime = 0.;
    m_eventTimer = new G4Timer();
    m_eventTimer->Start();
 
    m_runTimer->Start();
  }
 
  void TestActionTimer::EndOfEventAction(const G4Event*)
  {
    m_report.runTime += TimerSum(m_runTimer);
    m_eventTime = TimerSum(m_eventTimer);
 
    VPanic();
    PPanic();
  }
 
  void TestActionTimer::BeginOfRunAction(const G4Run*)
  {
    m_report.runTime=0.;
    m_runTimer->Start();
  }
 
  void TestActionTimer::EndOfRunAction(const G4Run*)
  {
    std::cerr<<"TestActionTimer::EndOfRunAction "<< m_report.runTime <<std::endl;
    m_report.runTime += TimerSum(m_runTimer);
    VPanic();
    PPanic();
  }
 
  void TestActionTimer::UserSteppingAction(const G4Step* aStep)
  {
    // HERE IS WHERE WE BEGIN OUR CLOCKING
 
    // Get basic information about the event
    G4Track* track = aStep->GetTrack();
 
    G4String thePrePVname = track->GetVolume()->GetName();
    G4String thePostPVname;
    if (track->GetNextVolume() != 0) {
      thePostPVname = track->GetNextVolume()->GetName();
    } else {
      thePostPVname = "OutOfWorld";
    }
 
    // Check what volume we are in.  If the volume does not agree with the clock, kill the clock
    G4Timer* timer = 0;
    int preIndex = ClassifyVolume( thePrePVname );
    int postIndex=-1;
    if (thePrePVname != thePostPVname){
      timer = m_timer[preIndex];
      if (!timer->IsValid()){ m_report.time[preIndex] += TimerSum(timer); } else { VPanic(); }
 
      // Now start the appropriate clock
      postIndex = ClassifyVolume( thePostPVname );
      m_timer[postIndex]->Start();
 
      // Otherwise it's going into "out of world"
    } else {
      timer = m_timer[preIndex];
      if (timer->IsValid()) {
        VPanic(); timer->Start();
      }
    }
 
    // Now for the particle based timers
    if (track->GetDefinition() == G4Electron::ElectronDefinition() ){
      if ( m_timer[eElec]->IsValid() ){
        m_timer[eElec]->Start();
      }
    } else if (!m_timer[eElec]->IsValid()){
      m_report.time[eElec] += TimerSum(m_timer[eElec]);
    }
    if (track->GetDefinition() == G4Positron::PositronDefinition() ){
      if ( m_timer[ePos]->IsValid() ){
        m_timer[ePos]->Start();
      }
    } else if (!m_timer[ePos]->IsValid()){
      m_report.time[ePos] += TimerSum(m_timer[ePos]);
    }
    if (track->GetDefinition() == G4Gamma::GammaDefinition() &&
        m_timer[eGam]->IsValid()){
      m_timer[eGam]->Start();
    } else if ( !m_timer[eGam]->IsValid() ){
      m_report.time[eGam] += TimerSum(m_timer[eGam]);
    }
    if (track->GetDefinition() == G4Neutron::NeutronDefinition() &&
        m_timer[eNeut]->IsValid()){
      m_timer[eNeut]->Start();
    } else if ( !m_timer[eNeut]->IsValid() ){
      m_report.time[eNeut] += TimerSum(m_timer[eNeut]);
    }
  }
 
 
  double TestActionTimer::TimerSum(G4Timer* timer) const
  {
    if (timer == 0) return -999.;
    timer->Stop();
    return (timer->GetUserElapsed() + timer->GetSystemElapsed());
  }
 
  void TestActionTimer::PPanic()
  {
#ifdef _myDebug
    G4cout << "TestActionTimer::PPanic" << G4endl;
#endif
 
    // stop all particle counters and add time
    for (int i(eElec); i < eMax; ++i) {
      G4Timer* timer = m_timer[i];
#ifdef _myDebug
      G4cout << "TestActionTimer::PPanic stopping counter i:" << i << " " << timer << G4endl;
#endif
      if (!timer->IsValid()){
        m_report.time[i] += TimerSum(timer);
      }
    }
 
#ifdef _myDebug
    G4cout << "TestActionTimer::PPanic done" << G4endl;
#endif
  }
 
  void TestActionTimer::VPanic()
  {
#ifdef _myDebug
    G4cout << "TestActionTimer::VPanic" << G4endl;
#endif
 
    // stop all volume counters and add time
    for (int i(0); i <= eOther; ++i) {
      G4Timer* timer = m_timer[i];
#ifdef _myDebug
      G4cout << "TestActionTimer::VPanic stopping counter i:" << i  << " " << timer << G4endl;
#endif
      if (!timer->IsValid()){
        m_report.time[i] += TimerSum(timer);
      }
    }
 
#ifdef _myDebug
    G4cout << "TestActionTimer::VPanic done" << G4endl;
#endif
  }
 
  int TestActionTimer::ClassifyVolume( G4String& nomstr ) const
  {
    std::string_view nom(nomstr); //Avoid copying characters during comparison
    if( nom.length() >= 17 &&
        nom.substr(13,4) == "EMEC" ){
      return eEMEC;
    }
    else if ( nom.length() >= 16 &&
              nom.substr(13,3) == "EMB" ){
      return eEMB;
    }
    else if( nom.length() >= 25 &&
             nom.substr(21,4) == "Cryo" ) {
      return eCry;
    }
    else if( nom.length() >= 26 &&
             nom.substr(13,13) == "FCAL::Module1"){
      return eFC1;
    }
    else if( nom.length() >= 25 &&
             nom.substr(13,12) == "FCAL::Module" ){
      return eFC23;
    }
    else if ( nom.length() >= 17 &&
              nom.substr(13,4) == "FCAL" ){
      return eFCO;
    }
    else if ( nom.length() >= 16 &&
              nom.substr(13,3) == "HEC" ){
      return eHEC;
    }
    else if( nom.length() >= 31 &&
             nom.substr(21,10) == "Presampler" ) {
      return ePre;
    }
    else if ( nom.length() >= 3 &&
              nom.substr(0,3) == "LAr" ){
      return eLAr;
    }
    else if( ( (nom.length() >= 4 &&
                nom.substr(0,4) == "Muon") ||
               nom.substr(0,4) == "MUON" ) ||
             ( nom.length() >= 9 &&
               nom.substr(0,9) == "DriftTube" ) ||
             G4StrContains(nom, "MDT") ||
             ( nom.length() >= 12 &&
               nom.substr(0,12) == "SensitiveGas" ) ||
             G4StrContains(nom, "MDT") ||
             G4StrContains(nom, "station") ){
      return eMu;
    }
    else if ( nom.length() >= 8 &&
              nom.substr(0,8) == "ITkPixel" ){
      return eITkPix;
    }
    else if ( nom.length() >= 8 &&
              nom.substr(0,8) == "ITkStrip" ){
      return eITkStrip;
    }
    else if ((nom.length() >= 5 &&
              nom.substr(0,5) == "Pixel") ||
             nom == "Outside Barrel Service"){
      return ePx;
    }
    else if ( nom.length() >= 3 &&
              nom.substr(0,3) == "SCT" ){
      return eSct;
    }
    else if ( ( nom.length() >= 3 &&
                nom.substr(0,3) == "TRT" ) ||
              nom == "GasMANeg" ){
      return eTrt;
    }
    else if ( nom.length() >= 4 &&
              nom.substr(0,4) == "HGTD"){
      return eHGTD;
    }
    else if ( nom.length() >= 4 &&
              nom.substr(0,4) == "Tile"){
      return eHCB;
    }
    else if ( ( nom.length() >= 12 &&
                nom.substr(0,12) == "InDetServMat" ) ||
              ( nom.length() >= 4 &&
                nom.substr(0,4) == "IDET" ) ||
              ( nom.length() >= 3 &&
                nom.substr(0,3) == "ITK" ) ||
              ( nom.length() >= 8 &&
                nom.substr(0,8) == "BeamPipe" ) ||
              ( nom.length() >= 7 &&
                nom.substr(0,7) == "Section" ) ||
              ( nom.length() >= 3 &&
                ( nom.substr(0,3) == "BLM" ||
                  nom.substr(0,3) == "BCM" ||
                  nom.substr(0,3) == "PLR" ) ) ||
              ( nom.length() >= 8 &&
                nom.substr(0,8) == "BCMPrime" ) ){
      return eSev;
    }
    return eOther;
  }
 
} // namespace G4UA