PFTau3ProngReco Class Reference

Inheritance diagram for PFTau3ProngReco:

Classes
struct	DiscCutPair

Public Types
enum	Alg { useKalmanFit = 0, useTrackHelix }
typedef std::vector< DiscCutPair * >	DiscCutPairVec
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType
Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex > >
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
	PFTau3ProngReco (const edm::ParameterSet &iConfig)
void	produce (edm::Event &, const edm::EventSetup &) override
	~PFTau3ProngReco () override
Public Member Functions inherited from edm::EDProducer
	EDProducer ()
SerialTaskQueue *	globalLuminosityBlocksQueue ()
SerialTaskQueue *	globalRunsQueue ()
ModuleDescription const &	moduleDescription () const
	~EDProducer () override
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const
std::vector< bool > const &	recordProvenanceList () const
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...
	~ProducerBase () noexcept(false) override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Private Attributes
int	Algorithm_
std::unique_ptr< StringCutObjectSelector< reco::PFTau > >	cut_
DiscCutPairVec	discriminators_
KinematicParticleVertexFitter	kpvFitter_
int	ndfPVT_
edm::InputTag	PFTauTag_
edm::InputTag	PFTauTIPTag_

Additional Inherited Members
Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
static bool	wantsGlobalLuminosityBlocks ()
static bool	wantsGlobalRuns ()
static bool	wantsInputProcessBlocks ()
static bool	wantsProcessBlocks ()
static bool	wantsStreamLuminosityBlocks ()
static bool	wantsStreamRuns ()
Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...
template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()
template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()
template<Transition Tr = Transition::Event>
auto	produces () noexcept
ProducesCollector	producesCollector ()
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
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)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 71 of file PFTau3ProngReco.cc.

Member Typedef Documentation

DiscCutPairVec

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

Definition at line 83 of file PFTau3ProngReco.cc.

Member Enumeration Documentation

Alg

enum PFTau3ProngReco::Alg

Enumerator
useKalmanFit
useTrackHelix

Definition at line 73 of file PFTau3ProngReco.cc.

{ useKalmanFit = 0, useTrackHelix };

Constructor & Destructor Documentation

PFTau3ProngReco()

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

explicit

Definition at line 99 of file PFTau3ProngReco.cc.

