ECLCalDigit.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 <ecl/dataobjects/ECLDsp.h>
 
namespace Belle2 {
  class ECLCalDigit : public RelationsObject {
  public:
 
    enum StatusBit {
      c_IsEnergyCalibrated = 1 << 0,
      c_IsTimeCalibrated = 1 << 1,
      c_IsTimeResolutionCalibrated = 1 << 2,
      c_IsFailedFit = 1 << 3,
      c_IsFailedTimeResolution = 1 << 4,
      c_IsCalibrated = c_IsEnergyCalibrated | c_IsTimeCalibrated | c_IsTimeResolutionCalibrated,
    };
 
    ECLCalDigit()
    {
      m_CellId         = 0; 
      m_Time           = 0; 
      m_TimeResolution = 0; 
      m_Energy         = 0; 
      m_Status         = 0; 
      m_TwoComponentTotalEnergy = 0; 
      m_TwoComponentHadronEnergy = 0; 
      m_TwoComponentDiodeEnergy = 0; 
      m_TwoComponentChi2 = -1; 
      m_TwoComponentSavedChi2[0] = -1;  
      m_TwoComponentSavedChi2[1] = -1;  
      m_TwoComponentSavedChi2[2] = -1;  
      m_TwoComponentFitType = ECLDsp::poorChi2; 
    }
 
    void setCellId(int CellId) { m_CellId = CellId; }
 
    void setEnergy(double Energy) { m_Energy = Energy; }
 
    void setTwoComponentTotalEnergy(double Energy) { m_TwoComponentTotalEnergy = Energy; }
 
    void setTwoComponentHadronEnergy(double Energy) { m_TwoComponentHadronEnergy = Energy; }
 
    void setTwoComponentDiodeEnergy(double Energy) { m_TwoComponentDiodeEnergy = Energy; }
 
    void setTwoComponentChi2(double chi) { m_TwoComponentChi2 = chi; }
 
    void setTwoComponentSavedChi2(ECLDsp::TwoComponentFitType FitTypeIn, double input)
    {
      unsigned int index = FitTypeIn ;
      m_TwoComponentSavedChi2[index] = input;
    }
 
    void setTwoComponentFitType(ECLDsp::TwoComponentFitType ft) { m_TwoComponentFitType = ft; }
 
    void setTime(double Time) { m_Time = Time; }
 
    void setTimeResolution(double TimeResolution) { m_TimeResolution = TimeResolution; }
 
    void setStatus(unsigned short int status) { m_Status = status; }
 
    void addStatus(unsigned short int bitmask) { m_Status |= bitmask; }
 
    void removeStatus(unsigned short int bitmask) { m_Status &= (~bitmask); }
 
    int getCellId() const { return m_CellId; }
 
    double getEnergy() const { return m_Energy; }
 
    double getTwoComponentTotalEnergy() const { return m_TwoComponentTotalEnergy; }
 
    double getTwoComponentHadronEnergy() const { return m_TwoComponentHadronEnergy; }
 
    double getTwoComponentDiodeEnergy() const { return m_TwoComponentDiodeEnergy; }
 
    double getTwoComponentChi2() const { return m_TwoComponentChi2; }
 
    double getTwoComponentSavedChi2(ECLDsp::TwoComponentFitType FitTypeIn) const
    {
      unsigned int index = FitTypeIn ;
      return m_TwoComponentSavedChi2[index];
    }
 
    ECLDsp::TwoComponentFitType getTwoComponentFitType() const { return m_TwoComponentFitType; }
 
    double getTime() const { return m_Time; }
 
    double getTimeResolution() const { return m_TimeResolution; }
 
    bool hasStatus(unsigned short int bitmask) const { return (m_Status & bitmask) == bitmask; }
 
    bool isCalibrated() const;
 
    bool isEnergyCalibrated() const;
 
    bool isTimeCalibrated() const;
 
    bool isTimeResolutionCalibrated() const;
 
    bool isFailedFit() const;
 
    bool isTimeResolutionFailed() const;
 
  private:
 
    int m_CellId;   
    double m_Time;   
    double m_TimeResolution;   
    double m_Energy; 
    unsigned short int m_Status;   
    double m_TwoComponentTotalEnergy;  
    double m_TwoComponentHadronEnergy; 
    double m_TwoComponentDiodeEnergy; 
    double m_TwoComponentChi2; 
    double m_TwoComponentSavedChi2[3]; 
    ECLDsp::TwoComponentFitType m_TwoComponentFitType;  
    // 1: first version (TF)
    // 2: added m_TimeResolution (TF)
    // 3: added status bits for failed fits (TF)
    // 4: added offline fit variables (SL)
    // 5: added diode and pile-up photon offline fit hypothesis (SL)
    // 6: added m_TwoComponentSavedChi2[3] to save chi2 for each fit tried (SL)
    ClassDef(ECLCalDigit, 6); 
  };
 
  // inline isCalibrated
  inline bool ECLCalDigit::isCalibrated() const
  {
    return hasStatus(c_IsCalibrated);
  }
 
  // inline isEnergyCalibrated
  inline bool ECLCalDigit::isEnergyCalibrated() const
  {
    return hasStatus(c_IsEnergyCalibrated);
  }
 
  // inline isTimeCalibrated
  inline bool ECLCalDigit::isTimeCalibrated() const
  {
    return hasStatus(c_IsTimeCalibrated);
  }
 
  // inline isTimeResolutionCalibrated
  inline bool ECLCalDigit::isTimeResolutionCalibrated() const
  {
    return hasStatus(c_IsTimeResolutionCalibrated);
  }
 
  // inline isFailedFit
  inline bool ECLCalDigit::isFailedFit() const
  {
    return hasStatus(c_IsFailedFit);
  }
 
  // inline isTimeResolutionFailed
  inline bool ECLCalDigit::isTimeResolutionFailed() const
  {
    return hasStatus(c_IsFailedTimeResolution);
  }
 
 
} // end namespace Belle2