LArTTL1Maker.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARL1SIM_LARTTL1MAKER_H
#define LARL1SIM_LARTTL1MAKER_H
// +======================================================================+
// +                                                                      +
// + Author ........: F. Ledroit                                          +
// + Institut ......: ISN Grenoble                                        +
// + Creation date .: 09/01/2003                                          +
// +                                                                      +
// +======================================================================+
//
// ....... include
//
 
#include "AthenaBaseComps/AthAlgorithm.h"
#include "Gaudi/Property.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "LArDigitization/LArHitEMap.h"
#include "LArElecCalib/ILArfSampl.h"
 
#include "AthenaKernel/IAthRNGSvc.h"
 
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
 
#include "LArSimEvent/LArHitContainer.h"
#include "LArRawEvent/LArTTL1Container.h"
 
#include "CaloTriggerTool/CaloTriggerTowerService.h"
 
// trigger time
#include "AthenaKernel/ITriggerTime.h"
 
#include <vector>
#include <array>
 
class CaloLVL1_ID;
class LArEM_ID;
class LArHEC_ID;
class LArFCAL_ID;
namespace CLHEP
{
  class HepRandomEngine;
}

 
class LArTTL1Maker : public AthAlgorithm,
                     public IIncidentListener
{
  //
  // >>>>>>>> public methods
  //
public:
  // delegate Constructor
  using AthAlgorithm::AthAlgorithm;
 
  //
  // ..... Gaudi algorithm hooks
  //
  virtual StatusCode initialize() override;
  virtual StatusCode execute() override;
 
  virtual StatusCode finalize() override;
  virtual void handle(const Incident&) override;
 
  virtual bool isClonable() const override final { return true; }
 
private:
 
  //
  // >>>>>>>> private algorithm parts
  //

 
  //virtual StatusCode initHitMap();
 
  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, CLHEP::HepRandomEngine* rndmEngine);

  //StatusCode fillEMap(int& totHit) ;

  StatusCode readAuxiliary();
 
  int decodeInverse(int region, int eta);
 
  // RNGWrapper hacks
  void setSeed(const std::string& algName, const EventContext& ctx);
  void setSeed(const std::string& algName, uint64_t ev, uint64_t run);
  void setSeed(size_t seed);
 
  //
  // >>>>>>>> private data parts
  //
 
  IChronoStatSvc*              m_chronSvc{};
  ServiceHandle<IAthRNGSvc> m_RandomSvc{this, "RndmSvc", "AthRNGSvc", ""};
  Gaudi::Property<std::string> m_randomStreamName{this, "RandomStreamName", "LArTTL1Maker", ""};
  Gaudi::Property<uint32_t> m_randomSeedOffset{this, "RandomSeedOffset", 2, ""};
  Gaudi::Property<bool> m_useLegacyRandomSeeds{this, "UseLegacyRandomSeeds", false,
    "Use MC16-style random number seeding"};

  Gaudi::Property<bool> m_useTriggerTime{this, "UseTriggerTime", false};
  PublicToolHandle<ITriggerTime> m_triggerTimeTool{this, "TriggerTimeToolName", ""}; //"CosmicTriggerTimeTool"
 
  int m_BeginRunPriority{100};
 
  PublicToolHandle<CaloTriggerTowerService>  m_ttSvc{this, "CaloTriggerTowerService", "CaloTriggerTowerService"}; // FIXME Naming!!
  const CaloLVL1_ID*           m_lvl1Helper{};
  const LArEM_ID*              m_emHelper{};
  const LArHEC_ID*             m_hecHelper{};
  const LArFCAL_ID*            m_fcalHelper{};
  const CaloCell_ID*           m_OflHelper{};
  //const DataHandle<ILArfSampl>    m_dd_fSampl;
  SG::ReadCondHandleKey<ILArfSampl> m_fSamplKey{this, "LArfSamplKey", "LArfSamplSym"};

  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<float> m_refEnergyEm ;
  std::vector<std::vector<float> > m_pulseShapeEm ;
  std::vector<std::vector<float> > m_pulseShapeDerEm ;
  std::vector<float> m_autoCorrEm ;

  std::vector<float> m_sinThetaEmb ;
  Gaudi::Property<std::vector<float>> m_calibCoeffEmb{this, "EmBarrelCalibrationCoeffs", std::vector<float>(s_NBETABINS, 1.)};
  std::vector<float> m_noiseRmsEmb ;
  // if later we want to disentangle between pre-sum and summing electronic noise...
  //  std::vector<std::vector<float> > m_noiseRmsEmb ;

  std::vector<float> m_sinThetaEmec ;
  Gaudi::Property<std::vector<float>> m_calibCoeffEmec{this, "EmEndCapCalibrationCoeffs", std::vector<float>(s_NBETABINS, 1.)};
  std::vector<float> m_noiseRmsEmec ;
  // if later we want to disentangle between pre-sum and summing electronic noise...
  //  std::vector<std::vector<float> > m_noiseRmsEmec ;

  std::vector<float> m_pulseShapeHec ;
  std::vector<float> m_pulseShapeDerHec ;
  Gaudi::Property<std::vector<float>> m_calibCoeffHec{this, "HECCalibrationCoeffs", std::vector<float>(s_NBETABINS, 1.)};
  std::vector<float> m_sinThetaHec ;
  std::vector<float> m_satEnergyHec ;
  std::vector<float> m_noiseRmsHec ;
  std::vector< std::vector<float> > m_autoCorrHec ;

  std::vector<float> m_cellRelGainFcal ;
  std::vector< std::vector<float> > m_pulseShapeFcal ;
  std::vector< std::vector<float> > m_pulseShapeDerFcal ;
  std::vector< std::vector<float> > m_calibCoeffFcal ;
  static constexpr int s_nEta = 4;
  Gaudi::Property<std::vector<float>> m_calibCoeffFcalEm{this, "EmFcalCalibrationCoeffs", std::vector<float>(s_nEta, .03)};
  Gaudi::Property<std::vector<float>> m_calibCoeffFcalHad{this, "HadFcalCalibrationCoeffs", std::vector<float>(s_nEta, .03)};
  //  std::vector<float> m_noiseRmsFcal ;
  std::vector< std::vector<float> > m_noiseRmsFcal ;
  std::vector<float> m_autoCorrFcal ;

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

  SG::WriteHandleKey<LArTTL1Container> m_EmTTL1ContainerName{this, "EmTTL1ContainerName", "LArTTL1EM"};
  SG::WriteHandleKey<LArTTL1Container> m_HadTTL1ContainerName{this, "HadTTL1ContainerName", "LArTTL1HAD"};
 
  std::array<SG::ReadHandleKey<LArHitContainer>,4> m_xxxHitContainerName{{
      {this, "EmBarrelHitContainerName", "LArHitEMB"},
      {this, "EmEndCapHitContainerName", "LArHitEMEC"},
      {this, "HecHitContainerName", "LArHitHEC"},
      {this, "ForWardHitContainerName", "LArHitFCAL"}
    }};

  Gaudi::Property<bool> m_NoiseOnOff{this, "NoiseOnOff", true};
  Gaudi::Property<bool> m_PileUp{this, "PileUp", false};
  Gaudi::Property<bool> m_noEmCalibMode{this, "NoEmCalibrationMode", false};
  Gaudi::Property<bool> m_noHadCalibMode{this, "NoHadCalibrationMode", false};
  Gaudi::Property<float> m_debugThresh{this, "DebugThreshold", 5000.};
  Gaudi::Property<bool> m_chronoTest{this, "ChronoTest", false};

  Gaudi::Property<std::string> m_truthHitsContainer{this, "TruthHitsContainer", "",
    "Specify a value to get a pair of LArTTL1 containers with the truth hits in them"};
 
};
 
#endif