ECLCluster.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016  Belle II Collaboration                              *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Torben Ferber (ferber@physics.ubc.ca)                    *
 *               Guglielmo De Nardo (denardo@na.infn.it)                  *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/datastore/RelationsObject.h>
 
#include <TVector3.h>
#include <TMatrixDSym.h>
 
#include <cmath>
 
namespace Belle2 {
  class ECLCluster : public RelationsObject {
  public:
 
    enum class EHypothesisBit : short unsigned int {
      c_none = 1 << 0,
      c_muonNPhotons = 1 << 1,
      c_chargedHadron = 1 << 2,
      c_electronNPhotons = 1 << 3,
      c_nPhotons = 1 << 4,
      c_neutralHadron = 1 << 5,
      c_mergedPi0 = 1 << 6
    };
 
    enum class EStatusBit : short unsigned int {
      c_TriggerCluster   = 1 << 0,
      c_TriggerClusterMatching = 1 << 1,
      c_PulseShapeDiscrimination = 1 << 2,
      c_fitTimeFailed = 1 << 3,
      c_timeResolutionFailed = 1 << 4,
 
    };
 
    ECLCluster() :
      m_isTrack(false),
      m_status(0),
      m_hypotheses(static_cast<unsigned short>(EHypothesisBit::c_nPhotons)), // set to c_nPhotons for b2bii
      m_maxECellId(0),
      m_connectedRegionId(0),
      m_clusterId(0),
      m_sqrtcovmat_00(0.),
      m_covmat_10(0.),
      m_sqrtcovmat_11(0.),
      m_covmat_20(0.),
      m_covmat_21(0.),
      m_sqrtcovmat_22(0.),
      m_deltaL(0.),
      m_minTrkDistance(0.),
      m_absZernike40(0.),
      m_absZernike51(0.),
      m_zernikeMVA(0.),
      m_E1oE9(0.),
      m_E9oE21(0.),
      m_secondMoment(0.),
      m_LAT(0.),
      m_numberOfCrystals(0.),
      m_time(0.),
      m_deltaTime99(0.),
      m_theta(0.),
      m_phi(0.),
      m_r(0.),
      m_logEnergy(-5.),
      m_logEnergyRaw(-5.),
      m_logEnergyHighestCrystal(-5.),
      m_PulseShapeDiscriminationMVA(0.5),
      m_ClusterHadronIntensity(0.),
      m_NumberOfHadronDigits(0.) {}
 
    void setIsTrack(bool istrack) { m_isTrack = istrack; }
 
    void setStatus(EStatusBit status) { m_status = static_cast<short unsigned>(status); }
 
    void addStatus(EStatusBit bitmask) { m_status |= static_cast<short unsigned>(bitmask); }
 
    void removeStatus(EStatusBit bitmask) { m_status &= (~static_cast<short unsigned>(bitmask)); }
 
    void setHypothesis(EHypothesisBit hypothesis) { m_hypotheses = static_cast<short unsigned>(hypothesis); }
 
    void addHypothesis(EHypothesisBit bitmask) { m_hypotheses |= static_cast<short unsigned>(bitmask); }
 
    void removeHypothesis(EHypothesisBit bitmask) { m_hypotheses &= (~static_cast<short unsigned>(bitmask)); }
 
    void setMaxECellId(unsigned short cellid) {m_maxECellId = cellid;}
 
    void setConnectedRegionId(int crid) { m_connectedRegionId = crid; }
 
    void setClusterId(int clusterid) { m_clusterId = clusterid; }
 
    void setCovarianceMatrix(double covArray[6])
    {
      m_sqrtcovmat_00 = sqrt(fabs(covArray[0])); // energy
      m_covmat_10 = covArray[1];
      m_sqrtcovmat_11 = sqrt(fabs(covArray[2])); // phi
      m_covmat_20 = covArray[3];
      m_covmat_21 = covArray[4];
      m_sqrtcovmat_22 = sqrt(fabs(covArray[5])); // theta
    }
 
    void setUncertaintyEnergy(double energyunc) { m_sqrtcovmat_00 = fabs(energyunc); }
 
    void setUncertaintyTheta(double thetaunc) { m_sqrtcovmat_22 = fabs(thetaunc); }
 
    void setUncertaintyPhi(double phiunc) { m_sqrtcovmat_11 = fabs(phiunc); }
 
    void setdeltaL(double deltaL) { m_deltaL = deltaL; }
 
    void setMinTrkDistance(double distance) { m_minTrkDistance = distance; }
 
