RecoTauCleanerImpl< Prod > Class Template Reference

Inheritance diagram for RecoTauCleanerImpl< Prod >:

Classes
struct	CleanerEntryType
class	RemoveDuplicateJets

Public Member Functions
template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
void	produce (edm::Event &evt, const edm::EventSetup &es) override
	RecoTauCleanerImpl (const edm::ParameterSet &pset)
	~RecoTauCleanerImpl () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

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

Private Types
typedef reco::tau::RecoTauCleanerPlugin	Cleaner
typedef std::vector< std::unique_ptr< CleanerEntryType > >	CleanerList
typedef Prod::value_type	output_type

Private Attributes
CleanerList	cleaners_
std::unique_ptr< const StringCutObjectSelector< reco::PFTau > >	outputSelector_
edm::EDGetTokenT< reco::PFTauCollection >	tau_token
edm::InputTag	tauSrc_
int	verbosity_

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

template<typename Prod>
class RecoTauCleanerImpl< Prod >

Definition at line 44 of file RecoTauCleaner.cc.

Member Typedef Documentation

Cleaner

template<typename Prod >

typedef reco::tau::RecoTauCleanerPlugin RecoTauCleanerImpl< Prod >::Cleaner

private

Definition at line 45 of file RecoTauCleaner.cc.

CleanerList

template<typename Prod >

typedef std::vector<std::unique_ptr<CleanerEntryType> > RecoTauCleanerImpl< Prod >::CleanerList

private

Definition at line 50 of file RecoTauCleaner.cc.

output_type

template<typename Prod >

typedef Prod::value_type RecoTauCleanerImpl< Prod >::output_type

private

Definition at line 52 of file RecoTauCleaner.cc.

Constructor & Destructor Documentation

RecoTauCleanerImpl()

template<typename Prod >

RecoTauCleanerImpl< Prod >::RecoTauCleanerImpl ( const edm::ParameterSet &  pset )

explicit

Definition at line 77 of file RecoTauCleaner.cc.

                                                                        {
  tauSrc_ = pset.getParameter<edm::InputTag>("src");
  tau_token = consumes<reco::PFTauCollection>(tauSrc_);
  // Build our list of quality plugins
  typedef std::vector<edm::ParameterSet> VPSet;
  // Get each of our tau builders
  const VPSet& cleaners = pset.getParameter<VPSet>("cleaners");
  for (VPSet::const_iterator cleanerPSet = cleaners.begin(); cleanerPSet != cleaners.end(); ++cleanerPSet) {
    auto cleanerEntry = std::make_unique<CleanerEntryType>();
    // Get plugin name
    const std::string& pluginType = cleanerPSet->getParameter<std::string>("plugin");
    // Build the plugin
    cleanerEntry->plugin_ = RecoTauCleanerPluginFactory::get()->create(pluginType, *cleanerPSet, consumesCollector());
    cleanerEntry->tolerance_ = cleanerPSet->getParameter<double>("tolerance");
    cleaners_.emplace_back(std::move(cleanerEntry));
  }
 
  // Check if we want to apply a final output selection
  std::string selection = pset.getParameter<std::string>("outputSelection");
  if (!selection.empty()) {
    outputSelector_ = std::make_unique<StringCutObjectSelector<reco::PFTau>>(selection);
  }
 
  // Enable/disable debug output
  verbosity_ = pset.getParameter<int>("verbosity");
 
  // Build the predicate that ranks our taus.
  produces<Prod>();
}

References HLT_2018_cff::cleaners, get, eostools::move(), muonDTDigis_cfi::pset, corrVsCorr::selection, AlCaHLTBitMon_QueryRunRegistry::string, and HistogramManager_cfi::VPSet().

~RecoTauCleanerImpl()

template<typename Prod >

RecoTauCleanerImpl< Prod >::~RecoTauCleanerImpl ( )

override

Definition at line 108 of file RecoTauCleaner.cc.

{}

Member Function Documentation

fillDescriptions() [1/3]

template<typename Prod >

static void RecoTauCleanerImpl< Prod >::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

fillDescriptions() [2/3]

template<>

void RecoTauCleanerImpl< reco::PFTauCollection >::fillDescriptions

(

edm::ConfigurationDescriptions &

descriptions

)

