LArG4FastSimSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
#ifndef LARG4FASTSIMSVC_LARG4FASTSIMSVC_H
#define LARG4FASTSIMSVC_LARG4FASTSIMSVC_H
 
// local includes
#include "LArG4FastSimSvc/ILArG4FastSimSvc.h"
#include "AthenaBaseComps/AthService.h"
 
// Minimal service includes
#include "GaudiKernel/StatusCode.h"
//#include "GaudiKernel/Service.h"
#include "Gaudi/Property.h"
 
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4Gamma.hh"
#include "G4Neutron.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
 
// STL includes
#include <string>
#include <map>
 
template <class TYPE> class SvcFactory;
 
#include "AtlasHepMC/IO_GenEvent_fwd.h"
 
 
class LArG4FastSimSvc : public AthService, virtual public ILArG4FastSimSvc {
 
 public:
 
  static const InterfaceID& interfaceID() { return IID_ILArG4FastSimSvc; }
 
  StatusCode queryInterface(const InterfaceID& riid, void** ppvIF);
 
  virtual StatusCode initialize();
  virtual StatusCode finalize();
 
  inline virtual bool   flagToShowerLib ( const G4ParticleDefinition& particleType )  const;          
  inline virtual double maxEneToShowerLib( const G4ParticleDefinition& particleType ) const;          
  inline virtual double minEneToShowerLib( const G4ParticleDefinition& particleType ) const;          
 
  inline virtual bool ContainLow()           const;           
  inline virtual bool ContainHigh()          const;           
  inline virtual bool ContainCrack()         const;           
 
  inline virtual bool              generateFSStartingPoints() const;
  virtual bool                     generateFSStartingPoint( const HepMC::GenEvent * ge);
  inline virtual float             generateFSStartingPointsRatio() const;
 
  inline virtual int DetectorTag() const;
 
  friend class SvcFactory<LArG4FastSimSvc>;
 
  LArG4FastSimSvc(const std::string& name, ISvcLocator* sl);
 
  virtual ~LArG4FastSimSvc();
 
 private:
 
  void   print() const;                    
 
  // data members
  bool   m_e_FlagShowerLib;              
  double m_e_MinEneShowerLib;                
  double m_e_MaxEneShowerLib;                
 
  bool   m_g_FlagShowerLib;              
  double m_g_MaxEneShowerLib;                
  double m_g_MinEneShowerLib;                
 
  bool   m_Neut_FlagShowerLib;                         
  double m_Neut_MinEneShowerLib;                       
  double m_Neut_MaxEneShowerLib;                       
 
  bool   m_Pion_FlagShowerLib;                         
  double m_Pion_MinEneShowerLib;                       
  double m_Pion_MaxEneShowerLib;                       
 
  bool   m_containLow;                               
  bool   m_containHigh;                              
  bool   m_containCrack;                             
 
  StringProperty   m_generated_starting_points_file;                 
  float            m_generated_starting_points_ratio;                
  bool             m_generate_starting_points;
  HepMC::IO_GenEvent * m_starting_points_file;
  int             m_detector_tag;                                   
  std::string     m_detector_tag_str;
  std::map<std::string,int> m_detmap;
 
 
};
 
// Get methods
inline bool   LArG4FastSimSvc::flagToShowerLib( const G4ParticleDefinition& particleType )   const
{
  if ( &particleType == G4Electron::ElectronDefinition() ||
       &particleType == G4Positron::PositronDefinition() ) {
         return m_e_FlagShowerLib;
  } else if ( &particleType == G4Gamma::GammaDefinition() ) {
         return m_g_FlagShowerLib;
  } else if ( &particleType == G4Neutron::NeutronDefinition() ) {
         return m_Neut_FlagShowerLib;
  } else if ( &particleType == G4PionPlus::PionPlusDefinition() ||
              &particleType == G4PionMinus::PionMinusDefinition() ) {
         return m_Pion_FlagShowerLib;
  } else return false;
}
inline double LArG4FastSimSvc::minEneToShowerLib( const G4ParticleDefinition& particleType ) const
{
  if ( &particleType == G4Electron::ElectronDefinition() ||
       &particleType == G4Positron::PositronDefinition() ) {
         return m_e_MinEneShowerLib;
  } else if ( &particleType == G4Gamma::GammaDefinition() ) {
         return m_g_MinEneShowerLib;
  } else if ( &particleType == G4Neutron::NeutronDefinition() ) {
         return m_Neut_MinEneShowerLib;
  } else if ( &particleType == G4PionPlus::PionPlusDefinition() ||
              &particleType == G4PionMinus::PionMinusDefinition() ) {
         return m_Pion_MinEneShowerLib;
  } else return 0.0;
}
 
inline double LArG4FastSimSvc::maxEneToShowerLib( const G4ParticleDefinition& particleType ) const
{
  if ( &particleType == G4Electron::ElectronDefinition() ||
       &particleType == G4Positron::PositronDefinition() ) {
         return m_e_MaxEneShowerLib;
  } else if ( &particleType == G4Gamma::GammaDefinition() ) {
         return m_g_MaxEneShowerLib;
  } else if ( &particleType == G4Neutron::NeutronDefinition() ) {
         return m_Neut_MaxEneShowerLib;
  } else if ( &particleType == G4PionPlus::PionPlusDefinition() ||
              &particleType == G4PionMinus::PionMinusDefinition() ) {
         return m_Pion_MaxEneShowerLib;
  } else return 0.0;
}
 
inline bool   LArG4FastSimSvc::ContainLow()         const { return m_containLow; }   
inline bool   LArG4FastSimSvc::ContainHigh()        const { return m_containHigh; }  
inline bool   LArG4FastSimSvc::ContainCrack()       const { return m_containCrack; } 
 
inline bool              LArG4FastSimSvc::generateFSStartingPoints() const { return m_generate_starting_points; }
inline float             LArG4FastSimSvc::generateFSStartingPointsRatio() const { return m_generated_starting_points_ratio; }
inline int LArG4FastSimSvc::DetectorTag() const { return m_detector_tag; }
#endif // LARG4FASTSIMSVC_LARG4FASTSIMSVC_H