    void setAbsZernike40(double zernike40) { m_absZernike40 = zernike40; }
 
    void setAbsZernike51(double zernike51) { m_absZernike51 = zernike51; }
 
    void setZernikeMVA(double zernikemva) { m_zernikeMVA = zernikemva; }
 
    void setE1oE9(double E1oE9) { m_E1oE9 = E1oE9; }
 
    void setE9oE21(double E9oE21) { m_E9oE21 = E9oE21; }
 
    [[deprecated("will be removed in release-04.")]]
    void setClusterHadronIntensity(double ClusterHadronIntensity) { m_ClusterHadronIntensity = ClusterHadronIntensity; }
 
    void setPulseShapeDiscriminationMVA(double PulseShapeDiscriminationMVA) { m_PulseShapeDiscriminationMVA = PulseShapeDiscriminationMVA; }
 
    void setNumberOfHadronDigits(double NumberOfHadronDigits) { m_NumberOfHadronDigits = NumberOfHadronDigits; }
 
    void setSecondMoment(double secondmoment) { m_secondMoment = secondmoment; }
 
    void setLAT(double LAT) { m_LAT = LAT; }
 
    void setNumberOfCrystals(double noc) { m_numberOfCrystals = noc; }
 
    void setTime(double time) { m_time = time; }
 
    void setDeltaTime99(double dtime99) { m_deltaTime99 = dtime99; }
 
    void setTheta(double theta) { m_theta = theta; }
 
    void setPhi(double phi) { m_phi = phi; }
 
    void setR(double r) { m_r = r; }
 
    void setEnergy(double energy) { m_logEnergy = log(energy); }
 
    void setEnergyRaw(double energyraw) { m_logEnergyRaw = log(energyraw); }
 
    void setEnergyHighestCrystal(double energyhighestcrystal) { m_logEnergyHighestCrystal = log(energyhighestcrystal); }
 
    bool isTrack() const { return m_isTrack; }
 
    bool isNeutral() const { return !m_isTrack; }
 
    unsigned short getStatus() const {return m_status;}
 
    unsigned short getHypotheses() const {return m_hypotheses;}
 
    unsigned short getMaxECellId() const {return m_maxECellId;}
 
    int getConnectedRegionId() const {return m_connectedRegionId;}
 
    [[deprecated("Please use hasHypothesis().")]]
    int getHypothesisId() const
    {
      if (hasHypothesis(EHypothesisBit::c_nPhotons)) return 5;
      else if (hasHypothesis(EHypothesisBit::c_neutralHadron)) return 6;
      else return 0;
    }
 
    int getClusterId() const {return m_clusterId;}
 
    double getMinTrkDistance() const { return m_minTrkDistance; }
 
    double getDeltaL() const { return m_deltaL; }
 
    double getAbsZernike40() const { return m_absZernike40; }
 
    double getAbsZernike51() const { return m_absZernike51; }
 
    double getZernikeMVA() const { return m_zernikeMVA; }
 
    double getE1oE9() const { return m_E1oE9; }
 
    double getE9oE21() const { return m_E9oE21; }
 
    [[deprecated("will be removed in release-04.")]]
    double getClusterHadronIntensity() const { return m_ClusterHadronIntensity; }
 
    double getPulseShapeDiscriminationMVA() const { return m_PulseShapeDiscriminationMVA; }
 
    double getNumberOfHadronDigits() const { return m_NumberOfHadronDigits; }
 
    double getSecondMoment() const { return m_secondMoment; }
 
    double getLAT() const {return m_LAT;}
 
    double getNumberOfCrystals() const {return m_numberOfCrystals;}
 
    double getTime() const {return m_time;}
 
    double getDeltaTime99() const {return m_deltaTime99;}
 
    double getPhi() const { return m_phi;}
 
    double getTheta() const {return m_theta;}
 
    double getR() const { return m_r; }
 
    double getEnergy(const EHypothesisBit& hypothesis) const;
 
    double getEnergyRaw() const {return exp(m_logEnergyRaw);}
 
    double getEnergyHighestCrystal() const {return exp(m_logEnergyHighestCrystal);}
 
    double getUncertaintyEnergy() const {return (m_sqrtcovmat_00);}
 
    double getUncertaintyTheta() const {return (m_sqrtcovmat_22);}
 
    double getUncertaintyPhi() const { return (m_sqrtcovmat_11);}
 
    TVector3 getClusterPosition() const;
 
    TMatrixDSym getCovarianceMatrix3x3() const;
 
    int getDetectorRegion() const;
 