Definition at line 297 of file RecoTauCleaner.cc.

                                                                                                         {
  // RecoTauCleaner
  edm::ParameterSetDescription desc;
  desc.add<std::string>("outputSelection", "");
  {
    // this description is the validator for all PSets in the cleaners VPSet passed to the plugin from the python configuration
    edm::ParameterSetDescription vps_description_for_cleaners;
    // the common parameters for all cleaners
    // no default value is provided -- the user has to provide the values for these parameters
    vps_description_for_cleaners.add<std::string>("plugin");
    vps_description_for_cleaners.add<double>("tolerance", 0);
    vps_description_for_cleaners.add<std::string>("name");
 
    // the following parameters are not common for all cleaners, they are needed for few PSets, therefore they are added as optional
    //     these optional parameters are used in the default cleaners vector
    vps_description_for_cleaners.addOptional<int>("passForCharge");
    vps_description_for_cleaners.addOptional<double>("selectionFailValue");
    vps_description_for_cleaners.addOptional<std::vector<unsigned int>>("nprongs");
    vps_description_for_cleaners.addOptional<edm::InputTag>("src");
    vps_description_for_cleaners.addOptional<double>("minTrackPt");
    vps_description_for_cleaners.addOptional<std::string>("selection");
    vps_description_for_cleaners.addOptional<std::string>("selectionPassFunction");
    //     more PSets for cleaners can be found in
    //     RecoTauTag/RecoTau/python/RecoTauCleanerPlugins.py
    //     however, at this moment (2018-11-09) they do not have any new optional parameters
 
    // the cleaner defaults, as in RecoTauTag/RecoTau/python/RecoTauCleaner_cfi.py
    std::vector<edm::ParameterSet> default_cleaners;
    default_cleaners.reserve(7);
    {
      edm::ParameterSet cleaner_Charge;
      cleaner_Charge.addParameter<std::string>("name", "Charge");
      cleaner_Charge.addParameter<std::string>("plugin", "RecoTauChargeCleanerPlugin");
      cleaner_Charge.addParameter<int>("passForCharge", 1);
      cleaner_Charge.addParameter<double>("selectionFailValue", 0);
      cleaner_Charge.addParameter<std::vector<unsigned int>>("nprongs",
                                                             {
                                                                 1,
                                                                 3,
                                                             });
      cleaner_Charge.addParameter<double>("tolerance", 0);
      default_cleaners.push_back(cleaner_Charge);
    }
    {
      edm::ParameterSet temp2;
      temp2.addParameter<std::string>("name", "HPS_Select");
      temp2.addParameter<std::string>("plugin", "RecoTauDiscriminantCleanerPlugin");
      temp2.addParameter<edm::InputTag>("src", edm::InputTag("hpsSelectionDiscriminator"));
      temp2.addParameter<double>("tolerance", 0);
      default_cleaners.push_back(temp2);
    }
    {
      edm::ParameterSet temp2;
      temp2.addParameter<std::string>("name", "killSoftTwoProngTaus");
      temp2.addParameter<std::string>("plugin", "RecoTauSoftTwoProngTausCleanerPlugin");
      temp2.addParameter<double>("minTrackPt", 5.0);
      temp2.addParameter<double>("tolerance", 0);
      default_cleaners.push_back(temp2);
    }
    {
      edm::ParameterSet temp2;
      temp2.addParameter<std::string>("name", "ChargedHadronMultiplicity");
      temp2.addParameter<std::string>("plugin", "RecoTauChargedHadronMultiplicityCleanerPlugin");
      temp2.addParameter<double>("tolerance", 0);
      default_cleaners.push_back(temp2);
    }
    {
      edm::ParameterSet temp2;
      temp2.addParameter<std::string>("name", "Pt");
      temp2.addParameter<std::string>("plugin", "RecoTauStringCleanerPlugin");
      temp2.addParameter<std::string>("selectionPassFunction", "-pt()");
      temp2.addParameter<std::string>("selection", "leadPFCand().isNonnull()");
      temp2.addParameter<double>("selectionFailValue", 1000.0);
      temp2.addParameter<double>("tolerance", 0.01);
      default_cleaners.push_back(temp2);
    }
    {
      edm::ParameterSet temp2;
      temp2.addParameter<std::string>("name", "StripMultiplicity");
      temp2.addParameter<std::string>("plugin", "RecoTauStringCleanerPlugin");
      temp2.addParameter<std::string>("selectionPassFunction", "-signalPiZeroCandidates().size()");
      temp2.addParameter<std::string>("selection", "leadPFCand().isNonnull()");
      temp2.addParameter<double>("selectionFailValue", 1000.0);
      temp2.addParameter<double>("tolerance", 0);
      default_cleaners.push_back(temp2);
    }
    {
      edm::ParameterSet temp2;
      temp2.addParameter<std::string>("name", "CombinedIsolation");
      temp2.addParameter<std::string>("plugin", "RecoTauStringCleanerPlugin");
      temp2.addParameter<std::string>("selectionPassFunction",
                                      "isolationPFChargedHadrCandsPtSum() + isolationPFGammaCandsEtSum()");
      temp2.addParameter<std::string>("selection", "leadPFCand().isNonnull()");
      temp2.addParameter<double>("selectionFailValue", 1000.0);
      temp2.addParameter<double>("tolerance", 0);
      default_cleaners.push_back(temp2);
    }
 
    desc.addVPSet("cleaners", vps_description_for_cleaners, default_cleaners);
  }
 
  desc.add<int>("verbosity", 0);
  desc.add<edm::InputTag>("src", edm::InputTag("combinatoricRecoTaus"));
  descriptions.add("RecoTauCleaner", desc);
}

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

