ConversionFinder.cc

Go to the documentation of this file.

#include "RecoEgamma/EgammaTools/interface/ConversionFinder.h"
#include "DataFormats/Math/interface/deltaR.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "TMath.h"

namespace egammaTools {

typedef math::XYZTLorentzVector LorentzVector;

ConversionInfo getConversionInfo(const reco::Track *el_track,
                                 const reco::Track *candPartnerTk,
                                 const double bFieldAtOrigin);

const reco::Track* getElectronTrack(const reco::GsfElectron &, const float minFracSharedHits = 0.45);

const reco::Track* getElectronTrack(const reco::GsfElectronCore &, const float minFracSharedHits = 0.45);

bool isFromConversion(const ConversionInfo &convInfo,
        double maxAbsDist, double maxAbsDcot)
{
  return (std::abs(convInfo.dist) < maxAbsDist) && (std::abs(convInfo.dcot) < maxAbsDcot);
}

//-----------------------------------------------------------------------------
ConversionInfo getConversionInfo(const reco::GsfElectron& gsfElectron,
                                const edm::Handle<reco::TrackCollection>& ctftracks_h,
                                const edm::Handle<reco::GsfTrackCollection>& gsftracks_h,
                                const double bFieldAtOrigin,
                                const double minFracSharedHits) {

  std::vector<ConversionInfo> temp = getConversionInfos(*gsfElectron.core(),ctftracks_h,gsftracks_h,bFieldAtOrigin,minFracSharedHits) ;
  return findBestConversionMatch(temp);

}
//-----------------------------------------------------------------------------
ConversionInfo getConversionInfo(const reco::GsfElectronCore& gsfElectron,
                            const edm::Handle<reco::TrackCollection>& ctftracks_h,
                            const edm::Handle<reco::GsfTrackCollection>& gsftracks_h,
                            const double bFieldAtOrigin,
                            const double minFracSharedHits) {

  std::vector<ConversionInfo> temp = getConversionInfos(gsfElectron,ctftracks_h,gsftracks_h,bFieldAtOrigin,minFracSharedHits) ;
  return findBestConversionMatch(temp);

}


//-----------------------------------------------------------------------------
std::vector<ConversionInfo> getConversionInfos(const reco::GsfElectronCore& gsfElectron,
                                const edm::Handle<reco::TrackCollection>& ctftracks_h,
                                const edm::Handle<reco::GsfTrackCollection>& gsftracks_h,
                                const double bFieldAtOrigin,
                                const double minFracSharedHits) {



  using namespace reco;
  using namespace std;
  using namespace edm;


  //get the track collections
  const TrackCollection    *ctftracks   = ctftracks_h.product();
  const GsfTrackCollection *gsftracks   = gsftracks_h.product();

  //get the references to the gsf and ctf tracks that are made
  //by the electron
  const reco::TrackRef    el_ctftrack   = gsfElectron.ctfTrack();
  const reco::GsfTrackRef& el_gsftrack  = gsfElectron.gsfTrack();

  //protect against the wrong collection being passed to the function
  if(el_ctftrack.isNonnull() && el_ctftrack.id() != ctftracks_h.id())
    throw cms::Exception("ConversionFinderError") << "ProductID of ctf track collection does not match ProductID of electron's CTF track! \n";
  if(el_gsftrack.isNonnull() && el_gsftrack.id() != gsftracks_h.id())
    throw cms::Exception("ConversionFinderError") << "ProductID of gsf track collection does not match ProductID of electron's GSF track! \n";

  //make p4s for the electron's tracks for use later
  LorentzVector el_ctftrack_p4;
  if(el_ctftrack.isNonnull() && gsfElectron.ctfGsfOverlap() > minFracSharedHits)
    el_ctftrack_p4 = LorentzVector(el_ctftrack->px(), el_ctftrack->py(), el_ctftrack->pz(), el_ctftrack->p());
  LorentzVector el_gsftrack_p4(el_gsftrack->px(), el_gsftrack->py(), el_gsftrack->pz(), el_gsftrack->p());

  //the electron's CTF track must share at least 45% of the inner hits
  //with the electron's GSF track
  int ctfidx = -999.;
  int gsfidx = -999.;
  if(el_ctftrack.isNonnull() && gsfElectron.ctfGsfOverlap() > minFracSharedHits)
    ctfidx = static_cast<int>(el_ctftrack.key());

  gsfidx = static_cast<int>(el_gsftrack.key());


  //these vectors are for those candidate partner tracks that pass our cuts
  vector<ConversionInfo> v_candidatePartners;
  //track indices required to make references
  int ctftk_i = 0;
  int gsftk_i = 0;


  //loop over the CTF tracks and try to find the partner track
  for(TrackCollection::const_iterator ctftk = ctftracks->begin();
      ctftk != ctftracks->end(); ctftk++, ctftk_i++) {

    if(ctftk_i == ctfidx)
      continue;

    //candidate track's p4
    LorentzVector ctftk_p4 = LorentzVector(ctftk->px(), ctftk->py(), ctftk->pz(), ctftk->p());

    //apply quality cuts to remove bad tracks
    if(ctftk->ptError()/ctftk->pt() > 0.05)
      continue;
    if(ctftk->numberOfValidHits() < 5)
      continue;

    if(el_ctftrack.isNonnull() &&
       gsfElectron.ctfGsfOverlap() > minFracSharedHits &&
       fabs(ctftk_p4.Pt() - el_ctftrack->pt())/el_ctftrack->pt() < 0.2)
      continue;

    //use the electron's CTF track, if not null, to search for the partner track
    //look only in a cone of 0.5 to save time, and require that the track is opp. sign
    if(el_ctftrack.isNonnull() && gsfElectron.ctfGsfOverlap() > minFracSharedHits &&
       deltaR(el_ctftrack_p4, ctftk_p4) < 0.5 &&
       (el_ctftrack->charge() + ctftk->charge() == 0) ) {

      ConversionInfo convInfo = getConversionInfo((const reco::Track*)(el_ctftrack.get()), &(*ctftk), bFieldAtOrigin);

      //need to add the track reference information for completeness
      //because the overloaded fnc above does not make a trackRef
      int deltaMissingHits = ctftk->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS)
          - el_ctftrack->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);


      v_candidatePartners.push_back({convInfo.dist,
                                     convInfo.dcot,
                                     convInfo.radiusOfConversion,
                                     convInfo.pointOfConversion,
                                     TrackRef(ctftracks_h, ctftk_i),
                                     GsfTrackRef() ,
                                     deltaMissingHits,
                                     0});

    }//using the electron's CTF track


