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 EDataTypes {
      c_Undefined = 0,         
      c_MC = 1,                
      c_Interim = 2,           
      c_Production = 3,        
      c_ProductionDebug = 4,   
      c_Other = 99             
    };
 
    enum {
      c_WindowSize = 64 
    };
 
    TOPRawDigit()
    {}
 
    TOPRawDigit(unsigned short scrodID, EDataTypes dataType):
      m_scrodID(scrodID), m_dataType(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 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 getCFDFallingTime() const
    {
      return timeCFDCrossing(getSampleFall(), getValueFall0(), getFallingSlope());
    }
 
    double getCFDLeadingTimeError(double rmsNoise) const
    {
      return rmsNoise * timeErrorCoefficient(m_VRise0, m_VRise1);
    }
 
    double getCFDFallingTimeError(double rmsNoise) const
    {
      return rmsNoise * timeErrorCoefficient(m_VFall0, m_VFall1);
    }
 
    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 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 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 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);
    }
 
    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); 
  };
 
 
} // end namespace Belle2