QwMollerADC_Channel.h

Go to the documentation of this file.

 
/*!
 * \file   QwMollerADC_Channel.h
 * \brief  Decoding and management for Moller ADC channels (6x32-bit datawords)
 * \author Kevin Ward (Original code by P.M. King)
 * \date   20021-05-25
 */
 
#pragma once
 
// System headers
#include <vector>
 
// ROOT headers
#include "TTree.h"
 
// Qweak headers
#include "VQwHardwareChannel.h"
#include "MQwMockable.h"
#include "QwRootFile.h"
 
// Forward declarations
class QwBlinder;
class QwParameterFile;
#ifdef __USE_DATABASE__
class QwErrDBInterface;
#endif
 
///
/// \ingroup QwAnalysis_ADC
///
/// \ingroup QwAnalysis_BL
/**
 * \class QwMollerADC_Channel
 * \ingroup QwAnalysis_ADC
 * \brief Concrete hardware channel for Moller ADC modules (6x32-bit words)
 *
 * Decodes and processes the data for a single Moller ADC channel and exposes
 * block-level values, sums, and statistical moments. Supports single-event
 * cuts, error propagation, blinding, and running statistics. Follows the
 * dual-operator pattern to provide both type-specific operators and
 * polymorphic operator overrides via VQwHardwareChannel.
 */
class QwMollerADC_Channel: public VQwHardwareChannel, public MQwMockable {
/****************************************************************//**
 *  Class: QwMollerADC_Channel
 *         Base class containing decoding functions for the MollerADC_Channel
 *         6 32-bit datawords.
 *         The functions in this class will decode a single channel
 *         worth of MollerADC_Channel data and provide the components
 *         through member functions.
 ******************************************************************/
 public:
  static Int_t GetBufferOffset(Int_t moduleindex, Int_t channelindex);
  static void SetDecodeMode(UInt_t input);
  static void  PrintErrorCounterHead();
  static void  PrintErrorCounterTail();
 
  static const Double_t kTimePerSample;
 
  using MQwMockable::LoadMockDataParameters;
 
  using VQwHardwareChannel::GetRawValue;
  using VQwHardwareChannel::GetValue;
  using VQwHardwareChannel::GetValueM2;
  using VQwHardwareChannel::GetValueError;
  using VQwHardwareChannel::GetValueWidth;
 
  using VQwHardwareChannel::AccumulateRunningSum;
  using VQwHardwareChannel::DeaccumulateRunningSum;
 
 public:
  QwMollerADC_Channel(): MQwMockable() {
    InitializeChannel("","");
    SetMollerADCSaturationLimt(8.5);//set the default saturation limit
  };
  QwMollerADC_Channel(TString name, TString datatosave = "raw"): MQwMockable() {
    InitializeChannel(name, datatosave);
    SetMollerADCSaturationLimt(8.5);//set the default saturation limit
  };
  QwMollerADC_Channel(const QwMollerADC_Channel& value):
    VQwHardwareChannel(value), MQwMockable(value),
    fBlocksPerEvent(value.fBlocksPerEvent),
    fNumberOfSamples_map(value.fNumberOfSamples_map),
    fSaturationABSLimit(value.fSaturationABSLimit)
  {
    *this = value;
  };
  QwMollerADC_Channel(const QwMollerADC_Channel& value, VQwDataElement::EDataToSave datatosave):
    VQwHardwareChannel(value,datatosave), MQwMockable(value),
    fBlocksPerEvent(value.fBlocksPerEvent),
    fNumberOfSamples_map(value.fNumberOfSamples_map),
    fSaturationABSLimit(value.fSaturationABSLimit)
  {
    *this = value;
  };
  ~QwMollerADC_Channel() override { };
 
  void CopyFrom(const QwMollerADC_Channel& value){
    VQwHardwareChannel::CopyFrom(value);
    fBlocksPerEvent = value.fBlocksPerEvent;
    fNumberOfSamples_map = value.fNumberOfSamples_map;
    fSaturationABSLimit = value.fSaturationABSLimit;
    *this = value;
  };
 
 
  using VQwHardwareChannel::Clone;
 
  VQwHardwareChannel* Clone(VQwDataElement::EDataToSave datatosave) const override{
    return new QwMollerADC_Channel(*this,datatosave);
  };
 
  /// \brief Initialize the fields in this object
  void  InitializeChannel(TString name, TString datatosave) override;
 