fillDescriptions() [3/3]

template<>

void RecoTauCleanerImpl< reco::PFTauRefVector >::fillDescriptions

(

edm::ConfigurationDescriptions &

descriptions

)

Definition at line 404 of file RecoTauCleaner.cc.

                                                                                                        {
  // there was no cfi file for this plugin
}

produce()

template<typename Prod >

void RecoTauCleanerImpl< Prod >::produce ( edm::Event &  evt, const edm::EventSetup &  es  )

override

Definition at line 221 of file RecoTauCleaner.cc.

                                                                             {
  if (verbosity_) {
    std::cout << "<RecoTauCleanerImpl::produce>:" << std::endl;
  }
 
  // Update all our cleaners with the event info if they need it
  for (typename CleanerList::iterator cleaner = cleaners_.begin(); cleaner != cleaners_.end(); ++cleaner) {
    (*cleaner)->plugin_->setup(evt, es);
  }
 
  // Get the input collection of all taus. Some are from the same PFJet. We must clean them.
  edm::Handle<reco::PFTauCollection> inputTaus;
  evt.getByToken(tau_token, inputTaus);
 
  // Sort the input tau refs according to our predicate
  std::list<PFTauRankType*> rankedTaus;
  size_t N = inputTaus->size();
  for (size_t idx = 0; idx < N; ++idx) {
    reco::PFTauRef inputRef(inputTaus, idx);
    PFTauRankType* rankedTau = new PFTauRankType(inputRef);
    rankedTau->N_ = cleaners_.size();
    rankedTau->ranks_.reserve(rankedTau->N_);
    rankedTau->tolerances_.reserve(rankedTau->N_);
    for (typename CleanerList::const_iterator cleaner = cleaners_.begin(); cleaner != cleaners_.end(); ++cleaner) {
      rankedTau->ranks_.push_back((*(*cleaner)->plugin_)(inputRef));
      rankedTau->tolerances_.push_back((*cleaner)->tolerance_);
    }
    if (verbosity_) {
      std::ostringstream os;
      os << "rankedTau #" << idx;
      rankedTau->print(os.str());
    }
    rankedTaus.push_back(rankedTau);
  }
  rankedTaus.sort(isHigherRank);
 
  // Make an STL algorithm friendly vector of refs
  typedef std::vector<reco::PFTauRef> PFTauRefs;
  PFTauRefs dirty(inputTaus->size());
  size_t idx_sorted = 0;
  for (std::list<PFTauRankType*>::const_iterator rankedTau = rankedTaus.begin(); rankedTau != rankedTaus.end();
       ++rankedTau) {
    dirty[idx_sorted] = (*rankedTau)->tauRef_;
    if (verbosity_) {
      std::cout << "dirty[" << idx_sorted << "] = " << dirty[idx_sorted].id() << ":" << dirty[idx_sorted].key()
                << std::endl;
    }
    delete (*rankedTau);
    ++idx_sorted;
  }
 
  // Clean the taus, ensuring that only one tau per jet is produced
  PFTauRefs cleanTaus = reco::tau::cleanOverlaps<PFTauRefs, RemoveDuplicateJets>(dirty);
 
  // create output collection
  auto output = std::make_unique<Prod>();
  //output->reserve(cleanTaus.size());
 
  // Copy clean refs into output
  for (PFTauRefs::const_iterator tau = cleanTaus.begin(); tau != cleanTaus.end(); ++tau) {
    // If we are applying an output selection, check if it passes
    bool selected = true;
    if (outputSelector_.get() && !(*outputSelector_)(**tau)) {
      selected = false;
    }
    if (selected) {
      output->push_back(convert<output_type>(*tau));
    }
  }
  evt.put(std::move(output));
}

References gather_cfg::cout, edm::Event::getByToken(), charmTagsComputerCvsB_cfi::idx, eostools::move(), N, convertSQLitetoXML_cfg::output, edm::Event::put(), and metsig::tau.

Member Data Documentation

cleaners_

template<typename Prod >

CleanerList RecoTauCleanerImpl< Prod >::cleaners_

private

Definition at line 69 of file RecoTauCleaner.cc.

outputSelector_

template<typename Prod >

std::unique_ptr<const StringCutObjectSelector<reco::PFTau> > RecoTauCleanerImpl< Prod >::outputSelector_

private

Definition at line 71 of file RecoTauCleaner.cc.

tau_token

template<typename Prod >

edm::EDGetTokenT<reco::PFTauCollection> RecoTauCleanerImpl< Prod >::tau_token

private

Definition at line 72 of file RecoTauCleaner.cc.

tauSrc_

template<typename Prod >

edm::InputTag RecoTauCleanerImpl< Prod >::tauSrc_

private

Definition at line 68 of file RecoTauCleaner.cc.

verbosity_

template<typename Prod >

int RecoTauCleanerImpl< Prod >::verbosity_

private

Definition at line 73 of file RecoTauCleaner.cc.