TrackAssociatorByPositionImpl.cc

Go to the documentation of this file.

#include "TrackAssociatorByPositionImpl.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"
 
#include <TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h>
#include <Geometry/CommonDetUnit/interface/GeomDet.h>
 
#include "DataFormats/Math/interface/deltaR.h"
//#include "PhysicsTools/Utilities/interface/DeltaR.h"
 
using namespace edm;
using namespace reco;
 
TrajectoryStateOnSurface TrackAssociatorByPositionImpl::getState(const TrackingParticleRef& st,
                                                                 const SimHitTPAssociationList& simHitsTPAssoc) const {
  using SimHitTPPair = std::pair<TrackingParticleRef, TrackPSimHitRef>;
  SimHitTPPair clusterTPpairWithDummyTP(st, TrackPSimHitRef());  //SimHit is dummy:
  // sorting only the cluster is needed
  auto range = std::equal_range(
      simHitsTPAssoc.begin(),
      simHitsTPAssoc.end(),
      clusterTPpairWithDummyTP,
      [](const SimHitTPPair& iLHS, const SimHitTPPair& iRHS) -> bool { return iLHS.first.key() > iRHS.first.key(); });
 
  //  TrackingParticle* simtrack = const_cast<TrackingParticle*>(&st);
  //loop over PSimHits
  const PSimHit* psimhit = nullptr;
  const BoundPlane* plane = nullptr;
  double dLim = thePositionMinimumDistance;
 
  //    look for the further most hit beyond a certain limit
  auto start = range.first;
  auto end = range.second;
  LogDebug("TrackAssociatorByPositionImpl") << range.second - range.first << " PSimHits.";
 
  unsigned int count = 0;
  for (auto ip = start; ip != end; ++ip) {
    TrackPSimHitRef psit = ip->second;
 
    //get the detid
    DetId dd(psit->detUnitId());
 
    if (!theConsiderAllSimHits && dd.det() != DetId::Tracker)
      continue;
 
    LogDebug("TrackAssociatorByPositionImpl") << count++ << "] PSimHit on: " << dd.rawId();
    //get the surface from the global geometry
    const GeomDet* gd = theGeometry->idToDet(dd);
    if (!gd) {
      edm::LogError("TrackAssociatorByPositionImpl") << "no geomdet for: " << dd.rawId() << ". will skip.";
      continue;
    }
    double d = gd->surface().toGlobal(psit->localPosition()).mag();
    if (d > dLim) {
      dLim = d;
      psimhit = &(*psit);
      plane = &gd->surface();
    }
  }
 
  if (psimhit && plane) {
    //build a trajectorystate on this surface
    SurfaceSideDefinition::SurfaceSide surfaceside = SurfaceSideDefinition::atCenterOfSurface;
    GlobalPoint initialPoint = plane->toGlobal(psimhit->localPosition());
    GlobalVector initialMomentum = plane->toGlobal(psimhit->momentumAtEntry());
    int initialCharge = (psimhit->particleType() > 0) ? -1 : 1;
    CartesianTrajectoryError initialCartesianErrors;  //no error at initial state
    const GlobalTrajectoryParameters initialParameters(
        initialPoint, initialMomentum, initialCharge, thePropagator->magneticField());
    return TrajectoryStateOnSurface(initialParameters, initialCartesianErrors, *plane, surfaceside);
  } else {
    //    edm::LogError("TrackAssociatorByPositionImpl")<<"no corresponding PSimHit for a tracking particle. will fail.";
    return TrajectoryStateOnSurface();
  }
}
 
FreeTrajectoryState TrackAssociatorByPositionImpl::getState(const reco::Track& track) const {
  //may be you want to do more than that if track does not go to IP
  return trajectoryStateTransform::initialFreeState(track, thePropagator->magneticField());
}
 
double TrackAssociatorByPositionImpl::quality(const TrajectoryStateOnSurface& tr,
                                              const TrajectoryStateOnSurface& sim) const {
  switch (theMethod) {
    case Method::chi2: {
      AlgebraicVector5 v(tr.localParameters().vector() - sim.localParameters().vector());
      AlgebraicSymMatrix55 m(tr.localError().matrix());
      int ierr = !m.Invert();
      if (ierr != 0)
        edm::LogInfo("TrackAssociatorByPositionImpl") << "error inverting the error matrix:\n" << m;
      double est = ROOT::Math::Similarity(v, m);
      return est;
      break;
    }
    case Method::dist: {
      return (tr.globalPosition() - sim.globalPosition()).mag();
      break;
    }
    case Method::momdr: {
      return (deltaR<double>(tr.globalDirection().eta(),
                             tr.globalDirection().phi(),
                             sim.globalDirection().eta(),
                             sim.globalDirection().phi()));
      break;
    }
    case Method::posdr: {
      return (deltaR<double>(
          tr.globalPosition().eta(), tr.globalPosition().phi(), sim.globalPosition().eta(), sim.globalPosition().phi()));
      break;
    }
  }
  //should never be reached
  edm::LogError("TrackAssociatorByPositionImpl")
      << "option: " << static_cast<int>(theMethod) << " has not been recognized. association has no meaning.";
  return -1;
}
 