  /// \brief Initialize the fields in this object
  void  InitializeChannel(TString subsystem, TString instrumenttype, TString name, TString datatosave) override;
 
  void LoadChannelParameters(QwParameterFile &paramfile) override;
 
  // Will update the default sample size for the module.
  void SetDefaultSampleSize(size_t num_samples_map) {
    // This will be checked against the no.of samples read by the module
    fNumberOfSamples_map = num_samples_map;
  };
  void  ClearEventData() override;
 
  /// Internally generate random event data
  void  RandomizeEventData(int helicity = 0.0, double time = 0.0) override;
 
  /// Forces the event "number of samples" variable to be what was expected from the mapfile.
  /// NOTE: this should only be used in mock data generation!
  void  ForceMapfileSampleSize() {fNumberOfSamples = fNumberOfSamples_map;};
 
//------------------------------------------------------------------------------------------
  void SmearByResolution(double resolution) override;
//------------------------------------------------------------------------------------------
 
  ///  TODO:  SetHardwareSum should be removed, and SetEventData
  ///         should be made protected.
  void  SetHardwareSum(Double_t hwsum, UInt_t sequencenumber = 0);
  void  SetEventData(Double_t* block, UInt_t sequencenumber = 0);
  void  SetRawEventData() override;
 
  // added this
  void SetMollerADCHeaderData(UInt_t region_number,
                            ULong64_t region_timestamp,
                            UInt_t header_num_words,
                            UInt_t header_block_number,
                            ULong64_t header_packet_count,
                            ULong64_t header_tsamples)
{
  fRegionNumber = region_number;
  fRegionTimestamp = region_timestamp;
  fHeaderNumWords = header_num_words;
  fHeaderBlockNumber = header_block_number;
  fHeaderPacketCount = header_packet_count;
  fHeaderTSamples = header_tsamples;
}
 
  void SetRegionNumber(UInt_t x)          { fRegionNumber = x; }
void SetRegionTimestamp(ULong64_t x)    { fRegionTimestamp = x; }
void SetHeaderPacketCount(ULong64_t x)  { fHeaderPacketCount = x; }
void SetHeaderBlockNumber(UInt_t x)     { fHeaderBlockNumber = x; }
void SetHeaderNumWords(UInt_t x)        { fHeaderNumWords = x; }
void SetHeaderTSamples(ULong64_t x)     { fHeaderTSamples = x; }
 
UInt_t GetRegionNumber() const              { return fRegionNumber; }
ULong64_t GetRegionTimestamp() const        { return fRegionTimestamp; }
ULong64_t GetHeaderPacketCount() const      { return fHeaderPacketCount; }
UInt_t GetHeaderBlockNumber() const         { return fHeaderBlockNumber; }
UInt_t GetHeaderNumWords() const            { return fHeaderNumWords; }
ULong64_t GetHeaderTSamples() const         { return fHeaderTSamples; }
 
  /// Encode the event data into a CODA buffer
  void  EncodeEventData(std::vector<UInt_t> &buffer) override;
  /// Decode the event data from a CODA buffer
  Int_t ProcessEvBuffer(UInt_t* buffer, UInt_t num_words_left, UInt_t index = 0) override;
  Int_t ProcessEvBuffer_oldmock(UInt_t* buffer, UInt_t num_words_left, UInt_t index = 0);
  Int_t ProcessEvBuffer_newreshuffled(UInt_t* buffer, UInt_t num_words_left, UInt_t index = 0); //{return 0;};
  /// Process the event data according to pedestal and calibration factor
  void  ProcessEvent() override;
 
 
  QwMollerADC_Channel& operator=  (const QwMollerADC_Channel &value);
  void AssignScaledValue(const QwMollerADC_Channel &value, Double_t scale);
  void AssignValueFrom(const VQwDataElement* valueptr) override;
  void AddValueFrom(const VQwHardwareChannel* valueptr) override;
  void SubtractValueFrom(const VQwHardwareChannel* valueptr) override;
  void MultiplyBy(const VQwHardwareChannel* valueptr) override;
  void DivideBy(const VQwHardwareChannel* valueptr) override;
  void ArcTan(const QwMollerADC_Channel &value);
 
  QwMollerADC_Channel& operator+= (const QwMollerADC_Channel &value);
  QwMollerADC_Channel& operator-= (const QwMollerADC_Channel &value);
  QwMollerADC_Channel& operator*= (const QwMollerADC_Channel &value);
 
