G4UA::TestActionVPTimerTool Class Reference

Tool which manages the TestActionVPTimer action. More...

#include <TestActionVPTimerTool.h>

Inheritance diagram for G4UA::TestActionVPTimerTool:

Collaboration diagram for G4UA::TestActionVPTimerTool:

Public Member Functions
	TestActionVPTimerTool (const std::string &type, const std::string &name, const IInterface *parent)
	Standard constructor.
virtual StatusCode	finalize () override
	Triggers report merging from threads.
virtual StatusCode	fillUserAction (G4AtlasUserActions &actionLists) override final
	Fill the user action lists.
StatusCode	BeginOfAthenaEvent (HitCollectionMap &) override
	Calls BeginOfAthenaEvent.
StatusCode	EndOfAthenaEvent (HitCollectionMap &) override
	Calls EndOfAthenaEvent.

Protected Member Functions
virtual std::unique_ptr< TestActionVPTimer >	makeAndFillAction (G4AtlasUserActions &) override final
	Create action for this thread.

Protected Attributes
ThreadSpecificUserAction< TestActionVPTimer >	m_actions
	Thread-specific storage of the user action.

Private Member Functions
void	TimerPrint (std::pair< VolTree, TestActionVPTimer::volumeData >, const double tTotal, const int depth=0) const
void	TreeOut (const VolTree &, const double tAtlas, int depth=0)

Private Attributes
TestActionVPTimer::Config	m_config
	holds the runtime configuration
TestActionVPTimer::Report	m_report
	holds data to be reported at end of run

Detailed Description

Tool which manages the TestActionVPTimer action.

Create the TestActionVPTimer for each worker thread and merges timing results in finalization.

Author

Andrea Di Simone

Definition at line 23 of file TestActionVPTimerTool.h.

Constructor & Destructor Documentation

TestActionVPTimerTool()

G4UA::TestActionVPTimerTool::TestActionVPTimerTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Standard constructor.

Definition at line 40 of file TestActionVPTimerTool.cxx.

    : UserActionToolBase<TestActionVPTimer>(type, name, parent)
  {
    declareProperty("CaloDepth",m_config.dCALO);
    declareProperty("BeamPipeDepth",m_config.dBeam);
    declareProperty("InDetDepth",m_config.dIDET);
    declareProperty("MuonDepth",m_config.dMUON);
    declareProperty("DetailDepth",m_config.dDetail);
  }

Member Function Documentation

BeginOfAthenaEvent()

StatusCode G4UA::UserActionToolBase< TestActionVPTimer >::BeginOfAthenaEvent ( HitCollectionMap & )

inlineoverrideinherited

Calls BeginOfAthenaEvent.

Definition at line 59 of file UserActionToolBase.h.

{return StatusCode::SUCCESS;};

EndOfAthenaEvent()

StatusCode G4UA::UserActionToolBase< TestActionVPTimer >::EndOfAthenaEvent ( HitCollectionMap & )

inlineoverrideinherited

Calls EndOfAthenaEvent.

Definition at line 61 of file UserActionToolBase.h.

{return StatusCode::SUCCESS;};

fillUserAction()

virtual StatusCode G4UA::UserActionToolBase< TestActionVPTimer >::fillUserAction ( G4AtlasUserActions & actionLists )

inlinefinaloverridevirtualinherited

Fill the user action lists.

Definition at line 47 of file UserActionToolBase.h.

      {
        auto myAction = makeAndFillAction(actionLists);
        if(myAction == nullptr) {
          ATH_MSG_ERROR( "Failed to construct user action in " << name() );
          return StatusCode::FAILURE;
        }
        m_actions.set( std::move(myAction) );
        return StatusCode::SUCCESS;
      }

finalize()

StatusCode G4UA::TestActionVPTimerTool::finalize ( )

overridevirtual

Triggers report merging from threads.

