edm::EventContentAnalyzer Class Reference

Inheritance diagram for edm::EventContentAnalyzer:

Public Member Functions
void	analyze (Event const &, EventSetup const &) override
void	endJob () override
	EventContentAnalyzer (ParameterSet const &)
	~EventContentAnalyzer () override
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
SerialTaskQueue *	globalLuminosityBlocksQueue ()
SerialTaskQueue *	globalRunsQueue ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
	~EDAnalyzer () override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)
static bool	wantsGlobalLuminosityBlocks ()
static bool	wantsGlobalRuns ()
static bool	wantsInputProcessBlocks ()
static bool	wantsProcessBlocks ()
static bool	wantsStreamLuminosityBlocks ()
static bool	wantsStreamRuns ()

Private Attributes
std::map< std::string, int >	cumulates_
int	evno_
bool	getData_
std::vector< std::string >	getModuleLabels_
std::string	indentation_
bool	listContent_
bool	listProvenance_
std::vector< std::string >	moduleLabels_
bool	verbose_
std::string	verboseIndentation_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 259 of file EventContentAnalyzer.cc.

Constructor & Destructor Documentation

EventContentAnalyzer()

edm::EventContentAnalyzer::EventContentAnalyzer ( ParameterSet const &  iConfig )

explicit

Definition at line 286 of file EventContentAnalyzer.cc.

      : indentation_(iConfig.getUntrackedParameter("indentation", std::string("++"))),
        verboseIndentation_(iConfig.getUntrackedParameter("verboseIndentation", std::string("  "))),
        moduleLabels_(iConfig.getUntrackedParameter("verboseForModuleLabels", std::vector<std::string>())),
        verbose_(iConfig.getUntrackedParameter("verbose", false) || !moduleLabels_.empty()),
        getModuleLabels_(iConfig.getUntrackedParameter("getDataForModuleLabels", std::vector<std::string>())),
        getData_(iConfig.getUntrackedParameter("getData", false) || !getModuleLabels_.empty()),
        evno_(1),
        listContent_(iConfig.getUntrackedParameter("listContent", true)),
        listProvenance_(iConfig.getUntrackedParameter("listProvenance", false)) {
    //now do what ever initialization is needed
    sort_all(moduleLabels_);
    sort_all(getModuleLabels_);
    if (getData_) {
      callWhenNewProductsRegistered([this](edm::BranchDescription const& iBranch) {
        if (getModuleLabels_.empty()) {
          const std::string kPathStatus("edm::PathStatus");
          const std::string kEndPathStatus("edm::EndPathStatus");
          if (iBranch.className() != kPathStatus && iBranch.className() != kEndPathStatus) {
            this->consumes(edm::TypeToGet{iBranch.unwrappedTypeID(), PRODUCT_TYPE},
                           edm::InputTag{iBranch.moduleLabel(), iBranch.productInstanceName(), iBranch.processName()});
          }
        } else {
          for (auto const& mod : this->getModuleLabels_) {
            if (iBranch.moduleLabel() == mod) {
              this->consumes(edm::TypeToGet{iBranch.unwrappedTypeID(), PRODUCT_TYPE},
                             edm::InputTag{mod, iBranch.productInstanceName(), iBranch.processName()});
              break;
            }
          }
        }
      });
    }
  }

References edm::EDAnalyzer::callWhenNewProductsRegistered(), edm::BranchDescription::className(), edm::EDConsumerBase::consumes(), getData_, getModuleLabels_, mod(), edm::BranchDescription::moduleLabel(), moduleLabels_, edm::BranchDescription::processName(), edm::PRODUCT_TYPE, edm::BranchDescription::productInstanceName(), edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::BranchDescription::unwrappedTypeID().

~EventContentAnalyzer()

edm::EventContentAnalyzer::~EventContentAnalyzer ( )

override

Definition at line 321 of file EventContentAnalyzer.cc.

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

Member Function Documentation

analyze()

