RPDDataAnalyzer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ZDCANALYSIS_RPDDATAANALYZER_H
#define ZDCANALYSIS_RPDDATAANALYZER_H
 
#include <string>
#include <vector>
#include <functional>
#include <bitset>
 
#include "ZdcAnalysis/ZDCMsg.h"
#include "ZdcUtils/RPDUtils.h"
 
 
namespace ZDC {
 
struct RPDConfig {
  unsigned int nSamples;
  unsigned int nBaselineSamples;
  unsigned int endSignalSample;
  float pulse2ndDerivThresh;
  float postPulseFracThresh;
  unsigned int goodPulseSampleStart;
  unsigned int goodPulseSampleStop;
  float nominalBaseline;
  float pileupBaselineSumThresh;
  float pileupBaselineStdDevThresh;
  unsigned int nNegativesAllowed;
  unsigned int ADCOverflow;
};
 
class RPDDataAnalyzer {
 public:
  enum {
    ValidBit                        =  0, // analysis and output are valid
    OutOfTimePileupBit              =  1, // OOT detected, pileup subtraction attempted
    OverflowBit                     =  2, // overflow detected => invalid
    PrePulseBit                     =  3, // pulse detected before expected range => invalid
    PostPulseBit                    =  4, // pulse detected after expected range => invalid
    NoPulseBit                      =  5, // no pulse detected => invalid
    BadAvgBaselineSubtrBit          =  6, // subtraction of avg. of baseline samples yielded too many negatives => invalid
    InsufficientPileupFitPointsBit  =  7, // baseline samples indicate pileup, but there are not enough points to perform fit -> nominal baseline used without pileup subtraction
    PileupStretchedExpFitFailBit    =  8, // fit to stretched exponential failed -> fallback to exponential fit
    PileupStretchedExpGrowthBit     =  9, // fit to stretched exponential does not decay -> fallback to exponential fit
    PileupBadStretchedExpSubtrBit   = 10, // subtraction of stretched exponential fit yielded too many negatives -> fallback to exponential fit
    PileupExpFitFailBit             = 11, // fit to exponential failed => invalid IF stretched exponential fit is also bad
    PileupExpGrowthBit              = 12, // fit to exponential does not decay => invalid IF stretched exponential fit is also bad
    PileupBadExpSubtrBit            = 13, // subtraction of stretched exponential yielded too many negatives => invalid IF stretched exponential fit is also bad
    PileupStretchedExpPulseLikeBit  = 14, // fit to stretched exponential probably looks more like a pulse than pileup
    N_STATUS_BITS
  };
  enum class PileupFitFuncType {
    None, Exp, SecondOrderStretchedExp
  };
 
  RPDDataAnalyzer(ZDCMsg::MessageFunctionPtr messageFunc_p, std::string tag, RPDConfig const& config, std::vector<float> const& calibFactors);
  virtual ~RPDDataAnalyzer() = default;
  // this class is not intended to be copied or moved
  RPDDataAnalyzer(RPDDataAnalyzer const&) = delete;
  RPDDataAnalyzer& operator=(RPDDataAnalyzer const&) = delete;
  RPDDataAnalyzer(RPDDataAnalyzer &&) = delete;
  RPDDataAnalyzer& operator=(RPDDataAnalyzer &&) = delete;
 
  void loadChannelData(unsigned int channel, const std::vector<uint16_t>& FadcData);
  void analyzeData();
 
  unsigned int getChMaxSample(unsigned int channel) const;
  float getChSumAdc(unsigned int channel) const;
  float getChSumAdcCalib(unsigned int channel) const;
  float getChMaxAdc(unsigned int channel) const;
  float getChMaxAdcCalib(unsigned int channel) const;
  float getChPileupFrac(unsigned int channel) const;
  float getChBaseline(unsigned int channel) const;
  const std::vector<float>& getChPileupExpFitParams(unsigned int channel) const;
  const std::vector<float>& getChPileupStretchedExpFitParams(unsigned int channel) const;
  const std::vector<float>& getChPileupExpFitParamErrs(unsigned int channel) const;
  const std::vector<float>& getChPileupStretchedExpFitParamErrs(unsigned int channel) const;
  float getChPileupExpFitMSE(unsigned int channel) const;
  float getChPileupStretchedExpFitMSE(unsigned int channel) const;
 
