TagVertex.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 <Math/Vector3D.h>
#include <TMatrixDSym.h>
#include <string>
 
namespace Belle2 {
  class MCParticle;
  class Particle;

 
  class TagVertex : public RelationsObject {
 
  public:

    TagVertex()
      : m_tagVertex(ROOT::Math::XYZVector(0, 0, 0))
    {
      m_tagVertexPval = 0;
      m_deltaT = 0;
      m_deltaTErr = 0;
      m_mcDeltaTau = 0;
      m_mcDeltaT = 0;
      m_mcPDG = 0;
      resetTagVertexErrorMatrix();
      resetConstraintCov();
      m_FitType = 0;
      m_NTracks = -1;
      m_tagVl = 0;
      m_tagVlErr = 0;
      m_tagVol = 0;
      m_tagVolErr = 0;
      m_truthTagVl = 0;
      m_truthTagVol = 0;
      m_tagVNDF = 0;
      m_tagVChi2 = 0;
      m_tagVChi2IP = 0;
      m_NFitTracks = 0;
      m_constraintType = "";
      m_constraintCenter = ROOT::Math::XYZVector(0, 0, 0);
      m_fitTruthStatus = 0;
      m_rollbackStatus = 0;
    }
 
    // get methods

    ROOT::Math::XYZVector getTagVertex() const;

    TMatrixDSym getTagVertexErrMatrix() const;

    float getTagVertexPval() const;

    const Particle* getVtxFitParticle(unsigned int trackIndex) const;

    const MCParticle* getVtxFitMCParticle(unsigned int trackIndex) const;

    float getDeltaT() const;

    float getDeltaTErr() const;

    ROOT::Math::XYZVector getMCTagVertex() const;

    int getMCTagBFlavor() const;

    float getMCDeltaTau() const;

    float getMCDeltaT() const;

    int getFitType() const;

    const std::string& getConstraintType() const;

    int getNTracks() const;

    int getNFitTracks() const;

    float getTagVl() const;

    float getTruthTagVl() const;

    float getTagVlErr() const;

    float getTagVol() const;

    float getTruthTagVol() const;

    float getTagVolErr() const;

    float getTagVNDF() const;

    float getTagVChi2() const;

    float getTagVChi2IP() const;

 
    ROOT::Math::XYZVector getConstraintCenter() const;

 
    TMatrixDSym getConstraintCov() const;

 
    ROOT::Math::XYZVector getVtxFitTrackP(unsigned int trackIndex) const;

 
    double getVtxFitTrackZ0(unsigned int trackIndex) const;

 
    double getVtxFitTrackD0(unsigned int trackIndex) const;

 
    double getRaveWeight(unsigned int trackIndex) const;

    int getFitTruthStatus() const;

    int getRollBackStatus() const;
 
    // set methods

    void setTagVertex(const ROOT::Math::XYZVector& TagVertex);

    void setTagVertexErrMatrix(const TMatrixDSym& TagVertexErrMatrix);

    void setTagVertexPval(float TagVertexPval);

    void setDeltaT(float DeltaT);

    void setDeltaTErr(float DeltaTErr);

    void setMCTagVertex(const ROOT::Math::XYZVector& mcTagVertex);

    void setMCTagBFlavor(int mcTagBFlavor);

    void setMCDeltaTau(float mcDeltaTau);

    void setMCDeltaT(float mcDeltaT);

    void setFitType(float FitType) ;

    void setNTracks(int nTracks) ;

    void setTagVl(float TagVl) ;

    void setTruthTagVl(float TruthTagVl) ;

    void setTagVlErr(float TagVlErr) ;

    void setTagVol(float TagVol) ;

    void setTruthTagVol(float TruthTagVol) ;

    void setTagVolErr(float TagVolErr) ;

    void setTagVNDF(float TagVNDF) ;

    void setTagVChi2(float TagVChi2) ;

    void setTagVChi2IP(float TagVChi2IP) ;

    void setVertexFitParticles(const std::vector<const Particle*>& vtxFitParticles);

    void setVertexFitMCParticles(const std::vector<const MCParticle*>& vtxFitMCParticles);

    void setRaveWeights(const std::vector<double>& raveWeights);

 
    void setConstraintCenter(const ROOT::Math::XYZVector& constraintCenter);

 
    void setConstraintCov(const TMatrixDSym& constraintCov);

 
    void setConstraintType(const std::string& constraintType);

    void setFitTruthStatus(int truthStatus);

    void setRollBackStatus(int backStatus);
 
  private:
    ROOT::Math::XYZVector m_tagVertex;  
    TMatrixDSym m_tagVertexErrMatrix;   
    float m_tagVertexPval;              
    float m_deltaT;                     
    float m_deltaTErr;                  
    ROOT::Math::XYZVector m_mcTagV;     
    int m_mcPDG;                        
    float m_mcDeltaTau;                 
    float m_mcDeltaT;                   
    int m_FitType;                      
    int m_NTracks;                      
    float m_tagVl;                      
    float m_truthTagVl;                 
    float m_tagVlErr;                   
    float m_tagVol;                     
    float m_truthTagVol;                
    float m_tagVolErr;                  
    float m_tagVNDF;                    
    float m_tagVChi2;                   
    float m_tagVChi2IP;                 
    std::vector<const Particle*> m_vtxFitParticles; 
    std::vector<const MCParticle*> m_vtxFitMCParticles; 
    int m_NFitTracks;                   
    std::vector<double> m_raveWeights;  
    std::string m_constraintType;       
    ROOT::Math::XYZVector m_constraintCenter;      
    TMatrixDSym m_constraintCov;        
    int m_fitTruthStatus;               
    int m_rollbackStatus;               
 

    void resetTagVertexErrorMatrix();

    void resetConstraintCov();
 
    ClassDef(TagVertex, 7) 
 
  };

} // end namespace Belle2