G4UA::TestActionTimer Class Reference

User action to measure time spent in subdetectors. More...

#include <TestActionTimer.h>

Inheritance diagram for G4UA::TestActionTimer:

Collaboration diagram for G4UA::TestActionTimer:

Classes
struct	Report
	this holds all the data from individual threads that needs to be merged at EoR More...

Public Types
enum	{   eEMB , eEMEC , eFC1 , eFC23 ,   eFCO , eHEC , eCry , eLAr ,   eHCB , ePre , eMu , ePx ,   eSct , eITkPix , eITkStrip , eSev ,   eTrt , eHGTD , eOther , eElec ,   ePos , eGam , eNeut , eMax }

Public Member Functions
	TestActionTimer ()
	constructor
	TestActionTimer (const TestActionTimer &)=delete
TestActionTimer &	operator= (const TestActionTimer &)=delete
const Report &	getReport () const
virtual void	BeginOfEventAction (const G4Event *) override
virtual void	EndOfEventAction (const G4Event *) override
virtual void	BeginOfRunAction (const G4Run *) override
virtual void	EndOfRunAction (const G4Run *) override
virtual void	UserSteppingAction (const G4Step *) override

Private Member Functions
double	TimerSum (G4Timer *timer) const
	Gets the appropriate time from the timer for adding to the sum.
void	PPanic ()
	Method to shut down all particle timers.
void	VPanic ()
	Method to shut down all volume timers.
int	ClassifyVolume (G4String &) const
	Method to sort out which volume we are in.

Private Attributes
Report	m_report {}
G4Timer *	m_runTimer {}
	Timer for the entire run.
G4Timer *	m_eventTimer {}
	Timer for this event.
double	m_eventTime {}
	Double for storing this event.
std::vector< G4Timer * >	m_timer {}
	Vector of timers for each of the enum.

Detailed Description

User action to measure time spent in subdetectors.

    @author Zachary Marshall, Caltech, USA
    @author Wolfgang Ehrenfeld, University of Hamburg, Germany 

Definition at line 52 of file TestActionTimer.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
eEMB
eEMEC
eFC1
eFC23
eFCO
eHEC
eCry
eLAr
eHCB
ePre
eMu
ePx
eSct
eITkPix
eITkStrip
eSev
eTrt
eHGTD
eOther
eElec
ePos
eGam
eNeut
eMax

Definition at line 97 of file TestActionTimer.h.

         { eEMB, eEMEC, eFC1, eFC23, eFCO, eHEC, eCry, eLAr, eHCB,
      ePre, eMu, ePx, eSct, eITkPix, eITkStrip, eSev, eTrt, eHGTD, eOther,
      eElec, ePos, eGam, eNeut, eMax };

Constructor & Destructor Documentation

TestActionTimer() [1/2]

G4UA::TestActionTimer::TestActionTimer

(

)

constructor

Definition at line 61 of file TestActionTimer.cxx.

  {
    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
  }

TestActionTimer() [2/2]

G4UA::TestActionTimer::TestActionTimer ( const TestActionTimer & )

delete

Member Function Documentation

BeginOfEventAction()

void G4UA::TestActionTimer::BeginOfEventAction ( const G4Event * )

overridevirtual

Definition at line 116 of file TestActionTimer.cxx.

  {
    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();
  }

BeginOfRunAction()

void G4UA::TestActionTimer::BeginOfRunAction ( const G4Run * )

overridevirtual

Definition at line 140 of file TestActionTimer.cxx.

  {
    m_report.runTime=0.;
    m_runTimer->Start();
  }

ClassifyVolume()

int G4UA::TestActionTimer::ClassifyVolume ( G4String & nomstr ) const

private

Method to sort out which volume we are in.

Definition at line 270 of file TestActionTimer.cxx.

  {
    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;
  }

EndOfEventAction()

void G4UA::TestActionTimer::EndOfEventAction ( const G4Event * )

overridevirtual

Definition at line 131 of file TestActionTimer.cxx.

  {
    m_report.runTime += TimerSum(m_runTimer);
    m_eventTime = TimerSum(m_eventTimer);
 
    VPanic();
    PPanic();
  }

EndOfRunAction()

void G4UA::TestActionTimer::EndOfRunAction ( const G4Run * )

overridevirtual

Definition at line 146 of file TestActionTimer.cxx.

  {
    std::cerr<<"TestActionTimer::EndOfRunAction "<< m_report.runTime <<std::endl;
    m_report.runTime += TimerSum(m_runTimer);
    VPanic();
    PPanic();
  }

getReport()

const Report & G4UA::TestActionTimer::getReport ( ) const

inline

Definition at line 85 of file TestActionTimer.h.

    { return m_report; }

operator=()

TestActionTimer & G4UA::TestActionTimer::operator= ( const TestActionTimer & )

delete

PPanic()

void G4UA::TestActionTimer::PPanic ( )

private

Method to shut down all particle timers.

Definition at line 226 of file TestActionTimer.cxx.

  {
#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
  }

TimerSum()

double G4UA::TestActionTimer::TimerSum ( G4Timer * timer ) const

private

Gets the appropriate time from the timer for adding to the sum.

Definition at line 219 of file TestActionTimer.cxx.

  {
    if (timer == 0) return -999.;
    timer->Stop();
    return (timer->GetUserElapsed() + timer->GetSystemElapsed());
  }

UserSteppingAction()

void G4UA::TestActionTimer::UserSteppingAction ( const G4Step * aStep )

overridevirtual

Definition at line 154 of file TestActionTimer.cxx.

  {
    // 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]);
    }
  }

VPanic()

void G4UA::TestActionTimer::VPanic ( )

private

Method to shut down all volume timers.

Definition at line 248 of file TestActionTimer.cxx.

  {
#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
  }

Member Data Documentation

m_eventTime

double G4UA::TestActionTimer::m_eventTime {}

private

Double for storing this event.

Definition at line 107 of file TestActionTimer.h.

{};           

m_eventTimer

G4Timer* G4UA::TestActionTimer::m_eventTimer {}

private

Timer for this event.

Definition at line 106 of file TestActionTimer.h.

{};                   

m_report

Report G4UA::TestActionTimer::m_report {}

private

Definition at line 103 of file TestActionTimer.h.

{};

m_runTimer

G4Timer* G4UA::TestActionTimer::m_runTimer {}

private

Timer for the entire run.

Definition at line 105 of file TestActionTimer.h.

{};                     

m_timer

std::vector<G4Timer*> G4UA::TestActionTimer::m_timer {}

private

Vector of timers for each of the enum.

Definition at line 109 of file TestActionTimer.h.

{};           

---

The documentation for this class was generated from the following files:

• TestActionTimer.h
• TestActionTimer.cxx