ImpactParameter.cc

Go to the documentation of this file.

/* class ImpactParameter
 * EDProducer for TauImpactParameterInfoCollection
 * author: Andrea Rizzi
 */
 
// system include files
#include <memory>
 
// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Framework/interface/makeRefToBaseProdFrom.h"
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
#include "DataFormats/BTauReco/interface/JetTag.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/BTauReco/interface/IsolatedTauTagInfo.h"
 
#include "TrackingTools/Records/interface/TransientTrackRecord.h"
 
#include "RecoTauTag/ImpactParameter/interface/ImpactParameterAlgorithm.h"
 
class ImpactParameter : public edm::EDProducer {
public:
  explicit ImpactParameter(const edm::ParameterSet&);
  ~ImpactParameter() override;
 
  void produce(edm::Event&, const edm::EventSetup&) override;
 
private:
  ImpactParameterAlgorithm* algo;
  edm::InputTag jetTrackSrc;
  edm::InputTag vertexSrc;
  bool usingVertex;
};
 
//
// constructors and destructor
//
ImpactParameter::ImpactParameter(const edm::ParameterSet& iConfig) {
  jetTrackSrc = iConfig.getParameter<edm::InputTag>("JetTagProd");
  vertexSrc = iConfig.getParameter<edm::InputTag>("vertexSrc");
  usingVertex = iConfig.getParameter<bool>("useVertex");
 
  algo = new ImpactParameterAlgorithm(iConfig);
 
  std::string modulname = iConfig.getParameter<std::string>("@module_label");
  produces<reco::JetTagCollection>().setBranchAlias(modulname);
  std::string infoBranchName = modulname + "Info";
  produces<reco::TauImpactParameterInfoCollection>().setBranchAlias(infoBranchName);
}
 
ImpactParameter::~ImpactParameter() { delete algo; }
 
//
// member functions
//
// ------------ method called to produce the data  ------------
void ImpactParameter::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  using namespace reco;
 
  edm::Handle<IsolatedTauTagInfoCollection> isolatedTaus;
  iEvent.getByLabel(jetTrackSrc, isolatedTaus);
 
  std::unique_ptr<JetTagCollection> tagCollection;
  auto extCollection = std::make_unique<TauImpactParameterInfoCollection>();
  if (not isolatedTaus->empty()) {
    edm::RefToBaseProd<reco::Jet> prod(edm::makeRefToBaseProdFrom(isolatedTaus->begin()->jet(), iEvent));
    tagCollection = std::make_unique<JetTagCollection>(prod);
  } else {
    tagCollection = std::make_unique<JetTagCollection>();
  }
 
  edm::ESHandle<TransientTrackBuilder> builder;
  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", builder);
  algo->setTransientTrackBuilder(builder.product());
 
  Vertex PV;
  if (usingVertex) {
    edm::Handle<reco::VertexCollection> vertices;
    iEvent.getByLabel(vertexSrc, vertices);
 
    const reco::VertexCollection vertCollection = *(vertices.product());
    reco::VertexCollection::const_iterator iVertex;
 
    for (iVertex = vertCollection.begin(); iVertex != vertCollection.end(); iVertex++) {
      PV = *iVertex;
    }
 
  } else {
    Vertex::Error e;
    e(0, 0) = 0;
    e(1, 1) = 0;
    e(2, 2) = 0;
    Vertex::Point p(0, 0, 0);
 
    Vertex dummyPV(p, e, 1, 1, 1);
    PV = dummyPV;
  }
 
  for (unsigned int i = 0; i < isolatedTaus->size(); ++i) {
    IsolatedTauTagInfoRef tauRef(isolatedTaus, i);
    std::pair<float, TauImpactParameterInfo> ipInfo = algo->tag(tauRef, PV);
    tagCollection->setValue(i, ipInfo.first);
    extCollection->push_back(ipInfo.second);
  }
 
  iEvent.put(std::move(extCollection));
  iEvent.put(std::move(tagCollection));
}
 
DEFINE_FWK_MODULE(ImpactParameter);