TrackPairInfoBuilder.cc

Go to the documentation of this file.

#include "RecoBTag/FeatureTools/interface/TrackPairInfoBuilder.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"

namespace btagbtvdeep{

     TrackPairInfoBuilder::TrackPairInfoBuilder(): 

        track_pt_(0),
        track_eta_(0),
        track_phi_(0),
        track_dz_(0),
        track_dxy_(0),
                
        pca_distance_(0),
        pca_significance_(0),
        
        pcaSeed_x_(0),
        pcaSeed_y_(0),
        pcaSeed_z_(0),
        pcaSeed_xerr_(0),
        pcaSeed_yerr_(0),
        pcaSeed_zerr_(0),
        pcaTrack_x_(0),
        pcaTrack_y_(0),
        pcaTrack_z_(0),
        pcaTrack_xerr_(0),
        pcaTrack_yerr_(0),
        pcaTrack_zerr_(0),
        
        dotprodTrack_(0),
        dotprodSeed_(0),
        pcaSeed_dist_(0),
        pcaTrack_dist_(0),
        
        track_candMass_(0),
        track_ip2d_(0),
        track_ip2dSig_(0),
        track_ip3d_(0),
        track_ip3dSig_(0),
        
        dotprodTrackSeed2D_(0),
        dotprodTrackSeed2DV_(0),
        dotprodTrackSeed3D_(0),
        dotprodTrackSeed3DV_(0),
        
        pca_jetAxis_dist_(0),
        pca_jetAxis_dotprod_(0),
        pca_jetAxis_dEta_(0),
        pca_jetAxis_dPhi_(0)
        
{

}


    void TrackPairInfoBuilder::buildTrackPairInfo(const reco::TransientTrack * it , const reco::TransientTrack * tt, const reco::Vertex & pv, float mass, GlobalVector jetdirection, 
                                                  const std::pair<bool,Measurement1D> & t_ip, const std::pair<bool,Measurement1D> & t_ip2d  )
    {
        
        GlobalPoint pvp(pv.x(),pv.y(),pv.z());
        
        VertexDistance3D distanceComputer;
        TwoTrackMinimumDistance dist;
        
        auto const& iImpactState = it->impactPointState();
        auto const& tImpactState = tt->impactPointState();
        
        if(dist.calculate(tImpactState,iImpactState)) {
            
            GlobalPoint ttPoint          = dist.points().first;
            GlobalError ttPointErr       = tImpactState.cartesianError().position();
            GlobalPoint seedPosition     = dist.points().second;
            GlobalError seedPositionErr  = iImpactState.cartesianError().position();
            
            Measurement1D m = distanceComputer.distance(VertexState(seedPosition,seedPositionErr), VertexState(ttPoint, ttPointErr));
            
            GlobalPoint cp(dist.crossingPoint()); 

            GlobalVector pairMomentum((Basic3DVector<float>) (it->track().momentum()+tt->track().momentum()));
            GlobalVector pvToPCA(cp-pvp);

            float pvToPCAseed = (seedPosition-pvp).mag();
            float pvToPCAtrack = (ttPoint-pvp).mag();
            float distance = dist.distance();

            GlobalVector trackDir2D(tImpactState.globalDirection().x(),tImpactState.globalDirection().y(),0.); 
            GlobalVector seedDir2D(iImpactState.globalDirection().x(),iImpactState.globalDirection().y(),0.); 
            GlobalVector trackPCADir2D(ttPoint.x()-pvp.x(),ttPoint.y()-pvp.y(),0.);
            GlobalVector seedPCADir2D(seedPosition.x()-pvp.x(),seedPosition.y()-pvp.y(),0.);

            float dotprodTrack = (ttPoint-pvp).unit().dot(tImpactState.globalDirection().unit());
            float dotprodSeed = (seedPosition-pvp).unit().dot(iImpactState.globalDirection().unit());

            Line::PositionType pos(pvp);
            Line::DirectionType dir(jetdirection);
            Line::DirectionType pairMomentumDir(pairMomentum);
            Line jetLine(pos,dir);   
            Line PCAMomentumLine(cp,pairMomentumDir);

           
            track_pt_=tt->track().pt();
            track_eta_=tt->track().eta();
            track_phi_=tt->track().phi();
            track_dz_=tt->track().dz(pv.position());
            track_dxy_=tt->track().dxy(pv.position());


            pca_distance_=distance;
            pca_significance_=m.significance();

            pcaSeed_x_=seedPosition.x();
            pcaSeed_y_=seedPosition.y();
            pcaSeed_z_=seedPosition.z();
            pcaSeed_xerr_=seedPositionErr.cxx();
            pcaSeed_yerr_=seedPositionErr.cyy();
            pcaSeed_zerr_=seedPositionErr.czz();
            pcaTrack_x_=ttPoint.x();
            pcaTrack_y_=ttPoint.y();
            pcaTrack_z_=ttPoint.z();
            pcaTrack_xerr_=ttPointErr.cxx();
            pcaTrack_yerr_=ttPointErr.cyy();
            pcaTrack_zerr_=ttPointErr.czz();

            dotprodTrack_=dotprodTrack;
            dotprodSeed_=dotprodSeed;
            pcaSeed_dist_=pvToPCAseed;
            pcaTrack_dist_=pvToPCAtrack;

            track_candMass_=mass;  
            track_ip2d_=t_ip2d.second.value();
            track_ip2dSig_=t_ip2d.second.significance();
            track_ip3d_=t_ip.second.value();
            track_ip3dSig_=t_ip.second.significance();

            dotprodTrackSeed2D_=trackDir2D.unit().dot(seedDir2D.unit());
            dotprodTrackSeed3D_=iImpactState.globalDirection().unit().dot(tImpactState.globalDirection().unit());
            dotprodTrackSeed2DV_=trackPCADir2D.unit().dot(seedPCADir2D.unit());
            dotprodTrackSeed3DV_=(seedPosition-pvp).unit().dot((ttPoint-pvp).unit());

            pca_jetAxis_dist_=jetLine.distance(cp).mag();
            pca_jetAxis_dotprod_=pairMomentum.unit().dot(jetdirection.unit());
            pca_jetAxis_dEta_=std::fabs(pvToPCA.eta()-jetdirection.eta());
            pca_jetAxis_dPhi_=std::fabs(pvToPCA.phi()-jetdirection.phi());


    }
    }
    
    
}