edm::CFWriter Class Reference

#include <CFWriter.h>

Inheritance diagram for edm::CFWriter:

Public Member Functions
void	beginRun (const edm::Run &run, const edm::EventSetup &es) override
	CFWriter (const edm::ParameterSet &conf)
void	produce (edm::Event &e, const edm::EventSetup &c) override
virtual void	put (edm::Event &e)
	~CFWriter () 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 Types
typedef std::vector< edm::HepMCProduct >	HepMCProductContainer

Private Member Functions
virtual void	branchesActivate (const std::string &friendlyName, std::string subdet, InputTag &tag, std::string &label)
PCrossingFrame< SimTrack >	fctTest (const PCrossingFrame< SimTrack > &p)

Private Attributes
bool	flagHepMCProduct_
bool	flagPCaloHit_
bool	flagPSimHit_
bool	flagSimTrack_
bool	flagSimVertex_
std::vector< std::string >	labCaloHit
std::vector< std::string >	labSimHit
bool	useCurrentProcessOnly_
std::vector< std::string >	wantedBranches_

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 30 of file CFWriter.h.

Member Typedef Documentation

HepMCProductContainer

typedef std::vector<edm::HepMCProduct> edm::CFWriter::HepMCProductContainer

private

Definition at line 59 of file CFWriter.h.

Constructor & Destructor Documentation

CFWriter()

CFWriter::CFWriter ( const edm::ParameterSet &  conf )

explicit

Definition at line 34 of file CFWriter.cc.

References branchesActivate(), flagHepMCProduct_, flagPCaloHit_, flagPSimHit_, flagSimTrack_, flagSimVertex_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), cuy::ii, labCaloHit, label, labSimHit, names, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, fireworks::subdets, makeGlobalPositionRcd_cfg::tag, and triggerMatcherToHLTDebug_cfi::tags.

      : flagSimTrack_(false),
        flagSimVertex_(false),
        flagHepMCProduct_(false),
        flagPCaloHit_(false),
        flagPSimHit_(false) {
    //register your products
    ParameterSet ps = iConfig.getParameter<ParameterSet>("mixObjects");
    std::vector<std::string> names = ps.getParameterNames();
    for (std::vector<std::string>::iterator it = names.begin(); it != names.end(); ++it) {
      ParameterSet pset = ps.getParameter<ParameterSet>((*it));
      if (!pset.exists("type"))
        continue;  //to allow replacement by empty pset

      std::string object = pset.getParameter<std::string>("type");
      std::vector<InputTag> tags = pset.getParameter<std::vector<InputTag>>("input");

      //SimTracks
      if (object == "SimTrack") {
        flagSimTrack_ = true;

        InputTag tag;
        if (!tags.empty())
          tag = tags[0];
        std::string label;
        branchesActivate(TypeID(typeid(std::vector<SimTrack>)).friendlyClassName(), std::string(""), tag, label);
        produces<PCrossingFrame<SimTrack>>(label);
        consumes<std::vector<SimTrack>>(tag);
        LogInfo("MixingModule") << "Add PCrossingFrame<SimTrack> " << object << "s with InputTag= " << tag.encode()
                                << ", label will be " << label;

      }
      //SimVertices
      else if (object == "SimVertex") {
        flagSimVertex_ = true;

        InputTag tag;
        if (!tags.empty())
          tag = tags[0];
        std::string label;
        branchesActivate(TypeID(typeid(std::vector<SimVertex>)).friendlyClassName(), std::string(""), tag, label);
        produces<PCrossingFrame<SimVertex>>(label);
        consumes<std::vector<SimVertex>>(tag);
        LogInfo("MixingModule") << "Add SimVertexContainer " << object << "s with InputTag= " << tag.encode()
                                << ", label will be " << label;

      }
      // PCaloHit
      else if (object == "PCaloHit") {
        flagPCaloHit_ = true;

        std::vector<std::string> subdets = pset.getParameter<std::vector<std::string>>("subdets");
        for (unsigned int ii = 0; ii < subdets.size(); ii++) {
          InputTag tag;
          if (tags.size() == 1)
            tag = tags[0];
          else if (tags.size() > 1)
            tag = tags[ii];
          std::string label;

          branchesActivate(TypeID(typeid(std::vector<PCaloHit>)).friendlyClassName(), subdets[ii], tag, label);
          produces<PCrossingFrame<PCaloHit>>(label);
          consumes<std::vector<PCaloHit>>(tag);
          LogInfo("MixingModule") << "Add PCrossingFrame<PCaloHit> " << object << "s with InputTag= " << tag.encode()
                                  << ", label will be " << label;

          // fill table with labels
          labCaloHit.push_back(label);
        }
      }

      // PSimHit
      else if (object == "PSimHit") {
        flagPSimHit_ = true;

        std::vector<std::string> subdets = pset.getParameter<std::vector<std::string>>("subdets");
        for (unsigned int ii = 0; ii < subdets.size(); ii++) {
          InputTag tag;
          if (tags.size() == 1)
            tag = tags[0];

          else if (tags.size() > 1)
            tag = tags[ii];
          std::string label;

          branchesActivate(TypeID(typeid(std::vector<PSimHit>)).friendlyClassName(), subdets[ii], tag, label);
          produces<PCrossingFrame<PSimHit>>(label);
          consumes<std::vector<PSimHit>>(tag);
          LogInfo("MixingModule") << "Add PSimHitContainer " << object << "s with InputTag= " << tag.encode()
                                  << ", label will be " << label;

          // fill table with labels
          labSimHit.push_back(label);
        }  //end for
      }

      // HepMCProduct
      else if (object == "HepMCProduct") {
        flagHepMCProduct_ = true;

        InputTag tag;
        if (!tags.empty())
          tag = tags[0];
        std::string label;

        branchesActivate(TypeID(typeid(HepMCProduct)).friendlyClassName(), std::string(""), tag, label);
        produces<PCrossingFrame<edm::HepMCProduct>>(label);
        consumes<HepMCProduct>(tag);
        LogInfo("MixingModule") << "Add HepMCProduct " << object << "s with InputTag= " << tag.encode()
                                << ", label will be " << label;
      } else
        LogWarning("MixingModule") << "You did not mix a type of object(" << object << ").";

    }  //end for
  }

