TOPRawDigit.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/datastore/RelationsObject.h>
 
namespace Belle2 {

 
  class TOPRawDigit : public RelationsObject {
  public:

    enum ErrorFlags {
      c_HeadMagic = 0x0001,  
      c_TailMagic = 0x0002,  
      c_HitMagic = 0x0004,   
      c_HitChecksum = 0x0008 
    };
    enum ErrorFlags {…};

    enum EDataTypes {
      c_Undefined = 0,         
      c_MC = 1,                
      c_Interim = 2,           
      c_Production = 3,        
      c_ProductionDebug = 4,   
      c_Other = 99             
    };
    enum EDataTypes {…};

    enum {
      c_WindowSize = 64 
    };

    TOPRawDigit()
    {}
    TOPRawDigit() {…}

    TOPRawDigit(unsigned short scrodID, EDataTypes dataType):
      m_scrodID(scrodID), m_dataType(dataType)
    {}
    TOPRawDigit(unsigned short scrodID, EDataTypes dataType): {…}

    void setCarrierNumber(unsigned short carrier) {m_carrier = carrier;}

    void setASICNumber(unsigned short asic) {m_asic = asic;}

    void setASICChannel(unsigned short channel) {m_channel = channel;}

    void setASICWindow(unsigned short window) {m_window = window;}

    void setStorageWindows(const std::vector<unsigned short>& windows)
    {
      m_windows = windows;
    }
    void setStorageWindows(const std::vector<unsigned short>& windows) {…}

    void setLastWriteAddr(unsigned short window) {m_lastWriteAddr = window;}

    void setTFine(unsigned short tfine) {m_TFine = tfine;}

    void setSampleRise(unsigned short sample) {m_sampleRise = sample;}

    void setDeltaSamplePeak(unsigned short dsample) {m_dSamplePeak = dsample;}

    void setDeltaSampleFall(unsigned short dsample) {m_dSampleFall = dsample;}

    void setValueRise0(short adc) {m_VRise0 = adc;}

    void setValueRise1(short adc) {m_VRise1 = adc;}

    void setValuePeak(short adc) {m_VPeak = adc;}

    void setValueFall0(short adc) {m_VFall0 = adc;}

    void setValueFall1(short adc) {m_VFall1 = adc;}

    void setIntegral(int integral) {m_integral = integral;}

    void setRevo9Counter(unsigned short revo9Counter) {m_revo9Counter = revo9Counter;}

    void setPhase(unsigned short phase) {m_phase = phase;}

    void setLookBackWindows(unsigned short lookBack) {m_lookBackWindows = lookBack;}

    void setErrorFlags(unsigned short flags) {m_errorFlags = flags;}

    void setOfflineFlag() {m_offline = true;}

    EDataTypes getDataType() const {return m_dataType;}

    unsigned getScrodID() const {return m_scrodID;}

    unsigned getCarrierNumber() const {return m_carrier;}

    unsigned getASICNumber() const {return m_asic;}

    unsigned getASICChannel() const {return m_channel;}
 

    unsigned getScrodChannel() const {return m_channel + m_asic * 8 + m_carrier * 32;}

    unsigned getASICWindow() const {return m_window;}

    const std::vector<unsigned short>& getStorageWindows() const {return m_windows;}

    unsigned getLastWriteAddr() const {return m_lastWriteAddr;}

    unsigned getTFine() const {return m_TFine;}

    unsigned getSampleRise() const {return m_sampleRise;}

    unsigned getDeltaSamplePeak() const {return m_dSamplePeak;}

    unsigned getSamplePeak() const {return m_sampleRise + m_dSamplePeak;}

    unsigned getDeltaSampleFall() const {return m_dSampleFall;}

    unsigned getSampleFall() const {return m_sampleRise + m_dSampleFall;}

    int getValueRise0() const {return m_VRise0;}

    int getValueRise1() const {return m_VRise1;}

    int getValuePeak() const {return m_VPeak;}

    int getValueFall0() const {return m_VFall0;}

    int getValueFall1() const {return m_VFall1;}

    int getIntegral() const {return m_integral;}

