pat::PATTauProducer Class Reference

Produces pat::Tau's. More...

#include "PhysicsTools/PatAlgos/interface/PATTauProducer.h"

Inheritance diagram for pat::PATTauProducer:

Public Member Functions
	PATTauProducer (const edm::ParameterSet &iConfig)
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override
	~PATTauProducer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
typedef std::pair< std::string, edm::InputTag >	NameTag

Private Member Functions
template<typename TauCollectionType , typename TauDiscrType >
float	getTauIdDiscriminator (const edm::Handle< TauCollectionType > &, size_t, const edm::Handle< TauDiscrType > &)

Private Attributes
bool	addEfficiencies_
bool	addGenJetMatch_
bool	addGenMatch_
bool	addResolutions_
bool	addTauID_
bool	addTauJetCorrFactors_
edm::EDGetTokenT< edm::View< reco::BaseTau > >	baseTauToken_
std::vector< edm::EDGetTokenT< reco::CaloTauDiscriminator > >	caloTauIDTokens_
edm::EDGetTokenT< reco::CaloTauCollection >	caloTauToken_
pat::helper::EfficiencyLoader	efficiencyLoader_
bool	embedGenJetMatch_
bool	embedGenMatch_
bool	embedIsolationPFCands_
bool	embedIsolationPFChargedHadrCands_
bool	embedIsolationPFGammaCands_
bool	embedIsolationPFNeutralHadrCands_
bool	embedIsolationTracks_
bool	embedLeadPFCand_
bool	embedLeadPFChargedHadrCand_
bool	embedLeadPFNeutralCand_
bool	embedLeadTrack_
bool	embedSignalPFCands_
bool	embedSignalPFChargedHadrCands_
bool	embedSignalPFGammaCands_
bool	embedSignalPFNeutralHadrCands_
bool	embedSignalTracks_
bool	firstOccurence_
edm::EDGetTokenT< edm::Association< reco::GenJetCollection > >	genJetMatchToken_
std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > >	genMatchTokens_
std::vector< std::pair< pat::IsolationKeys, edm::InputTag > >	isoDepositLabels_
std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > >	isoDepositTokens_
pat::helper::MultiIsolator	isolator_
pat::helper::MultiIsolator::IsolationValuePairs	isolatorTmpStorage_
std::vector< edm::EDGetTokenT< reco::PFTauDiscriminator > >	pfTauIDTokens_
edm::EDGetTokenT< reco::PFTauCollection >	pfTauToken_
GreaterByPt< Tau >	pTTauComparator_
pat::helper::KinResolutionsLoader	resolutionLoader_
bool	skipMissingTauID_
std::vector< NameTag >	tauIDSrcs_
std::vector< edm::EDGetTokenT< edm::ValueMap< TauJetCorrFactors > > >	tauJetCorrFactorsTokens_
edm::InputTag	tauTransverseImpactParameterSrc_
edm::EDGetTokenT< PFTauTIPAssociationByRef >	tauTransverseImpactParameterToken_
pat::PATUserDataHelper< pat::Tau >	userDataHelper_
bool	useUserData_

Additional Inherited Members
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

Detailed Description

Produces pat::Tau's.

The PATTauProducer produces analysis-level pat::Tau's starting from a collection of objects of TauType.

Author

Steven Lowette, Christophe Delaere

Definition at line 46 of file PATTauProducer.h.

Member Typedef Documentation

typedef std::pair<std::string, edm::InputTag> pat::PATTauProducer::NameTag

private

Definition at line 93 of file PATTauProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 31 of file PATTauProducer.cc.

