LArTTL1Maker.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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 <vector>
#include <array>
 
class ITriggerTime;
class CaloTriggerTowerService;
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:
  LArTTL1Maker(const std::string& name, ISvcLocator* pSvcLocator);
 
  virtual ~LArTTL1Maker();
//
// ..... 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"};
 
  bool m_useTriggerTime;
  ToolHandle<ITriggerTime> m_triggerTimeTool;
 
  int m_BeginRunPriority;
 
  ToolHandle<CaloTriggerTowerService>  m_ttSvc;
  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 = nullptr;
  //const DataHandle<ILArfSampl>    m_dd_fSampl;
  SG::ReadCondHandleKey<ILArfSampl> m_fSamplKey;
 
  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 ;
  std::vector<float> m_calibCoeffEmb ;
  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 ;
  std::vector<float>  m_calibCoeffEmec ;
  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 ;
  std::vector<float> m_calibCoeffHec ;
  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 ;
  std::vector<float> m_calibCoeffFcalEm ;
  std::vector<float> m_calibCoeffFcalHad ;
  //  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;   
  SG::WriteHandleKey<LArTTL1Container> m_HadTTL1ContainerName;  
 
  std::array<SG::ReadHandleKey<LArHitContainer>,4> m_xxxHitContainerName; 
 
  bool m_NoiseOnOff;               
  bool m_PileUp;                   
  bool m_noEmCalibMode;            
  bool m_noHadCalibMode;            
  float m_debugThresh;              
  bool m_chronoTest;               
 
   std::string m_truthHitsContainer;
 
};
 
#endif