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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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<>
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

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.

      : 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
  }

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, GlobalPosition_Frontier_DevDB_cff::tag, and triggerMatcherToHLTDebug_cfi::tags.

~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.

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

References edm::friendlyname::friendlyName(), HLT_FULL_cff::InputTag, label, SimL1EmulatorRepack_CalouGT_cff::processName, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, useCurrentProcessOnly_, and wantedBranches_.

Referenced by CFWriter().

fctTest()

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

inlineprivate

Definition at line 42 of file CFWriter.h.

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

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

produce()

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

override

Definition at line 154 of file CFWriter.cc.

                                                                      {
    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_
  }

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

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().