CDCTriggerTrack.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.                  *
 **************************************************************************/
#ifndef CDCTRIGGERTRACK_H
#define CDCTRIGGERTRACK_H
 
#include <framework/dataobjects/Helix.h>
#include <framework/geometry/BFieldManager.h>
 
namespace Belle2 {

  class CDCTriggerTrack : public Helix {
  public:
    CDCTriggerTrack(): Helix(), m_chi2D(0.), m_chi3D(0.), m_time(0), m_quadrant(-1), m_foundoldtrack(6, false), m_driftthreshold(9,
          false), m_valstereobit(false), m_expert(-1), m_tsvector(9, 0), m_qualityvector(0) { }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
    CDCTriggerTrack(double phi0, double omega, double chi2,
                    const std::vector<bool>& foundoldtrack,
                    const std::vector<bool>& driftthreshold,
                    bool valstereobit = false,
                    int expert = -1,
                    short time = 0,
                    short quadrant = -1):
      Helix(0., phi0, omega, 0., 0.), m_chi2D(chi2), m_chi3D(0.),
      m_time(time),
      m_quadrant(quadrant),
      m_foundoldtrack(foundoldtrack),
      m_driftthreshold(driftthreshold),
      m_valstereobit(valstereobit),
      m_expert(expert),
      m_tsvector(9, 0),
      m_qualityvector(0) { }
 
    CDCTriggerTrack(double phi0, double omega, double chi2,
                    short time = 0,
                    short quadrant = -1):
      Helix(0., phi0, omega, 0., 0.), m_chi2D(chi2), m_chi3D(0.),
      m_time(time),
      m_quadrant(quadrant),
      m_foundoldtrack(6, false),
      m_driftthreshold(9, false),
      m_valstereobit(false),
      m_expert(-1),
      m_tsvector(9, 0),
      m_qualityvector(0) { }

    CDCTriggerTrack(double phi0, double omega, double chi2D,
                    double z0, double cotTheta, double chi3D,
                    const std::vector<bool>& foundoldtrack = std::vector<bool>(6, false),
                    const std::vector<bool>& driftthreshold = std::vector<bool>(9, false),
                    bool valstereobit = false,
                    int expert = -1,
                    const std::vector<unsigned>& tsvector = std::vector<unsigned>(9, 0),
                    short time = 0, short quadrant = -1,
                    unsigned qualityvector = 0):
      Helix(0., phi0, omega, z0, cotTheta), m_chi2D(chi2D), m_chi3D(chi3D), m_time(time), m_quadrant(quadrant),
      m_foundoldtrack(foundoldtrack),
      m_driftthreshold(driftthreshold),
      m_valstereobit(valstereobit),
      m_expert(expert),
      m_tsvector(tsvector),
      m_qualityvector(qualityvector),
      m_etf_unpacked(0),
      m_etf_recalced(0) { }
 

    CDCTriggerTrack(double phi0, double omega, double chi2D,
                    double z0, double cotTheta, double prob, double chi3D,
                    const std::vector<bool>& foundoldtrack = std::vector<bool>(6, false),
                    const std::vector<bool>& driftthreshold = std::vector<bool>(9, false),
                    bool valstereobit = false,
                    int expert = -1,
                    const std::vector<unsigned>& tsvector = std::vector<unsigned>(9, 0),
                    short time = 0, short quadrant = -1,
                    unsigned qualityvector = 0):
      Helix(0., phi0, omega, z0, cotTheta), m_prob(prob), m_chi2D(chi2D), m_chi3D(chi3D), m_time(time), m_quadrant(quadrant),
      m_foundoldtrack(foundoldtrack),
      m_driftthreshold(driftthreshold),
      m_valstereobit(valstereobit),
      m_expert(expert),
      m_tsvector(tsvector),
      m_qualityvector(qualityvector),
      m_etf_unpacked(0),
      m_etf_recalced(0) { }
 
 

    ~CDCTriggerTrack() { }
 
    // accessors
    float getChi2D() const { return m_chi2D; }
    float getChi3D() const { return m_chi3D; }
    float getTime() const { return m_time; }
    double getPt() const
    {
      const double bField = BFieldManager::getField(0, 0, getZ0()).Z() / Unit::T;
      return getTransverseMomentum(bField);
    }

    short getQuadrant() const
    {
      return m_quadrant;
    }

    std::vector<bool> getFoundOldTrack() const {return m_foundoldtrack;}

    bool getValidStereoBit() const {return m_valstereobit;}

    std::vector<bool> getDriftThreshold() const {return m_driftthreshold;}

    int getExpert() const {return m_expert;}

    std::vector<unsigned> getTSVector() const {return m_tsvector;}
    void setQualityVector(const unsigned newbits)
    {
      m_qualityvector = m_qualityvector ^ newbits;
    }
 
    unsigned getQualityVector() const {return m_qualityvector;}
    void setHasETFTime(bool x) {m_hasETFTime = x;}
    bool getHasETFTime() const {return m_hasETFTime;}
    int getETF_unpacked() const {return m_etf_unpacked;}
    int getETF_recalced() const {return m_etf_recalced;}
    void setETF_unpacked(int x) {m_etf_unpacked = x;}
    void setETF_recalced(int x) {m_etf_recalced = x;}
    void setRawPhi0(const int phi0)
    {
      m_rawphi0 = phi0;
    }
    void setRawOmega(const int omega)
    {
      m_rawomega = omega;
    }
    void setRawZ(const int z)
    {
      m_rawz = z;
    }
    void setRawTheta(const int theta)
    {
      m_rawtheta = theta;
    }
    void setRawInput(const std::vector<int> input)
    {
      m_rawinput = input;
    }
    void setProb(const float input)
    {
      m_prob = input;
    }
    void setNNTToGDL(const bool nntgdl)
    {
      m_nntgdl = nntgdl;
    }
    void setSTTToGDL(const bool sttgdl)
    {
      m_sttgdl = sttgdl;
    }
    int getRawPhi0() const {return m_rawphi0;}
    int getRawOmega() const {return m_rawomega;}
    int getRawZ() const {return m_rawz;}
    int getRawTheta() const {return m_rawtheta;}
    double getProb() const {return m_prob;}
    std::vector<int> getRawInput() const {return m_rawinput;}
    bool getNNTToGDL() const {return m_nntgdl;}
    bool getSTTToGDL() const {return m_sttgdl;}
 
  protected:
    double m_prob;
 
    float m_chi2D;
    float m_chi3D;
    short m_time;
    short m_quadrant;
    std::vector<bool> m_foundoldtrack;
    std::vector<bool> m_driftthreshold;
    bool m_valstereobit;
    int m_expert;
    std::vector<unsigned> m_tsvector;
    unsigned m_qualityvector;
    int m_etf_unpacked{0};
    int m_etf_recalced{0};
    bool m_hasETFTime{0};
    int m_rawphi0{0};
    int m_rawomega{0};
    int m_rawz{0};
    int m_rawtheta{0};
    std::vector<int> m_rawinput;
    bool m_nntgdl{0};
    bool m_sttgdl{0};
    ClassDef(CDCTriggerTrack, 14);
 
  };

}
#endif