    unsigned short getRevo9Counter() const {return m_revo9Counter;}

    unsigned short getLookBackWindows() const {return m_lookBackWindows;}

    unsigned short getPhase() const {return m_phase;}

    unsigned short getErrorFlags() const {return m_errorFlags;}

    double getLeadingSlope() const {return getValueRise1() - getValueRise0();}

    double getFallingSlope() const {return getValueFall1() - getValueFall0();}

    double getCFDLeadingTime() const
    {
      return timeCFDCrossing(getSampleRise(), getValueRise0(), getLeadingSlope());
    }
    double getCFDLeadingTime() const {…}

    double getCFDFallingTime() const
    {
      return timeCFDCrossing(getSampleFall(), getValueFall0(), getFallingSlope());
    }
    double getCFDFallingTime() const {…}

    double getCFDLeadingTimeError(double rmsNoise) const
    {
      return rmsNoise * timeErrorCoefficient(m_VRise0, m_VRise1);
    }
    double getCFDLeadingTimeError(double rmsNoise) const {…}

    double getCFDFallingTimeError(double rmsNoise) const
    {
      return rmsNoise * timeErrorCoefficient(m_VFall0, m_VFall1);
    }
    double getCFDFallingTimeError(double rmsNoise) const {…}

    double getFWHM() const {return getCFDFallingTime() - getCFDLeadingTime();}

    bool isLeadingEdgeValid() const {return checkEdge(m_VRise0, m_VRise1, m_VPeak);}

    bool isFallingEdgeValid() const {return checkEdge(m_VFall1, m_VFall0, m_VPeak);}

    bool isFEValid() const
    {
      return isLeadingEdgeValid() and isFallingEdgeValid();
    }
    bool isFEValid() const {…}

    bool isPedestalJump() const;

    bool isAtWindowDiscontinuity(unsigned short storageDepth = 508) const;

    bool areWindowsInOrder(unsigned short storageDepth = 508) const;

    double correctTime(double time, unsigned short storageDepth = 508) const;

    bool isWindowConsistent() const
    {
      if (m_windows.empty()) return true;
      return m_windows[0] == m_window;
    }
    bool isWindowConsistent() const {…}

    bool isMadeOffline() const {return m_offline;}
 
  private:

    double timeCFDCrossing(int sample, int value, double slope) const
    {
      if (slope == 0) return sample;
      return (int(m_VPeak) - 2 * value) / (2 * slope) + sample;
    }
    double timeCFDCrossing(int sample, int value, double slope) const {…}

    double timeErrorCoefficient(double y1, double y2) const;

    bool checkEdge(int v1, int v2, int vp) const
    {
      return (vp > 0 and v1 < v2 and 2 * v1 <= vp and v2 <= vp)
             or (vp < 0 and v1 > v2 and 2 * v1 >= vp and v2 >= vp);
    }
    bool checkEdge(int v1, int v2, int vp) const {…}
 
    unsigned short m_scrodID = 0; 
    unsigned short m_carrier = 0; 
    unsigned short m_asic = 0;    
    unsigned short m_channel = 0; 
    unsigned short m_window = 0;  
    unsigned short m_TFine = 0; 
    unsigned short m_sampleRise = 0;  
    unsigned short m_dSamplePeak = 0; 
    unsigned short m_dSampleFall = 0; 
    short m_VRise0 = 0;       
    short m_VRise1 = 0;       
    short m_VPeak = 0;        
    short m_VFall0 = 0;       
    short m_VFall1 = 0;       
    int m_integral = 0;     
    unsigned short m_revo9Counter = 0; 
    unsigned short m_phase = 0; 
    unsigned short m_lookBackWindows = 0; 
    unsigned short m_errorFlags = 0; 
    unsigned short m_lastWriteAddr = 0; 
    std::vector<unsigned short> m_windows; 
    bool m_offline = false; 
    EDataTypes m_dataType = c_Undefined; 
 
    ClassDef(TOPRawDigit, 6); 
 
  };
  class TOPRawDigit : public RelationsObject {…};
 

} // end namespace Belle2