ECLTRGInformation.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2018 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Torben Ferber (torben.ferber@desy.de)                    *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/logging/Logger.h>
 
namespace Belle2 {
  class ECLTRGInformation : public TObject {
 
  public:
 
    static constexpr int c_nTCs = 576;
 
    ECLTRGInformation() :
      m_thetaIdTC(c_nTCs + 1),
      m_phiIdTC(c_nTCs + 1),
      m_energyTC(c_nTCs + 1),
      m_timingTC(c_nTCs + 1),
      m_revoGDLTC(c_nTCs + 1),
      m_revoFAMTC(c_nTCs + 1),
      m_hitWinTC(c_nTCs + 1),
      m_energyTCECLCalDigit(c_nTCs + 1),
      m_timingTCECLCalDigit(c_nTCs + 1),
      m_clusterEnergyThreshold(0.),
      m_sumEnergyTCECLCalDigitInECLCluster(0.),
      m_sumEnergyECLCalDigitInECLCluster(0.),
      m_evtTiming(std::numeric_limits<float>::quiet_NaN()),
      m_maximumTCId(-1)
    {
      // some vectors should not be initialized with zeroes but with NaN
      for (unsigned idx = 0; idx <= c_nTCs; idx++) {
        m_timingTC[idx] = std::numeric_limits<float>::quiet_NaN();
        m_timingTCECLCalDigit[idx] = std::numeric_limits<float>::quiet_NaN();
        m_hitWinTC[idx] = std::numeric_limits<int>::quiet_NaN();
      }
    }
 
    void setThetaIdTC(const int& tcid, const int& tcthetaid)
    {
      if (tcid > 0 and tcid <= c_nTCs + 1) {
        m_thetaIdTC[tcid] = tcthetaid;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    void setPhiIdTC(const int& tcid, const int& tcphiid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        m_phiIdTC[tcid] = tcphiid;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    void setEnergyTC(const int& tcid, const float& tcenergy)
    {
      if (tcid >= 1 and tcid < c_nTCs + 1) {
        m_energyTC[tcid] = tcenergy;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    void setTimingTC(const int& tcid, const float& tctiming)
    {
      if (tcid >= 1 and tcid < c_nTCs + 1) {
        m_timingTC[tcid] = tctiming;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    void setEvtTiming(float evttiming) { m_evtTiming = evttiming; }
 
    void setRevoGDLTC(const int& tcid, const float& tcrevotrg)
    {
      if (tcid >= 1 and tcid < c_nTCs + 1) {
        m_revoGDLTC[tcid] = tcrevotrg;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    void setRevoFAMTC(const int& tcid, const float& tcrevofam)
    {
      if (tcid >= 1 and tcid < c_nTCs + 1) {
        m_revoFAMTC[tcid] = tcrevofam;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    void setHitWinTC(const int& tcid, const int& hitwin)
    {
      if (tcid >= 1 and tcid < c_nTCs + 1) {
        m_hitWinTC[tcid] = hitwin;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    int getPhiIdTC(const int& tcid)
    {
      if (tcid >= 1 and tcid < c_nTCs + 1) {
        return m_phiIdTC[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    int getThetaIdTC(const int& tcid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        return m_thetaIdTC[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    float getEnergyTC(const int& tcid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        return m_energyTC[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    float getTimingTC(const int& tcid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        return m_timingTC[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    float getRevoGDLTC(const int& tcid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        return m_revoGDLTC[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    float getRevoFAMTC(const int& tcid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        return m_revoFAMTC[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    float getHitWinTC(const int& tcid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        return m_hitWinTC[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    void setEnergyTCECLCalDigit(const int& tcid, const float& tcenergy)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        m_energyTCECLCalDigit[tcid] = tcenergy;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    float getEnergyTCECLCalDigit(const int& tcid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        return m_energyTCECLCalDigit[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    void setTimingTCECLCalDigit(const int& tcid, const float& tctiming)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        m_timingTCECLCalDigit[tcid] = tctiming;
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
      }
    }
 
    float getTimingTCECLCalDigit(const int& tcid)
    {
      if (tcid > 0 and tcid < c_nTCs + 1) {
        return m_timingTCECLCalDigit[tcid];
      } else {
        B2ERROR("TC " << tcid << " does not exist.");
        return 0.;
      }
    }
 
    void setClusterEnergyThreshold(float thresh) { m_clusterEnergyThreshold = thresh; }
 
    float getClusterEnergyThreshold() const
    {
      return m_clusterEnergyThreshold;
    }
 
    void setSumEnergyTCECLCalDigitInECLCluster(float sumenergy) { m_sumEnergyTCECLCalDigitInECLCluster = sumenergy; }
 
    float getSumEnergyTCECLCalDigitInECLCluster() const
    {
      return m_sumEnergyTCECLCalDigitInECLCluster;
    }
 
    void setSumEnergyECLCalDigitInECLCluster(float sumenergy) { m_sumEnergyECLCalDigitInECLCluster = sumenergy; }
 
    float getSumEnergyECLCalDigitInECLCluster() const
    {
      return m_sumEnergyECLCalDigitInECLCluster;
    }
 
    float getEvtTiming() const
    {
      return m_evtTiming;
    }
 
    void setMaximumTCId(int maxtcid) { m_maximumTCId = maxtcid; }
 
    int getMaximumTCId() const
    {
      return m_maximumTCId;
    }
 
  private:
 
    std::vector<int>
    m_thetaIdTC; 
    std::vector<int>
    m_phiIdTC; 
    std::vector<float> m_energyTC; 
    std::vector<float> m_timingTC; 
    std::vector<float> m_revoGDLTC; 
    std::vector<float> m_revoFAMTC; 
    std::vector<int> m_hitWinTC; 
    std::vector<float> m_energyTCECLCalDigit; 
    std::vector<float>
    m_timingTCECLCalDigit; 
    float m_clusterEnergyThreshold; 
    float m_sumEnergyTCECLCalDigitInECLCluster; 
    float m_sumEnergyECLCalDigitInECLCluster; 
    float m_evtTiming; 
    int m_maximumTCId; 
    ClassDef(ECLTRGInformation, 3); 
  };
 
} // end namespace Belle2