Geant4TestActions.cpp

Go to the documentation of this file.

// $Id: $
//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//=========================================================================

// Framework include files
#include "DD4hep/Printout.h"
#include "DD4hep/InstanceCount.h"
#include "DDG4/Geant4TestActions.h"
#include "G4Run.hh"
#include "G4Event.hh"
#include "G4Step.hh"
#include "G4Track.hh"

// C/C++ include files
#include <stdexcept>

using namespace std;
using namespace DD4hep::Simulation;
using namespace DD4hep::Simulation::Test;

namespace {
  struct TestHit {
    TestHit() {
    }
    virtual ~TestHit() {
    }
  };
}

#define PRINT print


Geant4TestBase::Geant4TestBase(Geant4Action* a, const std::string& typ)
  : m_type(typ) {
  a->declareProperty("Property_int", m_value1 = 0);
  a->declareProperty("Property_double", m_value2 = 0e0);
  a->declareProperty("Property_string", m_value3);
  InstanceCount::increment(this);
}
Geant4TestBase::~Geant4TestBase() {
  InstanceCount::decrement(this);
}

Geant4TestGeneratorAction::Geant4TestGeneratorAction(Geant4Context* c, const std::string& n)
  : Geant4GeneratorAction(c, n), Geant4TestBase(this, "Geant4TestGeneratorAction") {
  InstanceCount::increment(this);
}

Geant4TestGeneratorAction::~Geant4TestGeneratorAction() {
  InstanceCount::decrement(this);
}

void Geant4TestGeneratorAction::operator()(G4Event* evt)  {
  PRINT("%s> calling Geant4TestGeneratorAction(event_id=%d Context: run=%p evt=%p)",
        m_type.c_str(), evt->GetEventID(), context()->runPtr(), context()->eventPtr());
}

Geant4TestRunAction::Geant4TestRunAction(Geant4Context* c, const std::string& n)
  : Geant4RunAction(c, n), Geant4TestBase(this, "Geant4TestRunAction") {
  InstanceCount::increment(this);
}

Geant4TestRunAction::~Geant4TestRunAction() {
  InstanceCount::decrement(this);
}

void Geant4TestRunAction::begin(const G4Run* run) {
  PRINT("%s> calling begin(run_id=%d,num_event=%d Context:%p)", m_type.c_str(), run->GetRunID(),
        run->GetNumberOfEventToBeProcessed(), &context()->run());
}

void Geant4TestRunAction::end(const G4Run* run) {
  PRINT("%s> calling end(run_id=%d, num_event=%d Context:%p)",
        m_type.c_str(), run->GetRunID(), run->GetNumberOfEvent(), &context()->run());
}

void Geant4TestRunAction::beginEvent(const G4Event* evt) {
  PRINT("%s> calling beginEvent(event_id=%d Context: run=%p evt=%p)",
        m_type.c_str(), evt->GetEventID(), context()->runPtr(), context()->eventPtr());
}

void Geant4TestRunAction::endEvent(const G4Event* evt) {
  PRINT("%s> calling endEvent(event_id=%d Context: run=%p evt=%p)",
        m_type.c_str(), evt->GetEventID(), context()->runPtr(), context()->eventPtr());
}

Geant4TestEventAction::Geant4TestEventAction(Geant4Context* c, const std::string& n)
  : Geant4EventAction(c, n), Geant4TestBase(this, "Geant4TestEventAction") {
  InstanceCount::increment(this);
}

Geant4TestEventAction::~Geant4TestEventAction() {
  InstanceCount::decrement(this);
}
void Geant4TestEventAction::begin(const G4Event* evt) {
  PRINT("%s> calling begin(event_id=%d Context:  run=%p (%d) evt=%p (%d))",
        m_type.c_str(), evt->GetEventID(),
        &context()->run(), context()->run().run().GetRunID(),
        &context()->event(), context()->event().event().GetEventID());
}

void Geant4TestEventAction::end(const G4Event* evt) {
  PRINT("%s> calling end(event_id=%d Context:  run=%p (%d) evt=%p (%d))",
        m_type.c_str(), evt->GetEventID(), &context()->run(), &context()->event(),
        &context()->run(), context()->run().run().GetRunID(),
        &context()->event(), context()->event().event().GetEventID());
}

