ExampleAction.cxx

Go to the documentation of this file.

#include "nutools/G4Base/ExampleAction.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

// self-register with the factory
#include "nutools/G4Base/UserActionFactory.h"
USERACTIONREG3(altns,ExampleAction,altns::ExampleAction)

// G4 includes
#include "Geant4/G4Event.hh"
#include "Geant4/G4Track.hh"
#include "Geant4/G4ThreeVector.hh"
#include "Geant4/G4ParticleDefinition.hh"
#include "Geant4/G4PrimaryParticle.hh"
#include "Geant4/G4DynamicParticle.hh"
#include "Geant4/G4VUserPrimaryParticleInformation.hh"
#include "Geant4/G4Step.hh"
#include "Geant4/G4StepPoint.hh"
#include "Geant4/G4VProcess.hh"
#include "Geant4/G4VPhysicalVolume.hh"
#include "Geant4/G4VTouchable.hh"

// ROOT includes
#include <TLorentzVector.h>
#include <TString.h>

// C/C++ includes
#include <algorithm>
#include <string>

namespace altns {

  // Initialize static members.

  //-------------------------------------------------------------
  // Constructor.
  ExampleAction::ExampleAction()
    : fSomeValue(0)
    , fVerbose(0)
    , fStepMsgMaxPerEvt(42)
    , fTrack2ndMsgMaxPerEvt(2)
  {
  }

  //-------------------------------------------------------------
  // Destructor.
  ExampleAction::~ExampleAction()
  {
  }

  //-------------------------------------------------------------
  void ExampleAction::Config(fhicl::ParameterSet const& pset)
  {

    fSomeValue            = pset.get< double >("SomeValue",0)*CLHEP::GeV;
    fVerbose              = pset.get< int    >("Verbose",0);
    fStepMsgMaxPerEvt     = pset.get< int    >("StepMsgMaxPerEvt",42);
    fTrack2ndMsgMaxPerEvt = pset.get< int    >("Track2ndMsgMaxPerEvt",2);

  }

  //-------------------------------------------------------------
  void ExampleAction::PrintConfig(std::string const& /* opt */)
  {
    mf::LogInfo("ExampleAction")
      << "ExampleAction::PrintConfig \n"
      << "    SomeValue            " << fSomeValue            << "\n"
      << "    Verbose              " << fVerbose              << "\n"
      << "    StepMsgMaxPerEvt     " << fStepMsgMaxPerEvt     << "\n"
      << "    Track2ndMsgMaxPerEvt " << fTrack2ndMsgMaxPerEvt << "\n";

  }

  //-------------------------------------------------------------
  void ExampleAction::BeginOfEventAction(const G4Event* event)
  {

    mf::LogInfo("ExampleAction")
      << "ExampleAction::BeginOfEventAction EventID="
      << event->GetEventID();

    fStepMsg = 0;
    fTrack2ndMsg = 0;

  }

  //-------------------------------------------------------------
  void ExampleAction::EndOfEventAction(const G4Event* event)
  {

    mf::LogInfo("ExampleAction")
      << "ExampleAction::EndOfEventAction EventID="
      << event->GetEventID();
  }

  //-------------------------------------------------------------
  void ExampleAction::PreTrackingAction(const G4Track* track)
  {

    G4int parent_id = track->GetParentID();
    if ( parent_id > 0 && fTrack2ndMsg > fTrack2ndMsgMaxPerEvt ) return;

    mf::LogInfo("ExampleAction")
      << "ExampleAction::PreTrackingAction TrackID="
      << track->GetTrackID()
      << " is a " << track->GetParticleDefinition()->GetParticleName();
  }

  //-------------------------------------------------------------
  void ExampleAction::PostTrackingAction( const G4Track* track)
  {

    G4int parent_id = track->GetParentID();
    std::string extra_msg = "";
    if ( parent_id > 0 ) {
      ++fTrack2ndMsg;
      if ( fTrack2ndMsg  > fTrack2ndMsgMaxPerEvt ) return;
      if ( fTrack2ndMsg == fTrack2ndMsgMaxPerEvt ) {
        extra_msg = "...last such message this event";
      }
    }

    mf::LogInfo("ExampleAction")
      << "ExampleAction::PostTrackingAction TrackID="
      << track->GetTrackID()
      << " " << extra_msg;
  }

  //-------------------------------------------------------------
  void ExampleAction::SteppingAction(const G4Step* step)
  {

    ++fStepMsg;
    if ( ++fStepMsg > fStepMsgMaxPerEvt ) return;

    std::string extra_msg = "";
    if ( fStepMsg == fStepMsgMaxPerEvt ) {
      extra_msg = "...last such message this event";
    }

    mf::LogInfo("ExampleAction")
      << "ExampleAction::SteppingAction TrackID="
      << step->GetTrack()->GetTrackID()
      << " " << extra_msg;


  }

  //-------------------------------------------------------------
  G4ClassificationOfNewTrack
  ExampleAction::StackClassifyNewTrack(const G4Track* track)
  {

    G4int parent_id = track->GetParentID();
    std::string tsrc = "primary";
    if ( parent_id < 0 ) tsrc = "postponed (from previous event)";
    if ( parent_id > 0 ) tsrc = "secondary";

    mf::LogInfo("ExampleAction")
      << "ExampleAction::StackClassifyNewTrack TrackID="
      << track->GetTrackID()
      << " ParentID=" << parent_id << " "
      << track->GetDefinition()->GetParticleName()
      << " (" << tsrc << " particle)";

    // One *must* return a classification
    // Since we're not doing anything useful in NewStage/PrepareNewEvent
    // the only things we should return are fUrgent or fKill
    return fUrgent;
  }

  //-------------------------------------------------------------
  void ExampleAction::StackNewStage()
  {

    mf::LogInfo("ExampleAction")
      << "ExampleAction::StackNewStage";
  }

  //-------------------------------------------------------------
  void ExampleAction::StackPrepareNewEvent()
  {

    mf::LogInfo("ExampleAction")
      << "ExampleAction::StackPrepareNewEvent";
  }

} // end namespace