Inheritance diagram for PFTauPrimaryVertexProducer:

Classes
struct	DiscCutPair

Public Types
enum	Alg { useInputPV =0, useFontPV }

typedef std::vector < DiscCutPair * >	DiscCutPairVec

Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
	PFTauPrimaryVertexProducer (const edm::ParameterSet &iConfig)

virtual void	produce (edm::Event &, const edm::EventSetup &)

	~PFTauPrimaryVertexProducer ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Attributes
int	Algorithm_

edm::InputTag	beamSpotTag_

edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

std::auto_ptr < StringCutObjectSelector < reco::PFTau > >	cut_

DiscCutPairVec	discriminators_

edm::InputTag	ElectronTag_

edm::EDGetTokenT< std::vector < reco::Electron > >	ElectronToken_

edm::InputTag	MuonTag_

edm::EDGetTokenT< std::vector < reco::Muon > >	MuonToken_

edm::InputTag	PFTauTag_

edm::EDGetTokenT< std::vector < reco::PFTau > >	PFTauToken_

edm::InputTag	PVTag_

edm::EDGetTokenT < reco::VertexCollection >	PVToken_

edm::ParameterSet	qualityCutsPSet_

bool	RemoveElectronTracks_

bool	RemoveMuonTracks_

edm::InputTag	TrackCollectionTag_

edm::EDGetTokenT < reco::TrackCollection >	TrackCollectionToken_

edm::InputTag	TracksTag_

bool	useBeamSpot_

bool	useSelectedTaus_

std::auto_ptr < tau::RecoTauVertexAssociator >	vertexAssociator_

Additional Inherited Members
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 59 of file PFTauPrimaryVertexProducer.cc.

Member Typedef Documentation

typedef std::vector<DiscCutPair*> PFTauPrimaryVertexProducer::DiscCutPairVec

Definition at line 71 of file PFTauPrimaryVertexProducer.cc.

Member Enumeration Documentation

enum PFTauPrimaryVertexProducer::Alg

Enumerator
useInputPV
useFontPV

Definition at line 61 of file PFTauPrimaryVertexProducer.cc.

61 {useInputPV=0, useFontPV};

PFTauPrimaryVertexProducer::useFontPV

Definition: PFTauPrimaryVertexProducer.cc:61

PFTauPrimaryVertexProducer::useInputPV

Definition: PFTauPrimaryVertexProducer.cc:61

Constructor & Destructor Documentation

PFTauPrimaryVertexProducer::PFTauPrimaryVertexProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 101 of file PFTauPrimaryVertexProducer.cc.

References edm::EDConsumerBase::consumesCollector(), PFTauPrimaryVertexProducer::DiscCutPair::cut_, cut_, PFTauPrimaryVertexProducer::DiscCutPair::cutFormula_, HLT_25ns14e33_v1_cff::discriminators, discriminators_, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), PFTauPrimaryVertexProducer::DiscCutPair::inputToken_, qualityCutsPSet_, AlCaHLTBitMon_QueryRunRegistry::string, and vertexAssociator_.

                                                                                     :
   PFTauTag_(iConfig.getParameter<edm::InputTag>("PFTauTag")),
   PFTauToken_(consumes<std::vector<reco::PFTau> >(PFTauTag_)),
   ElectronTag_(iConfig.getParameter<edm::InputTag>("ElectronTag")),
   ElectronToken_(consumes<std::vector<reco::Electron> >(ElectronTag_)),
   MuonTag_(iConfig.getParameter<edm::InputTag>("MuonTag")),
   MuonToken_(consumes<std::vector<reco::Muon> >(MuonTag_)),
   PVTag_(iConfig.getParameter<edm::InputTag>("PVTag")),
   PVToken_(consumes<reco::VertexCollection>(PVTag_)),
   beamSpotTag_(iConfig.getParameter<edm::InputTag>("beamSpot")),
   beamSpotToken_(consumes<reco::BeamSpot>(beamSpotTag_)),
   TrackCollectionTag_(iConfig.getParameter<edm::InputTag>("TrackCollectionTag")),
   TrackCollectionToken_(consumes<reco::TrackCollection>(TrackCollectionTag_)),
   Algorithm_(iConfig.getParameter<int>("Algorithm")),
   qualityCutsPSet_(iConfig.getParameter<edm::ParameterSet>("qualityCuts")),
   useBeamSpot_(iConfig.getParameter<bool>("useBeamSpot")),
   useSelectedTaus_(iConfig.getParameter<bool>("useSelectedTaus")),
   RemoveMuonTracks_(iConfig.getParameter<bool>("RemoveMuonTracks")),
   RemoveElectronTracks_(iConfig.getParameter<bool>("RemoveElectronTracks"))
 {
   std::vector<edm::ParameterSet> discriminators =iConfig.getParameter<std::vector<edm::ParameterSet> >("discriminators");
   // Build each of our cuts
   BOOST_FOREACH(const edm::ParameterSet &pset, discriminators) {
     DiscCutPair* newCut = new DiscCutPair();
     newCut->inputToken_ =consumes<reco::PFTauDiscriminator>(pset.getParameter<edm::InputTag>("discriminator"));
 
     if ( pset.existsAs<std::string>("selectionCut") ) newCut->cutFormula_ = new TFormula("selectionCut", pset.getParameter<std::string>("selectionCut").data());
     else newCut->cut_ = pset.getParameter<double>("selectionCut");
     discriminators_.push_back(newCut);
   }
   // Build a string cut if desired
   if (iConfig.exists("cut")) cut_.reset(new StringCutObjectSelector<reco::PFTau>(iConfig.getParameter<std::string>( "cut" )));
   produces<edm::AssociationVector<PFTauRefProd, std::vector<reco::VertexRef> > >();
   produces<VertexCollection>("PFTauPrimaryVertices"); 
 
   vertexAssociator_.reset(new tau::RecoTauVertexAssociator(qualityCutsPSet_,consumesCollector()));
 }

