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/LArG4Identifier.h"
#include "CaloSimEvent/CaloCalibrationHit.h"
#include <gtest/gtest_prod.h>
 
#include <set>
#include <vector>
 
// Forward declarations
class G4Step;
 
class LArEM_ID;
class LArFCAL_ID;
class LArHEC_ID;
class CaloDM_ID;
class AtlasDetectorID;
 
class ILArCalibCalculatorSvc; 
 
class CaloCalibrationHitContainer;
class SrCaloCalibrationHitContainer;
 

class LArG4CalibSD : public G4VSensitiveDetector
{
FRIEND_TEST( LArG4CalibSDtest, ProcessHits );
FRIEND_TEST( LArG4CalibSDtest, EndOfAthenaEvent );
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, bool doPID=false);

  virtual ~LArG4CalibSD();

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

  void EndOfAthenaEvent( CaloCalibrationHitContainer* hitContainer, CaloCalibrationHitContainer* deadHitContainer=nullptr);
 
  void EndOfAthenaEvent( CaloCalibrationHitContainer* hitContainer, CaloCalibrationHitContainer* deadHitContainer, SrCaloCalibrationHitContainer* srHitContainer);
  
  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:
 
  // We need two types containers for hits:
 
  // The set defined below is used to tell us if we've already had a
  // hit in a cell.  We store these hits in a set, so we can quickly
  // search it.  Note the use of a custom definition of a "less"
  // function for the set, so we're not just comparing hit pointers.
 
  class LessHit {
  public:
    bool operator() ( CaloCalibrationHit* const& p, CaloCalibrationHit* const& q ) const
    {
      return p->Less(q);
    }
  };
 
  typedef std::set< CaloCalibrationHit*, LessHit >  m_calibrationHits_t;
  G4bool SimpleHit( const LArG4Identifier& a_ident, const std::vector<double>& energies, m_calibrationHits_t& calibrationHits );
 
  G4bool SrHit( const LArG4Identifier& a_ident, const LArG4Identifier& sr_id, const std::vector<double>& energies, m_calibrationHits_t& calibrationHitsSr );  
  ILArCalibCalculatorSvc * m_calculator;

  G4int m_numberInvalidHits;

  G4bool m_doPID;

  m_calibrationHits_t m_calibrationHits;

  m_calibrationHits_t m_deadCalibrationHits;
    
  m_calibrationHits_t m_calibrationHitsSr;

  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;
  };
 
#endif