References addEfficiencies_, addGenJetMatch_, addGenMatch_, addResolutions_, addTauID_, addTauJetCorrFactors_, baseTauToken_, caloTauIDTokens_, caloTauToken_, pat::EcalIso, efficiencyLoader_, embedGenJetMatch_, embedGenMatch_, embedIsolationPFCands_, embedIsolationPFChargedHadrCands_, embedIsolationPFGammaCands_, embedIsolationPFNeutralHadrCands_, embedIsolationTracks_, embedLeadPFCand_, embedLeadPFChargedHadrCand_, embedLeadPFNeutralCand_, embedLeadTrack_, embedSignalPFCands_, embedSignalPFChargedHadrCands_, embedSignalPFGammaCands_, embedSignalPFNeutralHadrCands_, embedSignalTracks_, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), firstOccurence_, genJetMatchToken_, genMatchTokens_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), pat::HcalIso, isoDepositLabels_, isoDepositTokens_, crabWrapper::key, diffTwoXMLs::label, names, pat::PfAllParticleIso, pat::PfChargedHadronIso, pat::PfGammaIso, pat::PfNeutralHadronIso, pfTauIDTokens_, pfTauToken_, resolutionLoader_, skipMissingTauID_, GlobalPosition_Frontier_DevDB_cff::tag, tauIDSrcs_, tauJetCorrFactorsTokens_, tauTransverseImpactParameterSrc_, tauTransverseImpactParameterToken_, pat::TrackIso, pat::UserBaseIso, userDataHelper_, useUserData_, and edm::vector_transform().

                                                             :
  isolator_(iConfig.exists("userIsolation") ? iConfig.getParameter<edm::ParameterSet>("userIsolation") : edm::ParameterSet(), consumesCollector(), false) ,
  useUserData_(iConfig.exists("userData"))
{
  firstOccurence_=true;
  // initialize the configurables
  baseTauToken_ = consumes<edm::View<reco::BaseTau> >(iConfig.getParameter<edm::InputTag>( "tauSource" ));
  tauTransverseImpactParameterSrc_ = iConfig.getParameter<edm::InputTag>( "tauTransverseImpactParameterSource" );
  tauTransverseImpactParameterToken_ = consumes<PFTauTIPAssociationByRef>( tauTransverseImpactParameterSrc_);
  pfTauToken_ = consumes<reco::PFTauCollection>(iConfig.getParameter<edm::InputTag>( "tauSource" ));
  caloTauToken_ = mayConsume<reco::CaloTauCollection>(iConfig.getParameter<edm::InputTag>( "tauSource" ));
  embedIsolationTracks_ = iConfig.getParameter<bool>( "embedIsolationTracks" );
  embedLeadTrack_ = iConfig.getParameter<bool>( "embedLeadTrack" );
  embedSignalTracks_ = iConfig.getParameter<bool>( "embedSignalTracks" );
  embedLeadPFCand_ = iConfig.getParameter<bool>( "embedLeadPFCand" );
  embedLeadPFChargedHadrCand_ = iConfig.getParameter<bool>( "embedLeadPFChargedHadrCand" );
  embedLeadPFNeutralCand_ = iConfig.getParameter<bool>( "embedLeadPFNeutralCand" );
  embedSignalPFCands_ = iConfig.getParameter<bool>( "embedSignalPFCands" );
  embedSignalPFChargedHadrCands_ = iConfig.getParameter<bool>( "embedSignalPFChargedHadrCands" );
  embedSignalPFNeutralHadrCands_ = iConfig.getParameter<bool>( "embedSignalPFNeutralHadrCands" );
  embedSignalPFGammaCands_ = iConfig.getParameter<bool>( "embedSignalPFGammaCands" );
  embedIsolationPFCands_ = iConfig.getParameter<bool>( "embedIsolationPFCands" );
  embedIsolationPFChargedHadrCands_ = iConfig.getParameter<bool>( "embedIsolationPFChargedHadrCands" );
  embedIsolationPFNeutralHadrCands_ = iConfig.getParameter<bool>( "embedIsolationPFNeutralHadrCands" );
  embedIsolationPFGammaCands_ = iConfig.getParameter<bool>( "embedIsolationPFGammaCands" );
  addGenMatch_ = iConfig.getParameter<bool>( "addGenMatch" );
  if (addGenMatch_) {
    embedGenMatch_ = iConfig.getParameter<bool>( "embedGenMatch" );
    if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
      genMatchTokens_.push_back(consumes<edm::Association<reco::GenParticleCollection> >(iConfig.getParameter<edm::InputTag>( "genParticleMatch" )));
    }
    else {
      genMatchTokens_ = edm::vector_transform(iConfig.getParameter<std::vector<edm::InputTag> >( "genParticleMatch" ), [this](edm::InputTag const & tag){return consumes<edm::Association<reco::GenParticleCollection> >(tag);});
    }
  }
  addGenJetMatch_ = iConfig.getParameter<bool>( "addGenJetMatch" );
  if(addGenJetMatch_) {
    embedGenJetMatch_ = iConfig.getParameter<bool>( "embedGenJetMatch" );
    genJetMatchToken_ = consumes<edm::Association<reco::GenJetCollection> >(iConfig.getParameter<edm::InputTag>( "genJetMatch" ));
  }
  addTauJetCorrFactors_ = iConfig.getParameter<bool>( "addTauJetCorrFactors" );
  tauJetCorrFactorsTokens_ = edm::vector_transform(iConfig.getParameter<std::vector<edm::InputTag> >( "tauJetCorrFactorsSource" ), [this](edm::InputTag const & tag){return mayConsume<edm::ValueMap<TauJetCorrFactors> >(tag);});
  // tau ID configurables
  addTauID_ = iConfig.getParameter<bool>( "addTauID" );
  if ( addTauID_ ) {
    // read the different tau ID names
    edm::ParameterSet idps = iConfig.getParameter<edm::ParameterSet>("tauIDSources");
    std::vector<std::string> names = idps.getParameterNamesForType<edm::InputTag>();
    for (std::vector<std::string>::const_iterator it = names.begin(), ed = names.end(); it != ed; ++it) {
      tauIDSrcs_.push_back(NameTag(*it, idps.getParameter<edm::InputTag>(*it)));
    }
    // but in any case at least once
    if (tauIDSrcs_.empty()) throw cms::Exception("Configuration") <<
      "PATTauProducer: id addTauID is true, you must specify either:\n" <<
      "\tPSet tauIDSources = { \n" <<
      "\t\tInputTag <someName> = <someTag>   // as many as you want \n " <<
      "\t}\n";
  }
  caloTauIDTokens_ = edm::vector_transform(tauIDSrcs_, [this](NameTag const & tag){return mayConsume<reco::CaloTauDiscriminator>(tag.second);});
  pfTauIDTokens_   = edm::vector_transform(tauIDSrcs_, [this](NameTag const & tag){return mayConsume<reco::PFTauDiscriminator>(tag.second);});
  skipMissingTauID_ = iConfig.getParameter<bool>( "skipMissingTauID" );
  // IsoDeposit configurables
  if (iConfig.exists("isoDeposits")) {
    edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>("isoDeposits");
    if ( depconf.exists("tracker")         ) isoDepositLabels_.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
    if ( depconf.exists("ecal")            ) isoDepositLabels_.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
    if ( depconf.exists("hcal")            ) isoDepositLabels_.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
    if ( depconf.exists("pfAllParticles")  ) isoDepositLabels_.push_back(std::make_pair(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles")));
    if ( depconf.exists("pfChargedHadron") ) isoDepositLabels_.push_back(std::make_pair(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadron")));
    if ( depconf.exists("pfNeutralHadron") ) isoDepositLabels_.push_back(std::make_pair(pat::PfNeutralHadronIso,depconf.getParameter<edm::InputTag>("pfNeutralHadron")));
    if ( depconf.exists("pfGamma")         ) isoDepositLabels_.push_back(std::make_pair(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfGamma")));

    if ( depconf.exists("user") ) {
      std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
      std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
      int key = UserBaseIso;
      for ( ; it != ed; ++it, ++key) {
       isoDepositLabels_.push_back(std::make_pair(IsolationKeys(key), *it));
      }
    }
  }
  isoDepositTokens_ = edm::vector_transform(isoDepositLabels_, [this](std::pair<IsolationKeys,edm::InputTag> const & label){return consumes<edm::ValueMap<IsoDeposit> >(label.second);});
  // Efficiency configurables
  addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
  if (addEfficiencies_) {
     efficiencyLoader_ = pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
  }
  // Resolution configurables
  addResolutions_ = iConfig.getParameter<bool>("addResolutions");
  if (addResolutions_) {
     resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
  }
  // Check to see if the user wants to add user data
  if ( useUserData_ ) {
    userDataHelper_ = PATUserDataHelper<Tau>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
  }
  // produces vector of taus
  produces<std::vector<Tau> >();
}

PATTauProducer::~PATTauProducer ( )

override

Definition at line 131 of file PATTauProducer.cc.

{
}

Member Function Documentation

void PATTauProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 513 of file PATTauProducer.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addOptional(), DEFINE_FWK_MODULE, pat::helper::KinResolutionsLoader::fillDescription(), pat::PATUserDataHelper< ObjectType >::fillDescription(), edm::ParameterSetDescription::setAllowAnything(), edm::ParameterSetDescription::setComment(), and edm::ParameterDescriptionNode::setComment().

{
  edm::ParameterSetDescription iDesc;
  iDesc.setComment("PAT tau producer module");

  // input source
  iDesc.add<edm::InputTag>("tauSource", edm::InputTag())->setComment("input collection");

  // embedding
  iDesc.add<bool>("embedIsolationTracks", false)->setComment("embed external isolation tracks");
  iDesc.add<bool>("embedLeadTrack", false)->setComment("embed external leading track");
  iDesc.add<bool>("embedLeadTracks", false)->setComment("embed external signal tracks");

  // MC matching configurables
  iDesc.add<bool>("addGenMatch", true)->setComment("add MC matching");
  iDesc.add<bool>("embedGenMatch", false)->setComment("embed MC matched MC information");
  std::vector<edm::InputTag> emptySourceVector;
  iDesc.addNode( edm::ParameterDescription<edm::InputTag>("genParticleMatch", edm::InputTag(), true) xor
                 edm::ParameterDescription<std::vector<edm::InputTag> >("genParticleMatch", emptySourceVector, true)
         )->setComment("input with MC match information");

  // MC jet matching variables
  iDesc.add<bool>("addGenJetMatch", true)->setComment("add MC jet matching");
  iDesc.add<bool>("embedGenJetMatch", false)->setComment("embed MC jet matched jet information");
  iDesc.add<edm::InputTag>("genJetMatch", edm::InputTag("tauGenJetMatch"));


  pat::helper::KinResolutionsLoader::fillDescription(iDesc);

  // tau ID configurables
  iDesc.add<bool>("addTauID", true)->setComment("add tau ID variables");
  edm::ParameterSetDescription tauIDSourcesPSet;
  tauIDSourcesPSet.setAllowAnything();
  iDesc.addNode( edm::ParameterDescription<edm::InputTag>("tauIDSource", edm::InputTag(), true) xor
                 edm::ParameterDescription<edm::ParameterSetDescription>("tauIDSources", tauIDSourcesPSet, true)
               )->setComment("input with tau ID variables");
  // (Dis)allow to skip missing tauId sources
  iDesc.add<bool>("skipMissingTauID", false)->setComment("allow to skip a tau ID variable when not present in the event");

  // IsoDeposit configurables
  edm::ParameterSetDescription isoDepositsPSet;
  isoDepositsPSet.addOptional<edm::InputTag>("tracker");
  isoDepositsPSet.addOptional<edm::InputTag>("ecal");
  isoDepositsPSet.addOptional<edm::InputTag>("hcal");
  isoDepositsPSet.addOptional<edm::InputTag>("pfAllParticles");
  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadron");
  isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadron");
  isoDepositsPSet.addOptional<edm::InputTag>("pfGamma");
  isoDepositsPSet.addOptional<std::vector<edm::InputTag> >("user");
  iDesc.addOptional("isoDeposits", isoDepositsPSet);

  // Efficiency configurables
  edm::ParameterSetDescription efficienciesPSet;
  efficienciesPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
  iDesc.add("efficiencies", efficienciesPSet);
  iDesc.add<bool>("addEfficiencies", false);

  // Check to see if the user wants to add user data
  edm::ParameterSetDescription userDataPSet;
  PATUserDataHelper<Tau>::fillDescription(userDataPSet);
  iDesc.addOptional("userData", userDataPSet);

  edm::ParameterSetDescription isolationPSet;
  isolationPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
  iDesc.add("userIsolation", isolationPSet);

}

template<typename TauCollectionType , typename TauDiscrType >

float PATTauProducer::getTauIdDiscriminator ( const edm::Handle< TauCollectionType > &  tauCollection, size_t  tauIdx, const edm::Handle< TauDiscrType > &  tauIdDiscr  )

private

Definition at line 506 of file PATTauProducer.cc.

Referenced by produce().

{
  edm::Ref<TauCollectionType> tauRef(tauCollection, tauIdx);
  return (*tauIdDiscr)[tauRef];
}

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

override

Definition at line 135 of file PATTauProducer.cc.

References addGenJetMatch_, addGenMatch_, pat::PATObject< ObjectType >::addGenParticleRef(), pat::Tau::addJECFactors(), addTauID_, addTauJetCorrFactors_, baseTauToken_, pat::helper::MultiIsolator::beginEvent(), caloTauIDTokens_, caloTauToken_, CandIsolatorFromDeposits_cfi::deposits, reco::PFTauTransverseImpactParameter::dxy(), pat::tau::TauPFEssential::dxy_, reco::PFTauTransverseImpactParameter::dxy_error(), pat::tau::TauPFEssential::dxy_error_, reco::PFTauTransverseImpactParameter::dxy_PCA(), pat::tau::TauPFEssential::dxy_PCA_, MillePedeFileConverter_cfg::e, pat::tau::TauPFEssential::ecalEnergy_, pat::tau::TauPFEssential::ecalEnergyLeadChargedHadrCand_, efficiencyLoader_, embedGenMatch_, pat::PATObject< ObjectType >::embedGenParticle(), pat::Tau::embedIsolationPFCands(), embedIsolationPFCands_, pat::Tau::embedIsolationPFChargedHadrCands(), embedIsolationPFChargedHadrCands_, pat::Tau::embedIsolationPFGammaCands(), embedIsolationPFGammaCands_, pat::Tau::embedIsolationPFNeutralHadrCands(), embedIsolationPFNeutralHadrCands_, pat::Tau::embedIsolationTracks(), embedIsolationTracks_, pat::Tau::embedLeadPFCand(), embedLeadPFCand_, pat::Tau::embedLeadPFChargedHadrCand(), embedLeadPFChargedHadrCand_, pat::Tau::embedLeadPFNeutralCand(), embedLeadPFNeutralCand_, pat::Tau::embedLeadTrack(), embedLeadTrack_, pat::Tau::embedSignalPFCands(), embedSignalPFCands_, pat::Tau::embedSignalPFChargedHadrCands(), embedSignalPFChargedHadrCands_, pat::Tau::embedSignalPFGammaCands(), embedSignalPFGammaCands_, pat::Tau::embedSignalPFNeutralHadrCands(), embedSignalPFNeutralHadrCands_, pat::Tau::embedSignalTracks(), embedSignalTracks_, pat::tau::TauPFEssential::emFraction_, pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), pat::helper::MultiIsolator::enabled(), pat::helper::MultiIsolator::endEvent(), pat::tau::TauPFEssential::etaAtEcalEntrance_, pat::tau::TauPFEssential::etaAtEcalEntranceLeadChargedCand_, Exception, pat::helper::MultiIsolator::fill(), spr::find(), plotBeamSpotDB::first, firstOccurence_, reco::PFTauTransverseImpactParameter::flightLength(), pat::tau::TauPFEssential::flightLength_, reco::PFTauTransverseImpactParameter::flightLengthSig(), pat::tau::TauPFEssential::flightLengthSig_, jetProducer_cfi::genJetMatch, genJetMatchToken_, genMatchTokens_, edm::Ptr< T >::get(), edm::Event::getByToken(), getTauIdDiscriminator(), reco::PFTauTransverseImpactParameter::hasSecondaryVertex(), pat::tau::TauPFEssential::hasSV_, pat::tau::TauPFEssential::hcalEnergy_, pat::tau::TauPFEssential::hcalEnergyLeadChargedHadrCand_, mps_fire::i, photons_cff::ids, training_settings::idx, pat::Tau::initializeJEC(), reco::PFTauTransverseImpactParameter::ip3d(), pat::tau::TauPFEssential::ip3d_, reco::PFTauTransverseImpactParameter::ip3d_error(), pat::tau::TauPFEssential::ip3d_error_, edm::Ref< C, T, F >::isAvailable(), edm::Ptr< T >::isNonnull(), edm::Ref< C, T, F >::isNonnull(), isoDepositLabels_, isoDepositTokens_, isolator_, isolatorTmpStorage_, pat::Tau::isPFTau(), edm::EventBase::isRealData(), edm::HandleBase::isValid(), edm::InputTag::label(), pat::tau::TauPFEssential::leadingTrackNormChi2_, jets_cff::levels, eostools::move(), gen::n, pat::helper::EfficiencyLoader::newEvent(), pat::helper::KinResolutionsLoader::newEvent(), hemisphereProducer_cfi::patTaus, pat::Tau::pfEssential_, RecoPFTauTag_cff::PFTau, pfTauIDTokens_, pfTauToken_, pat::tau::TauPFEssential::phiAtEcalEntrance_, reco::TrackBase::pt(), pat::tau::TauPFEssential::ptLeadChargedCand_, pTTauComparator_, edm::Event::put(), resolutionLoader_, pat::Tau::setDecayMode(), pat::helper::EfficiencyLoader::setEfficiencies(), pat::Tau::setGenJet(), pat::Lepton< LeptonType >::setIsoDeposit(), pat::Lepton< LeptonType >::setIsolation(), pat::helper::KinResolutionsLoader::setResolutions(), pat::Tau::setTauIDs(), skipMissingTauID_, AlCaHLTBitMon_QueryRunRegistry::string, tauIDSrcs_, tauJetCorrFactorsTokens_, tauTransverseImpactParameterSrc_, tauTransverseImpactParameterToken_, HiIsolationCommonParameters_cff::track, userDataHelper_, and useUserData_.

{
  // switch off embedding (in unschedules mode)
  if (iEvent.isRealData()){
    addGenMatch_    = false;
    embedGenMatch_  = false;
    addGenJetMatch_ = false;
  }

  // Get the collection of taus from the event
  edm::Handle<edm::View<reco::BaseTau> > anyTaus;
  try {
    iEvent.getByToken(baseTauToken_, anyTaus);
  } catch (const edm::Exception &e) {
    edm::LogWarning("DataSource") << "WARNING! No Tau collection found. This missing input will not block the job. Instead, an empty tau collection is being be produced.";
    auto patTaus = std::make_unique<std::vector<Tau>>();
    iEvent.put(std::move(patTaus));
    return;
  }

  if (isolator_.enabled()) isolator_.beginEvent(iEvent,iSetup);

  if (efficiencyLoader_.enabled()) efficiencyLoader_.newEvent(iEvent);
  if (resolutionLoader_.enabled()) resolutionLoader_.newEvent(iEvent, iSetup);

  std::vector<edm::Handle<edm::ValueMap<IsoDeposit> > > deposits(isoDepositTokens_.size());
  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
    iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
  }

  // prepare the MC matching
  std::vector<edm::Handle<edm::Association<reco::GenParticleCollection> > >genMatches(genMatchTokens_.size());
  if (addGenMatch_) {
    for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
      iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
    }
  }

  edm::Handle<edm::Association<reco::GenJetCollection> > genJetMatch;
  if (addGenJetMatch_) iEvent.getByToken(genJetMatchToken_, genJetMatch);

  // read in the jet correction factors ValueMap
  std::vector<edm::ValueMap<TauJetCorrFactors> > tauJetCorrs;
  if (addTauJetCorrFactors_) {
    for ( size_t i = 0; i < tauJetCorrFactorsTokens_.size(); ++i ) {
      edm::Handle<edm::ValueMap<TauJetCorrFactors> > tauJetCorr;
      iEvent.getByToken(tauJetCorrFactorsTokens_[i], tauJetCorr);
      tauJetCorrs.push_back( *tauJetCorr );
    }
  }

  auto patTaus = std::make_unique<std::vector<Tau>>();

  bool first=true; // this is introduced to issue warnings only for the first tau-jet
  for (size_t idx = 0, ntaus = anyTaus->size(); idx < ntaus; ++idx) {
    edm::RefToBase<reco::BaseTau> tausRef = anyTaus->refAt(idx);
    edm::Ptr<reco::BaseTau> tausPtr = anyTaus->ptrAt(idx);

    Tau aTau(tausRef);
    if (embedLeadTrack_)       aTau.embedLeadTrack();
    if (embedSignalTracks_)    aTau.embedSignalTracks();
    if (embedIsolationTracks_) aTau.embedIsolationTracks();
    if (embedLeadPFCand_) {
      if (aTau.isPFTau() )
    aTau.embedLeadPFCand();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedLeadPFChargedHadrCand_) {
      if (aTau.isPFTau() )
    aTau.embedLeadPFChargedHadrCand();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedLeadPFNeutralCand_) {
      if (aTau.isPFTau() )
    aTau.embedLeadPFNeutralCand();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedSignalPFCands_) {
      if (aTau.isPFTau() )
    aTau.embedSignalPFCands();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedSignalPFChargedHadrCands_) {
      if (aTau.isPFTau() )
    aTau.embedSignalPFChargedHadrCands();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedSignalPFNeutralHadrCands_) {
      if (aTau.isPFTau() )
    aTau.embedSignalPFNeutralHadrCands();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedSignalPFGammaCands_) {
      if (aTau.isPFTau() )
    aTau.embedSignalPFGammaCands();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedIsolationPFCands_) {
      if (aTau.isPFTau() )
    aTau.embedIsolationPFCands();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedIsolationPFChargedHadrCands_) {
      if (aTau.isPFTau() )
    aTau.embedIsolationPFChargedHadrCands();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedIsolationPFNeutralHadrCands_) {
      if (aTau.isPFTau() )
    aTau.embedIsolationPFNeutralHadrCands();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }
    if (embedIsolationPFGammaCands_) {
      if (aTau.isPFTau() )
    aTau.embedIsolationPFGammaCands();
      else
    edm::LogWarning("Type Error") << "Embedding a PFTau-specific information into a pat::Tau which wasn't made from a reco::PFTau is impossible.\n";
    }

    if (addTauJetCorrFactors_) {
      // add additional JetCorrs to the jet
      for ( unsigned int i=0; i<tauJetCorrs.size(); ++i ) {
    const TauJetCorrFactors& tauJetCorr = tauJetCorrs[i][tausRef];
    // uncomment for debugging
    // tauJetCorr.print();
    aTau.addJECFactors(tauJetCorr);
      }
      std::vector<std::string> levels = tauJetCorrs[0][tausRef].correctionLabels();
      if(std::find(levels.begin(), levels.end(), "L2L3Residual")!=levels.end()){
    aTau.initializeJEC(tauJetCorrs[0][tausRef].jecLevel("L2L3Residual"));
      }
      else if(std::find(levels.begin(), levels.end(), "L3Absolute")!=levels.end()){
    aTau.initializeJEC(tauJetCorrs[0][tausRef].jecLevel("L3Absolute"));
      }
      else{
    aTau.initializeJEC(tauJetCorrs[0][tausRef].jecLevel("Uncorrected"));
    if(first){
      edm::LogWarning("L3Absolute not found")
        << "L2L3Residual and L3Absolute are not part of the correction applied jetCorrFactors \n"
        << "of module " <<  tauJetCorrs[0][tausRef].jecSet() << " jets will remain"
        << " uncorrected.";
      first=false;
    }
      }
    }

    // store the match to the generated final state muons
    if (addGenMatch_) {
      for(size_t i = 0, n = genMatches.size(); i < n; ++i) {
          reco::GenParticleRef genTau = (*genMatches[i])[tausRef];
          aTau.addGenParticleRef(genTau);
      }
      if (embedGenMatch_) aTau.embedGenParticle();
    }

    // store the match to the visible part of the generated tau
    if (addGenJetMatch_) {
      reco::GenJetRef genJetTau = (*genJetMatch)[tausRef];
      if (genJetTau.isNonnull() && genJetTau.isAvailable() ) {
        aTau.setGenJet( genJetTau );
      } // leave empty if no match found
    }

    // prepare ID extraction
    if ( addTauID_ ) {
      std::string missingDiscriminators;
      std::vector<pat::Tau::IdPair> ids(tauIDSrcs_.size());
      for ( size_t i = 0; i < tauIDSrcs_.size(); ++i ) {
    if ( typeid(*tausRef) == typeid(reco::PFTau) ) {
      //std::cout << "filling PFTauDiscriminator '" << tauIDSrcs_[i].first << "' into pat::Tau object..." << std::endl;
      edm::Handle<reco::PFTauCollection> pfTauCollection;
      iEvent.getByToken(pfTauToken_, pfTauCollection);

      edm::Handle<reco::PFTauDiscriminator> pfTauIdDiscr;
      iEvent.getByToken(pfTauIDTokens_[i], pfTauIdDiscr);

      if(skipMissingTauID_ && !pfTauIdDiscr.isValid()){
        if(!missingDiscriminators.empty()){
          missingDiscriminators+=", ";
        }
        missingDiscriminators+=tauIDSrcs_[i].first;
        continue;
      }
      ids[i].first = tauIDSrcs_[i].first;
      ids[i].second = getTauIdDiscriminator(pfTauCollection, idx, pfTauIdDiscr);
    } else if ( typeid(*tausRef) == typeid(reco::CaloTau) ) {
      //std::cout << "filling CaloTauDiscriminator '" << tauIDSrcs_[i].first << "' into pat::Tau object..." << std::endl;
      edm::Handle<reco::CaloTauCollection> caloTauCollection;
      iEvent.getByToken(caloTauToken_, caloTauCollection);

      edm::Handle<reco::CaloTauDiscriminator> caloTauIdDiscr;
      iEvent.getByToken(caloTauIDTokens_[i], caloTauIdDiscr);

      if(skipMissingTauID_ && !caloTauIdDiscr.isValid()){
        if(!missingDiscriminators.empty()){
          missingDiscriminators+=", ";
        }
        missingDiscriminators+=tauIDSrcs_[i].first;
        continue;
      }
      ids[i].first = tauIDSrcs_[i].first;
      ids[i].second = getTauIdDiscriminator(caloTauCollection, idx, caloTauIdDiscr);
    } else {
      throw cms::Exception("Type Mismatch") <<
        "PATTauProducer: unsupported datatype '" << typeid(*tausRef).name() << "' for tauSource\n";
    }
      }
      if(!missingDiscriminators.empty() && firstOccurence_){
    edm::LogWarning("DataSource") << "The following tau discriminators have not been found in the event:\n" 
                      << missingDiscriminators <<"\n"
                      << "They will not be embedded into the pat::Tau object.\n"
                      << "Note: this message will be printed only at first occurence.";
    firstOccurence_=false;
      }
      aTau.setTauIDs(ids);
    }

    // extraction of reconstructed tau decay mode
    // (only available for PFTaus)
    if ( aTau.isPFTau() ) {
      edm::Handle<reco::PFTauCollection> pfTaus;
      iEvent.getByToken(pfTauToken_, pfTaus);
      reco::PFTauRef pfTauRef(pfTaus, idx);

      aTau.setDecayMode(pfTauRef->decayMode());
    }

    // extraction of variables needed to rerun MVA isolation and anti-electron discriminator on MiniAOD
    if( aTau.isPFTau() ) {
      edm::Handle<reco::PFTauCollection> pfTaus;
      iEvent.getByToken(pfTauToken_, pfTaus);
      reco::PFTauRef pfTauRef(pfTaus, idx);
      pat::tau::TauPFEssential& aTauPFEssential = aTau.pfEssential_[0];
      float ecalEnergy = 0;
      float hcalEnergy = 0;
      float sumPhiTimesEnergy = 0.;
      float sumEtaTimesEnergy = 0.;
      float sumEnergy = 0.;
      float leadChargedCandPt = -99;
      float leadChargedCandEtaAtEcalEntrance = -99; 
      const std::vector<reco::PFCandidatePtr>& signalCands = pfTauRef->signalPFCands();
      for(std::vector<reco::PFCandidatePtr>::const_iterator it = signalCands.begin(); it != signalCands.end(); ++it) {
        const reco::PFCandidatePtr& icand = *it;
        ecalEnergy += icand->ecalEnergy();
        hcalEnergy += icand->hcalEnergy();
    sumPhiTimesEnergy += icand->positionAtECALEntrance().phi()*icand->energy();     
    sumEtaTimesEnergy += icand->positionAtECALEntrance().eta()*icand->energy();
        sumEnergy += icand->energy();    
    const reco::Track* track = nullptr;
        if ( icand->trackRef().isNonnull() ) track = icand->trackRef().get();
        else if ( icand->muonRef().isNonnull() && icand->muonRef()->innerTrack().isNonnull()  ) track = icand->muonRef()->innerTrack().get();
        else if ( icand->muonRef().isNonnull() && icand->muonRef()->globalTrack().isNonnull() ) track = icand->muonRef()->globalTrack().get();
        else if ( icand->muonRef().isNonnull() && icand->muonRef()->outerTrack().isNonnull()  ) track = icand->muonRef()->outerTrack().get();
        else if ( icand->gsfTrackRef().isNonnull() ) track = icand->gsfTrackRef().get();
        if( track ) {
          if( track->pt() > leadChargedCandPt ) {
            leadChargedCandEtaAtEcalEntrance = icand->positionAtECALEntrance().eta();
            leadChargedCandPt = track->pt();
          }
        }       
      }
      aTauPFEssential.ecalEnergy_ = ecalEnergy;
      aTauPFEssential.hcalEnergy_ = hcalEnergy;
      aTauPFEssential.ptLeadChargedCand_ = leadChargedCandPt;      
      aTauPFEssential.etaAtEcalEntranceLeadChargedCand_ = leadChargedCandEtaAtEcalEntrance;
      if (sumEnergy != 0.) {
        aTauPFEssential.phiAtEcalEntrance_ = sumPhiTimesEnergy/sumEnergy;
        aTauPFEssential.etaAtEcalEntrance_ = sumEtaTimesEnergy/sumEnergy;
      }
      else {
        aTauPFEssential.phiAtEcalEntrance_ = -99.;
        aTauPFEssential.etaAtEcalEntrance_ = -99.;
      } 
      float leadingTrackNormChi2 = 0;
      float ecalEnergyLeadChargedHadrCand = -99.;
      float hcalEnergyLeadChargedHadrCand = -99.;
      float emFraction = -1.;
      float myHCALenergy = 0.;
      float myECALenergy = 0.;  
      const reco::PFCandidatePtr& leadingPFCharged = pfTauRef->leadPFChargedHadrCand();
      if(leadingPFCharged.isNonnull()) {
    ecalEnergyLeadChargedHadrCand = leadingPFCharged->ecalEnergy();
        hcalEnergyLeadChargedHadrCand = leadingPFCharged->hcalEnergy(); 
        reco::TrackRef trackRef = leadingPFCharged->trackRef();
        if( trackRef.isNonnull() ) {
          leadingTrackNormChi2 = trackRef->normalizedChi2();            
      for( std::vector<reco::PFCandidatePtr>::const_iterator tauIt = pfTauRef->isolationPFCands().begin(); tauIt!=pfTauRef->isolationPFCands().end(); ++tauIt ){
        myHCALenergy += (*tauIt)->hcalEnergy();
        myECALenergy += (*tauIt)->ecalEnergy();
      }
      for( std::vector<reco::PFCandidatePtr>::const_iterator tauIt = pfTauRef->signalPFCands().begin(); tauIt!=pfTauRef->signalPFCands().end(); ++tauIt ){
        myHCALenergy += (*tauIt)->hcalEnergy();
        myECALenergy += (*tauIt)->ecalEnergy();
      }   
      if( myHCALenergy + myECALenergy != 0. ) {
            emFraction = myECALenergy/( myHCALenergy + myECALenergy);    
      }
        }
      }
      aTauPFEssential.emFraction_ = emFraction;
      aTauPFEssential.leadingTrackNormChi2_ = leadingTrackNormChi2;
      aTauPFEssential.ecalEnergyLeadChargedHadrCand_ = ecalEnergyLeadChargedHadrCand;
      aTauPFEssential.hcalEnergyLeadChargedHadrCand_ = hcalEnergyLeadChargedHadrCand;   
      // extraction of tau lifetime information
      if( tauTransverseImpactParameterSrc_.label() != "" ) {
        edm::Handle<PFTauTIPAssociationByRef> tauLifetimeInfos;
        iEvent.getByToken(tauTransverseImpactParameterToken_, tauLifetimeInfos);
        const reco::PFTauTransverseImpactParameter& tauLifetimeInfo = *(*tauLifetimeInfos)[pfTauRef];
        pat::tau::TauPFEssential& aTauPFEssential = aTau.pfEssential_[0];
        aTauPFEssential.dxy_PCA_ = tauLifetimeInfo.dxy_PCA();
        aTauPFEssential.dxy_ = tauLifetimeInfo.dxy();
        aTauPFEssential.dxy_error_ = tauLifetimeInfo.dxy_error();
        aTauPFEssential.hasSV_ = tauLifetimeInfo.hasSecondaryVertex();
        aTauPFEssential.flightLength_ = tauLifetimeInfo.flightLength();
        aTauPFEssential.flightLengthSig_ = tauLifetimeInfo.flightLengthSig();
        aTauPFEssential.ip3d_ = tauLifetimeInfo.ip3d();
        aTauPFEssential.ip3d_error_ = tauLifetimeInfo.ip3d_error();
      }
    }

    // Isolation
    if (isolator_.enabled()) {
      isolator_.fill(*anyTaus, idx, isolatorTmpStorage_);
      typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
      // better to loop backwards, so the vector is resized less times
      for ( IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(),
          ed = isolatorTmpStorage_.rend(); it != ed; ++it) {
    aTau.setIsolation(it->first, it->second);
      }
    }

    for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
      aTau.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[tausRef]);
    }

    if (efficiencyLoader_.enabled()) {
      efficiencyLoader_.setEfficiencies( aTau, tausRef );
    }

    if (resolutionLoader_.enabled()) {
      resolutionLoader_.setResolutions(aTau);
    }

    if ( useUserData_ ) {
      userDataHelper_.add( aTau, iEvent, iSetup );
    }

    patTaus->push_back(aTau);
  }

  // sort taus in pT
  std::sort(patTaus->begin(), patTaus->end(), pTTauComparator_);

  // put genEvt object in Event
  iEvent.put(std::move(patTaus));

  // clean up
  if (isolator_.enabled()) isolator_.endEvent();
}