  VQwHardwareChannel& operator+=(const VQwHardwareChannel& input) override;
  VQwHardwareChannel& operator-=(const VQwHardwareChannel& input) override;
  VQwHardwareChannel& operator*=(const VQwHardwareChannel& input) override;
  VQwHardwareChannel& operator/=(const VQwHardwareChannel& input) override;
 
  const QwMollerADC_Channel operator+ (const QwMollerADC_Channel &value) const;
  const QwMollerADC_Channel operator- (const QwMollerADC_Channel &value) const;
  const QwMollerADC_Channel operator* (const QwMollerADC_Channel &value) const;
  void Sum(const QwMollerADC_Channel &value1, const QwMollerADC_Channel &value2);
  void Difference(const QwMollerADC_Channel &value1, const QwMollerADC_Channel &value2);
  void Ratio(const QwMollerADC_Channel &numer, const QwMollerADC_Channel &denom);
  void Product(const QwMollerADC_Channel &value1, const QwMollerADC_Channel &value2);
  void DivideBy(const QwMollerADC_Channel& denom);
  void AddChannelOffset(Double_t Offset);
  void Scale(Double_t Offset) override;
 
 
  /**
   * Accumulate event values into the running sum with optional scaling.
   * @param value     Source channel to accumulate from.
   * @param count     Event count scaling (0 means use value.fGoodEventCount).
   * @param ErrorMask Bit mask of error flags to exclude when accumulating.
   */
  void AccumulateRunningSum(const QwMollerADC_Channel& value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF);
  void AccumulateRunningSum(const VQwHardwareChannel *value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF) override{
    const QwMollerADC_Channel *tmp_ptr = dynamic_cast<const QwMollerADC_Channel*>(value);
    if (tmp_ptr != NULL) {
      AccumulateRunningSum(*tmp_ptr, count, ErrorMask);
    } else {
      throw std::invalid_argument("Standard exception from QwMollerADC_Channel::AccumulateRunningSum: incompatible hardware channel type");
    }
  };
  ////deaccumulate one value from the running sum
  inline void DeaccumulateRunningSum(const QwMollerADC_Channel& value, Int_t ErrorMask=0xFFFFFFF){
    AccumulateRunningSum(value, -1, ErrorMask);
  };
  /*
  void DeaccumulateRunningSum(VQwHardwareChannel *value){
    const QwMollerADC_Channel *tmp_ptr = dynamic_cast<const QwMollerADC_Channel*>(value);
    if (tmp_ptr != NULL) {
      DeaccumulateRunningSum(*tmp_ptr);
    } else {
      throw std::invalid_argument("Standard exception from QwMollerADC_Channel::DeaccumulateRunningSum: incompatible hardware channel type");
    }
  };
  */
 
  void CalculateRunningAverage() override;
 
  Bool_t MatchSequenceNumber(size_t seqnum);
  Bool_t MatchNumberOfSamples(size_t numsamp);
 
  /*Event cut related routines*/
  Bool_t ApplySingleEventCuts(Double_t LL,Double_t UL);//check values read from modules are at desired level
  Bool_t ApplySingleEventCuts() override;//check values read from modules are at desired level by comparing upper and lower limits (fULimit and fLLimit) set on this channel
  void PrintErrorCounters() const override;// report number of events failed due to HW and event cut failure
 
  void SetMollerADCSaturationLimt(Double_t sat_volts=8.5){//Set the absolute staturation limit in volts.
    fSaturationABSLimit=sat_volts;
  }
 
  Double_t GetMollerADCSaturationLimt(){//Get the absolute staturation limit in volts.
    return fSaturationABSLimit;
  }
 
 
  Int_t ApplyHWChecks() override; //Check for hardware errors in the devices. This will return the device error code.
 
  void IncrementErrorCounters() override;//update the error counters based on the internal fErrorFlag
 
  /*End*/
 
  void  ConstructHistograms(TDirectory *folder, TString &prefix) override;
  void  FillHistograms() override;
 
  void  ConstructBranchAndVector(TTree *tree, TString &prefix, QwRootTreeBranchVector &values) override;
  void  ConstructBranch(TTree *tree, TString &prefix) override;
  void  FillTreeVector(QwRootTreeBranchVector &values) const override;
#ifdef HAS_RNTUPLE_SUPPORT
  void  ConstructNTupleAndVector(std::unique_ptr<ROOT::RNTupleModel>& model, TString& prefix, std::vector<Double_t>& values, std::vector<std::shared_ptr<Double_t>>& fieldPtrs) override;
  void  FillNTupleVector(std::vector<Double_t>& values) const override;
#endif // HAS_RNTUPLE_SUPPORT
 
