LArSCL1Maker.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARL1SIM_LARSCL1MAKER_H
#define LARL1SIM_LARSCL1MAKER_H
// +======================================================================+
// +                                                                      +
// + Author ........: Denis O. Damazio                                    +
// + Institut ......: BNL                                                 +
// + Creation date .: 18/11/2013                                          +
// +                                                                      +
// +======================================================================+
//
// ....... include
//
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "AthenaKernel/IAthRNGSvc.h"
#include "Gaudi/Property.h"
#include "GaudiKernel/ServiceHandle.h"
//
#include "CaloDetDescr/ICaloSuperCellIDTool.h"
#include "LArCabling/LArOnOffIdMapping.h"
#include "LArDigitization/LArHitEMap.h"
#include "LArRawConditions/LArADC2MeV.h"
#include "LArRawConditions/LArAutoCorrNoise.h"
#include "LArRawEvent/LArDigitContainer.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
//
#include "LArElecCalib/ILArNoise.h"
#include "LArElecCalib/ILArPedestal.h"
#include "LArElecCalib/ILArShape.h"
#include "LArElecCalib/ILArfSampl.h"
 
class ITriggerTime;
class CaloCell_SuperCell_ID;
class CaloCell_ID;
class LArOnline_SuperCellID;

 
class LArSCL1Maker : public AthReentrantAlgorithm {
  //
  // >>>>>>>> public methods
  //
 public:
  LArSCL1Maker(const std::string& name, ISvcLocator* pSvcLocator);

  ~LArSCL1Maker();
  //
  // ..... Gaudi algorithm hooks
  //
  StatusCode initialize();
  StatusCode execute(const EventContext& context) const;
 
  StatusCode finalize();
 
 private:
  SG::ReadCondHandleKey<LArOnOffIdMapping> m_cablingKeySC{
      this, "ScCablingKey", "LArOnOffIdMapSC",
      "SG Key of SC LArOnOffIdMapping object"};

  SG::ReadCondHandleKey<ILArShape> m_shapesKey{
      this, "ShapeKey", "LArShapeSC", "SG Key of Shape conditions object"};

  SG::ReadCondHandleKey<ILArfSampl> m_fracSKey{
      this, "FracSKey", "LArfSamplSC", "SG Key of fSamplS conditions object"};

  SG::ReadCondHandleKey<ILArPedestal> m_pedestalSCKey{
      this, "PedestalKey", "LArPedestalSC", "SGKey of LArPedestal object"};

  SG::ReadCondHandleKey<ILArNoise> m_noiseSCKey{
      this, "LArNoiseKey", "LArNoiseSC", "SGKey of LArNoise object"};

  SG::ReadCondHandleKey<LArAutoCorrNoise> m_autoCorrNoiseSCKey{
      this, "LArAutoCorrKey", "LArAutoCorrNoiseSC",
      "SGKey of LArAutoCorrNoise object"};

  SG::ReadCondHandleKey<LArADC2MeV> m_adc2mevSCKey{
      this, "LArADC2MeVKey", "LArADC2MeVSC", "SGKey of LArADC2MeV object"};
 
  template <class T>
  const T* retrieve(const EventContext& context,
                    const SG::ReadCondHandleKey<T>& handleKey) const {
    SG::ReadCondHandle<T> handle(handleKey, context);
    if (not handle.isValid()) {
      ATH_MSG_ERROR("could not retrieve : " << handle.key());
      return nullptr;
    } else
      return handle.cptr();
  }
 
  //
  // >>>>>>>> private algorithm parts
  //
 
  std::vector<float> computeSignal(const Identifier towerId, const int Ieta,
                                   const int specialCase,
                                   std::vector<float> visEnergy,
                                   const int refTime) const;
 
  std::vector<float> computeNoise(const Identifier towerId, const int Ieta,
                                  std::vector<float>& inputV);

  void printConditions(const HWIdentifier& hwSC);

  void ConvertHits2Samples(const EventContext& context,
                           const HWIdentifier& hwSC, CaloGain::CaloGain igain,
                           const std::vector<std::pair<float, float> >& TimeE,
                           std::vector<float>& samples) const;
 
  //
  // >>>>>>>> private data parts
  //
 
  IChronoStatSvc* m_chronSvc;
  Gaudi::Property<std::string> m_randomStreamName{this, "RandomStreamName",
                                                  "LArSCL1Maker", ""};
  ServiceHandle<IAthRNGSvc> m_atRndmGenSvc{this, "RndmSvc", "AthRNGSvc", ""};
  Gaudi::Property<uint32_t> m_randomSeedOffset{this, "RandomSeedOffset", 2, ""};
  Gaudi::Property<bool> m_useLegacyRandomSeeds{
      this, "UseLegacyRandomSeeds", false,
      "Use MC16-style random number seeding"};

  bool m_useTriggerTime;
  // ToolHandle<ITriggerTime> p_triggerTimeTool;
 
  int m_BeginRunPriority;
 
  ToolHandle<ICaloSuperCellIDTool> m_scidtool;
  const CaloCell_SuperCell_ID* m_scHelper;
  const CaloCell_ID* m_OflHelper = nullptr;
  const LArOnline_SuperCellID* m_OnlSCHelper;
 
  ServiceHandle<IIncidentSvc> m_incSvc;

  static const short s_NBDEPTHS = 4;
  static const short s_NBSAMPLES = 7;
  static const short s_MAXSAMPLES = 24;
  static const short s_PEAKPOS = 3;
  static const short s_NBETABINS = 15;
  static const short s_NBENERGIES = 12;

  std::vector<std::vector<float> > m_autoCorrHec;

  SG::ReadHandleKey<LArHitEMap> m_hitMapKey{this, "LArHitEMapKey",
                                            "LArHitEMap"};

  SG::ReadHandleKey<LArDigitContainer> m_bkgDigitsKey{this, "BkgDigitKey", ""};
  SG::WriteHandleKey<LArDigitContainer> m_sLArDigitsContainerKey{
      this, "SCL1ContainerName", "LArDigitSCL1", "Output LArDigit container"};

  std::vector<std::string> m_HitContainer;

  std::string m_SubDetectors;
 
#ifdef DONTDO
  std::string m_EmBarrelHitContainerName;
  std::string m_EmEndCapHitContainerName;
  std::string m_HecHitContainerName;
  std::string m_ForWardHitContainerName;
#endif

  bool m_NoiseOnOff;
  bool m_PileUp;
  bool m_noEmCalibMode;
  bool m_noHadCalibMode;
  bool m_chronoTest;

  unsigned int m_nSamples;
  unsigned int m_firstSample;
 
  std::string m_saveHitsContainer;
};
 
#endif