LArG4CalibSD.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARG4CALIBSD_H
#define LARG4CALIBSD_H
 
#include "G4VSensitiveDetector.hh"
 
#include "LArG4Code/LArCalibrationHitContainerBuilder.h"
#include "LArG4Code/LArG4Identifier.h"
#include "CaloSimEvent/CaloCalibrationHit.h"
#include <gtest/gtest_prod.h>
 
#include <vector>
 
// Forward declarations
class G4Step;
class G4HCofThisEvent;
 
class LArEM_ID;
class LArFCAL_ID;
class LArHEC_ID;
class CaloDM_ID;
class AtlasDetectorID;
 
class ILArCalibCalculatorSvc; 

class LArG4CalibSD : public G4VSensitiveDetector
{
FRIEND_TEST( LArG4CalibSDtest, ProcessHits );
FRIEND_TEST( LArG4CalibSDtest, setupHelpers );
FRIEND_TEST( LArG4CalibSDtest, addDetectorHelper );
FRIEND_TEST( LArG4CalibSDtest, SpecialHit );
FRIEND_TEST( LArG4CalibSDtest, SimpleHit );
FRIEND_TEST( LArG4CalibSDtest, ConvertID );
public:

  LArG4CalibSD(G4String a_name, ILArCalibCalculatorSvc* calc,
               std::string hitCollectionName,
               std::string deadHitCollectionName,
               std::string srHitCollectionName,
               bool doPID=false);

  virtual ~LArG4CalibSD();

  void Initialize(G4HCofThisEvent*) override;

  G4bool ProcessHits(G4Step* a_step,G4TouchableHistory*) override;

  void setupHelpers( const LArEM_ID* EM ,
                     const LArFCAL_ID* FCAL ,
                     const LArHEC_ID* HEC ,
                     const CaloDM_ID* caloDm ) {
    m_larEmID = EM;
    m_larFcalID = FCAL;
    m_larHecID = HEC;
    m_caloDmID = caloDm;
  }
 
  void addDetectorHelper( const AtlasDetectorID* id_helper) { m_id_helper=id_helper; }

  G4bool SpecialHit(G4Step* a_step, const std::vector<G4double>& a_energies);
 
protected:
  G4bool SimpleHit(const LArG4Identifier& a_ident,
                   const std::vector<double>& energies,
                   bool deadMaterialHit = false);
 
  G4bool SrHit(const LArG4Identifier& a_ident, const LArG4Identifier& sr_id,
               const std::vector<double>& energies);
  ILArCalibCalculatorSvc * m_calculator;

  G4int m_numberInvalidHits;

  G4bool m_doPID;

  Identifier ConvertID(const LArG4Identifier& a_ident) const;
 
  Identifier ConvertSRID(const LArG4Identifier& sr_id, const LArG4Identifier& lr_id) const;
  const LArEM_ID*       m_larEmID;
  const LArFCAL_ID*     m_larFcalID;
  const LArHEC_ID*      m_larHecID;
  const CaloDM_ID*      m_caloDmID;
  const AtlasDetectorID* m_id_helper;
 
  LArCalibrationHitContainerBuilder* getCalibrationHits(bool deadMaterialHit) const;
  LArSrCalibrationHitContainerBuilder* getSrCalibrationHits() const;
 
private:
  std::string m_hitCollectionName;
  std::string m_deadHitCollectionName;
  std::string m_srHitCollectionName;
  std::string m_hitSourceName;
};
 
#endif