TOPRawWaveform.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>
#include <vector>
#include <algorithm>
 
namespace Belle2 {
  class TOPRawWaveform : public RelationsObject {
  public:
 
    enum {c_WindowSize = 64 
         };
 
    struct FeatureExtraction {
      int sampleRise = 0; 
      int samplePeak = 0; 
      int sampleFall = 0; 
      short vRise0 = 0;   
      short vRise1 = 0;   
      short vPeak = 0;    
      short vFall0 = 0;   
      short vFall1 = 0;   
      int integral = 0;   
    };
 
 
    TOPRawWaveform()
    {}
 
 
    TOPRawWaveform(int moduleID,
                   int pixelID,
                   unsigned channel,
                   unsigned scrodID,
                   unsigned window,
                   int startSample,
                   const std::vector<short>& data):
      m_moduleID(moduleID), m_pixelID(pixelID), m_channel(channel), m_scrodID(scrodID),
      m_window(window), m_startSample(startSample), m_data(data),
      m_physicalWindow(window)
    {}
 
    void setPedestalSubtractedFlag(bool value) {m_pedestalSubtracted = value;}
 
    void setPhysicalWindow(unsigned window) {m_physicalWindow = window;}
 
    void setLastWriteAddr(unsigned lastWriteAddr) {m_lastWriteAddr = lastWriteAddr;}
 
    void setStorageWindows(const std::vector<unsigned short>& windows)
    {
      m_windows = windows;
    }
 
    void setRevo9Counter(unsigned short revo9Counter) {m_revo9Counter = revo9Counter;}
 
    void setOffsetWindows(int offsetWindows) {m_offsetWindows = offsetWindows;}
 
    int getModuleID() const { return m_moduleID; }
 
    int getPixelID() const { return m_pixelID; }
 
    unsigned getChannel() const { return m_channel; }
 
    unsigned getScrodID() const { return m_scrodID; }
 
    unsigned getStorageWindow() const { return m_window; }
 
    int getStartSample() const { return m_startSample;}
 
    bool isPedestalSubtracted() const {return m_pedestalSubtracted;}
 
    unsigned getPhysicalWindow() const {return m_physicalWindow;}
 
    unsigned getReferenceWindow() const { return m_lastWriteAddr; }
 
    const std::vector<unsigned short>& getStorageWindows() const { return m_windows; }
 
    unsigned short getRevo9Counter() const {return m_revo9Counter;}
 
    int getOffsetWindows() const {return m_offsetWindows;}
 
    unsigned getASICChannel() const {return m_channel & 0x07;}
 
    unsigned getASICNumber() const {return (m_channel >> 3) & 0x03;}
 
    unsigned getCarrierNumber() const {return (m_channel >> 5) & 0x03;}
 
    unsigned getBoardstackNumber() const {return (m_channel >> 7) & 0x03;}
 
    unsigned getSize() const {return m_data.size();}
 
    const std::vector<short>& getWaveform() const
    {
      return m_data;
    }
 
    bool areWindowsInOrder(unsigned lastSample = 0xFFFFFFFF,
                           unsigned short storageDepth = 508) const
    {
      unsigned last = lastSample / c_WindowSize + 1;
      unsigned size = m_windows.size();
      for (unsigned i = 1; i < std::min(last, size); i++) {
        int diff = m_windows[i] - m_windows[i - 1];
        if (diff < 0) diff += storageDepth;
        if (diff != 1) return false;
      }
      return true;
    }
 
    int getIntegral(int sampleRise, int samplePeak, int sampleFall) const;
 
    int featureExtraction(int threshold, int hysteresis, int thresholdCount) const;
 
    const std::vector<FeatureExtraction>& getFeatureExtractionData() const
    {
      return m_features;
    }
 
 
  private:
 
    int Integral(int sampleRise, int samplePeak, int sampleFall) const;
 
    int m_moduleID = 0;                 
    int m_pixelID = 0;                  
    unsigned m_channel = 0;             
    unsigned short m_scrodID = 0;       
    unsigned short m_window = 0;   
    int m_startSample = 0;   
    std::vector<short> m_data;      
    bool m_pedestalSubtracted = false; 
    unsigned short m_physicalWindow = 0;
    unsigned short m_lastWriteAddr = 0; 
    std::vector<unsigned short> m_windows; 
    unsigned short m_revo9Counter = 0; 
    int m_offsetWindows = 0; 
    mutable std::vector<FeatureExtraction> m_features; 
 
    ClassDef(TOPRawWaveform, 9); 
  };
 
 
} // end namespace Belle2