PFTauPrimaryVertexProducer::~PFTauPrimaryVertexProducer ( )

Definition at line 141 of file PFTauPrimaryVertexProducer.cc.

                                                        {
 
 }

Member Function Documentation

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

virtual

Implements edm::stream::EDProducerBase.

Definition at line 145 of file PFTauPrimaryVertexProducer.cc.

References Algorithm_, SiPixelRawToDigiRegional_cfi::beamSpot, beamSpotToken_, PFTauPrimaryVertexProducer::DiscCutPair::cut_, cut_, PFTauPrimaryVertexProducer::DiscCutPair::cutFormula_, listHistos::discr, PFTauPrimaryVertexProducer::DiscCutPair::discr_, discriminators_, configurableAnalysis::Electron, ElectronToken_, edm::EventSetup::get(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), PFTauPrimaryVertexProducer::DiscCutPair::inputToken_, edm::Ref< C, T, F >::isNonnull(), edm::HandleBase::isValid(), Mu, MuonToken_, PFTauToken_, edm::Event::put(), PVToken_, RemoveElectronTracks_, RemoveMuonTracks_, AdaptiveVertexFitter::setWeightThreshold(), metsig::tau, HLT_25ns14e33_v3_cff::trackCollection, TrackCollectionToken_, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), useBeamSpot_, useFontPV, useInputPV, useSelectedTaus_, AdaptiveVertexFitter::vertex(), and vertexAssociator_.

                                                                                     {
   // Obtain Collections
   edm::ESHandle<TransientTrackBuilder> transTrackBuilder;
   iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",transTrackBuilder);
   
   edm::Handle<std::vector<reco::PFTau> > Tau;
   iEvent.getByToken(PFTauToken_,Tau);
 
   edm::Handle<std::vector<reco::Electron> > Electron;
   iEvent.getByToken(ElectronToken_,Electron);
 
   edm::Handle<std::vector<reco::Muon> > Mu;
   iEvent.getByToken(MuonToken_,Mu);
 
   edm::Handle<reco::VertexCollection > PV;
   iEvent.getByToken(PVToken_,PV);
 
   edm::Handle<reco::BeamSpot> beamSpot;
   iEvent.getByToken(beamSpotToken_,beamSpot);
 
   edm::Handle<reco::TrackCollection> trackCollection;
   iEvent.getByToken(TrackCollectionToken_,trackCollection);
 
   // Set Association Map
   auto_ptr<edm::AssociationVector<PFTauRefProd, std::vector<reco::VertexRef> > > AVPFTauPV(new edm::AssociationVector<PFTauRefProd, std::vector<reco::VertexRef> >(PFTauRefProd(Tau)));
   std::auto_ptr<VertexCollection>  VertexCollection_out= std::auto_ptr<VertexCollection>(new VertexCollection);
   reco::VertexRefProd VertexRefProd_out = iEvent.getRefBeforePut<reco::VertexCollection>("PFTauPrimaryVertices");
 
   // Load each discriminator
   BOOST_FOREACH(DiscCutPair *disc, discriminators_) {
     edm::Handle<reco::PFTauDiscriminator> discr;
     iEvent.getByToken(disc->inputToken_, discr);
     disc->discr_ = &(*discr);
   }
 
   // For each Tau Run Algorithim 
   if(Tau.isValid()){
     for(reco::PFTauCollection::size_type iPFTau = 0; iPFTau < Tau->size(); iPFTau++) {
       reco::PFTauRef tau(Tau, iPFTau);
       reco::Vertex thePV;
       if(useInputPV==Algorithm_){
     vertexAssociator_->setEvent(iEvent);
     thePV =(*( vertexAssociator_->associatedVertex(*tau)));
       }
       else if(useFontPV==Algorithm_){
     thePV=PV->front();
       }
       // Check if it passed all the discrimiantors
       bool passed(true); 
       BOOST_FOREACH(const DiscCutPair* disc, discriminators_) {
         // Check this discriminator passes
     bool passedDisc = true;
     if ( disc->cutFormula_ )passedDisc = (disc->cutFormula_->Eval((*disc->discr_)[tau]) > 0.5);
     else passedDisc = ((*disc->discr_)[tau] > disc->cut_);
         if ( !passedDisc ){passed = false; break;}
       }
       if (passed && cut_.get()){passed = (*cut_)(*tau);}
       if (passed){
     std::vector<reco::TrackBaseRef> SignalTracks;
     for(reco::PFTauCollection::size_type jPFTau = 0; jPFTau < Tau->size(); jPFTau++) {
       if(useSelectedTaus_ || iPFTau==jPFTau){
         reco::PFTauRef RefPFTau(Tau, jPFTau);
         // Get tracks from PFTau daugthers
         const std::vector<edm::Ptr<reco::PFCandidate> > cands = RefPFTau->signalPFChargedHadrCands(); 
         for (std::vector<edm::Ptr<reco::PFCandidate> >::const_iterator iter = cands.begin(); iter!=cands.end(); iter++){
           if(iter->get()->trackRef().isNonnull()) SignalTracks.push_back(reco::TrackBaseRef(iter->get()->trackRef()));
           else if(iter->get()->gsfTrackRef().isNonnull()){SignalTracks.push_back(reco::TrackBaseRef(((iter)->get()->gsfTrackRef())));}
         }
       }
     }
     // Get Muon tracks
     if(RemoveMuonTracks_){
 
       if(Mu.isValid()) {
         for(reco::MuonCollection::size_type iMuon = 0; iMuon< Mu->size(); iMuon++){
           reco::MuonRef RefMuon(Mu, iMuon);
           if(RefMuon->track().isNonnull()) SignalTracks.push_back(reco::TrackBaseRef(RefMuon->track()));
         }
       }
     }
     // Get Electron Tracks
     if(RemoveElectronTracks_){
       if(Electron.isValid()) {
         for(reco::ElectronCollection::size_type iElectron = 0; iElectron<Electron->size(); iElectron++){
           reco::ElectronRef RefElectron(Electron, iElectron);
           if(RefElectron->track().isNonnull()) SignalTracks.push_back(reco::TrackBaseRef(RefElectron->track()));
         }
       }
     }
     // Get Non-Tau tracks
     reco::TrackCollection nonTauTracks;
 //  if (trackCollection.isValid()) {
 //    // remove tau tracks and only tracks associated with the vertex
 //    unsigned int idx = 0;
 //    for (reco::TrackCollection::const_iterator iTrk = trackCollection->begin(); iTrk != trackCollection->end(); ++iTrk, idx++) {
 //      reco::TrackRef tmpRef(trackCollection, idx);
 //      reco::TrackRef tmpRefForBase=tmpRef;
 //      bool isSigTrk = false;
 //      bool fromVertex=false;
 //      for (unsigned int sigTrk = 0; sigTrk < SignalTracks.size(); sigTrk++) {
 //        if (reco::TrackBaseRef(tmpRefForBase)==SignalTracks.at(sigTrk)){isSigTrk = true; break;}
 //      }
 //    if (!isSigTrk) nonSigTracks.push_back(*iTrk);
 //    }
 //  }
     
     for(std::vector<reco::TrackBaseRef>::const_iterator vtxTrkRef=thePV.tracks_begin();vtxTrkRef<thePV.tracks_end();vtxTrkRef++){
       bool matched = false;
       for (unsigned int sigTrk = 0; sigTrk < SignalTracks.size(); sigTrk++) {
         if ( (*vtxTrkRef) == SignalTracks[sigTrk] ) {
           matched = true;
         }
       }
       if ( !matched ) nonTauTracks.push_back(**vtxTrkRef);
     }   
     // Refit the vertex
     TransientVertex transVtx;
     std::vector<reco::TransientTrack> transTracks;
     for (reco::TrackCollection::iterator iter=nonTauTracks.begin(); iter!=nonTauTracks.end(); ++iter){
       transTracks.push_back(transTrackBuilder->build(*iter));
     }
     bool FitOk(true);
     if ( transTracks.size() >= 2 ) {
       AdaptiveVertexFitter avf;
       avf.setWeightThreshold(0.1); //weight per track. allow almost every fit, else --> exception
       try {
         if ( !useBeamSpot_ ){
           transVtx = avf.vertex(transTracks);
         } else {
           transVtx = avf.vertex(transTracks, *beamSpot);
         }
       } catch (...) {
         FitOk = false;
       }
     } else FitOk = false;
     if ( FitOk ) thePV = transVtx;
       }
       VertexRef VRef = reco::VertexRef(VertexRefProd_out, VertexCollection_out->size());
       VertexCollection_out->push_back(thePV);
       AVPFTauPV->setValue(iPFTau, VRef);
     }
   }
   iEvent.put(VertexCollection_out,"PFTauPrimaryVertices");
   iEvent.put(AVPFTauPV);
 }