ECLDsp.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 ECLDsp : public RelationsObject {
  public:
 
    enum TwoComponentFitType {
      poorChi2 = -1,  
      photonHadron = 0,  
      photonHadronBackgroundPhoton = 1,  
      photonDiodeCrossing = 2  
    };
 
    ECLDsp() : m_DspAVector(31, 0) {}
 
    ECLDsp(int CellId, int NADCPoints, int* ADCData)
    {
      m_CellId     = CellId;
      m_DspAVector.assign(ADCData, ADCData + NADCPoints);
    }
 
    ECLDsp(int CellId, const std::vector<int>& ADCData) :
      m_CellId(CellId), m_DspAVector(ADCData) {}
 
    void setCellId(int CellId) { m_CellId = CellId; }
 
    void setDspA(int  DspArray[31])
    {
      m_DspAVector.assign(DspArray, DspArray + 31);
    }
 
    void setDspA(const std::vector <int>& DspArrayVector)
    {
      m_DspAVector = DspArrayVector;
    }
 
    void setTwoComponentTotalAmp(double input) {  m_TwoComponentTotalAmp = input; }
 
    void setTwoComponentHadronAmp(double input) { m_TwoComponentHadronAmp = input; }
 
    void setTwoComponentDiodeAmp(double input) { m_TwoComponentDiodeAmp = input; }
 
    void setTwoComponentChi2(double input) { m_TwoComponentChi2 = input; }
 
    void setTwoComponentSavedChi2(TwoComponentFitType FitTypeIn, double input)
    {
      unsigned int index = FitTypeIn ;
      m_TwoComponentSavedChi2[index] = input;
    }
 
    void setTwoComponentTime(double input) { m_TwoComponentTime = input; }
 
    void setTwoComponentBaseline(double input) {  m_TwoComponentBaseline = input; }
 
    void setbackgroundPhotonEnergy(double input) {  m_backgroundPhotonEnergy = input; }
 
    void setbackgroundPhotonTime(double input) {  m_backgroundPhotonTime = input; }
 
    void setTwoComponentFitType(TwoComponentFitType ft) { m_TwoComponentFitType = ft; }
 
    int getCellId() const { return m_CellId; }
 
    void getDspA(int  DspArray[31]) const
    {
      for (int i = 0; i < 31; i++)
        DspArray[i] = m_DspAVector[i];
    }
 
 
    double getTwoComponentTotalAmp() const { return m_TwoComponentTotalAmp;}
 
    double getTwoComponentHadronAmp() const { return m_TwoComponentHadronAmp; }
 
    double getTwoComponentDiodeAmp() const { return m_TwoComponentDiodeAmp; }
 
    double getTwoComponentChi2() const { return m_TwoComponentChi2; }
 
    double getTwoComponentSavedChi2(TwoComponentFitType FitTypeIn) const
    {
      unsigned int index = FitTypeIn ;
      return m_TwoComponentSavedChi2[index];
    }
 
    double getTwoComponentTime() const { return m_TwoComponentTime; }
 
    double getTwoComponentBaseline() const { return m_TwoComponentBaseline; }
 
    TwoComponentFitType getTwoComponentFitType() const { return m_TwoComponentFitType; }
 
    double getbackgroundPhotonEnergy() const { return m_backgroundPhotonEnergy; }
 
    double getbackgroundPhotonTime() const { return m_backgroundPhotonTime; }
 
    std::vector <int> getDspA() const
    {
      return m_DspAVector;
    }
 
    int computePeaktoPeakAmp() const
    {
      const auto [min, max] = std::minmax_element(m_DspAVector.begin(), m_DspAVector.end());
      return *max - *min;
    }
 
    int getNADCPoints() const
    {
      return m_DspAVector.size();
    }
 
    static ECLDsp* getByCellID(int cid);
 
  private:
 
    int m_CellId{0};                      
    double m_TwoComponentTotalAmp{ -1};   
    double m_TwoComponentHadronAmp{ -1};  
    double m_TwoComponentDiodeAmp{ -1};   
    double m_TwoComponentChi2{ -1};       
    double m_TwoComponentSavedChi2[3] = { -1, -1, -1}; 
    double m_TwoComponentTime{1};         
    double m_TwoComponentBaseline{1};     
    double m_backgroundPhotonEnergy{ -1}; 
    double m_backgroundPhotonTime{ -1};   
    TwoComponentFitType m_TwoComponentFitType{poorChi2};  
    std::vector <int> m_DspAVector;       
    ClassDef(ECLDsp, 6);
 
  };
 
} // end namespace Belle2