TOPDigit.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/dataobjects/DigitBase.h>
 
namespace Belle2 {
  class TOPDigit : public DigitBase {
  public:
 
    enum EHitQuality {
      c_Junk = 0, // invalid feature extraction, pedestal jump, width too narrow/too wide
      c_Good = 1, // good photon hit
      c_CrossTalk = 3, // cross-talk
      c_CalPulse = 4,  // calibration pulse
      c_Uncalibrated = 5, // good photon hit, but no time-base or channel T0 calibration
      c_Masked = 6 // good photon hit, but channel is masked as dead or hot
    };
 
    enum EStatusBits {
      c_TimeBaseCalibrated =  1,
      c_ChannelT0Calibrated = 2,
      c_ModuleT0Calibrated =  4,
      c_CommonT0Calibrated =  8,
      c_FullyCalibrated = c_TimeBaseCalibrated | c_ChannelT0Calibrated | c_ModuleT0Calibrated | c_CommonT0Calibrated,
      c_OffsetSubtracted = 16,       // offset used in MC
      c_EventT0Subtracted = 32,
      c_BunchOffsetSubtracted = 64,  // reconstructed average bunch offset
    };
 
    enum EChargeShare {
      c_PrimaryChargeShare = 1, 
      c_SecondaryChargeShare = 2  
    };
 
    TOPDigit()
    {}
 
    TOPDigit(int moduleID, int pixelID, double rawTime):
      m_moduleID(moduleID),
      m_pixelID(pixelID),
      m_rawTime(rawTime),
      m_quality(c_Good)
    {}
 
    static void setDoubleHitResolution(double time) {s_doubleHitResolution = time;}
 
    static void setPileupTime(double time) {s_pileupTime = time;}
 
    void setModuleID(int moduleID) {m_moduleID = moduleID;}
 
    void setPixelID(int pixelID) {m_pixelID = pixelID;}
 
    void setChannel(unsigned int channel) {m_channel = channel;}
 
    void setRawTime(double rawTime) {m_rawTime = rawTime;}
 
    void setTime(double time) {m_time = time;}
 
    void setTimeError(double timeError) {m_timeError = timeError;}
 
    void setPulseHeight(int pulseHeight) {m_pulseHeight = pulseHeight;}
 
    void setPulseWidth(double width) {m_pulseWidth = width;}
 
    void setIntegral(int integral) {m_integral = integral;}
 
    void setFirstWindow(unsigned window) { m_firstWindow = window;}
 
    void setHitQuality(EHitQuality quality) {m_quality = quality;}
 
    void setStatus(unsigned short status) { m_status = status; }
 
    void addStatus(unsigned short bitmask) { m_status |= bitmask; }
 
    void removeStatus(unsigned short bitmask) { m_status &= (~bitmask); }
 
    void setPrimaryChargeShare() {m_chargeShare = c_PrimaryChargeShare;}
 
    void setSecondaryChargeShare() {m_chargeShare = c_SecondaryChargeShare;}
 
    void resetChargeShare() {m_chargeShare = 0;}
 
    void subtractT0(double t0) { m_time -= t0;}
 
    EHitQuality getHitQuality() const {return m_quality; }
 
    unsigned short getStatus() const {return m_status;}
 
    bool hasStatus(unsigned short bitmask) const
    {
      return (m_status & bitmask) == bitmask;
    }
 
    bool isCalibrated() const {return hasStatus(c_FullyCalibrated);}
 
    bool isTimeBaseCalibrated() const {return hasStatus(c_TimeBaseCalibrated);}
 
    bool isChannelT0Calibrated() const {return hasStatus(c_ChannelT0Calibrated);}
 
    bool isModuleT0Calibrated() const {return hasStatus(c_ModuleT0Calibrated);}
 
    bool isCommonT0Calibrated() const {return hasStatus(c_CommonT0Calibrated);}
 
    bool isChargeShare() const {return m_chargeShare != 0;}
 
    bool isPrimaryChargeShare() const {return m_chargeShare == c_PrimaryChargeShare;}
 
    bool isSecondaryChargeShare() const {return m_chargeShare == c_SecondaryChargeShare;}
 
    int getModuleID() const { return m_moduleID; }
 
    int getPixelID() const { return m_pixelID; }
 
    int getPixelRow() const { return (m_pixelID - 1) / 64 + 1;}
 
    int getPixelCol() const { return (m_pixelID - 1) % 64 + 1;}
 
    int getPMTRow() const {return (getPixelRow() - 1) / 4 + 1;}
 
    int getPMTCol() const {return (getPixelCol() - 1) / 4 + 1;}
 
    int getPMTNumber() const {return getPMTCol() + (getPMTRow() - 1) * 16;}
 
    int getPMTPixelRow() const {return (getPixelRow() - 1) % 4 + 1;}
 
    int getPMTPixelCol() const {return (getPixelCol() - 1) % 4 + 1;}
 
    int getPMTPixel() const {return getPMTPixelCol() + (getPMTPixelRow() - 1) * 4;}
 
    unsigned int getChannel() const { return m_channel; }
 
    unsigned int getASICChannel() const {return m_channel & 0x07;}
 
    unsigned int getASICNumber() const {return (m_channel >> 3) & 0x03;}
 
    unsigned int getCarrierNumber() const {return (m_channel >> 5) & 0x03;}
 
    unsigned int getBoardstackNumber() const {return (m_channel >> 7) & 0x03;}
 
    double getRawTime() const { return m_rawTime; }
 
    int getModulo256Sample() const;
 
    double getTime() const { return m_time; }
 
    double getTimeError() const {return m_timeError;}
 
    int getPulseHeight() const { return m_pulseHeight; }
 
    double getPulseWidth() const { return m_pulseWidth; }
 
    int getIntegral() const {return m_integral;}
 
    unsigned getFirstWindow() const { return m_firstWindow;}
 
    unsigned int getUniqueChannelID() const override {return m_pixelID + (m_moduleID << 16);}
 
    DigitBase::EAppendStatus addBGDigit(const DigitBase* bg) override;
 
 
  private:
    int m_moduleID = 0;       
    int m_pixelID = 0;        
    unsigned m_channel = 0;   
    float m_rawTime = 0;      
    float m_time = 0;         
    float m_timeError = 0;    
    int m_pulseHeight = 0;    
    float m_pulseWidth = 0;   
    int m_integral = 0;       
    unsigned short m_firstWindow = 0; 
    EHitQuality m_quality = c_Junk;  
    unsigned short m_status = 0; 
    unsigned short m_chargeShare = 0; 
    static float s_doubleHitResolution; 
    static float s_pileupTime; 
    ClassDefOverride(TOPDigit, 15); 
  };
 
 
} // end namespace Belle2