    //now we check using the electron's gsf track
    if(deltaR(el_gsftrack_p4, ctftk_p4) < 0.5 &&
       (el_gsftrack->charge() + ctftk->charge() == 0) &&
       el_gsftrack->ptError()/el_gsftrack->pt() < 0.25) {

      int deltaMissingHits = ctftk->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS)
          - el_gsftrack->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);

      ConversionInfo convInfo = getConversionInfo((const reco::Track*)(el_gsftrack.get()), &(*ctftk), bFieldAtOrigin);

      v_candidatePartners.push_back({convInfo.dist,
                                     convInfo.dcot,
                                     convInfo.radiusOfConversion,
                                     convInfo.pointOfConversion,
                                     TrackRef(ctftracks_h, ctftk_i),
                                     GsfTrackRef(),
                                     deltaMissingHits,
                                     1});
    }//using the electron's GSF track

  }//loop over the CTF track collection


  //------------------------------------------------------ Loop over GSF collection ----------------------------------//
  for(GsfTrackCollection::const_iterator gsftk = gsftracks->begin();
      gsftk != gsftracks->end(); gsftk++, gsftk_i++) {

    //reject the electron's own gsfTrack
    if(gsfidx == gsftk_i)
      continue;

    LorentzVector gsftk_p4 = LorentzVector(gsftk->px(), gsftk->py(), gsftk->pz(), gsftk->p());

    //apply quality cuts to remove bad tracks
    if(gsftk->ptError()/gsftk->pt() > 0.5)
      continue;
    if(gsftk->numberOfValidHits() < 5)
      continue;

    if(fabs(gsftk->pt() - el_gsftrack->pt())/el_gsftrack->pt() < 0.25)
      continue;

    //try using the electron's CTF track first if it exists
    //look only in a cone of 0.5 around the electron's track
    //require opposite sign
    if(el_ctftrack.isNonnull() && gsfElectron.ctfGsfOverlap() > minFracSharedHits &&
       deltaR(el_ctftrack_p4, gsftk_p4) < 0.5 &&
       (el_ctftrack->charge() + gsftk->charge() == 0)) {

      int deltaMissingHits = gsftk->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS)
          - el_ctftrack->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
      
      ConversionInfo convInfo = getConversionInfo((const reco::Track*)(el_ctftrack.get()), (const reco::Track*)(&(*gsftk)), bFieldAtOrigin);
      //fill the Ref info
      v_candidatePartners.push_back({convInfo.dist,
                                     convInfo.dcot,
                                     convInfo.radiusOfConversion,
                                     convInfo.pointOfConversion,
                                     TrackRef(),
                                     GsfTrackRef(gsftracks_h, gsftk_i),
                                     deltaMissingHits,
                                     2});
    }

    //use the electron's gsf track
    if(deltaR(el_gsftrack_p4, gsftk_p4) < 0.5 &&
       (el_gsftrack->charge() + gsftk->charge() == 0) &&
       (el_gsftrack->ptError()/el_gsftrack_p4.pt() < 0.5)) {
      ConversionInfo convInfo = getConversionInfo((const reco::Track*)(el_gsftrack.get()), (const reco::Track*)(&(*gsftk)), bFieldAtOrigin);
      //fill the Ref info

      int deltaMissingHits = gsftk->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS)
          - el_gsftrack->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);


      v_candidatePartners.push_back({convInfo.dist,
                                     convInfo.dcot,
                                     convInfo.radiusOfConversion,
                                     convInfo.pointOfConversion,
                                     TrackRef(),
                                     GsfTrackRef(gsftracks_h, gsftk_i),
                                     deltaMissingHits,
                                     3});
    }
  }//loop over the gsf track collection


  return v_candidatePartners;

}