void edm::EventContentAnalyzer::analyze ( Event const &  iEvent, EventSetup const &    )

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 331 of file EventContentAnalyzer.cc.

                                                                           {
    typedef std::vector<StableProvenance const*> Provenances;
    Provenances provenances;
 
    iEvent.getAllStableProvenance(provenances);
 
    if (listContent_) {
      LogAbsolute("EventContent") << "\n"
                                  << indentation_ << "Event " << std::setw(5) << evno_ << " contains "
                                  << provenances.size() << " product" << (provenances.size() == 1 ? "" : "s")
                                  << " with friendlyClassName, moduleLabel, productInstanceName and processName:"
                                  << std::endl;
    }
 
    std::string startIndent = indentation_ + verboseIndentation_;
    for (auto const& provenance : provenances) {
      std::string const& className = provenance->className();
      const std::string kPathStatus("edm::PathStatus");
      const std::string kEndPathStatus("edm::EndPathStatus");
      if (className == kPathStatus || className == kEndPathStatus) {
        continue;
      }
      std::string const& friendlyName = provenance->friendlyClassName();
      //if(friendlyName.empty())  friendlyName = std::string("||");
 
      std::string const& modLabel = provenance->moduleLabel();
      //if(modLabel.empty()) modLabel = std::string("||");
 
      std::string const& instanceName = provenance->productInstanceName();
      //if(instanceName.empty()) instanceName = std::string("||");
 
      std::string const& processName = provenance->processName();
 
      bool doVerbose = verbose_ && (moduleLabels_.empty() || binary_search_all(moduleLabels_, modLabel));
 
      if (listContent_ || doVerbose) {
        LogAbsolute("EventContent") << indentation_ << friendlyName << " \"" << modLabel << "\" \"" << instanceName
                                    << "\" \"" << processName << "\""
                                    << " (productId = " << provenance->productID() << ")" << std::endl;
 
        if (listProvenance_) {
          auto const& prov = iEvent.getProvenance(provenance->branchID());
          auto const* productProvenance = prov.productProvenance();
          if (productProvenance) {
            const bool isAlias = productProvenance->branchID() != provenance->branchID();
            std::string aliasForModLabel;
            LogAbsolute("EventContent") << prov;
            if (isAlias) {
              aliasForModLabel = iEvent.getProvenance(productProvenance->branchID()).moduleLabel();
              LogAbsolute("EventContent") << "Is an alias for " << aliasForModLabel;
            }
            ProcessHistory const& processHistory = iEvent.processHistory();
            for (ProcessConfiguration const& pc : processHistory) {
              if (pc.processName() == prov.processName()) {
                ParameterSetID const& psetID = pc.parameterSetID();
                pset::Registry const* psetRegistry = pset::Registry::instance();
                ParameterSet const* processPset = psetRegistry->getMapped(psetID);
                if (processPset) {
                  if (processPset->existsAs<ParameterSet>(modLabel)) {
                    if (isAlias) {
                      LogAbsolute("EventContent") << "Alias PSet";
                    }
                    LogAbsolute("EventContent") << processPset->getParameterSet(modLabel);
                  }
                  if (isAlias and processPset->existsAs<ParameterSet>(aliasForModLabel)) {
                    LogAbsolute("EventContent") << processPset->getParameterSet(aliasForModLabel);
                  }
                }
              }
            }
          }
        }
      }
      std::string key = friendlyName + std::string(" + \"") + modLabel + std::string("\" + \"") + instanceName +
                        "\" \"" + processName + "\"";
      ++cumulates_[key];
 
      if (doVerbose) {
        //indent one level before starting to print
        printObject(iEvent, className, modLabel, instanceName, processName, startIndent, verboseIndentation_);
        continue;
      }
      if (getData_) {
        std::string class_and_label = friendlyName + "_" + modLabel;
        if (getModuleLabels_.empty() || binary_search_all(getModuleLabels_, modLabel) ||
            binary_search_all(getModuleLabels_, class_and_label)) {
          try {
            GenericHandle handle(className);
          } catch (edm::Exception const&) {
            LogAbsolute("EventContent") << startIndent << " \"" << className << "\""
                                        << " is an unknown type" << std::endl;
            return;
          }
          GenericHandle handle(className);
          iEvent.getByLabel(InputTag(modLabel, instanceName, processName), handle);
        }
      }
    }
    //std::cout << "Mine" << std::endl;
    ++evno_;
  }

References edm::binary_search_all(), className(), cumulates_, evno_, edm::ParameterSet::existsAs(), edm::friendlyname::friendlyName(), getData_, edm::pset::Registry::getMapped(), getModuleLabels_, edm::ParameterSet::getParameterSet(), patZpeak::handle, iEvent, indentation_, HLT_FULL_cff::InputTag, edm::pset::Registry::instance(), MuonErrorMatrixAdjuster_cfi::instanceName, crabWrapper::key, listContent_, listProvenance_, HerwigMaxPtPartonFilter_cfi::moduleLabel, moduleLabels_, SimL1EmulatorRepack_CalouGT_cff::processName, AlCaHLTBitMon_QueryRunRegistry::string, verbose_, and verboseIndentation_.

endJob()