  void CopyParameters(const VQwHardwareChannel* valueptr) override;
 
  Int_t GetRawValue(size_t element) const override {
    RangeCheck(element);
    if (element==0) return fHardwareBlockSum_raw;
    return fBlock_raw[element-1];
  }
  Double_t GetValue(size_t element) const override {
    RangeCheck(element);
    if (element==0) return fHardwareBlockSum;
    return fBlock[element-1];
  }
  Double_t GetValueM2(size_t element) const override {
    RangeCheck(element);
    if (element==0) return fHardwareBlockSumM2;
    return fBlockM2[element-1];
  }
  Double_t GetValueError(size_t element) const override {
    RangeCheck(element);
    if (element==0) return fHardwareBlockSumError;
    return fBlockError[element-1];
  }
 
 
  Double_t GetAverageVolts() const;
 
  size_t GetSequenceNumber() const {return (fSequenceNumber);};
  size_t GetNumberOfSamples() const {return (fNumberOfSamples);};
 
  void   SetCalibrationToVolts(){SetCalibrationFactor(kMollerADC_VoltsPerBit);};
 
  friend std::ostream& operator<< (std::ostream& stream, const QwMollerADC_Channel& channel);
  void PrintValue() const override;
  void PrintInfo() const override;
 
  /// \brief Blind this channel as an asymmetry
  void Blind(const QwBlinder *blinder);
  /// \brief Blind this channel as a difference
  void Blind(const QwBlinder *blinder, const QwMollerADC_Channel& yield);
 
  void ScaledAdd(Double_t scale, const VQwHardwareChannel *value) override;
 
#ifdef __USE_DATABASE__
  // Error Counters exist in QwMollerADC_Channel, not in VQwHardwareChannel
  //
  void AddErrEntriesToList(std::vector<QwErrDBInterface> &row_list) override;
#endif
 
 protected:
  QwMollerADC_Channel& operator/= (const QwMollerADC_Channel &value);
 
private:
  //  The following specific access methods should only be used internally,
  //  if at all.
  Double_t GetBlockValue(size_t blocknum) const { return GetValue(blocknum+1);};
  Double_t GetBlockErrorValue(size_t blocknum) const { return GetValueError(blocknum+1);};
 
  Double_t GetHardwareSum() const       { return GetValue(0);};
  Double_t GetHardwareSumM2() const     { return GetValueM2(0); };
  Double_t GetHardwareSumWidth() const  { return GetValueWidth(0); };
  Double_t GetHardwareSumError() const  { return GetValueError(0); };
  //  Double_t GetSoftwareSum() const {return fSoftwareBlockSum;};
 
  Int_t GetRawBlockValue(size_t blocknum) const {return GetRawValue(blocknum+1);};
  Int_t GetRawHardwareSum() const       { return GetRawValue(0);};
  Int_t GetRawSoftwareSum() const {return fSoftwareBlockSum_raw;};
 
 private:
  static const Bool_t kDEBUG;
 
  static const Int_t  kMaxChannels;     //no.of channels per module
  static const Int_t  kModuleHeaderWords;     //no.of words per header
  static constexpr Int_t kMaxBlock=15; // maximum no.of blocks
  enum EDecodeMode {kOldMock = 0, kNewReshuffled = 1};
  static EDecodeMode fDecodeMode;
  static constexpr Int_t kOldMockChannelsPerModule = 8;
  static constexpr Int_t kNewReshuffledChannelsPerModule = 16;
  static constexpr Int_t kOldMockDefaultBlocks = 4;
  static constexpr Int_t kNewReshuffledDefaultBlocks = kMaxBlock;
  static constexpr Int_t kOldMockWordsPerChannel = 30;
  static constexpr Int_t kNewReshuffledWordsPerChannel = 14;
  static Bool_t fDecodeModeHasBeenSet;
  static Int_t GetWordsPerChannel();
  static Int_t GetChannelsPerModule();
  static Int_t GetModuleHeaderWords();
  static Int_t GetDefaultBlocksPerEvent();
 
  /*! \name ADC Calibration                    */
  // @{
  static const Double_t kMollerADC_VoltsPerBit;
  //@}
 
 
  /*! \name Channel information data members   */
 
