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
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

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<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

template<typename Prod>
class RecoTauCleanerImpl< Prod >

Definition at line 42 of file RecoTauCleaner.cc.

Member Typedef Documentation

Cleaner

template<typename Prod >

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

private

Definition at line 43 of file RecoTauCleaner.cc.

CleanerList

template<typename Prod >

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

private

Definition at line 48 of file RecoTauCleaner.cc.

output_type

template<typename Prod >

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

private

Definition at line 50 of file RecoTauCleaner.cc.

Constructor & Destructor Documentation

RecoTauCleanerImpl()

template<typename Prod >

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

explicit

Definition at line 75 of file RecoTauCleaner.cc.

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

                                                                        {
  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>();
}

~RecoTauCleanerImpl()

template<typename Prod >

RecoTauCleanerImpl< Prod >::~RecoTauCleanerImpl ( )

override

Definition at line 106 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 295 of file RecoTauCleaner.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), submitPVResolutionJobs::desc, HLT_2022v11_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                         {
  // 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);
}

fillDescriptions() [3/3]

template<>

void RecoTauCleanerImpl< reco::PFTauRefVector >::fillDescriptions

(

edm::ConfigurationDescriptions &

descriptions

)

Definition at line 402 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 219 of file RecoTauCleaner.cc.

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

                                                                             {
  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));
}

Member Data Documentation

cleaners_

template<typename Prod >

CleanerList RecoTauCleanerImpl< Prod >::cleaners_

private

Definition at line 67 of file RecoTauCleaner.cc.

outputSelector_

template<typename Prod >

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

private

Definition at line 69 of file RecoTauCleaner.cc.

tau_token

template<typename Prod >

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

private

Definition at line 70 of file RecoTauCleaner.cc.

tauSrc_

template<typename Prod >

edm::InputTag RecoTauCleanerImpl< Prod >::tauSrc_

private

Definition at line 66 of file RecoTauCleaner.cc.

verbosity_

template<typename Prod >

int RecoTauCleanerImpl< Prod >::verbosity_

private

Definition at line 71 of file RecoTauCleaner.cc.