References PFTau3ProngReco::DiscCutPair::cut_, cut_, PFTau3ProngReco::DiscCutPair::cutFormula_, PDWG_TauSkim_cff::discriminators, discriminators_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), PFTau3ProngReco::DiscCutPair::inputTag_, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

    : PFTauTag_(iConfig.getParameter<edm::InputTag>("PFTauTag")),
      PFTauTIPTag_(iConfig.getParameter<edm::InputTag>("PFTauTIPTag")),
      Algorithm_(iConfig.getParameter<int>("Algorithm")),
      ndfPVT_(iConfig.getUntrackedParameter("ndfPVT", (int)5)) {
  std::vector<edm::ParameterSet> discriminators =
      iConfig.getParameter<std::vector<edm::ParameterSet>>("discriminators");
  // Build each of our cuts
  for (auto const& pset : discriminators) {
    DiscCutPair* newCut = new DiscCutPair();
    newCut->inputTag_ = 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_ = std::make_unique<StringCutObjectSelector<reco::PFTau>>(iConfig.getParameter<std::string>("cut"));
  produces<edm::AssociationVector<PFTauRefProd, std::vector<reco::PFTau3ProngSummaryRef>>>();
  produces<PFTau3ProngSummaryCollection>("PFTau3ProngSummary");
}

~PFTau3ProngReco()

PFTau3ProngReco::~PFTau3ProngReco ( )

override

Definition at line 125 of file PFTau3ProngReco.cc.

{}

Member Function Documentation

produce()

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

overridevirtual

Implements edm::EDProducer.

Definition at line 146 of file PFTau3ProngReco.cc.

References PdtPdgMini::a_1_plus, funct::abs(), reco::PFTau3ProngSummary::AddSolution(), Algorithm_, TransientTrackBuilder::build(), c, HLT_2022v12_cff::cands, ALCARECOTkAlJpsiMuMu_cff::charge, cut_, ztail::d, TtSemiLepEvtBuilder_cfi::disc, discriminators_, MillePedeFileConverter_cfg::e, TransientTrackBuilder::field(), tauImpactParameter::TauA1NuConstrainedFitter::fit(), KinematicParticleVertexFitter::fit(), edm::EventSetup::get(), tauImpactParameter::TauA1NuConstrainedFitter::getMother(), tauImpactParameter::TauA1NuConstrainedFitter::getRefitDaughters(), getTrack(), mps_fire::i, iEvent, MagneticField::inInverseGeV(), dqmiolumiharvest::j, kpvFitter_, eostools::move(), ndfPVT_, HLTMuonOfflineAnalyzer_cfi::NVertex, tauImpactParameter::LorentzVectorParticle::p4(), KinematicParticleFactoryFromTransientTrack::particle(), TriggerAnalyzer::passed, EgammaValidation_cff::pdgid, EgammaValidation_cff::pdgId, PFTauTag_, PFTauTIPTag_, tauImpactParameter::PDGInfo::pi_mass(), BeamMonitor_cff::primaryVertex, MetAnalyzer::pv(), TrackCollections2monitor_cff::selectedTracks, pfDeepBoostedJetPreprocessParams_cfi::sv, L1TRate_Offline_cfi::Tau, metsig::tau, HLT_2022v12_cff::track, gather_cfg::Tracks, useKalmanFit, useTrackHelix, trackerHitRTTI::vector, and PV3DBase< T, PVType, FrameType >::z().

                                                                           {
  // Obtain Collections
  edm::ESHandle<TransientTrackBuilder> transTrackBuilder;
  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", transTrackBuilder);

  edm::Handle<std::vector<reco::PFTau>> Tau;
  iEvent.getByLabel(PFTauTag_, Tau);

  edm::Handle<edm::AssociationVector<PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef>>> TIPAV;
  iEvent.getByLabel(PFTauTIPTag_, TIPAV);

  auto AVPFTau3PS = std::make_unique<edm::AssociationVector<PFTauRefProd, std::vector<reco::PFTau3ProngSummaryRef>>>(
      PFTauRefProd(Tau));
  auto PFTau3PSCollection_out = std::make_unique<PFTau3ProngSummaryCollection>();
  reco::PFTau3ProngSummaryRefProd PFTau3RefProd_out =
      iEvent.getRefBeforePut<reco::PFTau3ProngSummaryCollection>("PFTau3ProngSummary");

  // Load each discriminator
  for (auto& disc : discriminators_) {
    iEvent.getByLabel(disc->inputTag_, disc->handle_);
  }

  // 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::PFTau3ProngSummary PFTau3PS;
      // Check if it passed all the discrimiantors
      bool passed(true);
      for (auto const& disc : discriminators_) {
        // Check this discriminator passes
        bool passedDisc = true;
        if (disc->cutFormula_)
          passedDisc = (disc->cutFormula_->Eval((*disc->handle_)[tau]) > 0.5);
        else
          passedDisc = ((*disc->handle_)[tau] > disc->cut_);
        if (!passedDisc) {
          passed = false;
          break;
        }
      }
      if (passed && cut_.get()) {
        passed = (*cut_)(*tau);
      }
      if (passed) {
        PDGInfo pdgInfo;
        const reco::PFTauTransverseImpactParameterRef theTIP = TIPAV->value(tau.key());
        const reco::VertexRef primaryVertex = theTIP->primaryVertex();
        // Now compute the 3 prong Tau
        bool SecondaryVtxOK(false);
        LorentzVectorParticle a1;
        if (theTIP->hasSecondaryVertex() && primaryVertex->ndof() > ndfPVT_) {
          const VertexRef secVtx = theTIP->secondaryVertex();
          GlobalPoint sv(secVtx->position().x(), secVtx->position().y(), secVtx->position().z());
          double vtxchi2(0), vtxndf(1);
          if (useKalmanFit == Algorithm_) {
            vtxchi2 = secVtx->chi2();
            vtxndf = secVtx->ndof();
            const std::vector<reco::Track>& selectedTracks = secVtx->refittedTracks();
            std::vector<reco::TransientTrack> transTrkVect;
            for (unsigned int i = 0; i != selectedTracks.size(); i++)
              transTrkVect.push_back(transTrackBuilder->build(selectedTracks[i]));
            KinematicParticleFactoryFromTransientTrack kinFactory;
            float piMassSigma(1.e-6), piChi(0.0), piNdf(0.0);
            std::vector<RefCountedKinematicParticle> pions;
            for (unsigned int i = 0; i < transTrkVect.size(); i++)
              pions.push_back(kinFactory.particle(transTrkVect[i], pdgInfo.pi_mass(), piChi, piNdf, sv, piMassSigma));
            RefCountedKinematicTree jpTree = kpvFitter_.fit(pions);
            jpTree->movePointerToTheTop();
            const KinematicParameters parameters = jpTree->currentParticle()->currentState().kinematicParameters();
            AlgebraicSymMatrix77 cov = jpTree->currentParticle()->currentState().kinematicParametersError().matrix();
            // get pions
            double c(0);
            std::vector<reco::Track> Tracks;
            std::vector<LorentzVectorParticle> ReFitPions;
            for (unsigned int i = 0; i < transTrkVect.size(); i++) {
              c += transTrkVect[i].charge();
              ReFitPions.push_back(ParticleBuilder::createLorentzVectorParticle(transTrkVect[i], *secVtx, true, true));
            }
            // now covert a1 into LorentzVectorParticle
            TVectorT<double> a1_par(LorentzVectorParticle::NLorentzandVertexPar);
            TMatrixTSym<double> a1_cov(LorentzVectorParticle::NLorentzandVertexPar);
            for (int i = 0; i < LorentzVectorParticle::NLorentzandVertexPar; i++) {
              a1_par(i) = parameters(i);
              for (int j = 0; j < LorentzVectorParticle::NLorentzandVertexPar; j++) {
                a1_cov(i, j) = cov(i, j);
              }
            }
            a1 = LorentzVectorParticle(
                a1_par, a1_cov, abs(PdtPdgMini::a_1_plus) * c, c, transTrackBuilder->field()->inInverseGeV(sv).z());
            SecondaryVtxOK = true;
            PFTau3PS = reco::PFTau3ProngSummary(theTIP, a1.p4(), vtxchi2, vtxndf);
          } else if (useTrackHelix == Algorithm_) {
            // use Track Helix
            std::vector<TrackParticle> pions;
            GlobalPoint pvpoint(
                primaryVertex->position().x(), primaryVertex->position().y(), primaryVertex->position().z());
            const std::vector<edm::Ptr<reco::Candidate>> cands = tau->signalChargedHadrCands();
            for (std::vector<edm::Ptr<reco::Candidate>>::const_iterator iter = cands.begin(); iter != cands.end();
                 ++iter) {
              const reco::Track* track = getTrack(**iter);
              if (track != nullptr) {
                reco::TransientTrack transTrk = transTrackBuilder->build(*track);
                pions.push_back(ParticleBuilder::createTrackParticle(transTrk, pvpoint, true, true));
              }
            }
            TVector3 pv(secVtx->position().x(), secVtx->position().y(), secVtx->position().z());
            Chi2VertexFitter chi2v(pions, pv);
            SecondaryVtxOK = chi2v.fit();
            double c(0);
            for (unsigned int i = 0; i < pions.size(); i++) {
              c += pions[i].charge();
            }
            int pdgid = abs(PdtPdgMini::a_1_plus) * c;
            a1 = chi2v.getMother(pdgid);
            PFTau3PS = reco::PFTau3ProngSummary(theTIP, a1.p4(), vtxchi2, vtxndf);
          }
        }
        if (SecondaryVtxOK) {
          // Tau Solver
          TVector3 pv(primaryVertex->position().x(), primaryVertex->position().y(), primaryVertex->position().z());
          TMatrixTSym<double> pvcov(LorentzVectorParticle::NVertex);
          math::Error<LorentzVectorParticle::NVertex>::type pvCov;
          primaryVertex->fill(pvCov);
          for (int i = 0; i < LorentzVectorParticle::NVertex; i++) {
            for (int j = 0; j < LorentzVectorParticle::NVertex; j++) {
              pvcov(i, j) = pvCov(i, j);
            }
          }
          for (unsigned int i = 0; i < PFTau3ProngSummary::nsolutions; i++) {
            TauA1NuConstrainedFitter TauA1NU(i, a1, pv, pvcov);
            bool isFitOK = TauA1NU.fit();
            if (isFitOK) {
              LorentzVectorParticle theTau = TauA1NU.getMother();
              std::vector<LorentzVectorParticle> daughter = TauA1NU.getRefitDaughters();
              std::vector<TLorentzVector> daughter_p4;
              std::vector<int> daughter_charge, daughter_PDGID;
              for (unsigned int d = 0; d < daughter.size(); d++) {
                daughter_p4.push_back(daughter[d].p4());
                daughter_charge.push_back((int)daughter[d].charge());
                daughter_PDGID.push_back(daughter[d].pdgId());
              }
              PFTau3PS.AddSolution(i, theTau.p4(), daughter_p4, daughter_charge, daughter_PDGID, (isFitOK), 0.0, -999);
            }
          }
        }
      }
      reco::PFTau3ProngSummaryRef PFTau3PSRef =
          reco::PFTau3ProngSummaryRef(PFTau3RefProd_out, PFTau3PSCollection_out->size());
      PFTau3PSCollection_out->push_back(PFTau3PS);
      AVPFTau3PS->setValue(iPFTau, PFTau3PSRef);
    }
  }
  iEvent.put(std::move(PFTau3PSCollection_out), "PFTau3ProngSummary");
  iEvent.put(std::move(AVPFTau3PS));
}