Member Data Documentation

bool pat::PATTauProducer::addEfficiencies_

private

Definition at line 106 of file PATTauProducer.h.

Referenced by PATTauProducer().

bool pat::PATTauProducer::addGenJetMatch_

private

Definition at line 85 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::addGenMatch_

private

Definition at line 81 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::addResolutions_

private

Definition at line 109 of file PATTauProducer.h.

Referenced by PATTauProducer().

bool pat::PATTauProducer::addTauID_

private

Definition at line 92 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::addTauJetCorrFactors_

private

Definition at line 89 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

edm::EDGetTokenT<edm::View<reco::BaseTau> > pat::PATTauProducer::baseTauToken_

private

Definition at line 61 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

std::vector<edm::EDGetTokenT<reco::CaloTauDiscriminator> > pat::PATTauProducer::caloTauIDTokens_

private

Definition at line 95 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

edm::EDGetTokenT<reco::CaloTauCollection> pat::PATTauProducer::caloTauToken_

private

Definition at line 64 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

pat::helper::EfficiencyLoader pat::PATTauProducer::efficiencyLoader_

private

Definition at line 107 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedGenJetMatch_

private

Definition at line 86 of file PATTauProducer.h.

Referenced by PATTauProducer().

bool pat::PATTauProducer::embedGenMatch_