//-------------------------------------------------------------------------------------
ConversionInfo getConversionInfo(const reco::Track *el_track,
                           const reco::Track *candPartnerTk,
                           const double bFieldAtOrigin) {

  using namespace reco;

  //now calculate the conversion related information
  LorentzVector el_tk_p4(el_track->px(), el_track->py(), el_track->pz(), el_track->p());
  double elCurvature = -0.3*bFieldAtOrigin*(el_track->charge()/el_tk_p4.pt())/100.;
  double rEl = fabs(1./elCurvature);
  double xEl = -1*(1./elCurvature - el_track->d0())*sin(el_tk_p4.phi());
  double yEl = (1./elCurvature - el_track->d0())*cos(el_tk_p4.phi());


  LorentzVector cand_p4 = LorentzVector(candPartnerTk->px(), candPartnerTk->py(),candPartnerTk->pz(), candPartnerTk->p());
  double candCurvature = -0.3*bFieldAtOrigin*(candPartnerTk->charge()/cand_p4.pt())/100.;
  double rCand = fabs(1./candCurvature);
  double xCand = -1*(1./candCurvature - candPartnerTk->d0())*sin(cand_p4.phi());
  double yCand = (1./candCurvature - candPartnerTk->d0())*cos(cand_p4.phi());

  double d = sqrt(pow(xEl-xCand, 2) + pow(yEl-yCand , 2));
  double dist = d - (rEl + rCand);
  double dcot = 1./tan(el_tk_p4.theta()) - 1./tan(cand_p4.theta());

  //get the point of conversion
  double xa1 = xEl   + (xCand-xEl) * rEl/d;
  double xa2 = xCand + (xEl-xCand) * rCand/d;
  double ya1 = yEl   + (yCand-yEl) * rEl/d;
  double ya2 = yCand + (yEl-yCand) * rCand/d;

  double x=.5*(xa1+xa2);
  double y=.5*(ya1+ya2);
  double rconv = sqrt(pow(x,2) + pow(y,2));
  double z = el_track->dz() + rEl*el_track->pz()*TMath::ACos(1-pow(rconv,2)/(2.*pow(rEl,2)))/el_track->pt();

  math::XYZPoint convPoint(x, y, z);

  //now assign a sign to the radius of conversion
  float tempsign = el_track->px()*x + el_track->py()*y;
  tempsign = tempsign/fabs(tempsign);
  rconv = tempsign*rconv;

  //return an instance of ConversionInfo, but with a NULL track refs
  return ConversionInfo{dist, dcot, rconv, convPoint, TrackRef(), GsfTrackRef(), -9999, -9999};

}