  /*! \name Channel configuration data members */
  // @{
 
  //UInt_t  fBlocksPerEvent;
  Short_t fBlocksPerEvent;
  // @}
 
 
  /*! \name Event data members---Raw values */
  // @{
  Long64_t fBlock_raw[kMaxBlock];      ///< Array of the sub-block data as read from the module
  Long64_t fHardwareBlockSum_raw; ///< Module-based sum of the four sub-blocks as read from the module
  Long64_t fSoftwareBlockSum_raw; ///< Sum of the data in the four sub-blocks raw
  Long64_t fBlockSumSq_raw[kMaxBlock+1];
  Int_t fBlock_min[kMaxBlock+1];
  Int_t fBlock_max[kMaxBlock+1];
  Short_t fBlock_numSamples[kMaxBlock+1];
  UInt_t fBlockSample[kMaxBlock+1]; // number of samples in each block
  // @}
 
  /*! \name Event data members---Potentially calibrated values*/
  // @{
  // The following values potentially have pedestal removed  and calibration applied
  Double_t fBlock[kMaxBlock];          ///< Array of the sub-block data
  Double_t fHardwareBlockSum;  ///< Module-based sum of the four sub-blocks
  // @}
 
 
  /// \name Calculation of the statistical moments
  // @{
  // Moments of the separate blocks
  Double_t fBlockM2[kMaxBlock];        ///< Second moment of the sub-block
  Double_t fBlockError[kMaxBlock];     ///< Uncertainty on the sub-block
  // Moments of the hardware sum
  Double_t fHardwareBlockSumM2;    ///< Second moment of the hardware sum
  Double_t fHardwareBlockSumError; ///< Uncertainty on the hardware sum
 
  Double_t fHardwareBlockSumRMS;   // RMS of the hardware sum
  Double_t fBlockRMS[kMaxBlock+1]; // RMS of the sub-blocks
 
  Double_t GetHardwareSumRMS() const { return fHardwareBlockSumRMS; } // RMS of the hardware sum
  Double_t GetBlockRMS(Int_t i) const { return fBlockRMS[i]; }        // RMS of the sub-blocks
 
  // @}
 
 
  UInt_t fSequenceNumber;      ///< Event sequence number for this channel
  UInt_t fPreviousSequenceNumber; ///< Previous event sequence number for this channel
  UInt_t fNumberOfSamples;     ///< Number of samples  read through the module
  UInt_t    fRegionNumber;
ULong64_t fRegionTimestamp;
UInt_t    fHeaderNumWords;
UInt_t    fHeaderBlockNumber;
ULong64_t fHeaderPacketCount;
ULong64_t fHeaderTSamples;
  UInt_t fNumberOfSamples_map; ///< Number of samples in the expected to  read through the module. This value is set in the QwBeamline map file
  // Set of error counters for each HW test.
  Int_t fErrorCount_HWSat;    ///< check to see ADC channel is saturated
  Int_t fErrorCount_sample;   ///< for sample size check
  Int_t fErrorCount_SW_HW;    ///< HW_sum==SW_sum check
  Int_t fErrorCount_Sequence; ///< sequence number check
  Int_t fErrorCount_SameHW;   ///< check to see ADC returning same HW value
  Int_t fErrorCount_ZeroHW;   ///< check to see ADC returning zero
 
  Int_t fNumEvtsWithEventCutsRejected; ///< Counts the Event cut rejected events
 
 
 
 
 
 
  Int_t fADC_Same_NumEvt; ///< Keep track of how many events with same ADC value returned
  Int_t fSequenceNo_Prev; ///< Keep the sequence number of the last event
  Int_t fSequenceNo_Counter; ///< Internal counter to keep track of the sequence number
  Double_t fPrev_HardwareBlockSum; ///< Previous Module-based sum of the four sub-blocks
 
 
 
  Double_t fSaturationABSLimit;///<absolute value of the MollerADC saturation volt
 
 
  const static Bool_t bDEBUG=kFALSE;///<debugging display purposes
 
  ///<For MollerADC data element trimming uses
  Bool_t bHw_sum;
  Bool_t bHw_sum_raw;
  Bool_t  bBlock;
  Bool_t  bBlock_raw;
  Bool_t bNum_samples;
  Bool_t bDevice_Error_Code;
  Bool_t bSequence_number;
 
private:
 
 
 
 
 
 
};