VertexFromTrackProducer.cc

Go to the documentation of this file.

#include "RecoTauTag/HLTProducers/interface/VertexFromTrackProducer.h"

#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "FWCore/Framework/interface/ESHandle.h"

#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Error.h"
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"

//using namespace reco;

//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
VertexFromTrackProducer::VertexFromTrackProducer(const edm::ParameterSet& conf) : 
  trackToken( consumes<edm::View<reco::Track> >(conf.getParameter<edm::InputTag>("trackLabel")) ),
  candidateToken( consumes<edm::View<reco::RecoCandidate> >(conf.getParameter<edm::InputTag>("trackLabel")) ),
  triggerFilterElectronsSrc( consumes<trigger::TriggerFilterObjectWithRefs>(conf.getParameter<edm::InputTag>("triggerFilterElectronsSrc")) ),
  triggerFilterMuonsSrc( consumes<trigger::TriggerFilterObjectWithRefs>(conf.getParameter<edm::InputTag>("triggerFilterMuonsSrc")) ),
  vertexLabel( consumes<edm::View<reco::Vertex> >(conf.getParameter<edm::InputTag>("vertexLabel")) ),
  beamSpotLabel( consumes<reco::BeamSpot>(conf.getParameter<edm::InputTag>("beamSpotLabel")) ),
  fIsRecoCandidate( conf.getParameter<bool>("isRecoCandidate") ),
  fUseBeamSpot( conf.getParameter<bool>("useBeamSpot") ),
  fUseVertex( conf.getParameter<bool>("useVertex") ),
  fUseTriggerFilterElectrons( conf.getParameter<bool>("useTriggerFilterElectrons") ),
  fUseTriggerFilterMuons( conf.getParameter<bool>("useTriggerFilterMuons") ),
  fVerbose( conf.getUntrackedParameter<bool>("verbose", false) )
{
  edm::LogInfo("PVDebugInfo") 
    << "Initializing  VertexFromTrackProducer" << "\n";

  produces<reco::VertexCollection>();

}


VertexFromTrackProducer::~VertexFromTrackProducer() {}

//
// member functions
//

// ------------ method called to produce the data  ------------
void
VertexFromTrackProducer::produce(edm::StreamID iStreamId, edm::Event& iEvent, const edm::EventSetup& iSetup) const
{
  using namespace edm;

  std::unique_ptr<reco::VertexCollection> result(new reco::VertexCollection);
  reco::VertexCollection vColl;

  math::XYZPoint vertexPoint;
  bool vertexAvailable = false;

  // get the BeamSpot
  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
  iEvent.getByToken(beamSpotLabel,recoBeamSpotHandle);
  if (recoBeamSpotHandle.isValid()){
    reco::BeamSpot beamSpot = *recoBeamSpotHandle;
    vertexPoint = beamSpot.position();
  }else{
    edm::LogError("UnusableBeamSpot") << "No beam spot found in Event";
  }

  if(fUseVertex)
  {
    // get the Vertex
    edm::Handle<edm::View<reco::Vertex> > recoVertexHandle;
    iEvent.getByToken(vertexLabel,recoVertexHandle);
    if ((recoVertexHandle.isValid()) && (!recoVertexHandle->empty())){
      reco::Vertex vertex = recoVertexHandle->at(0);
      vertexPoint = vertex.position();
      vertexAvailable = true;
    }else {
      edm::LogInfo("UnusableVertex")
    << "No vertex found in Event, beam spot used instaed" << "\n";
    }
  }

  const reco::Track* track = nullptr;
  if(fIsRecoCandidate)
  {
    edm::Handle<edm::View<reco::RecoCandidate> > candidateHandle;
    iEvent.getByToken(candidateToken, candidateHandle);
    if ((candidateHandle.isValid())&&(!candidateHandle->empty())){
      double maxpt=0.;
      unsigned i_maxpt=0;
      for (unsigned i = 0; i < candidateHandle->size(); ++i) {
        double pt=candidateHandle->ptrAt(i)->pt();
        if(pt>maxpt)
    {
      i_maxpt=i;
      maxpt=pt;
    }
      }
      track = dynamic_cast<const reco::Track*>(candidateHandle->ptrAt(i_maxpt)->bestTrack());
    }
  } 
  else if(fUseTriggerFilterElectrons) {
    edm::Handle<trigger::TriggerFilterObjectWithRefs> triggerfilter;
    iEvent.getByToken(triggerFilterElectronsSrc, triggerfilter);
    std::vector<reco::ElectronRef> recocandidates;
    triggerfilter->getObjects(trigger::TriggerElectron,recocandidates);
    if ((!recocandidates.empty())){
      double maxpt=0.;
      unsigned i_maxpt=0;
      for (unsigned i = 0; i < recocandidates.size(); ++i) {
    double pt=recocandidates.at(i)->pt();
    if(pt>maxpt) 
      {
        i_maxpt=i;
        maxpt=pt;
      }
    track = dynamic_cast<const reco::Track*>(recocandidates.at(i_maxpt)->bestTrack());
      }
    }
  }  
  else if(fUseTriggerFilterMuons) {
    edm::Handle<trigger::TriggerFilterObjectWithRefs> triggerfilter;
    iEvent.getByToken(triggerFilterMuonsSrc, triggerfilter);
    std::vector<reco::RecoChargedCandidateRef> recocandidates;
    triggerfilter->getObjects(trigger::TriggerMuon,recocandidates);
    if ((!recocandidates.empty())){
      double maxpt=0.;
      unsigned i_maxpt=0;
      for (unsigned i = 0; i < recocandidates.size(); ++i) {
    double pt=recocandidates.at(i)->pt();
    if(pt>maxpt) 
      {
        i_maxpt=i;
        maxpt=pt;
      }
    track = dynamic_cast<const reco::Track*>(recocandidates.at(i_maxpt)->bestTrack());
      }
    }
  }
  else {
    edm::Handle<edm::View<reco::Track> > trackHandle;
    iEvent.getByToken(trackToken, trackHandle);
    if ((trackHandle.isValid())&&(!trackHandle->empty())){
      double maxpt=0.;
      unsigned i_maxpt=0;
      for (unsigned i = 0; i < trackHandle->size(); ++i) {
        double pt=trackHandle->ptrAt(i)->pt();
        if(pt>maxpt)
    {
      i_maxpt=i;
      maxpt=pt;
    }
      }
      track = dynamic_cast<const reco::Track*>(&*trackHandle->ptrAt(i_maxpt));
    }
  }

  if(track) {
    if(fUseBeamSpot || (fUseVertex && vertexAvailable) ) {
      vertexPoint.SetZ(vertexPoint.z()+track->dz(vertexPoint));
    }
    else {
      vertexPoint.SetZ(track->vz());
    }
  }
  math::Error<3>::type noErrors;
  reco::Vertex v(vertexPoint, noErrors);
  vColl.push_back(v);

  // provide beamspot or primary vertex if no candidate found
  //if(vColl.size()==0)
  //{
  //    math::Error<3>::type noErrors;
  //    reco::Vertex v(vertexPoint, noErrors);
  //    vColl.push_back(v);
  //}

  if(fVerbose){
    int ivtx=0;
    edm::LogInfo("PVDebugInfo")<< "Vertices by VertexFromTrackProducer: \n"; 
    for(reco::VertexCollection::const_iterator v=vColl.begin(); 
    v!=vColl.end(); ++v){
      edm::LogInfo("PVDebugInfo")<< "\t" 
                 << "recvtx "<< ivtx++ 
                 << " x "  << std::setw(6) << v->position().x() 
                 << " dx " << std::setw(6) << v->xError()
                 << " y "  << std::setw(6) << v->position().y() 
                 << " dy " << std::setw(6) << v->yError()
                 << " z "  << std::setw(6) << v->position().z() 
                 << " dz " << std::setw(6) << v->zError()
                 << " \n ";
    }
  }

  
  *result = vColl;
  iEvent.put(std::move(result));
  
}