Member Data Documentation

Algorithm_

int PFTau3ProngReco::Algorithm_

private

Definition at line 92 of file PFTau3ProngReco.cc.

Referenced by produce().

cut_

std::unique_ptr<StringCutObjectSelector<reco::PFTau> > PFTau3ProngReco::cut_

private

Definition at line 94 of file PFTau3ProngReco.cc.

Referenced by PFTau3ProngReco(), and produce().

discriminators_

DiscCutPairVec PFTau3ProngReco::discriminators_

private

Definition at line 93 of file PFTau3ProngReco.cc.

Referenced by PFTau3ProngReco(), and produce().

kpvFitter_

KinematicParticleVertexFitter PFTau3ProngReco::kpvFitter_

private

Definition at line 96 of file PFTau3ProngReco.cc.

Referenced by produce().

ndfPVT_

int PFTau3ProngReco::ndfPVT_

private

Definition at line 95 of file PFTau3ProngReco.cc.

Referenced by produce().

PFTauTag_

edm::InputTag PFTau3ProngReco::PFTauTag_

private

Definition at line 90 of file PFTau3ProngReco.cc.

Referenced by produce().

PFTauTIPTag_

edm::InputTag PFTau3ProngReco::PFTauTIPTag_

private

Definition at line 91 of file PFTau3ProngReco.cc.

Referenced by produce().