Geant4ActionPhase.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// 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/InstanceCount.h>
#include <DDG4/Geant4ActionPhase.h>
 
using namespace dd4hep::sim;
 
Geant4PhaseAction::Geant4PhaseAction(Geant4Context* ctxt, const std::string& nam)
  : Geant4Action(ctxt,nam)
{
}
 
Geant4PhaseAction::~Geant4PhaseAction()   {
}
 
void Geant4PhaseAction::operator()() {
}
 
dd4hep::Callback Geant4PhaseAction::callback()    {
  return Callback(this).make(&Geant4PhaseAction::operator());
}
 
Geant4ActionPhase::Geant4ActionPhase(Geant4Context* ctxt, const std::string& nam, const std::type_info& arg_type0,
                                     const std::type_info& arg_type1, const std::type_info& arg_type2)
  : Geant4Action(ctxt, nam) {
  m_argTypes[0] = &arg_type0;
  m_argTypes[1] = &arg_type1;
  m_argTypes[2] = &arg_type2;
  InstanceCount::increment(this);
}
 
Geant4ActionPhase::~Geant4ActionPhase() {
  for (Members::iterator i = m_members.begin(); i != m_members.end(); ++i)
    (*i).first->release();
  m_members.clear();
  InstanceCount::decrement(this);
}
 
bool Geant4ActionPhase::add(Geant4Action* action, Callback callback) {
  action->addRef();
  m_members.emplace_back(action,callback);
  return true;
}
 
bool Geant4ActionPhase::remove(Geant4Action* action, Callback callback) {
  if (action && callback.func.first) {
    Members::iterator i = find(m_members.begin(), m_members.end(), std::make_pair(action,callback));
    if (i != m_members.end()) {
      (*i).first->release();
      m_members.erase(i);
      return true;
    }
    return false;
  }
  size_t len = m_members.size();
  for (Members::iterator i = m_members.begin(); i != m_members.end(); ++i) {
    if ( (*i).first == action && (*i).second.par == callback.par) {
      (*i).first->release();
      m_members.erase(i);
      i = m_members.begin();
    }
  }
  return (len > m_members.size());
}
 
void Geant4ActionPhase::execute(void* argument) {
  for (Members::iterator i = m_members.begin(); i != m_members.end(); ++i) {
    (*i).second.execute((const void**) &argument);
  }
}
 
class G4HCofThisEvent;
class G4TouchableHistory;
#include <DDG4/Geant4RunAction.h>
#include <DDG4/Geant4EventAction.h>
#include <DDG4/Geant4TrackingAction.h>
#include <DDG4/Geant4SteppingAction.h>
#include <DDG4/Geant4StackingAction.h>
#include <DDG4/Geant4GeneratorAction.h>
namespace dd4hep {
  namespace sim {
    void Geant4ActionPhase::call() {
      this->execute(0);
    }
    template <> void Geant4ActionPhase::call(G4StackManager* stackManager) {
      this->execute((const void**) &stackManager);
    }
    template <> void Geant4ActionPhase::call<const G4Run*>(const G4Run* run) {
      this->execute((const void**) &run);
    }
    template <> void Geant4ActionPhase::call<G4Event*>(G4Event* event) {
      this->execute((const void**) &event);
    }
    template <> void Geant4ActionPhase::call<const G4Event*>(const G4Event* event) {
      this->execute((const void**) &event);
    }
    template <> void Geant4ActionPhase::call<const G4Track*>(const G4Track* track) {
      this->execute((const void**) &track);
    }
    template <> void Geant4ActionPhase::call<const G4Step*>(const G4Step* step) {
      this->execute((const void**) &step);
    }
    template <> void Geant4ActionPhase::call<const G4Step*, G4SteppingManager*>(const G4Step* step, G4SteppingManager* mgr) {
      const void * args[] = { step, mgr };
      this->execute(args);
    }
    template <> void Geant4ActionPhase::call<G4HCofThisEvent*>(G4HCofThisEvent* hce) {
      this->execute((const void**) &hce);
    }
    template <> void Geant4ActionPhase::call<G4Step*, G4TouchableHistory*>(G4Step* step, G4TouchableHistory* history) {
      const void * args[] = { step, history };
      this->execute(args);
    }
  }
}