void
VertexFromTrackProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) 
{

  edm::ParameterSetDescription desc;

  desc.add<bool>("isRecoCandidate",false)->setComment("If isRecoCandidate=True \"trackLabel\" is used and assumed to be collection of candidates.\nOtherwise it is assumed that \"trackLabel\" is collection of tracks and is used when useTriggerFilterElectrons=False and useTriggerFilterMuons=False");
  desc.add<edm::InputTag>("trackLabel",edm::InputTag("hltL3MuonCandidates"))->setComment("Collection of tracks or candidates");
  desc.add<bool>("useTriggerFilterElectrons",false)->setComment("Use leading electron passing \"triggerFilterElectronsSrc\" filter to determine z vertex position");
  desc.add<edm::InputTag>("triggerFilterElectronsSrc",edm::InputTag("hltEle20CaloIdVTCaloIsoTTrkIdTTrkIsoL1JetTrackIsoFilter"))->setComment("Name of electron filter");
  desc.add<bool>("useTriggerFilterMuons",true)->setComment("Use leading muon passing \"triggerFilterMuonsSrc\" filter to determine z vertex position");
  desc.add<edm::InputTag>("triggerFilterMuonsSrc",edm::InputTag("hltSingleMuIsoL3IsoFiltered15"))->setComment("Name of muon filter");
  desc.add<bool>("useBeamSpot",true)->setComment("Use beam spot for x/y vertex position");
  desc.add<edm::InputTag>("beamSpotLabel",edm::InputTag("hltOnlineBeamSpot"))->setComment("Beamspot collection");
  desc.add<bool>("useVertex",true)->setComment("Use vertex for x/y vertex position (beam spot is used when PV does not exit)");
  desc.add<edm::InputTag>("vertexLabel",edm::InputTag("hltPixelVertices"))->setComment("Vertex collection");

  desc.addUntracked<bool>("verbose",false)->setComment("Switch on/off verbosity");
  descriptions.setComment("This module produces vertex with z-coordinate determined with the highest-Pt lepton track and x/y-coordinates taken from BeamSpot/Vertex");
  descriptions.add("hltVertexFromTrackProducer",desc);

}