void Geant4TestEventAction::beginRun(const G4Run* run) {
  PRINT("%s> calling beginRun(run_id=%d,num_event=%d Context:%p)",
        m_type.c_str(), run->GetRunID(),
        run->GetNumberOfEventToBeProcessed(), context()->runPtr());
}

void Geant4TestEventAction::endRun(const G4Run* run) {
  PRINT("%s> calling endRun(run_id=%d, num_event=%d Context:%p)",
        m_type.c_str(), run->GetRunID(),
        run->GetNumberOfEvent(), context()->runPtr());
}

Geant4TestTrackAction::Geant4TestTrackAction(Geant4Context* c, const std::string& n)
  : Geant4TrackingAction(c, n), Geant4TestBase(this, "Geant4TestTrackAction") {
  InstanceCount::increment(this);
}

Geant4TestTrackAction::~Geant4TestTrackAction() {
  InstanceCount::decrement(this);
}
void Geant4TestTrackAction::begin(const G4Track* trk) {
  PRINT("%s> calling begin(track=%d, parent=%d, position=(%f,%f,%f) Context: run=%p evt=%p)",
        m_type.c_str(), trk->GetTrackID(),
        trk->GetParentID(), trk->GetPosition().x(), trk->GetPosition().y(), trk->GetPosition().z(),
        &context()->run(), &context()->event());
}

void Geant4TestTrackAction::end(const G4Track* trk) {
  PRINT("%s> calling end(track=%d, parent=%d, position=(%f,%f,%f) Context: run=%p evt=%p)",
        m_type.c_str(), trk->GetTrackID(),
        trk->GetParentID(), trk->GetPosition().x(), trk->GetPosition().y(), trk->GetPosition().z(),
        &context()->run(), &context()->event());
}

Geant4TestStepAction::Geant4TestStepAction(Geant4Context* c, const std::string& n)
  : Geant4SteppingAction(c, n), Geant4TestBase(this, "Geant4TestStepAction") {
  InstanceCount::increment(this);
}

Geant4TestStepAction::~Geant4TestStepAction() {
  InstanceCount::decrement(this);
}
void Geant4TestStepAction::operator()(const G4Step*, G4SteppingManager*) {
  PRINT("%s> calling operator()", m_type.c_str());
}

Geant4TestSensitive::Geant4TestSensitive(Geant4Context* c, const std::string& n, DetElement det, LCDD& lcdd)
  : Geant4Sensitive(c, n, det, lcdd), Geant4TestBase(this, "Geant4TestSensitive") {
  InstanceCount::increment(this);
  m_collectionID = defineCollection < TestHit > (n);
  PRINT("%s> Collection ID is %d", m_type.c_str(), int(m_collectionID));
}

Geant4TestSensitive::~Geant4TestSensitive() {
  InstanceCount::decrement(this);
}

void Geant4TestSensitive::begin(G4HCofThisEvent* hce) {
  Geant4HitCollection* c = collectionByID(m_collectionID);
  PRINT("%s> calling begin(num_coll=%d, coll=%s Context: run=%p evt=%p)",
        m_type.c_str(), hce->GetNumberOfCollections(),
        c ? c->GetName().c_str() : "None", &context()->run(), &context()->event());
}

void Geant4TestSensitive::end(G4HCofThisEvent* hce) {
  Geant4HitCollection* c = collection(m_collectionID);
  PRINT("%s> calling end(num_coll=%d, coll=%s Context: run=%p evt=%p)",
        m_type.c_str(), hce->GetNumberOfCollections(),
        c ? c->GetName().c_str() : "None", &context()->run(), &context()->event());
}

bool Geant4TestSensitive::process(G4Step* step, G4TouchableHistory*) {
  Geant4HitCollection* c = collection(m_collectionID);
  PRINT("%s> calling process(track=%d, dE=%f, dT=%f len=%f, First,last in Vol=(%c,%c), coll=%s Context: run=%p evt=%p)",
        m_type.c_str(), step->GetTrack()->GetTrackID(),
        step->GetTotalEnergyDeposit(), step->GetDeltaTime(),
        step->GetStepLength(), step->IsFirstStepInVolume() ? 'Y' : 'N',
        step->IsLastStepInVolume() ? 'Y' : 'N',
        c ? c->GetName().c_str() : "None", &context()->run(), &context()->event());
  return true;
}