TagVertex.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2014-2019 - Belle II Collaboration                        *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Luigi Li Gioi, Stefano Lacaprara, Thibaud Humair         *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/datastore/RelationsObject.h>
 
#include <TVector3.h>
#include <TMatrixDSym.h>
#include <string>
 
// DataObjects
#include <mdst/dataobjects/TrackFitResult.h>
#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_constraintType = "";
      m_constraintCenter(0) = 0; m_constraintCenter(1) = 0, m_constraintCenter(2) = 0;
      m_fitTruthStatus = 0;
      m_rollbackStatus = 0;
    }
 
    // get methods
 
    TVector3 getTagVertex();
 
    TMatrixDSym getTagVertexErrMatrix();
 
    float getTagVertexPval();
 
    const Particle* getVtxFitParticle(unsigned int trackIndex);
 
    const MCParticle* getVtxFitMCParticle(unsigned int trackIndex);
 
    float getDeltaT();
 
    float getDeltaTErr();
 
    TVector3 getMCTagVertex();
 
    int getMCTagBFlavor();
 
    float getMCDeltaTau();
 
    float getMCDeltaT();
 
    int getFitType() ;
 
    std::string getConstraintType();
 
    int getNTracks() ;
 
    int getNFitTracks() ;
 
    float getTagVl() ;
 
    float getTruthTagVl() ;
 
    float getTagVlErr() ;
 
    float getTagVol() ;
 
    float getTruthTagVol() ;
 
    float getTagVolErr() ;
 
    float getTagVNDF() ;
 
    float getTagVChi2() ;
 
    float getTagVChi2IP() ;
 
    TVector3 getConstraintCenter();
 
    TMatrixDSym getConstraintCov();
 
    TVector3 getVtxFitTrackPosition(unsigned int trackIndex);
 
    TVector3 getVtxFitTrackP(unsigned int trackIndex);
 
    double getVtxFitTrackPComponent(unsigned int trackIndex, unsigned int component);
 
    double getVtxFitTrackZ0(unsigned int trackIndex);
 
    double getVtxFitTrackD0(unsigned int trackIndex);
 
    double getRaveWeight(unsigned int trackIndex);
 
    int getFitTruthStatus();
 
    int getRollBackStatus();
 
    // set methods
 
    void setTagVertex(const TVector3& TagVertex);
 
    void setTagVertexErrMatrix(const TMatrixDSym& TagVertexErrMatrix);
 
    void setTagVertexPval(float TagVertexPval);
 
    void setDeltaT(float DeltaT);
 
    void setDeltaTErr(float DeltaTErr);
 
    void setMCTagVertex(const TVector3& 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 TVector3& constraintCenter);
 
    void setConstraintCov(const TMatrixDSym& constraintCov);
 
    void setConstraintType(const std::string& constraintType);
 
    void setFitTruthStatus(int truthStatus);
 
    void setRollBackStatus(int backStatus);
 
  private:
    TVector3 m_tagVertex;               
    TMatrixDSym m_tagVertexErrMatrix;   
    float m_tagVertexPval;              
    float m_deltaT;                     
    float m_deltaTErr;                  
    TVector3 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;       
    TVector3 m_constraintCenter;        
    TMatrixDSym m_constraintCov;        
    int m_fitTruthStatus;               
    int m_rollbackStatus;               
    void resetTagVertexErrorMatrix();
 
    void resetConstraintCov();
 
    ClassDef(TagVertex, 5) 
  };
 
} // end namespace Belle2