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 <framework/geometry/B2Vector3.h>
#include <TMatrixDSym.h>
#include <string>
 
// DataObjects
#include <mdst/dataobjects/MCParticle.h>
#include <analysis/dataobjects/Particle.h>
 
namespace Belle2 {
  class TagVertex : public RelationsObject {
 
  public:
 
    TagVertex()
    {
      m_tagVertex(0) = 0; m_tagVertex(1) = 0; m_tagVertex(2) = 0;
      m_tagVertexPval = 0;
      m_deltaT = 0;
      m_deltaTErr = 0;
      m_mcDeltaTau = 0;
      m_mcDeltaT = 0;
      m_mcTagV(0) = 0; m_mcTagV(1) = 0; m_mcTagV(2) = 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(0) = 0; m_constraintCenter(1) = 0, m_constraintCenter(2) = 0;
      m_fitTruthStatus = 0;
      m_rollbackStatus = 0;
    }
 
    // get methods
 
    B2Vector3D 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;
 
    B2Vector3D getMCTagVertex() const;
 
    int getMCTagBFlavor() const;
 
    float getMCDeltaTau() const;
 
    float getMCDeltaT() const;
 
    int getFitType() 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;
 
    B2Vector3D 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 B2Vector3D& TagVertex);
 
    void setTagVertexErrMatrix(const TMatrixDSym& TagVertexErrMatrix);
 
    void setTagVertexPval(float TagVertexPval);
 
    void setDeltaT(float DeltaT);
 
    void setDeltaTErr(float DeltaTErr);
 
    void setMCTagVertex(const B2Vector3D& 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 B2Vector3D& constraintCenter);
 
    void setConstraintCov(const TMatrixDSym& constraintCov);
 
    void setConstraintType(const std::string& constraintType);
 
    void setFitTruthStatus(int truthStatus);
 
    void setRollBackStatus(int backStatus);
 
  private:
    B2Vector3D m_tagVertex;             
    TMatrixDSym m_tagVertexErrMatrix;   
    float m_tagVertexPval;              
    float m_deltaT;                     
    float m_deltaTErr;                  
    B2Vector3D 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;       
    B2Vector3D m_constraintCenter;      
    TMatrixDSym m_constraintCov;        
    int m_fitTruthStatus;               
    int m_rollbackStatus;               
    void resetTagVertexErrorMatrix();
 
    void resetConstraintCov();
 
    ClassDef(TagVertex, 6) 
  };
 
} // end namespace Belle2