RecoToSimCollection TrackAssociatorByPositionImpl::associateRecoToSim(
    const edm::RefToBaseVector<reco::Track>& tCH, const edm::RefVector<TrackingParticleCollection>& tPCH) const {
  RecoToSimCollection outputCollection;
  //for each reco track find a matching tracking particle
  std::pair<unsigned int, unsigned int> minPair;
  const double dQmin_default = 1542543;
  double dQmin = dQmin_default;
 
  //cdj edm::Handle<SimHitTPAssociationProducer::SimHitTPAssociationList> simHitsTPAssoc;
 
  //warning: make sure the TP collection used in the map is the same used in the associator!
  //e->getByLabel(_simHitTpMapTag,simHitsTPAssoc);
 
  for (unsigned int Ti = 0; Ti != tCH.size(); ++Ti) {
    //initial state (initial OR inner OR outter)
    FreeTrajectoryState iState = getState(*(tCH)[Ti]);
 
    bool atLeastOne = false;
    //    for each tracking particle, find a state position and the plane to propagate the track to.
    for (unsigned int TPi = 0; TPi != tPCH.size(); ++TPi) {
      //get a state in the muon system
      TrajectoryStateOnSurface simReferenceState = getState((tPCH)[TPi], *theSimHitsTPAssoc);
      if (!simReferenceState.isValid())
        continue;
 
      //propagate the TRACK to the surface
      TrajectoryStateOnSurface trackReferenceState = thePropagator->propagate(iState, simReferenceState.surface());
      if (!trackReferenceState.isValid())
        continue;
 
      //comparison
      double dQ = quality(trackReferenceState, simReferenceState);
      if (dQ < theQCut) {
        atLeastOne = true;
        outputCollection.insert(tCH[Ti],
                                std::make_pair(tPCH[TPi], -dQ));  //association map with quality, is order greater-first
        edm::LogVerbatim("TrackAssociatorByPositionImpl")
            << "track number: " << Ti << " associated with dQ: " << dQ << " to TrackingParticle number: " << TPi;
      }
      if (dQ < dQmin) {
        dQmin = dQ;
        minPair = std::make_pair(Ti, TPi);
      }
    }  //loop over tracking particles
    if (theMinIfNoMatch && !atLeastOne && dQmin != dQmin_default) {
      outputCollection.insert(tCH[minPair.first], std::make_pair(tPCH[minPair.second], -dQmin));
    }
  }  //loop over tracks
  outputCollection.post_insert();
  return outputCollection;
}
 
SimToRecoCollection TrackAssociatorByPositionImpl::associateSimToReco(
    const edm::RefToBaseVector<reco::Track>& tCH, const edm::RefVector<TrackingParticleCollection>& tPCH) const {
  SimToRecoCollection outputCollection;
  //for each tracking particle, find matching tracks.
 
  std::pair<unsigned int, unsigned int> minPair;
  const double dQmin_default = 1542543;
  double dQmin = dQmin_default;
 
  //edm::Handle<SimHitTPAssociationProducer::SimHitTPAssociationList> simHitsTPAssoc;
 
  //warning: make sure the TP collection used in the map is the same used in the associator!
  //e->getByLabel(_simHitTpMapTag,simHitsTPAssoc);
 
  for (unsigned int TPi = 0; TPi != tPCH.size(); ++TPi) {
    //get a state in the muon system
    TrajectoryStateOnSurface simReferenceState = getState((tPCH)[TPi], *theSimHitsTPAssoc);
 
    if (!simReferenceState.isValid())
      continue;
    bool atLeastOne = false;
    //  propagate every track from any state (initial, inner, outter) to the surface
    //  and make the position test
    for (unsigned int Ti = 0; Ti != tCH.size(); ++Ti) {
      //initial state
      FreeTrajectoryState iState = getState(*(tCH)[Ti]);
 
      //propagation to surface
      TrajectoryStateOnSurface trackReferenceState = thePropagator->propagate(iState, simReferenceState.surface());
      if (!trackReferenceState.isValid())
        continue;
 
      //comparison
      double dQ = quality(trackReferenceState, simReferenceState);
      if (dQ < theQCut) {
        atLeastOne = true;
        outputCollection.insert(tPCH[TPi],
                                std::make_pair(tCH[Ti], -dQ));  //association map with quality, is order greater-first
        edm::LogVerbatim("TrackAssociatorByPositionImpl")
            << "TrackingParticle number: " << TPi << " associated with dQ: " << dQ << " to track number: " << Ti;
      }
      if (dQ < dQmin) {
        dQmin = dQ;
        minPair = std::make_pair(TPi, Ti);
      }
    }  //loop over tracks
    if (theMinIfNoMatch && !atLeastOne && dQmin != dQmin_default) {
      outputCollection.insert(tPCH[minPair.first], std::make_pair(tCH[minPair.second], -dQmin));
    }
  }  //loop over tracking particles
 
  outputCollection.post_insert();
  return outputCollection;
}