FakeTrackProducers.cc

Go to the documentation of this file.

//
//

#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"

#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackExtra.h"
#include "DataFormats/TrackCandidate/interface/TrackCandidate.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "TrackingTools/TrackRefitter/interface/TrackTransformer.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
#include "Geometry/Records/interface/TrackerTopologyRcd.h"
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"

template <class T>
class FakeTrackProducer : public edm::stream::EDProducer<> {
public:
  explicit FakeTrackProducer(const edm::ParameterSet &iConfig);
  ~FakeTrackProducer() override {}

  void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override;

private:
  edm::EDGetTokenT<std::vector<T>> src_;

  //StringCutObjectSelector<T> selector_;

  const PTrajectoryStateOnDet &getState(const TrajectorySeed &seed) const { return seed.startingState(); }
  const PTrajectoryStateOnDet &getState(const TrackCandidate &seed) const { return seed.trajectoryStateOnDet(); }
  TrajectorySeed::range getHits(const TrajectorySeed &seed) const { return seed.recHits(); }
  TrajectorySeed::range getHits(const TrackCandidate &seed) const { return seed.recHits(); }
};

template <typename T>
FakeTrackProducer<T>::FakeTrackProducer(const edm::ParameterSet &iConfig)
    : src_(consumes<std::vector<T>>(iConfig.getParameter<edm::InputTag>("src")))
//,selector_(iConfig.existsAs<std::string>("cut") ? iConfig.getParameter<std::string>("cut") : "", true)
{
  produces<std::vector<reco::Track>>();
  produces<std::vector<reco::TrackExtra>>();
  produces<edm::OwnVector<TrackingRecHit>>();
}

template <typename T>
void FakeTrackProducer<T>::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
  using namespace edm;
  using namespace std;

  edm::ESHandle<TrackerGeometry> theGeometry;
  iSetup.get<TrackerDigiGeometryRecord>().get(theGeometry);
  edm::ESHandle<MagneticField> theMagField;
  iSetup.get<IdealMagneticFieldRecord>().get(theMagField);
  edm::ESHandle<TrackerTopology> httopo;
  iSetup.get<TrackerTopologyRcd>().get(httopo);
  const TrackerTopology &ttopo = *httopo;

  Handle<vector<T>> src;
  iEvent.getByToken(src_, src);

  unique_ptr<vector<reco::Track>> out(new vector<reco::Track>());
  out->reserve(src->size());
  unique_ptr<vector<reco::TrackExtra>> outEx(new vector<reco::TrackExtra>());
  outEx->reserve(src->size());
  unique_ptr<OwnVector<TrackingRecHit>> outHits(new OwnVector<TrackingRecHit>());

  TrackingRecHitRefProd rHits = iEvent.getRefBeforePut<TrackingRecHitCollection>();
  reco::TrackExtraRefProd rTrackExtras = iEvent.getRefBeforePut<reco::TrackExtraCollection>();
  for (typename vector<T>::const_iterator it = src->begin(), ed = src->end(); it != ed; ++it) {
    const T &mu = *it;
    //if (!selector_(mu)) continue;
    const PTrajectoryStateOnDet &pstate = getState(mu);
    const GeomDet *det = theGeometry->idToDet(DetId(pstate.detId()));
    if (det == nullptr) {
      std::cerr << "ERROR:  bogus detid " << pstate.detId() << std::endl;
      continue;
    }
    TrajectoryStateOnSurface state = trajectoryStateTransform::transientState(pstate, &det->surface(), &*theMagField);
    GlobalPoint gx = state.globalPosition();
    GlobalVector gp = state.globalMomentum();
    reco::Track::Point x(gx.x(), gx.y(), gx.z());
    reco::Track::Vector p(gp.x(), gp.y(), gp.z());
    int charge = state.localParameters().charge();
    out->push_back(reco::Track(1.0, 1.0, x, p, charge, reco::Track::CovarianceMatrix()));
    TrajectorySeed::range hits = getHits(mu);
    out->back().appendHits(hits.first, hits.second, ttopo);
    // Now Track Extra
    const TrackingRecHit *hit0 = &*hits.first;
    const TrackingRecHit *hit1 = &*(hits.second - 1);
    const GeomDet *det0 = theGeometry->idToDet(hit0->geographicalId());
    const GeomDet *det1 = theGeometry->idToDet(hit1->geographicalId());
    if (det0 == nullptr || det1 == nullptr) {
      std::cerr << "ERROR:  bogus detids at beginning or end of range" << std::endl;
      continue;
    }
    GlobalPoint gx0 = det0->toGlobal(hit0->localPosition());
    GlobalPoint gx1 = det1->toGlobal(hit1->localPosition());
    reco::Track::Point x0(gx0.x(), gx0.y(), gx0.z());
    reco::Track::Point x1(gx1.x(), gx1.y(), gx1.z());
    if (x0.R() > x1.R())
      std::swap(x0, x1);
    outEx->push_back(reco::TrackExtra(x1,
                                      p,
                                      true,
                                      x0,
                                      p,
                                      true,
                                      reco::Track::CovarianceMatrix(),
                                      hit0->geographicalId().rawId(),
                                      reco::Track::CovarianceMatrix(),
                                      hit1->geographicalId().rawId(),
                                      alongMomentum));
    out->back().setExtra(reco::TrackExtraRef(rTrackExtras, outEx->size() - 1));
    reco::TrackExtra &ex = outEx->back();
    auto const firstHitIndex = outHits->size();
    for (OwnVector<TrackingRecHit>::const_iterator it2 = hits.first; it2 != hits.second; ++it2) {
      outHits->push_back(*it2);
    }
    ex.setHits(rHits, firstHitIndex, outHits->size() - firstHitIndex);
  }

  iEvent.put(std::move(out));
  iEvent.put(std::move(outEx));
  iEvent.put(std::move(outHits));
}

typedef FakeTrackProducer<TrajectorySeed> FakeTrackProducerFromSeed;
typedef FakeTrackProducer<TrackCandidate> FakeTrackProducerFromCandidate;
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(FakeTrackProducerFromSeed);
DEFINE_FWK_MODULE(FakeTrackProducerFromCandidate);