//-------------------------------------------------------------------------------------
const reco::Track* getElectronTrack(const reco::GsfElectron& electron, const float minFracSharedHits) {

  if(electron.closestCtfTrackRef().isNonnull() &&
     electron.shFracInnerHits() > minFracSharedHits)
    return (const reco::Track*)electron.closestCtfTrackRef().get();

  return (const reco::Track*)(electron.gsfTrack().get());
}

//------------------------------------------------------------------------------------

//takes in a vector of candidate conversion partners
//and arbitrates between them returning the one with the
//smallest R=sqrt(dist*dist + dcot*dcot)
ConversionInfo arbitrateConversionPartnersbyR(const std::vector<ConversionInfo>& v_convCandidates) {

  if(v_convCandidates.size() == 1)
    return v_convCandidates.at(0);

  double R = sqrt(pow(v_convCandidates.at(0).dist,2) + pow(v_convCandidates.at(0).dcot,2));

  int iArbitrated = 0;
  int i = 0;

  for(auto const& temp : v_convCandidates) {
    double temp_R = sqrt(pow(temp.dist,2) + pow(temp.dcot,2));
    if(temp_R < R) {
      R = temp_R;
      iArbitrated = i;
    }
    ++i;
  }

  return v_convCandidates.at(iArbitrated);

 }

