TagVertexModule.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/core/Module.h>
 
// framework - DataStore
#include <framework/database/DBObjPtr.h>
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.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 <analysis/dataobjects/Particle.h>
#include <analysis/dataobjects/ParticleList.h>
#include <analysis/dataobjects/TagVertex.h>
#include <mdst/dataobjects/Track.h>
#include <mdst/dataobjects/TrackFitResult.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:
 
    StoreArray<TagVertex> m_verArray; 
    StoreArray<MCParticle> m_mcParticles; 
    StoreObjPtr<ParticleList> m_plist; 
    //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;  
  };
 
}