~CFWriter()

CFWriter::~CFWriter ( )

override

Definition at line 152 of file CFWriter.cc.

{}

Member Function Documentation

beginRun()

void CFWriter::beginRun ( const edm::Run &  run, const edm::EventSetup &  es  )

override

Definition at line 150 of file CFWriter.cc.

{}

branchesActivate()

void CFWriter::branchesActivate ( const std::string &  friendlyName, std::string  subdet, InputTag &  tag, std::string &  label  )

privatevirtual

Definition at line 235 of file CFWriter.cc.

References edm::friendlyname::friendlyName(), EgammaHLTValidationUtils::getProcessName(), HLT_2022v14_cff::InputTag, label, SimL1EmulatorRepack_CalouGT_cff::processName, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, useCurrentProcessOnly_, and wantedBranches_.

Referenced by CFWriter().

                                                    {
    label = tag.label() + tag.instance();
    wantedBranches_.push_back(friendlyName + '_' + tag.label() + '_' + tag.instance());

    //if useCurrentProcessOnly, we have to change the input tag
    if (useCurrentProcessOnly_) {
      const std::string processName = edm::Service<edm::service::TriggerNamesService>()->getProcessName();
      tag = InputTag(tag.label(), tag.instance(), processName);
    }
  }

fctTest()

PCrossingFrame<SimTrack> edm::CFWriter::fctTest ( const PCrossingFrame< SimTrack > &  p )

inlineprivate

Definition at line 42 of file CFWriter.h.

References gather_cfg::cout, and AlCaHLTBitMon_ParallelJobs::p.

                                                                               {
      return p;
      std::cout << " call PCrossingFrame object" << std::endl;
    };

produce()

void CFWriter::produce ( edm::Event &  e, const edm::EventSetup &  c  )

override

Definition at line 154 of file CFWriter.cc.