//------------------------------------------------------------------------------------
ConversionInfo findBestConversionMatch(const std::vector<ConversionInfo>& v_convCandidates)
 {
  using namespace std;

  if(v_convCandidates.empty())
    return   ConversionInfo{-9999.,-9999.,-9999.,
                math::XYZPoint(-9999.,-9999.,-9999),
                reco::TrackRef(), reco::GsfTrackRef(),
                -9999, -9999};


  if(v_convCandidates.size() == 1)
    return v_convCandidates.at(0);

  vector<ConversionInfo> v_0;
  vector<ConversionInfo> v_1;
  vector<ConversionInfo> v_2;
  vector<ConversionInfo> v_3;
  //loop over the candidates
  for(unsigned int i = 1; i < v_convCandidates.size(); i++) {
    ConversionInfo temp = v_convCandidates.at(i);

    if(temp.flag == 0) {
      bool isConv = false;
      if(fabs(temp.dist) < 0.02 &&
     fabs(temp.dcot) < 0.02 &&
     temp.deltaMissingHits < 3 &&
     temp.radiusOfConversion > -2)
    isConv = true;
      if(sqrt(pow(temp.dist,2) + pow(temp.dcot,2)) < 0.05  &&
     temp.deltaMissingHits < 2 &&
     temp.radiusOfConversion > -2)
    isConv = true;

      if(isConv)
    v_0.push_back(temp);
    }

    if(temp.flag == 1) {

      if(sqrt(pow(temp.dist,2) + pow(temp.dcot,2)) < 0.05  &&
     temp.deltaMissingHits < 2 &&
     temp.radiusOfConversion > -2)
    v_1.push_back(temp);
    }
    if(temp.flag == 2) {

      if(sqrt(pow(temp.dist,2) + pow(temp.dcot*temp.dcot,2)) < 0.05 &&
     temp.deltaMissingHits < 2 &&
     temp.radiusOfConversion > -2)
    v_2.push_back(temp);

    }
    if(temp.flag == 3) {

      if(sqrt(temp.dist*temp.dist + temp.dcot*temp.dcot) < 0.05
     && temp.deltaMissingHits < 2
     && temp.radiusOfConversion > -2)
    v_3.push_back(temp);

    }

  }//candidate conversion loop

  //now do some arbitration

  //give preference to conversion partners found in the CTF collection
  //using the electron's CTF track
  if(!v_0.empty())
    return arbitrateConversionPartnersbyR(v_0);

  if(!v_1.empty())
    return arbitrateConversionPartnersbyR(v_1);

  if(!v_2.empty())
    return arbitrateConversionPartnersbyR(v_2);

  if(!v_3.empty())
    return arbitrateConversionPartnersbyR(v_3);


  //if we get here, we didn't find a candidate conversion partner that
  //satisfied even the loose selections
  //return the the closest partner by R
  return arbitrateConversionPartnersbyR(v_convCandidates);

 }




//------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------
// Exists here for backwards compatibility only. Provides only the dist and dcot
std::pair<double, double> getConversionInfo(LorentzVector trk1_p4,
                                  int trk1_q, float trk1_d0,
                                  LorentzVector trk2_p4,
                                  int trk2_q, float trk2_d0,
                                  float bFieldAtOrigin) {


  double tk1Curvature = -0.3*bFieldAtOrigin*(trk1_q/trk1_p4.pt())/100.;
  double rTk1 = fabs(1./tk1Curvature);
  double xTk1 = -1.*(1./tk1Curvature - trk1_d0)*sin(trk1_p4.phi());
  double yTk1 = (1./tk1Curvature - trk1_d0)*cos(trk1_p4.phi());


  double tk2Curvature = -0.3*bFieldAtOrigin*(trk2_q/trk2_p4.pt())/100.;
  double rTk2 = fabs(1./tk2Curvature);
  double xTk2 = -1.*(1./tk2Curvature - trk2_d0)*sin(trk2_p4.phi());
  double yTk2 = (1./tk2Curvature - trk2_d0)*cos(trk2_p4.phi());


  double dist = sqrt(pow(xTk1-xTk2, 2) + pow(yTk1-yTk2 , 2));
  dist = dist - (rTk1 + rTk2);

  double dcot = 1./tan(trk1_p4.theta()) - 1./tan(trk2_p4.theta());

  return std::make_pair(dist, dcot);

 }