private

Definition at line 82 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedIsolationPFCands_

private

Definition at line 76 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedIsolationPFChargedHadrCands_

private

Definition at line 77 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedIsolationPFGammaCands_

private

Definition at line 79 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedIsolationPFNeutralHadrCands_

private

Definition at line 78 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedIsolationTracks_

private

Definition at line 66 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedLeadPFCand_

private

Definition at line 69 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedLeadPFChargedHadrCand_

private

Definition at line 70 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedLeadPFNeutralCand_

private

Definition at line 71 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedLeadTrack_

private

Definition at line 67 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedSignalPFCands_

private

Definition at line 72 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedSignalPFChargedHadrCands_

private

Definition at line 73 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedSignalPFGammaCands_

private

Definition at line 75 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedSignalPFNeutralHadrCands_

private

Definition at line 74 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::embedSignalTracks_

private

Definition at line 68 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::firstOccurence_

private

Definition at line 58 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

edm::EDGetTokenT<edm::Association<reco::GenJetCollection> > pat::PATTauProducer::genJetMatchToken_

private

Definition at line 87 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

std::vector<edm::EDGetTokenT<edm::Association<reco::GenParticleCollection> > > pat::PATTauProducer::genMatchTokens_

private

Definition at line 83 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

std::vector<std::pair<pat::IsolationKeys,edm::InputTag> > pat::PATTauProducer::isoDepositLabels_