  unsigned int getChStatus(unsigned int channel) const;
  unsigned int getSideStatus() const;
 
  void reset();
 
 private:
  bool checkOverflow(unsigned int channel);
  bool checkPulses(unsigned int channel);
  unsigned int countSignalRangeNegatives(std::vector<float> const& values) const;
  bool doBaselinePileupSubtraction(unsigned int channel);
  void calculateMaxSampleMaxAdc(unsigned int channel);
  void calculateSumAdc(unsigned int channel);
 
  void setSideStatusBits();
 
  bool doPileupExpFit(unsigned int channel, std::vector<std::pair<unsigned int, float>> const& pileupFitPoints);
  bool doPileupStretchedExpFit(unsigned int channel, std::vector<std::pair<unsigned int, float>> const& pileupFitPoints);
  float calculateBaselineSamplesMSE(unsigned int channel, std::function<float(unsigned int)> const& fit) const;
 
  ZDCMsg::MessageFunctionPtr m_msgFunc_p;
  std::string m_tag;
 
  static unsigned int constexpr s_nChannels = RPDUtils::nChannels; // for convenience
 
  unsigned int m_nChannelsLoaded = 0;
  unsigned int m_nSamples;
  unsigned int m_nBaselineSamples; 
  unsigned int m_endSignalSample; 
  float m_pulse2ndDerivThresh; 
  float m_postPulseFracThresh; 
  unsigned int m_goodPulseSampleStart; 
  unsigned int m_goodPulseSampleStop; 
  float m_nominalBaseline; 
  float m_pileupBaselineSumThresh; 
  float m_pileupBaselineStdDevThresh; 
  unsigned int m_nNegativesAllowed; 
  unsigned int m_AdcOverflow; 
  std::array<float, s_nChannels> m_outputCalibFactors {}; 
 
  std::array<std::vector<uint16_t>, s_nChannels> m_chFADCData; 
  std::array<std::vector<float>, s_nChannels> m_chCorrectedFadcData; 
  std::array<unsigned int, s_nChannels> m_chMaxSample {}; 
  std::array<float, s_nChannels> m_chSumAdc {}; 
  std::array<float, s_nChannels> m_chSumAdcCalib {}; 
  std::array<float, s_nChannels> m_chMaxAdc {}; 
  std::array<float, s_nChannels> m_chMaxAdcCalib {}; 
  std::array<float, s_nChannels> m_chPileupFrac {}; 
  std::array<float, s_nChannels> m_chBaseline {}; 
  std::array<std::vector<float>, s_nChannels> m_chPileupExpFitParams; 
  std::array<std::vector<float>, s_nChannels> m_chPileupStretchedExpFitParams; 
  std::array<std::vector<float>, s_nChannels> m_chPileupExpFitParamErrs; 
  std::array<std::vector<float>, s_nChannels> m_chPileupStretchedExpFitParamErrs; 
  std::array<PileupFitFuncType, s_nChannels> m_chPileupFuncType {}; 
  std::array<std::function<float(unsigned int)>, s_nChannels> m_chExpPileupFuncs; 
  std::array<std::function<float(unsigned int)>, s_nChannels> m_ch2ndOrderStretchedExpPileupFuncs; 
  std::array<float, s_nChannels> m_chExpPileupMSE {}; 
  std::array<float, s_nChannels> m_ch2ndOrderStretchedExpPileupMSE {}; 
  std::array<std::bitset<N_STATUS_BITS>, s_nChannels> m_chStatus; 
  std::bitset<N_STATUS_BITS> m_sideStatus; 

  static unsigned int constexpr s_minPileupFitPoints = 3;
};
 
} // namespace ZDC
 
#endif