//-------------------------------------- Also for backwards compatibility reasons  ---------------------------------------------------------------
ConversionInfo getConversionInfo(const reco::GsfElectron& gsfElectron,
                           const edm::Handle<reco::TrackCollection>& track_h,
                           const double bFieldAtOrigin,
                           const double minFracSharedHits) {


  using namespace reco;
  using namespace std;
  using namespace edm;


  const TrackCollection *ctftracks = track_h.product();
  const reco::TrackRef el_ctftrack = gsfElectron.closestCtfTrackRef();
  int ctfidx = -999.;
  int flag = -9999.;
  if(el_ctftrack.isNonnull() && gsfElectron.shFracInnerHits() > minFracSharedHits) {
    ctfidx = static_cast<int>(el_ctftrack.key());
    flag = 0;
  } else
    flag = 1;


  /*
    determine whether we're going to use the CTF track or the GSF track
    using the electron's CTF track to find the dist, dcot has been shown
    to reduce the inefficiency
  */
  const reco::Track* el_track = getElectronTrack(gsfElectron, minFracSharedHits);
  LorentzVector el_tk_p4(el_track->px(), el_track->py(), el_track->pz(), el_track->p());


  int tk_i = 0;
  double mindcot = 9999.;
  //make a null Track Ref
  TrackRef candCtfTrackRef = TrackRef() ;


  for(TrackCollection::const_iterator tk = ctftracks->begin();
      tk != ctftracks->end(); tk++, tk_i++) {
    //if the general Track is the same one as made by the electron, skip it
    if(tk_i == ctfidx)
      continue;

    LorentzVector tk_p4 = LorentzVector(tk->px(), tk->py(),tk->pz(), tk->p());

    //look only in a cone of 0.5
    double dR = deltaR(el_tk_p4, tk_p4);
    if(dR>0.5)
      continue;


    //require opp. sign -> Should we use the majority logic??
    if(tk->charge() + el_track->charge() != 0)
      continue;

    double dcot = fabs(1./tan(tk_p4.theta()) - 1./tan(el_tk_p4.theta()));
    if(dcot < mindcot) {
      mindcot = dcot;
      candCtfTrackRef = reco::TrackRef(track_h, tk_i);
    }
  }//track loop


  if(!candCtfTrackRef.isNonnull())
    return ConversionInfo{-9999.,-9999.,-9999.,
              math::XYZPoint(-9999.,-9999.,-9999),
              reco::TrackRef(), reco::GsfTrackRef(),
              -9999, -9999};



  //now calculate the conversion related information
  double elCurvature = -0.3*bFieldAtOrigin*(el_track->charge()/el_tk_p4.pt())/100.;
  double rEl = fabs(1./elCurvature);
  double xEl = -1*(1./elCurvature - el_track->d0())*sin(el_tk_p4.phi());
  double yEl = (1./elCurvature - el_track->d0())*cos(el_tk_p4.phi());


  LorentzVector cand_p4 = LorentzVector(candCtfTrackRef->px(), candCtfTrackRef->py(),candCtfTrackRef->pz(), candCtfTrackRef->p());
  double candCurvature = -0.3*bFieldAtOrigin*(candCtfTrackRef->charge()/cand_p4.pt())/100.;
  double rCand = fabs(1./candCurvature);
  double xCand = -1*(1./candCurvature - candCtfTrackRef->d0())*sin(cand_p4.phi());
  double yCand = (1./candCurvature - candCtfTrackRef->d0())*cos(cand_p4.phi());

  double d = sqrt(pow(xEl-xCand, 2) + pow(yEl-yCand , 2));
  double dist = d - (rEl + rCand);
  double dcot = 1./tan(el_tk_p4.theta()) - 1./tan(cand_p4.theta());

  //get the point of conversion
  double xa1 = xEl   + (xCand-xEl) * rEl/d;
  double xa2 = xCand + (xEl-xCand) * rCand/d;
  double ya1 = yEl   + (yCand-yEl) * rEl/d;
  double ya2 = yCand + (yEl-yCand) * rCand/d;

  double x=.5*(xa1+xa2);
  double y=.5*(ya1+ya2);
  double rconv = sqrt(pow(x,2) + pow(y,2));
  double z = el_track->dz() + rEl*el_track->pz()*TMath::ACos(1-pow(rconv,2)/(2.*pow(rEl,2)))/el_track->pt();

  math::XYZPoint convPoint(x, y, z);

  //now assign a sign to the radius of conversion
  float tempsign = el_track->px()*x + el_track->py()*y;
  tempsign = tempsign/fabs(tempsign);
  rconv = tempsign*rconv;

  int deltaMissingHits = -9999;

  deltaMissingHits = candCtfTrackRef->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS)
      - el_track->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);

  return ConversionInfo{dist, dcot, rconv, convPoint, candCtfTrackRef, GsfTrackRef(), deltaMissingHits, flag};

 }

}

//-------------------------------------------------------------------------------------