TestActionVPTimer.h

Go to the documentation of this file.

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

//                                                              //
//$Id:TestActionVPTimer.h,v 1.0 2008/07/08 13:46:47 zmarshal Exp $//
//                                                              //
//                      TestActionVPTimer                        //
//      Code for text output (into log file)                    //
//      of information about the time spent simulating          //
//      various pieces of the detector and particles.           //
//                                                              //
//      Written by                                              //
//         Zachary Marshall, Caltech, USA                       //
//         Wolfgang Ehrenfeld, University of Hamburg, Germany   //
//      Revised by                                              //
//         Kevin Sapp, Pitt, USA                                //
//                                                              //
//      @version $Revision: 660034 $                            //
//                                                              //
 
#ifndef G4PROFILINGTOOLS_TestActionVPTimer_H
#define G4PROFILINGTOOLS_TestActionVPTimer_H
 
#include "VolumeTreeNavigator.h"
 
#include "G4Timer.hh"
#include "G4VPhysicalVolume.hh"
 
#include <string>
#include <map>
#include <utility>
#include <vector>
#include <ostream>
#include <sstream>
 
#include "G4UserEventAction.hh"
#include "G4UserRunAction.hh"
#include "G4UserSteppingAction.hh"
 
// Forward declarations
class G4Run;
class G4Event;
class G4Step;
 
namespace G4UA
{
 
  class TestActionVPTimer:
  public G4UserEventAction, public G4UserRunAction, public G4UserSteppingAction
  {
 
  public:
 
    struct Config
    {
      int dCALO=2;
      int dBeam=2;
      int dIDET=2;
      int dMUON=2;      
      std::string dDetail="";   
    };
 
    TestActionVPTimer(const Config& config);
 
    TestActionVPTimer(const TestActionVPTimer&) = delete;
    TestActionVPTimer& operator=(const TestActionVPTimer&) = delete;
 
 
    struct volumeData {                 
    public:
      volumeData operator+= (const volumeData& acc){
        this->tTotal += acc.tTotal;
        this->tElectron += acc.tElectron;
        this->tPhoton += acc.tPhoton;
        this->tNeutron += acc.tNeutron;
        this->tPion += acc.tPion;
        this->tBaryon += acc.tBaryon;
        this->tLepton += acc.tLepton;
        this->tMeson += acc.tMeson;
        this->tOther += acc.tOther;
        return *this;
      };        
 
      double tTotal=0;                  
      double tElectron=0;                       
      double tPhoton=0;                 
      double tNeutron=0;                        
      double tPion=0;                           
      double tBaryon=0;                 
      double tLepton=0;                 
      double tMeson=0;                  
      double tOther=0;                  
 
    };
 
    typedef std::map<VolTree, TestActionVPTimer::volumeData> VolMap;
    typedef VolMap::const_iterator VolIt;
 
    struct Report
    {
      // time_index is map<VolTree, TestActionVPTimer::volumeData>
      // VolTree is  vector< pair<physvol*,int> >
 
      VolMap time_index;
      int nev=0;        
      double runTime=0; 
 
      void merge(const Report& rep){
 
        nev+=rep.nev;
        runTime+=rep.runTime;
 
        // copy first map
        if(time_index.empty()){
          time_index=rep.time_index;
          return;
        }
 
        // must merge timers per particle and per tree
        // loop on new report
        for(auto& element:rep.time_index){
 
          // check if key exists
          auto existing=time_index.find(element.first);
          if(existing!=time_index.end()){
            // sum timings (using volData)
            existing->second+=element.second;
          }
          else {
            // add new entry
            time_index.insert(element);
          }
        }
 
      }
    };
 
    const Report& getReport() const
    { return m_report; }
 
    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:
    Config m_config;
    Report m_report;
 
    G4Timer* m_runTimer;                        
    G4Timer* m_eventTimer;              
    G4Timer* v_timer;                   
    double m_eventTime; 
 
    VolTree v_history;  
 
    double TimerSum(G4Timer* timer) const;              
 
  }; // class TestActionVPTimer

  inline double TestActionVPTimer::TimerSum(G4Timer* timer) const
  {
    if (timer == 0) return -999.;
    timer->Stop();
    return (timer->GetUserElapsed() + timer->GetSystemElapsed());
  }
 
} // namespace G4UA
 
#endif // #define G4PROFILINGTOOLS_TestActionVPTimer_H