edm::HiMixingModule Class Reference

Inheritance diagram for edm::HiMixingModule:

Public Member Functions
	HiMixingModule (const edm::ParameterSet &)
	~HiMixingModule () 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 Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
bool	verifyRegistry (std::string object, std::string subdet, InputTag &tag, std::string &label)

Private Attributes
std::vector< HiMixingWorkerBase * >	workers_

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

Definition at line 151 of file HiMixingModule.cc.

Constructor & Destructor Documentation

HiMixingModule()

HiMixingModule::HiMixingModule ( const edm::ParameterSet &  pset )

explicit

Definition at line 177 of file HiMixingModule.cc.

                                                            {
    ParameterSet ps = pset.getParameter<ParameterSet>("mixObjects");
    std::vector<std::string> names = ps.getParameterNames();
    std::vector<std::string> simtags = pset.getParameter<std::vector<std::string> >("srcSIM");
    std::vector<std::string> gentags = pset.getParameter<std::vector<std::string> >("srcGEN");
 
    if (simtags.size() != gentags.size())
      LogError("MixingInput") << "Generator and Simulation input lists are not matching each other" << endl;
 
    for (std::vector<string>::iterator it = names.begin(); it != names.end(); ++it) {
      ParameterSet pstag = ps.getParameter<ParameterSet>((*it));
      if (!pstag.exists("type"))
        continue;  //to allow replacement by empty pset
      std::string object = pstag.getParameter<std::string>("type");
      std::vector<InputTag> tags = pstag.getParameter<std::vector<InputTag> >("input");
 
      std::string signal;
      for (size_t itag = 0; itag < tags.size(); ++itag) {
        InputTag tag = tags[itag];
        std::vector<InputTag> inputs;
 
        for (size_t input = 0; input < simtags.size(); ++input) {
          if (object == "HepMCProduct")
            signal = gentags[input];
          else
            signal = simtags[input];
          inputs.push_back(InputTag(signal, tag.instance()));
        }
 
        std::string label = tag.label() + tag.instance();
        //   verifyRegistry(object,std::string(""),tag,label);
        if (object == "HepMCProduct") {
          workers_.push_back(new HiMixingWorker<HepMCProduct>(object, inputs, label));
          produces<CrossingFrame<HepMCProduct> >(label);
          consumes<HepMCProduct>(tag);
        } else if (object == "SimTrack") {
          workers_.push_back(new HiMixingWorker<SimTrack>(object, inputs, label));
          produces<CrossingFrame<SimTrack> >(label);
          consumes<std::vector<SimTrack> >(tag);
        } else if (object == "SimVertex") {
          workers_.push_back(new HiMixingWorker<SimVertex>(object, inputs, label));
          produces<CrossingFrame<SimVertex> >(label);
          consumes<std::vector<SimVertex> >(tag);
        } else if (object == "PSimHit") {
          workers_.push_back(new HiMixingWorker<PSimHit>(object, inputs, label));
          produces<CrossingFrame<PSimHit> >(label);
          consumes<std::vector<PSimHit> >(tag);
        } else if (object == "PCaloHit") {
          workers_.push_back(new HiMixingWorker<PCaloHit>(object, inputs, label));
          produces<CrossingFrame<PCaloHit> >(label);
          consumes<std::vector<PCaloHit> >(tag);
        } else
          LogInfo("Error") << "What the hell is this object?!";
 
        LogInfo("HiMixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
                                  << label;
      }
    }
 
    produces<PileupMixingContent>();
  }

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), input, PixelMapPlotter::inputs, HLT_FULL_cff::InputTag, label, names, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, and triggerMatcherToHLTDebug_cfi::tags.

~HiMixingModule()

HiMixingModule::~HiMixingModule ( )

override

Definition at line 239 of file HiMixingModule.cc.

                                  {
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
  }

Member Function Documentation

produce()

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

overrideprivate

Definition at line 249 of file HiMixingModule.cc.

                                                                            {
    using namespace edm;
 
    for (size_t i = 0; i < workers_.size(); ++i) {
      (workers_[i])->addSignals(iEvent);
    }
 
    std::unique_ptr<PileupMixingContent> PileupMixing_ = std::make_unique<PileupMixingContent>();
    iEvent.put(std::move(PileupMixing_));
  }

References mps_fire::i, iEvent, and eostools::move().

verifyRegistry()

bool HiMixingModule::verifyRegistry ( std::string  object, std::string  subdet, InputTag &  tag, std::string &  label  )

private

Definition at line 260 of file HiMixingModule.cc.

                                                                                                         {
    // verify that the given product exists in the product registry
    // and create the label to be given to the CrossingFrame
 
    edm::Service<edm::ConstProductRegistry> reg;
    // Loop over provenance of products in registry.
    std::string lookfor;
    if (object == "HepMCProduct")
      lookfor = "edm::" + object;  //exception for HepMCProduct
    else if (object == "edm::HepMCProduct")
      lookfor = object;
    else
      lookfor = "std::vector<" + object + ">";
    bool found = false;
    for (edm::ProductRegistry::ProductList::const_iterator it = reg->productList().begin();
         it != reg->productList().end();
         ++it) {
      // See FWCore/Framework/interface/BranchDescription.h
      // BranchDescription contains all the information for the product.
      edm::BranchDescription desc = it->second;
      if (desc.className() == lookfor && desc.moduleLabel() == tag.label() &&
          desc.productInstanceName() == tag.instance()) {
        label = desc.moduleLabel() + desc.productInstanceName();
        found = true;
        /*
     wantedBranches_.push_back(desc.friendlyClassName() + '_' +
                   desc.moduleLabel() + '_' +
                   desc.productInstanceName());
     */
        break;
      }
    }
    if (!found) {
      LogWarning("MixingModule") << "!!!!!!!!!Could not find in registry requested object: " << object << " with "
                                 << tag << ".\nWill NOT be considered for mixing!!!!!!!!!";
      return false;
    }
 
    return true;
  }

References submitPVResolutionJobs::desc, newFWLiteAna::found, label, resolutioncreator_cfi::object, edm::ConstProductRegistry::productList(), AlCaHLTBitMon_QueryRunRegistry::string, and makeGlobalPositionRcd_cfg::tag.

Member Data Documentation

workers_

std::vector<HiMixingWorkerBase*> edm::HiMixingModule::workers_

private

Definition at line 163 of file HiMixingModule.cc.