VersionedIdProducer< PhysicsObjectPtr, SelectorType > Class Template Reference

#include <VersionedIdProducer.h>

Inheritance diagram for VersionedIdProducer< PhysicsObjectPtr, SelectorType >:

Public Types
using	Collection = edm::View< PhysicsObjectType >
using	PhysicsObjectType = typename PhysicsObjectPtr::value_type
using	TokenType = edm::EDGetTokenT< Collection >
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

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
	VersionedIdProducer (const edm::ParameterSet &)
	~VersionedIdProducer () 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

Private Attributes
std::vector< std::unique_ptr< SelectorType > >	ids_
TokenType	physicsObjectSrc_
bool	verbose_

Detailed Description

template<class PhysicsObjectPtr, class SelectorType = VersionedSelector<PhysicsObjectPtr>>
class VersionedIdProducer< PhysicsObjectPtr, SelectorType >

Definition at line 27 of file VersionedIdProducer.h.

Member Typedef Documentation

Collection

template<class PhysicsObjectPtr , class SelectorType = VersionedSelector<PhysicsObjectPtr>>

using VersionedIdProducer< PhysicsObjectPtr, SelectorType >::Collection = edm::View<PhysicsObjectType>

Definition at line 31 of file VersionedIdProducer.h.

PhysicsObjectType

template<class PhysicsObjectPtr , class SelectorType = VersionedSelector<PhysicsObjectPtr>>

using VersionedIdProducer< PhysicsObjectPtr, SelectorType >::PhysicsObjectType = typename PhysicsObjectPtr::value_type

Definition at line 29 of file VersionedIdProducer.h.

TokenType

template<class PhysicsObjectPtr , class SelectorType = VersionedSelector<PhysicsObjectPtr>>

using VersionedIdProducer< PhysicsObjectPtr, SelectorType >::TokenType = edm::EDGetTokenT<Collection>

Definition at line 32 of file VersionedIdProducer.h.

Constructor & Destructor Documentation

VersionedIdProducer()

template<class PhysicsObjectPtr , class SelectorType >

VersionedIdProducer< PhysicsObjectPtr, SelectorType >::VersionedIdProducer ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 59 of file VersionedIdProducer.h.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), edm::ParameterSet::getParameterSetVector(), edm::ParameterSet::getUntrackedParameter(), versionedElectronIDProducer_cfi::idMD5, cutBasedElectronHLTPreselecition_Summer16_V1_cff::isPOGApproved, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                       {
  constexpr char bitmap_label[] = "Bitmap";

  verbose_ = iConfig.getUntrackedParameter<bool>("verbose", false);

  physicsObjectSrc_ = consumes<Collection>(iConfig.getParameter<edm::InputTag>("physicsObjectSrc"));

  const std::vector<edm::ParameterSet>& ids = iConfig.getParameterSetVector("physicsObjectIDs");
  for (const auto& id : ids) {
    const std::string& idMD5 = id.getParameter<std::string>("idMD5");
    const edm::ParameterSet& the_id = id.getParameterSet("idDefinition");
    const std::string& idname = the_id.getParameter<std::string>("idName");
    std::string calculated_md5;
    ids_.emplace_back(new SelectorType(the_id));
    calculated_md5 = ids_.back()->md5String();
    ids_.back()->setConsumes(consumesCollector());
    if (ids_.back()->cutFlowSize() == 0) {
      throw cms::Exception("InvalidCutFlow") << "Post-processing cutflow size is zero! You may have configured"
                                             << " the python incorrectly!";
    }

    if (idMD5 != calculated_md5) {
      edm::LogInfo("IdConfigurationNotValidated") << "ID: " << ids_.back()->name() << "\n"
                                                  << "The expected md5: " << idMD5 << " does not match the md5\n"
                                                  << "calculated by the ID: " << calculated_md5 << " please\n"
                                                  << "update your python configuration or determine the source\n"
                                                  << "of transcription error!";
    }

    std::stringstream idmsg;

    // dump whatever information about the ID we have
    idmsg << "Instantiated ID: " << idname << std::endl << "with MD5 hash: " << idMD5 << std::endl;
    const bool isPOGApproved = id.getUntrackedParameter<bool>("isPOGApproved", false);
    if (isPOGApproved) {
      idmsg << "This ID is POG approved!" << std::endl;
    } else {
      idmsg << "This ID is not POG approved and likely under development!!!\n"
            << "Please make sure to report your progress with this ID "
            << "at the next relevant POG meeting." << std::endl;
    }

    if (!isPOGApproved) {
      edm::LogWarning("IdInformation") << idmsg.str();
    } else {
      edm::LogInfo("IdInformation") << idmsg.str();
    }

    produces<std::string>(idname);
    produces<edm::ValueMap<bool>>(idname);
    produces<edm::ValueMap<float>>(idname);  // for PAT
    produces<edm::ValueMap<unsigned>>(idname);
    produces<edm::ValueMap<unsigned>>(idname + std::string(bitmap_label));
    produces<edm::ValueMap<vid::CutFlowResult>>(idname);
    produces<pat::UserDataCollection>(idname);
    produces<edm::ValueMap<edm::Ptr<pat::UserData>>>(idname);
  }
}

~VersionedIdProducer()

template<class PhysicsObjectPtr , class SelectorType = VersionedSelector<PhysicsObjectPtr>>

