deep_helpers.h

Go to the documentation of this file.

#ifndef RecoBTag_FeatureTools_deep_helpers_h
#define RecoBTag_FeatureTools_deep_helpers_h

#include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"
#include "DataFormats/BTauReco/interface/TaggingVariable.h"

#include "TrackingTools/IPTools/interface/IPTools.h"

#include "DataFormats/BTauReco/interface/CandIPTagInfo.h"

#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h"
//#include "RecoVertex/VertexTools/interface/VertexDistanceXY.h"

#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "DataFormats/PatCandidates/interface/Jet.h"

namespace btagbtvdeep {

  // remove infs and NaNs with value  (adapted from DeepNTuples)
  const float catch_infs(const float in,
             const float replace_value = 0.);

  // remove infs/NaN and bound (adapted from DeepNTuples)
  const float catch_infs_and_bound(const float in,
                   const float replace_value,
                   const float lowerbound,
                   const float upperbound,
                   const float offset=0.,
                   const bool use_offsets = true);

  // 2D distance between SV and PV (adapted from DeepNTuples)
  Measurement1D vertexDxy(const reco::VertexCompositePtrCandidate &svcand, const reco::Vertex &pv);

  //3D distance between SV and PV (adapted from DeepNTuples)
  Measurement1D vertexD3d(const reco::VertexCompositePtrCandidate &svcand, const reco::Vertex &pv);

  // dot product between SV and PV (adapted from DeepNTuples)
  float vertexDdotP(const reco::VertexCompositePtrCandidate &sv, const reco::Vertex &pv);

  // helper to order vertices by significance (adapted from DeepNTuples)
  template < typename SVType, typename PVType>
    bool sv_vertex_comparator(const SVType & sva, const SVType & svb, const PVType & pv) {
    auto adxy = vertexDxy(sva,pv);
    auto bdxy = vertexDxy(svb,pv);
    float aval= adxy.value();
    float bval= bdxy.value();
    float aerr= adxy.error();
    float berr= bdxy.error();

    float asig= catch_infs(aval/aerr,0.);
    float bsig= catch_infs(bval/berr,0.);
    return bsig<asig;
  }

  // write tagging variables to vector (adapted from DeepNTuples)
  template <typename T>
    int dump_vector(reco::TaggingVariableList& from, T* to,
            reco::btau::TaggingVariableName name, const size_t max) {
    std::vector<T> vals = from.getList(name ,false);
    size_t size=std::min(vals.size(),max);
    if(size > 0){
      for(size_t i=0;i<vals.size();i++){
        to[i]=catch_infs(vals[i],-0.1);
      }
    }
    return size;
  }

  // compute minimum dr between SVs and a candidate (from DeepNTuples, now polymorphic)
  float mindrsvpfcand(const std::vector<reco::VertexCompositePtrCandidate> & svs,
                      const reco::Candidate* cand, float mindr=0.4);

  // mimic the calculation in PackedCandidate
  float vtx_ass_from_pfcand(const reco::PFCandidate &pfcand, int pv_ass_quality, const reco::VertexRef & pv);
  float quality_from_pfcand(const reco::PFCandidate &pfcand);
  float lost_inner_hits_from_pfcand(const reco::PFCandidate &pfcand);
}
#endif //RecoBTag_FeatureTools_deep_helpers_h