release-05-02-19/doxygen/TagVertexModule_8h_source.html

/**************************************************************************

 * BASF2 (Belle Analysis Framework 2)                                     *

 * Copyright(C) 2014 - Belle II Collaboration                             *

 *                                                                        *

 * Author: The Belle II Collaboration                                     *

 * Contributors: Luigi Li Gioi, Thibaud Humair                            *

 *                                                                        *

 * This software is provided "as is" without any warranty.                *

 **************************************************************************/


#pragma once


#include <framework/core/Module.h>


// DataStore

#include <framework/database/DBObjPtr.h>


// Rave

#include <analysis/VertexFitting/RaveInterface/RaveSetup.h>

#include <analysis/VertexFitting/RaveInterface/RaveVertexFitter.h>

#include <analysis/VertexFitting/RaveInterface/RaveKinematicVertexFitter.h>


// KFit

#include <CLHEP/Geometry/Point3D.h>

#include <CLHEP/Matrix/SymMatrix.h>

#include <CLHEP/Vector/LorentzVector.h>


// DataObjects

#include <mdst/dataobjects/Track.h>

#include <mdst/dataobjects/TrackFitResult.h>

#include <analysis/dataobjects/FlavorTaggerInfo.h>

#include <mdst/dbobjects/BeamSpot.h>

#include <mdst/dataobjects/MCParticle.h>


#include <string>

#include <vector>


namespace Belle2 {

  class Particle;

  struct ParticleAndWeight;


  class TagVertexModule : public Module {


  public:


    TagVertexModule();


    virtual void initialize() override;


    virtual void beginRun() override;


    virtual void event() override;


    const BeamSpot& getBeamSpot() const { return *m_beamSpotDB; }


  private:


    //std::string m_EventType;      /**< Btag decay type */

    std::string m_listName;

    double m_confidenceLevel;

    std::string m_useMCassociation;

    //std::string m_useFitAlgorithm;    /**< Choose constraint: from Breco or tube in the boost direction w/wo cut */

    std::string m_constraintType;

    std::string m_trackFindingType;

    int m_reqPXDHits;

    std::string m_roeMaskName;

    double m_Bfield;

    std::vector<const Particle*> m_tagParticles;

    std::vector<const Particle*> m_raveParticles;

    std::vector<double> m_raveWeights;

    std::vector<const MCParticle*>

    m_raveMCParticles;

    bool m_useTruthInFit;

    int m_fitTruthStatus;

    bool m_useRollBack;

    int m_rollbackStatus;

    double m_fitPval;

    TVector3 m_tagV;

    TMatrixDSym m_tagVErrMatrix;

    TVector3 m_mcTagV;

    double   m_mcTagLifeTime;

    int m_mcPDG;

    TVector3 m_mcVertReco;

    double m_mcLifeTimeReco;

    double m_deltaT;

    double m_deltaTErr;

    double m_mcDeltaTau;

    double m_mcDeltaT;

    TMatrixDSym m_constraintCov;

    TVector3 m_constraintCenter;

    TVector3 m_BeamSpotCenter;

    TMatrixDSym m_BeamSpotCov;

    bool m_mcInfo;

    double m_shiftZ;

    DBObjPtr<BeamSpot> m_beamSpotDB;

    int m_FitType;

    double m_tagVl;

    double m_truthTagVl;

    double m_tagVlErr;

    double m_tagVol;

    double m_truthTagVol;

    double m_tagVolErr;

    double m_tagVNDF;

    double m_tagVChi2;

    double m_tagVChi2IP;

    std::string m_fitAlgo;

    bool m_verbose;

    TMatrixDSym m_pvCov;

    TLorentzVector m_tagMomentum;

    bool doVertexFit(const Particle* Breco);


    Particle* doVertexFitForBTube(const Particle* mother, std::string fitType) const;


    std::pair<TVector3, TMatrixDSym> findConstraint(const Particle* Breco, double cut) const;


    std::pair<TVector3, TMatrixDSym> findConstraintBoost(double cut, double shiftAlongBoost = -2000.) const;


    std::pair<TVector3, TMatrixDSym> findConstraintBTube(const Particle* Breco, double cut);


    void BtagMCVertex(const Particle* Breco);


    static bool compBrecoBgen(const Particle* Breco, const MCParticle* Bgen);


    std::vector<const Particle*> getTagTracks_standardAlgorithm(const Particle* Breco, int nPXDHits) const;


    std::vector<ParticleAndWeight> getParticlesWithoutKS(const std::vector<const Particle*>& tagParticles,

                                                         double massWindowWidth = 0.01) const;


    //bool makeSemileptonicFit(Particle *Breco);


    bool makeGeneralFit();


    bool makeGeneralFitRave();


    void fillParticles(std::vector<ParticleAndWeight>& particleAndWeights);


    void fillTagVinfo(const TVector3& tagVpos, const TMatrixDSym& tagVposErr);


    bool makeGeneralFitKFit();


    void deltaT(const Particle* Breco);


    void resetReturnParams();


    static std::string printVector(const TVector3& vec);


    static std::string printMatrix(const TMatrixD& mat);


    static std::string printMatrix(const TMatrixDSym& mat);


    TrackFitResult getTrackWithTrueCoordinates(ParticleAndWeight const& paw) const;


    static TVector3 getTruePoca(ParticleAndWeight const& paw);


    TrackFitResult getTrackWithRollBackCoordinates(ParticleAndWeight const& paw);


    TVector3 getRollBackPoca(ParticleAndWeight const& paw);

  };


  struct ParticleAndWeight {

    double weight;

    const Particle* particle;

    const MCParticle* mcParticle;

  };


}