LArOFFCRawChannelBuilder.h

Go to the documentation of this file.

/* -*-c++-*- */
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARROD_LAROFFCRAWCHANNELBUILDER_H
#define LARROD_LAROFFCRAWCHANNELBUILDER_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "AthenaPoolUtilities/AthenaAttributeList.h"
#include "LArCabling/LArOnOffIdMapping.h"
#include "LArElecCalib/ILArOFC.h"
#include "LArElecCalib/ILArPedestal.h"
#include "LArElecCalib/ILArShape.h"
#include "LArRawConditions/LArADC2MeV.h"
#include "LArRawConditions/LArDSPThresholdsComplete.h"
#include "CaloIdentifier/CaloCell_ID.h"
#include "CxxUtils/checker_macros.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
 
#include <atomic>
#include <map>
#include <mutex>
#include <string>
#include <vector>
 
// Event classes
class LArDigitContainer;
class LArRawChannelContainer;
class LArOnlineID;
class CaloCell_ID;
 
class LArOFFCRawChannelBuilder : public AthReentrantAlgorithm {
 
 public:
  using AthReentrantAlgorithm::AthReentrantAlgorithm;
 
  StatusCode initialize() override;
  StatusCode execute(const EventContext& ctx) const override;
  StatusCode finalize() override;
 
 private:
  // Event input
  SG::ReadHandleKey<LArDigitContainer> m_digitKey{
      this, "LArDigitKey", "FREE", "SG Key of LArDigitContainer"};
 
  // Event output
  SG::WriteHandleKey<LArRawChannelContainer> m_rawChannelKey{
      this, "LArRawChannelKey", "LArRawChannels",
      "SG key of the output LArRawChannelContainer"};
 
  // Conditions input
  SG::ReadCondHandleKey<ILArPedestal> m_pedestalKey{
      this, "PedestalKey", "LArPedestal",
      "SG Key of Pedestal conditions object"};
  SG::ReadCondHandleKey<LArADC2MeV> m_adc2MeVKey{
      this, "ADC2MeVKey", "LArADC2MeV", "SG Key of ADC2MeV conditions object"};
  SG::ReadCondHandleKey<ILArOFC> m_ofcKey{this, "OFCKey", "LArOFC",
                                          "SG Key of OFC conditions object"};
  SG::ReadCondHandleKey<ILArShape> m_shapeKey{
      this, "ShapeKey", "LArShape", "SG Key of Shape conditions object"};
 
  SG::ReadCondHandleKey<LArOnOffIdMapping> m_cablingKey{
      this, "CablingKey", "LArOnOffIdMap",
      "SG Key of LArOnOffIdMapping object"};
  SG::ReadCondHandleKey<LArDSPThresholdsComplete> m_run1DSPThresholdsKey{
      this, "Run1DSPThresholdsKey", "",
      "SG Key for thresholds to compute time and quality, run 1"};
  SG::ReadCondHandleKey<AthenaAttributeList> m_run2DSPThresholdsKey{
      this, "Run2DSPThresholdsKey", "",
      "SG Key for thresholds to compute time and quality, run 2"};
 
  // Other jobOptions
  Gaudi::Property<float> m_eCutFortQ{this, "ECutFortQ", 256.0,
                                     "Time and Quality will be computed only "
                                     "for channels with E above this value"};
  Gaudi::Property<bool> m_absECutFortQ{
      this, "absECut", true, "Cut on fabs(E) for Q and t computation"};
  Gaudi::Property<bool> m_useShapeDer{
      this, "useShapeDer", true,
      "Use shape derivative in Q-factor computation"};
  Gaudi::Property<bool> m_useDBFortQ{this, "useDB", true,
                                     "Use DB for cut on t,Q"};

  Gaudi::Property<int> m_firstSample{
      this, "firstSample", 0,
      "Index of the digit sample the OFC window starts at"};

 
  // OFFC algorithm configuration
  Gaudi::Property<double> m_belowThreshold{
      this, "BelowThreshold", 0,
      "ADC threshold below which samples are treated as noise"};

