dc/de1/RPDDataAnalyzer_8h_source.html

/*

  Copyright (C) 2002-2024 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"


#include "CxxUtils/checker_macros.h"


ATLAS_NO_CHECK_FILE_THREAD_SAFETY;


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