References flagHepMCProduct_, flagPCaloHit_, flagPSimHit_, flagSimTrack_, flagSimVertex_, iEvent, cuy::ii, labCaloHit, labSimHit, eostools::move(), and edm::Handle< T >::product().

                                                                      {
    if (flagSimTrack_) {
      bool gotTracks;
      edm::Handle<CrossingFrame<SimTrack>> cf_simtrack;
      gotTracks = iEvent.getByLabel("mix", "g4SimHits", cf_simtrack);

      if (gotTracks) {
        PCrossingFrame<SimTrack>* PCFbis = new PCrossingFrame<SimTrack>(*cf_simtrack.product());
        std::unique_ptr<PCrossingFrame<SimTrack>> pOutTrack(PCFbis);
        iEvent.put(std::move(pOutTrack), "g4SimHits");
      } else {
        LogInfo("MixingModule") << " Please, check if the object <SimTrack> has been mixed by the MixingModule!";
      }
    }  //end if flagSimTrack_

    //SimVertex
    if (flagSimVertex_) {
      bool gotSimVertex;
      edm::Handle<CrossingFrame<SimVertex>> cf_simvtx;
      gotSimVertex = iEvent.getByLabel("mix", "g4SimHits", cf_simvtx);

      if (gotSimVertex) {
        PCrossingFrame<SimVertex>* PCFvtx = new PCrossingFrame<SimVertex>(*cf_simvtx.product());
        std::unique_ptr<PCrossingFrame<SimVertex>> pOutVertex(PCFvtx);
        iEvent.put(std::move(pOutVertex), "g4SimHits");
      } else {
        LogInfo("MixingModule") << " Please, check if the object <SimVertex> has been mixed by the MixingModule!";
      }
    }

    // PCaloHit
    if (flagPCaloHit_) {
      for (unsigned int ii = 0; ii < labCaloHit.size(); ii++) {
        bool gotPCaloHit;
        edm::Handle<CrossingFrame<PCaloHit>> cf_calohit;
        gotPCaloHit = iEvent.getByLabel("mix", labCaloHit[ii], cf_calohit);

        if (gotPCaloHit) {
          PCrossingFrame<PCaloHit>* PCFPhCaloHit = new PCrossingFrame<PCaloHit>(*cf_calohit.product());
          std::unique_ptr<PCrossingFrame<PCaloHit>> pOutHCalo(PCFPhCaloHit);
          iEvent.put(std::move(pOutHCalo), labCaloHit[ii]);
        } else {
          LogInfo("MixingModule") << " Please, check if the object <PCaloHit> " << labCaloHit[ii]
                                  << " has been mixed by the MixingModule!";
        }
      }
    }

    if (flagPSimHit_) {
      for (unsigned int ii = 0; ii < labSimHit.size(); ii++) {
        bool gotPSimHit;
        edm::Handle<CrossingFrame<PSimHit>> cf_simhit;
        gotPSimHit = iEvent.getByLabel("mix", labSimHit[ii], cf_simhit);

        if (gotPSimHit) {
          PCrossingFrame<PSimHit>* PCFSimHit = new PCrossingFrame<PSimHit>(*cf_simhit.product());
          std::unique_ptr<PCrossingFrame<PSimHit>> pOutSimHit(PCFSimHit);
          iEvent.put(std::move(pOutSimHit), labSimHit[ii]);
        } else {
          LogInfo("MixingModule") << " Please, check if the object <PSimHit> " << labSimHit[ii]
                                  << " has been mixed by the MixingModule!";
        }
      }
    }

    //HepMCProduct
    if (flagHepMCProduct_) {
      bool gotHepMCProduct;
      edm::Handle<CrossingFrame<edm::HepMCProduct>> cf_hepmc;
      gotHepMCProduct = iEvent.getByLabel("mix", "generatorSmeared", cf_hepmc);
      if (gotHepMCProduct) {
        PCrossingFrame<edm::HepMCProduct>* PCFHepMC = new PCrossingFrame<edm::HepMCProduct>(*cf_hepmc.product());
        std::unique_ptr<PCrossingFrame<edm::HepMCProduct>> pOuthepmcpr(PCFHepMC);
        iEvent.put(std::move(pOuthepmcpr), "generator");
      } else {
        LogInfo("MixingModule") << " Please, check if the object <HepMCProduct> has been mixed by the MixingModule!";
      }

    }  // end if flagHepMCProduct_
  }

put()

virtual void edm::CFWriter::put ( edm::Event &  e )

inlinevirtual

Definition at line 39 of file CFWriter.h.

{ ; }

Member Data Documentation

flagHepMCProduct_

bool edm::CFWriter::flagHepMCProduct_

private

Definition at line 55 of file CFWriter.h.

Referenced by CFWriter(), and produce().

flagPCaloHit_

bool edm::CFWriter::flagPCaloHit_

private

Definition at line 56 of file CFWriter.h.

Referenced by CFWriter(), and produce().

flagPSimHit_

bool edm::CFWriter::flagPSimHit_

private

Definition at line 57 of file CFWriter.h.

Referenced by CFWriter(), and produce().

flagSimTrack_

bool edm::CFWriter::flagSimTrack_

private

Definition at line 53 of file CFWriter.h.

Referenced by CFWriter(), and produce().

flagSimVertex_

bool edm::CFWriter::flagSimVertex_

private

Definition at line 54 of file CFWriter.h.

Referenced by CFWriter(), and produce().

labCaloHit

std::vector<std::string> edm::CFWriter::labCaloHit

private

Definition at line 61 of file CFWriter.h.

Referenced by CFWriter(), and produce().

labSimHit

std::vector<std::string> edm::CFWriter::labSimHit

private

Definition at line 60 of file CFWriter.h.

Referenced by CFWriter(), and produce().

useCurrentProcessOnly_

bool edm::CFWriter::useCurrentProcessOnly_

private

Definition at line 52 of file CFWriter.h.

Referenced by branchesActivate().

wantedBranches_

std::vector<std::string> edm::CFWriter::wantedBranches_

private

Definition at line 51 of file CFWriter.h.

Referenced by branchesActivate().