private

Definition at line 103 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

std::vector<edm::EDGetTokenT<edm::ValueMap<IsoDeposit> > > pat::PATTauProducer::isoDepositTokens_

private

Definition at line 104 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

pat::helper::MultiIsolator pat::PATTauProducer::isolator_

private

Definition at line 101 of file PATTauProducer.h.

Referenced by produce().

pat::helper::MultiIsolator::IsolationValuePairs pat::PATTauProducer::isolatorTmpStorage_

private

Definition at line 102 of file PATTauProducer.h.

Referenced by produce().

std::vector<edm::EDGetTokenT<reco::PFTauDiscriminator> > pat::PATTauProducer::pfTauIDTokens_

private

Definition at line 96 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

edm::EDGetTokenT<reco::PFTauCollection> pat::PATTauProducer::pfTauToken_

private

Definition at line 63 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

GreaterByPt<Tau> pat::PATTauProducer::pTTauComparator_

private

Definition at line 99 of file PATTauProducer.h.

Referenced by produce().

pat::helper::KinResolutionsLoader pat::PATTauProducer::resolutionLoader_

private

Definition at line 110 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::skipMissingTauID_

private

Definition at line 97 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

std::vector<NameTag> pat::PATTauProducer::tauIDSrcs_

private

Definition at line 94 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

std::vector<edm::EDGetTokenT<edm::ValueMap<TauJetCorrFactors> > > pat::PATTauProducer::tauJetCorrFactorsTokens_

private

Definition at line 90 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

edm::InputTag pat::PATTauProducer::tauTransverseImpactParameterSrc_

private

Definition at line 65 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

edm::EDGetTokenT<PFTauTIPAssociationByRef> pat::PATTauProducer::tauTransverseImpactParameterToken_

private

Definition at line 62 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

pat::PATUserDataHelper<pat::Tau> pat::PATTauProducer::userDataHelper_

private

Definition at line 113 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().

bool pat::PATTauProducer::useUserData_

private

Definition at line 112 of file PATTauProducer.h.

Referenced by PATTauProducer(), and produce().