VersionedIdProducer< PhysicsObjectPtr, SelectorType >::~VersionedIdProducer ( )

inlineoverride

Definition at line 35 of file VersionedIdProducer.h.

{}

Member Function Documentation

produce()

template<class PhysicsObjectPtr , class SelectorType >

void VersionedIdProducer< PhysicsObjectPtr, SelectorType >::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

override

Definition at line 119 of file VersionedIdProducer.h.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), edm::helper::Filler< Map >::fill(), mps_fire::i, EcalPhiSymFlatTableProducers_cfi::id, iEvent, edm::helper::Filler< Map >::insert(), pat::UserData::make(), eostools::move(), edm::View< T >::ptrAt(), edm::View< T >::size(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                               {
  constexpr char bitmap_label[] = "Bitmap";

  edm::Handle<Collection> physicsObjectsHandle;
  iEvent.getByToken(physicsObjectSrc_, physicsObjectsHandle);

  const Collection& physicsobjects = *physicsObjectsHandle;

  for (const auto& id : ids_) {
    auto outPass = std::make_unique<edm::ValueMap<bool>>();
    auto outPassf = std::make_unique<edm::ValueMap<float>>();
    auto outHowFar = std::make_unique<edm::ValueMap<unsigned>>();
    auto outBitmap = std::make_unique<edm::ValueMap<unsigned>>();
    auto out_cfrs = std::make_unique<edm::ValueMap<vid::CutFlowResult>>();
    auto out_usrd = std::make_unique<pat::UserDataCollection>();

    std::vector<bool> passfail;
    std::vector<float> passfailf;
    std::vector<unsigned> howfar;
    std::vector<unsigned> bitmap;
    std::vector<vid::CutFlowResult> cfrs;

    for (size_t i = 0; i < physicsobjects.size(); ++i) {
      auto po = physicsobjects.ptrAt(i);
      passfail.push_back((*id)(po, iEvent));
      passfailf.push_back(passfail.back());
      howfar.push_back(id->howFarInCutFlow());
      bitmap.push_back(id->bitMap());
      cfrs.push_back(id->cutFlowResult());
      out_usrd->push_back(pat::UserData::make(cfrs.back(), false));
    }

    edm::ValueMap<bool>::Filler fillerpassfail(*outPass);
    fillerpassfail.insert(physicsObjectsHandle, passfail.begin(), passfail.end());
    fillerpassfail.fill();

    edm::ValueMap<float>::Filler fillerpassfailf(*outPassf);
    fillerpassfailf.insert(physicsObjectsHandle, passfailf.begin(), passfailf.end());
    fillerpassfailf.fill();

    edm::ValueMap<unsigned>::Filler fillerhowfar(*outHowFar);
    fillerhowfar.insert(physicsObjectsHandle, howfar.begin(), howfar.end());
    fillerhowfar.fill();

    edm::ValueMap<unsigned>::Filler fillerbitmap(*outBitmap);
    fillerbitmap.insert(physicsObjectsHandle, bitmap.begin(), bitmap.end());
    fillerbitmap.fill();

    edm::ValueMap<vid::CutFlowResult>::Filler fillercfr(*out_cfrs);
    fillercfr.insert(physicsObjectsHandle, cfrs.begin(), cfrs.end());
    fillercfr.fill();

    iEvent.put(std::move(outPass), id->name());
    iEvent.put(std::move(outPassf), id->name());
    iEvent.put(std::move(outHowFar), id->name());
    iEvent.put(std::move(outBitmap), id->name() + std::string(bitmap_label));
    iEvent.put(std::move(out_cfrs), id->name());
    iEvent.put(std::make_unique<std::string>(id->md5String()), id->name());
    auto usrd_handle = iEvent.put(std::move(out_usrd), id->name());
    //now add the value map of ptrs to user datas
    auto out_usrdptrs = std::make_unique<edm::ValueMap<edm::Ptr<pat::UserData>>>();
    std::vector<edm::Ptr<pat::UserData>> usrdptrs;
    for (unsigned i = 0; i < usrd_handle->size(); ++i) {
      usrdptrs.push_back(edm::Ptr<pat::UserData>(usrd_handle, i));
    }

    edm::ValueMap<edm::Ptr<pat::UserData>>::Filler fillerusrdptrs(*out_usrdptrs);
    fillerusrdptrs.insert(physicsObjectsHandle, usrdptrs.begin(), usrdptrs.end());
    fillerusrdptrs.fill();

    iEvent.put(std::move(out_usrdptrs), id->name());
  }
}

Member Data Documentation

ids_

template<class PhysicsObjectPtr , class SelectorType = VersionedSelector<PhysicsObjectPtr>>

std::vector<std::unique_ptr<SelectorType> > VersionedIdProducer< PhysicsObjectPtr, SelectorType >::ids_

private

Definition at line 44 of file VersionedIdProducer.h.

physicsObjectSrc_

template<class PhysicsObjectPtr , class SelectorType = VersionedSelector<PhysicsObjectPtr>>

TokenType VersionedIdProducer< PhysicsObjectPtr, SelectorType >::physicsObjectSrc_

private

Definition at line 42 of file VersionedIdProducer.h.

verbose_

template<class PhysicsObjectPtr , class SelectorType = VersionedSelector<PhysicsObjectPtr>>

bool VersionedIdProducer< PhysicsObjectPtr, SelectorType >::verbose_

private

Definition at line 41 of file VersionedIdProducer.h.