    [[deprecated("will be removed in release-04.")]]
    int getUniqueId() const;
 
    bool hasStatus(EStatusBit bitmask) const { return (m_status & static_cast<short unsigned>(bitmask)) == static_cast<short unsigned>(bitmask); }
 
    bool hasHypothesis(EHypothesisBit bitmask) const { return (m_hypotheses & static_cast<short unsigned>(bitmask)) == static_cast<short unsigned>(bitmask); }
 
    bool isTriggerCluster() const {return hasStatus(EStatusBit::c_TriggerCluster);}
 
    bool hasTriggerClusterMatching() const {return hasStatus(EStatusBit::c_TriggerClusterMatching);}
 
    bool hasPulseShapeDiscrimination() const {return hasStatus(EStatusBit::c_PulseShapeDiscrimination);}
 
    bool hasFailedFitTime() const {return hasStatus(EStatusBit::c_fitTimeFailed);}
 
    bool hasFailedTimeResolution() const {return hasStatus(EStatusBit::c_timeResolutionFailed);}
 
 
  private:
 
    bool m_isTrack;
 
    unsigned short m_status;
 
    unsigned short m_hypotheses;
 
    unsigned short m_maxECellId;
 
    int m_connectedRegionId;
 
    int m_clusterId;
 
    //Covariance matrix:
    //       E    phi   theta
    // E     00   01    02
    // phi   10   11    12
    // theta 20   21    22
    Double32_t m_sqrtcovmat_00; //[0.0, 0.3, 10]
 
    Double32_t m_covmat_10; //[0.0, 10., 12]
 
    Double32_t m_sqrtcovmat_11; //[0.0, 0.05, 8]
 
    Double32_t m_covmat_20; //[0.0, 10., 12]
 
    Double32_t m_covmat_21; //[0.0, 10., 12]
 
    Double32_t m_sqrtcovmat_22; //[0.0, 0.050, 8]
 
    Double32_t  m_deltaL;  //[-250, 250., 10]
 
    Double32_t  m_minTrkDistance;  //[0.0, 250., 10]
 
    Double32_t  m_absZernike40;  //[0.0, 1.7, 10]
 
    Double32_t  m_absZernike51;  //[0.0, 1.2, 10]
 
    Double32_t  m_zernikeMVA;  //[0.0, 1., 10]
 
    Double32_t  m_E1oE9;  //[0.0, 1., 10]
 
    Double32_t  m_E9oE21;  //[0.0, 1., 10]
 
    Double32_t  m_secondMoment;  //[0.0, 40.0, 10]
 
    Double32_t  m_LAT;  //[0.0, 1., 10]
 
    Double32_t  m_numberOfCrystals;  //[0.0, 200.0, 10]
 
    Double32_t  m_time;  //[-1000.0, 1000.0, 12]
 
    Double32_t  m_deltaTime99;  //[0.0, 1000.0, 12]
 
    Double32_t  m_theta;  //[0.0, pi, 16]
 
    Double32_t  m_phi;  //[-pi, pi, 16]
 
    Double32_t  m_r;  //[75.0, 300.0, 16]
 
    Double32_t  m_logEnergy;  //[-5, 3., 18]
 
    Double32_t  m_logEnergyRaw;  //[-5, 3., 18]
 
    Double32_t  m_logEnergyHighestCrystal;  //[-5, 3., 18]
 
    Double32_t  m_PulseShapeDiscriminationMVA;  //[0.0, 1.0, 18]
 
    Double32_t  m_ClusterHadronIntensity;  //[-0.1, 0.8, 18]
 
    Double32_t m_NumberOfHadronDigits;  //[0, 255, 18]
 
    ClassDef(ECLCluster, 14);
    // 14: Added m_maxECellId
    // 13: Added m_hypotheses
    // 12: Added m_PulseShapeDiscriminationMVA. Indicated that m_ClusterHadronIntensity will be removed in release-04.
    // 11: Added m_ClusterHadronIntensity an m_NumberOfHadronDigits variables
    // 10: Added status enum, added status setter
    // 9: Removed all momentum, 4x4, and 7x7 covariance matrix getters.
    // 8: Added clusterId, getUniqueId
    // 7: Changed range of SecondMoment from 0..100 to 0..40
    // 6: Changed stored variances to sqrt(covmat_ii).
    // 5: New HypothesisId default, removed relative covariance entries, renamed some setters/getters, adjusted covariance variable ranges.
    // 4: Complete revision and new variables. Introduction of Double32_t. Some new setters and getters.
 
  };
 
}// end namespace Belle2