  Gaudi::Property<int> m_belowTillReset{
      this, "BelowTillReset", 0,
      "Number of consecutive noise samples before cache reset (<=0 disables)"};

  Gaudi::Property<int> m_nPulse{
      this, "NPulse", 0, "Maximum number of pulse corrections in flight"};

  Gaudi::Property<double> m_Q3cut{
      this, "Q3Cut", 0.1,
      "Shape-consistency cut for pulse acceptance, on Q3/A"};

  Gaudi::Property<double> m_Q3Offset{
      this, "Q3Offset", 2.0,
      "Absolute term of the Q3 cut in ADC, covering the noise floor"};

  Gaudi::Property<double> m_filterThreshold{
      this, "FilterThreshold", 0,
      "Minimum corrected amplitude for pulse finding"};
 
  // PER-LAYER CONFIGURATION. The scalars above remain the global fallback,
  // so a job setting nothing new behaves as before. FilterThreshold is in
  // ADC, a different energy in every layer -- the useful threshold sits near
  // 3 sigma of local noise, 25 ADC in EMB/2 but 100 in EMEC-OW/1.
  // Keys are "<REGION>/<LAYER>": EMB, EMEC-OW, EMEC-IW, HEC, FCAL, and the
  // sampling (FCAL module).
  Gaudi::Property<std::map<std::string, double>> m_filterThresholdByLayer{
      this, "FilterThresholdByLayer", {},
      "Per-layer FilterThreshold, keyed <REGION>/<LAYER>; unlisted layers "
      "fall back to FilterThreshold"};
  Gaudi::Property<std::map<std::string, double>> m_q3CutByLayer{
      this, "Q3CutByLayer", {},
      "Per-layer Q3Cut; unlisted layers fall back to Q3Cut"};
  Gaudi::Property<std::map<std::string, double>> m_q3OffsetByLayer{
      this, "Q3OffsetByLayer", {},
      "Per-layer Q3Offset; unlisted layers fall back to Q3Offset"};
  Gaudi::Property<std::map<std::string, int>> m_nPulseByLayer{
      this, "NPulseByLayer", {},
      "Per-layer NPulse; unlisted layers fall back to NPulse"};

  Gaudi::Property<std::vector<std::string>> m_enabledLayers{
      this, "EnabledLayers", {},
      "Layers where the correction may fire; empty means all"};

  struct LayerParams {
    double q3Cut = 0.1;
    double q3Offset = 2.0;
    double filterThreshold = 0.0;
    int nPulse = 0;
    double belowThreshold = 0.0;
    int belowTillReset = 0;
  };

  static constexpr size_t s_nSlots = 20;
  std::vector<LayerParams> m_layerParams;

  static size_t slotOf(int region, int layer);
  static size_t slotOfKey(const std::string& key);
  static std::string keyOfSlot(size_t slot);

  mutable std::vector<uint8_t> m_slotByHash ATLAS_THREAD_SAFE;
  mutable std::once_flag m_slotOnce ATLAS_THREAD_SAFE;
  mutable StatusCode m_slotStatus ATLAS_THREAD_SAFE{StatusCode::SUCCESS};
  StatusCode buildLayerMap(const EventContext& ctx) const;
 
  // Identifier helpers
  const LArOnlineID* m_onlineId = nullptr;
  const CaloCell_ID* m_caloId = nullptr;

  mutable std::atomic<unsigned long> m_nSubtracted{0};
  mutable std::atomic<unsigned long> m_nDropped{0};
 
  // --- Member functions ---
  std::vector<double> pulseResponse(const ILArShape::ShapeRef_t& shape,
                                    const ILArOFC::OFCRef_t& ofc) const;
 
  double computeOFFC(const std::vector<short>& samples, int firstSample,
                     const ILArOFC::OFCRef_t& ofc,
                     const ILArShape::ShapeRef_t& shape, double pedestal,
                     const LayerParams& par) const;
};
 
#endif