Geant4SensDetFilters.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
//
//==========================================================================
 
#include <DDG4/Geant4SensDetAction.h>
#include <DDG4/Geant4FastSimSpot.h>
 
 
class G4ParticleDefinition;
 
namespace dd4hep {
 
  namespace sim {
 
 
    struct ParticleFilter : public Geant4Filter  {
    protected:
      std::string m_particle;
      mutable G4ParticleDefinition* m_definition;
    public:
      ParticleFilter(Geant4Context* context, const std::string& name);
      virtual ~ParticleFilter();
      const G4ParticleDefinition* definition() const;
      bool isSameType(const G4Track* track)  const;
      bool isGeantino(const G4Track* track) const;
      const G4Track* getTrack(const G4Step* step)   const   {
        return step->GetTrack();
      }
      const G4Track* getTrack(const Geant4FastSimSpot* spot)   const   {
        return spot->primary;
      }
      const G4Track* getTrack(const G4FastTrack* fast)   const   {
        return fast->GetPrimaryTrack();
      }
    };
 
 
    struct ParticleRejectFilter : public ParticleFilter  {
      ParticleRejectFilter(Geant4Context* c, const std::string& n);
      virtual ~ParticleRejectFilter();
      virtual bool operator()(const G4Step* step) const  override  final   {
        return !isSameType(getTrack(step));
      }
      virtual bool operator()(const Geant4FastSimSpot* spot) const  override  final   {
        return !isSameType(getTrack(spot));
      }
    };
 
 
    struct ParticleSelectFilter : public ParticleFilter  {
      ParticleSelectFilter(Geant4Context* c, const std::string& n);
      virtual ~ParticleSelectFilter();
      virtual bool operator()(const G4Step* step) const  override  final   {
        return isSameType(getTrack(step));
      }
      virtual bool operator()(const Geant4FastSimSpot* spot) const  override  final   {
        return isSameType(getTrack(spot));
      }
    };
 
 
    struct GeantinoRejectFilter : public ParticleFilter  {
      GeantinoRejectFilter(Geant4Context* c, const std::string& n);
      virtual ~GeantinoRejectFilter();
      virtual bool operator()(const G4Step* step) const  override  final   {
        return !isGeantino(getTrack(step));
      }
      virtual bool operator()(const Geant4FastSimSpot* spot) const  override  final   {
        return !isGeantino(getTrack(spot));
      }
    };
 
 
    struct EnergyDepositMinimumCut : public Geant4Filter  {
      double m_energyCut;
    public:
      EnergyDepositMinimumCut(Geant4Context* c, const std::string& n);
      virtual ~EnergyDepositMinimumCut();
      virtual bool operator()(const G4Step* step) const  override  final  {
        return step->GetTotalEnergyDeposit() > m_energyCut;
      }
      virtual bool operator()(const Geant4FastSimSpot* spot) const  override  final  {
        return spot->energy() > m_energyCut;
      }
    };
  }
}
 
#include <DD4hep/InstanceCount.h>
#include <DDG4/Factories.h>
 
// Geant4 include files
#include <G4ParticleTable.hh>
#include <G4ChargedGeantino.hh>
#include <G4Geantino.hh>
#include <G4Track.hh>
#include <G4Step.hh>
 
using namespace dd4hep::sim;
 
//DECLARE_GEANT4ACTION()
DECLARE_GEANT4ACTION(GeantinoRejectFilter)
DECLARE_GEANT4ACTION(ParticleRejectFilter)
DECLARE_GEANT4ACTION(ParticleSelectFilter)
DECLARE_GEANT4ACTION(EnergyDepositMinimumCut)
 
ParticleFilter::ParticleFilter(Geant4Context* ctxt, const std::string& nam)
: Geant4Filter(ctxt,nam), m_definition(0)
{
  declareProperty("particle",m_particle);
  InstanceCount::increment(this);
}
 
ParticleFilter::~ParticleFilter()   {
  InstanceCount::decrement(this);
}
 
const G4ParticleDefinition* ParticleFilter::definition() const  {
  if ( m_definition ) return m_definition;
  m_definition = G4ParticleTable::GetParticleTable()->FindParticle(m_particle);
  if ( 0 == m_definition )  {
    throw std::runtime_error("Invalid particle name:'"+m_particle+"' [Not-in-particle-table]");
  }
  return m_definition;
}
 
bool ParticleFilter::isSameType(const G4Track* track)  const   {
  G4ParticleDefinition* def = track->GetDefinition();
  return definition() == def;
}
 
bool ParticleFilter::isGeantino(const G4Track* track) const   {
  if ( track ) {
    G4ParticleDefinition* def = track->GetDefinition();
    if ( def == G4ChargedGeantino::Definition() )
      return true;
    if ( def == G4Geantino::Definition() ) {
      return true;
    }
  }
  return false;
}
 
GeantinoRejectFilter::GeantinoRejectFilter(Geant4Context* c, const std::string& n)
  : ParticleFilter(c,n) {
  InstanceCount::increment(this);
}
 
GeantinoRejectFilter::~GeantinoRejectFilter() {
  InstanceCount::decrement(this);
}
 
ParticleRejectFilter::ParticleRejectFilter(Geant4Context* c, const std::string& n)
  : ParticleFilter(c,n) {
  InstanceCount::increment(this);
}
 
ParticleRejectFilter::~ParticleRejectFilter() {
  InstanceCount::decrement(this);
}
 
ParticleSelectFilter::ParticleSelectFilter(Geant4Context* c, const std::string& n)
  : ParticleFilter(c,n) {
  InstanceCount::increment(this);
}
 
ParticleSelectFilter::~ParticleSelectFilter() {
  InstanceCount::decrement(this);
}
 
EnergyDepositMinimumCut::EnergyDepositMinimumCut(Geant4Context* c, const std::string& n)
  : Geant4Filter(c,n) {
  InstanceCount::increment(this);
  declareProperty("Cut",m_energyCut=0.0);
}
 
EnergyDepositMinimumCut::~EnergyDepositMinimumCut() {
  InstanceCount::decrement(this);
}