void edm::EventContentAnalyzer::endJob ( void  )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 434 of file EventContentAnalyzer.cc.

                                    {
    typedef std::map<std::string, int> nameMap;
 
    LogAbsolute("EventContent") << "\nSummary for key being the concatenation of friendlyClassName, moduleLabel, "
                                   "productInstanceName and processName"
                                << std::endl;
    for (nameMap::const_iterator it = cumulates_.begin(), itEnd = cumulates_.end(); it != itEnd; ++it) {
      LogAbsolute("EventContent") << std::setw(6) << it->second << " occurrences of key " << it->first << std::endl;
    }
 
    // Test boost::lexical_cast  We don't need this right now so comment it out.
    // int k = 137;
    // std::string ktext = boost::lexical_cast<std::string>(k);
    // std::cout << "\nInteger " << k << " expressed as a string is |" << ktext << "|" << std::endl;
  }

References cumulates_.

fillDescriptions()

void edm::EventContentAnalyzer::fillDescriptions ( ConfigurationDescriptions &  descriptions )

static

Definition at line 450 of file EventContentAnalyzer.cc.

                                                                                     {
    descriptions.setComment(
        "This plugin will print a list of all products in the event "
        "provenance.  It also has options to print and/or get each product.");
 
    ParameterSetDescription desc;
 
    ParameterDescriptionNode* np;
 
    std::string defaultString("++");
    np = desc.addOptionalUntracked<std::string>("indentation", defaultString);
    np->setComment("This string is printed at the beginning of every line printed during event processing.");
 
    np = desc.addOptionalUntracked<bool>("verbose", false);
    np->setComment("If true, the contents of products are printed.");
 
    defaultString = "  ";
    np = desc.addOptionalUntracked<std::string>("verboseIndentation", defaultString);
    np->setComment(
        "This string is used to further indent lines when printing the contents of products in verbose mode.");
 
    std::vector<std::string> defaultVString;
 
    np = desc.addOptionalUntracked<std::vector<std::string> >("verboseForModuleLabels", defaultVString);
    np->setComment("If this vector is not empty, then only products with module labels on this list are printed.");
 
    np = desc.addOptionalUntracked<bool>("getData", false);
    np->setComment("If true the products will be retrieved using getByLabel.");
 
    np = desc.addOptionalUntracked<std::vector<std::string> >("getDataForModuleLabels", defaultVString);
    np->setComment(
        "If this vector is not empty, then only products with module labels on this list are retrieved by getByLabel.");
 
    np = desc.addOptionalUntracked<bool>("listContent", true);
    np->setComment("If true then print a list of all the event content.");
 
    np = desc.addOptionalUntracked<bool>("listProvenance", false);
    np->setComment("If true, and if listContent or verbose is true, print provenance information for each product");
 
    descriptions.add("printContent", desc);
  }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, np, edm::ConfigurationDescriptions::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

Member Data Documentation

cumulates_

std::map<std::string, int> edm::EventContentAnalyzer::cumulates_

private

Definition at line 278 of file EventContentAnalyzer.cc.

Referenced by analyze(), and endJob().

evno_

int edm::EventContentAnalyzer::evno_

private

Definition at line 277 of file EventContentAnalyzer.cc.

Referenced by analyze().

getData_

bool edm::EventContentAnalyzer::getData_

private

Definition at line 276 of file EventContentAnalyzer.cc.

Referenced by analyze(), and EventContentAnalyzer().

getModuleLabels_

std::vector<std::string> edm::EventContentAnalyzer::getModuleLabels_

private

Definition at line 275 of file EventContentAnalyzer.cc.

Referenced by analyze(), and EventContentAnalyzer().

indentation_

std::string edm::EventContentAnalyzer::indentation_

private

Definition at line 271 of file EventContentAnalyzer.cc.

Referenced by analyze().

listContent_

bool edm::EventContentAnalyzer::listContent_

private

Definition at line 279 of file EventContentAnalyzer.cc.

Referenced by analyze().

listProvenance_

bool edm::EventContentAnalyzer::listProvenance_

private

Definition at line 280 of file EventContentAnalyzer.cc.

Referenced by analyze().

moduleLabels_

std::vector<std::string> edm::EventContentAnalyzer::moduleLabels_

private

Definition at line 273 of file EventContentAnalyzer.cc.

Referenced by analyze(), and EventContentAnalyzer().

verbose_

bool edm::EventContentAnalyzer::verbose_

private

Definition at line 274 of file EventContentAnalyzer.cc.

Referenced by analyze().

verboseIndentation_

std::string edm::EventContentAnalyzer::verboseIndentation_

private

Definition at line 272 of file EventContentAnalyzer.cc.

Referenced by analyze().