Definition at line 65 of file TestActionVPTimerTool.cxx.

  {
    // We shouldn't need this. End-run actions should be called by Geant4.
    // I'll leave this here, commented out for now, for reference.
    //for(auto& tidAction : m_actions) {
    //  ((G4UserRunAction*)tidAction.second)->EndOfRunAction(0);
    //}
 
    // Accumulate results across threads
    m_actions.accumulate(m_report, &TestActionVPTimer::getReport,
                         &TestActionVPTimer::Report::merge);
 
    if(m_report.time_index.size()){
 
      VolTree topPV; // vector< pair<physvol*,int> >
      // time_index is map<VolTree, TestActionVPTimer::volumeData>
 
      topPV.push_back(m_report.time_index.begin()->first.front());
      auto it =  m_report.time_index.find(topPV);
      if (it == m_report.time_index.end()){
        ATH_MSG_WARNING("topPV not found.");
        return StatusCode::FAILURE;
      }
      TestActionVPTimer::volumeData atlasData =it->second;
      G4double DeadTime  = m_report.runTime - atlasData.tTotal;
 
      ATH_MSG_INFO("Runtime " << m_report.runTime
                   <<  " Dead Time " << DeadTime );
 
      if (m_report.nev != 0){
        ATH_MSG_INFO("******* Beginning timer dump *******" );
 
        ATH_MSG_INFO(setw(12) << "Time" << setw(12) << "per Event" << setw(12)
                     << "per Run" << setw(6) << "Depth" << "  Location/Particle" );
        ATH_MSG_INFO(vPrFmt(m_report.runTime, m_report.nev, atlasData.tTotal, -999, "  Event Average") );
        ATH_MSG_INFO(vPrFmt(DeadTime, m_report.nev, atlasData.tTotal, -999, "  Dead/Initialization") );
 
        ATH_MSG_INFO("\n******* Data by volume/select particles *******");
        ATH_MSG_INFO("Data printed in reverse tree order (mother following daughter)");
 
        TreeOut(topPV, atlasData.tTotal);
        //      for (VolIt c = v_time_index.begin(); c != v_time_index.end(); c++) {
        //          TimerPrint(*c, atlasData.tTotal, c->first.size());
        //      }
 
        ATH_MSG_INFO( "\n******* Data by particle/category *******");
 
        ATH_MSG_INFO(vPrFmt(atlasData.tElectron, m_report.nev, atlasData.tTotal, -999, "e+/-"   ) );
        ATH_MSG_INFO(vPrFmt(atlasData.tPhoton,   m_report.nev, atlasData.tTotal, -999, "gamma"  ) );
        ATH_MSG_INFO(vPrFmt(atlasData.tNeutron,  m_report.nev, atlasData.tTotal, -999, "neutron") );
        ATH_MSG_INFO(vPrFmt(atlasData.tPion,     m_report.nev, atlasData.tTotal, -999, "pi+/-/0") );
        ATH_MSG_INFO(vPrFmt(atlasData.tBaryon,   m_report.nev, atlasData.tTotal, -999, "baryon" ) );
        ATH_MSG_INFO(vPrFmt(atlasData.tLepton,   m_report.nev, atlasData.tTotal, -999, "lepton" ) );
        ATH_MSG_INFO(vPrFmt(atlasData.tMeson,    m_report.nev, atlasData.tTotal, -999, "meson"  ) );
        ATH_MSG_INFO(vPrFmt(atlasData.tOther,    m_report.nev, atlasData.tTotal, -999, "other"  ) );
 
      } else { ATH_MSG_WARNING("******* No events timed! *******"); }
    } else { ATH_MSG_WARNING("******* No Timing information recorded! *******"); }
 
    return StatusCode::SUCCESS;
  }

makeAndFillAction()

std::unique_ptr< TestActionVPTimer > G4UA::TestActionVPTimerTool::makeAndFillAction ( G4AtlasUserActions & actionList )

finaloverrideprotectedvirtual

Create action for this thread.

Implements G4UA::UserActionToolBase< TestActionVPTimer >.

Definition at line 54 of file TestActionVPTimerTool.cxx.

  {
    ATH_MSG_DEBUG("Constructing a TestActionVPTimer");
    auto action = std::make_unique<TestActionVPTimer>(m_config);
    actionList.runActions.push_back( action.get() );
    actionList.eventActions.push_back( action.get() );
    actionList.steppingActions.push_back( action.get() );
    return action;
  }

TimerPrint()

void G4UA::TestActionVPTimerTool::TimerPrint ( std::pair< VolTree, TestActionVPTimer::volumeData > vp, const double tTotal, const int depth = 0 ) const

inlineprivate

Definition at line 144 of file TestActionVPTimerTool.cxx.

  {
    G4VPhysicalVolume* pv = vp.first.back().first;
    std::string physical = stringify(pv->GetName());
    std::string copyNo = stringify(vp.first.back().second);
    std::string mother = "";
    if (vp.first.size() != 1) mother = stringify( (vp.first.end()-2)->first->GetName() );
    ATH_MSG_INFO(vPrFmt(vp.second.tTotal, m_report.nev, tTotal, depth-1, physical+"_"+copyNo+"  "+mother) );
    ATH_MSG_INFO(vPrFmt(vp.second.tElectron, m_report.nev, tTotal, depth-1, " - electrons & positrons") );
    ATH_MSG_INFO(vPrFmt(vp.second.tPhoton, m_report.nev, tTotal, depth-1, " - photons") );
    ATH_MSG_INFO(vPrFmt(vp.second.tNeutron, m_report.nev, tTotal, depth-1, " - neutrons") );
    ATH_MSG_INFO(vPrFmt(vp.second.tPion, m_report.nev, tTotal, depth-1, " - pions") );
 
    double tOther = vp.second.tTotal - vp.second.tElectron - vp.second.tPhoton - vp.second.tNeutron - vp.second.tPion;
    ATH_MSG_INFO(vPrFmt(tOther, m_report.nev, m_report.runTime, depth-1, " - other particles") );
  }

TreeOut()

void G4UA::TestActionVPTimerTool::TreeOut ( const VolTree & id, const double tAtlas, int depth = 0 )

private

Definition at line 128 of file TestActionVPTimerTool.cxx.

  {
    VolIt v = m_report.time_index.find(id);
    if (v != m_report.time_index.end()) {
      depth++;
      for (VolIt c = m_report.time_index.begin(); c != m_report.time_index.end(); ++c) {
        VolTree check = c->first;
        check.pop_back();
        if (id == check)  TreeOut(c->first, tAtlas, depth);
      }
      TimerPrint(*v, tAtlas, depth);
    }
  }

Member Data Documentation

m_actions

ThreadSpecificUserAction<TestActionVPTimer> G4UA::UserActionToolBase< TestActionVPTimer >::m_actions

protectedinherited

Thread-specific storage of the user action.

Definition at line 70 of file UserActionToolBase.h.

m_config

TestActionVPTimer::Config G4UA::TestActionVPTimerTool::m_config

private

holds the runtime configuration

Definition at line 42 of file TestActionVPTimerTool.h.

m_report

TestActionVPTimer::Report G4UA::TestActionVPTimerTool::m_report

private

holds data to be reported at end of run

Definition at line 44 of file TestActionVPTimerTool.h.

---

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

• TestActionVPTimerTool.h
• TestActionVPTimerTool.cxx