fwlite::EventContainer Class Reference

#include <EventContainer.h>

Inheritance diagram for fwlite::EventContainer:

Public Types
typedef void(*	FuncPtr) (std::string &)
typedef std::map< std::string, std::string >	SSMap

Public Member Functions
void	add (TH1 *histPtr, const std::string &directory="")
bool	atEnd () const override
edm::EventAuxiliary const &	eventAuxiliary () const override
	EventContainer (optutl::CommandLineParser &parser, FuncPtr funcPtr=nullptr)
int	eventsSeen () const
Long64_t	fileIndex () const override
const std::string	getBranchNameFor (const std::type_info &iInfo, const char *iModuleLabel, const char *iProductInstanceLabel, const char *iProcessLabel) const override
template<class T >
bool	getByLabel (const edm::InputTag &tag, edm::Handle< T > &handle) const
bool	getByLabel (const std::type_info &iInfo, const char *iModuleLabel, const char *iProductInstanceLabel, const char *iProcessLabel, void *oData) const override
TH1 *	hist (const char *name)
TH1 *	hist (const std::string &name)
TH1 *	hist (const TString &name)
const EventContainer &	operator++ () override
optutl::CommandLineParser &	parser ()
Long64_t	secondaryFileIndex () const override
const EventContainer &	toBegin () override
edm::TriggerNames const &	triggerNames (edm::TriggerResults const &triggerResults) const override
edm::TriggerResultsByName	triggerResultsByName (edm::TriggerResults const &triggerResults) const override
	~EventContainer () override
Public Member Functions inherited from fwlite::EventBase
	EventBase ()
virtual edm::WrapperBase const *	getByProductID (edm::ProductID const &) const =0
	~EventBase () override
Public Member Functions inherited from edm::EventBase
int	bunchCrossing () const
	EventBase ()
edm::EventAuxiliary::ExperimentType	experimentType () const
template<typename T >
bool	get (ProductID const &, Handle< T > &) const
template<>
bool	getByLabel (edm::InputTag const &tag, Handle< FWGenericObject > &result) const
	Specialize the getByLabel method to work with a Handle<FWGenericObject> More...
template<typename T >
bool	getByLabel (InputTag const &, Handle< T > &) const
edm::EventID	id () const
bool	isRealData () const
edm::LuminosityBlockNumber_t	luminosityBlock () const
int	orbitNumber () const
virtual edm::ParameterSet const *	parameterSet (edm::ParameterSetID const &psID) const =0
virtual ProcessHistory const &	processHistory () const =0
edm::Timestamp	time () const

Private Member Functions
	EventContainer (const EventContainer &rhs)

Private Attributes
fwlite::EventBase *	m_eventBasePtr
int	m_eventsSeen
TH1Store	m_histStore
int	m_maxWanted
int	m_outputEvery
std::string	m_outputName
optutl::CommandLineParser *	m_parserPtr

Static Private Attributes
static bool	sm_autoloaderCalled = false

Friends
std::ostream &	operator<< (std::ostream &o_stream, const EventContainer &rhs)

Additional Inherited Members
Static Protected Member Functions inherited from edm::EventBase
static edm::ParameterSet const *	parameterSetForID_ (edm::ParameterSetID const &psID)
static TriggerNames const *	triggerNames_ (edm::TriggerResults const &triggerResults)

Detailed Description

Definition at line 21 of file EventContainer.h.

Member Typedef Documentation

FuncPtr

typedef void(* fwlite::EventContainer::FuncPtr) (std::string &)

Definition at line 28 of file EventContainer.h.

SSMap

typedef std::map<std::string, std::string> fwlite::EventContainer::SSMap

Definition at line 27 of file EventContainer.h.

Constructor & Destructor Documentation

EventContainer() [1/2]

EventContainer::EventContainer	(	optutl::CommandLineParser &	parser,
		FuncPtr	funcPtr = nullptr
	)

Definition at line 23 of file EventContainer.cc.

    : m_eventsSeen(0), m_maxWanted(0), m_parserPtr(nullptr) {
  // get the user-defined tag
  string tag;
  if (funcPtr) {
    (*funcPtr)(tag);
  }
 
  // finish defaultt options and create fwlite::Event
  parser._finishDefaultOptions(tag);
 
  // Call the autoloader if not already called.
  if (!sm_autoloaderCalled) {
    FWLiteEnabler::enable();
    sm_autoloaderCalled = true;
  }
 
  const optutl::CommandLineParser::SVec& secondaryInputFiles = parser.stringVector("secondaryInputFiles");
  if (!secondaryInputFiles.empty()) {
    m_eventBasePtr = new fwlite::MultiChainEvent(
        parser.stringVector("inputFiles"), secondaryInputFiles, parser.boolValue("orderedSecondaryFiles"));
  } else {
    m_eventBasePtr = new fwlite::ChainEvent(parser.stringVector("inputFiles"));
  }
 
  // get whatever other info you want
  m_outputName = parser.stringValue("outputFile");
  m_maxWanted = parser.integerValue("maxEvents");
  m_outputEvery = parser.integerValue("outputEvery");
 
  // remember my parser
  m_parserPtr = &parser;
 
  // TH1::AddDirectory(false);
}

References optutl::CommandLineParser::_finishDefaultOptions(), optutl::VariableMapCont::boolValue(), FWLiteEnabler::enable(), optutl::VariableMapCont::integerValue(), m_eventBasePtr, m_maxWanted, m_outputEvery, m_outputName, m_parserPtr, parser(), sm_autoloaderCalled, optutl::VariableMapCont::stringValue(), optutl::VariableMapCont::stringVector(), and GlobalPosition_Frontier_DevDB_cff::tag.

~EventContainer()

EventContainer::~EventContainer ( )

override

Definition at line 59 of file EventContainer.cc.

                                {
  // if the pointer is non-zero, then we should run the standard
  // destructor.  If it is zero, then we should do nothing
  if (!m_eventBasePtr) {
    return;
  }
  // If we're still here, let's get to work.
  cout << "EventContainer Summary: Processed " << m_eventsSeen << " events." << endl;
  optutl::CommandLineParser& parser = this->parser();
  if (optutl::CommandLineParser::kStringVector == parser.hasOption("inputFiles")) {
    m_histStore.write(m_outputName, parser.argVec(), parser.stringVector("inputFiles"));
  } else {
    m_histStore.write(m_outputName, parser.argVec());
  }
  delete m_eventBasePtr;
}

References optutl::CommandLineParser::argVec(), gather_cfg::cout, optutl::VariableMapCont::hasOption(), optutl::VariableMapCont::kStringVector, m_eventBasePtr, m_eventsSeen, m_histStore, m_outputName, parser(), optutl::VariableMapCont::stringVector(), and TH1Store::write().

EventContainer() [2/2]

fwlite::EventContainer::EventContainer ( const EventContainer &  rhs )

inlineprivate

Definition at line 119 of file EventContainer.h.

{}

Member Function Documentation

add()

void EventContainer::add	(	TH1 *	histPtr,
		const std::string &	directory = ""
	)

Definition at line 76 of file EventContainer.cc.

{ m_histStore.add(histPtr, directory); }

References TH1Store::add(), createBeamHaloJobs::directory, and m_histStore.

Referenced by bookHistograms(), main(), and counter.Counter::register().

atEnd()

bool EventContainer::atEnd ( ) const

overridevirtual

Implements fwlite::EventBase.

Definition at line 124 of file EventContainer.cc.

                                 {
  assert(m_eventBasePtr);
  // first check to see that we haven't already processed the maxinum
  // number of events that we asked for.
  if (m_maxWanted && m_eventsSeen >= m_maxWanted) {
    // we're done
    return true;
  }
 
  return m_eventBasePtr->atEnd();
}

References cms::cuda::assert(), fwlite::EventBase::atEnd(), m_eventBasePtr, m_eventsSeen, and m_maxWanted.

Referenced by main().

eventAuxiliary()

edm::EventAuxiliary const& fwlite::EventContainer::eventAuxiliary ( ) const

inlineoverridevirtual

Implements edm::EventBase.

Definition at line 103 of file EventContainer.h.

{ return m_eventBasePtr->eventAuxiliary(); }

References edm::EventBase::eventAuxiliary(), and m_eventBasePtr.

Referenced by main().

eventsSeen()

int fwlite::EventContainer::eventsSeen ( ) const

inline

Definition at line 54 of file EventContainer.h.

{ return m_eventsSeen; }

References m_eventsSeen.

fileIndex()

Long64_t fwlite::EventContainer::fileIndex ( ) const

inlineoverridevirtual

Reimplemented from fwlite::EventBase.

Definition at line 100 of file EventContainer.h.

{ return m_eventBasePtr->fileIndex(); }

References fwlite::EventBase::fileIndex(), and m_eventBasePtr.

getBranchNameFor()

const std::string EventContainer::getBranchNameFor ( const std::type_info &  iInfo, const char *  iModuleLabel, const char *  iProductInstanceLabel, const char *  iProcessLabel  ) const

overridevirtual

Implements fwlite::EventBase.

Definition at line 94 of file EventContainer.cc.

                                                                                    {
  assert(m_eventBasePtr);
  return m_eventBasePtr->getBranchNameFor(iInfo, iModuleLabel, iProductInstanceLabel, iProcessLabel);
}

References cms::cuda::assert(), fwlite::EventBase::getBranchNameFor(), and m_eventBasePtr.

getByLabel() [1/2]

template<class T >

bool fwlite::EventContainer::getByLabel ( const edm::InputTag &  tag, edm::Handle< T > &  handle  ) const

inline

Definition at line 106 of file EventContainer.h.

                                                                        {
      return m_eventBasePtr->getByLabel(tag, handle);
    }

References fwlite::EventBase::getByLabel(), patZpeak::handle, m_eventBasePtr, and GlobalPosition_Frontier_DevDB_cff::tag.

getByLabel() [2/2]

bool EventContainer::getByLabel ( const std::type_info &  iInfo, const char *  iModuleLabel, const char *  iProductInstanceLabel, const char *  iProcessLabel, void *  oData  ) const

overridevirtual

Implements fwlite::EventBase.

Definition at line 85 of file EventContainer.cc.

                                                   {
  assert(m_eventBasePtr);
  return m_eventBasePtr->getByLabel(iInfo, iModuleLabel, iProductInstanceLabel, iProcessLabel, oData);
}

References cms::cuda::assert(), fwlite::EventBase::getByLabel(), and m_eventBasePtr.

Referenced by main().

hist() [1/3]

TH1* fwlite::EventContainer::hist ( const char *  name )

inline

Definition at line 66 of file EventContainer.h.

{ return hist((const std::string)name); }

References hist(), Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by hist().

hist() [2/3]

TH1* fwlite::EventContainer::hist

(

const std::string &

name

)

Referenced by main().

hist() [3/3]

TH1* fwlite::EventContainer::hist ( const TString &  name )

inline

Definition at line 67 of file EventContainer.h.

{ return hist((const char*)name); }

References hist(), and Skims_PA_cff::name.

Referenced by hist().

operator++()

const EventContainer & EventContainer::operator++ ( void  )

overridevirtual

Implements fwlite::EventBase.

Definition at line 102 of file EventContainer.cc.

                                                 {
  assert(m_eventBasePtr);
 
  m_eventBasePtr->operator++();
  ++m_eventsSeen;
  if (m_outputEvery && m_eventsSeen % m_outputEvery == 0) {
    cout << "Processing Event: " << m_eventsSeen << endl;
  }
  return *this;
}

References cms::cuda::assert(), gather_cfg::cout, m_eventBasePtr, m_eventsSeen, and m_outputEvery.

parser()

optutl::CommandLineParser & EventContainer::parser

(

)

Definition at line 78 of file EventContainer.cc.

                                                {
  assert(m_parserPtr);
  return *m_parserPtr;
}

References cms::cuda::assert(), and m_parserPtr.

Referenced by bookHistograms(), calcSampleName(), EventContainer(), and ~EventContainer().

secondaryFileIndex()

Long64_t fwlite::EventContainer::secondaryFileIndex ( ) const

inlineoverridevirtual

Reimplemented from fwlite::EventBase.

Definition at line 101 of file EventContainer.h.

{ return m_eventBasePtr->secondaryFileIndex(); }

References m_eventBasePtr, and fwlite::EventBase::secondaryFileIndex().

toBegin()

const EventContainer & EventContainer::toBegin ( )

overridevirtual

Implements fwlite::EventBase.

Definition at line 113 of file EventContainer.cc.

                                              {
  assert(m_eventBasePtr);
  m_eventsSeen = 0;
  m_eventBasePtr->toBegin();
 
  // If we're going to skip over any events, do it here.
 
  // O.k.  We should be good to go.
  return *this;
}

References cms::cuda::assert(), m_eventBasePtr, m_eventsSeen, and fwlite::EventBase::toBegin().

Referenced by main().

triggerNames()

edm::TriggerNames const& fwlite::EventContainer::triggerNames ( edm::TriggerResults const &  triggerResults ) const

inlineoverridevirtual

Implements edm::EventBase.

Definition at line 92 of file EventContainer.h.

                                                                                                {
      return m_eventBasePtr->triggerNames(triggerResults);
    }

References m_eventBasePtr, edm::EventBase::triggerNames(), and triggerResults.

triggerResultsByName()

edm::TriggerResultsByName fwlite::EventContainer::triggerResultsByName ( edm::TriggerResults const &  triggerResults ) const

inlineoverridevirtual

Implements edm::EventBase.

Definition at line 96 of file EventContainer.h.

                                                                                                         {
      return m_eventBasePtr->triggerResultsByName(triggerResults);
    }

References m_eventBasePtr, triggerResults, and edm::EventBase::triggerResultsByName().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  o_stream, const EventContainer &  rhs  )

friend

Member Data Documentation

m_eventBasePtr

fwlite::EventBase* fwlite::EventContainer::m_eventBasePtr

private

Definition at line 125 of file EventContainer.h.

Referenced by atEnd(), eventAuxiliary(), EventContainer(), fileIndex(), getBranchNameFor(), getByLabel(), operator++(), secondaryFileIndex(), toBegin(), triggerNames(), triggerResultsByName(), and ~EventContainer().

m_eventsSeen

int fwlite::EventContainer::m_eventsSeen

private

Definition at line 128 of file EventContainer.h.

Referenced by atEnd(), eventsSeen(), operator++(), toBegin(), and ~EventContainer().

m_histStore

TH1Store fwlite::EventContainer::m_histStore

private

Definition at line 126 of file EventContainer.h.

Referenced by add(), and ~EventContainer().

m_maxWanted

int fwlite::EventContainer::m_maxWanted

private

Definition at line 129 of file EventContainer.h.

Referenced by atEnd(), and EventContainer().

m_outputEvery

int fwlite::EventContainer::m_outputEvery

private

Definition at line 130 of file EventContainer.h.

Referenced by EventContainer(), and operator++().

m_outputName

std::string fwlite::EventContainer::m_outputName

private

Definition at line 127 of file EventContainer.h.

Referenced by EventContainer(), and ~EventContainer().

m_parserPtr

optutl::CommandLineParser* fwlite::EventContainer::m_parserPtr

private

Definition at line 131 of file EventContainer.h.

Referenced by EventContainer(), and parser().

sm_autoloaderCalled

bool EventContainer::sm_autoloaderCalled = false

staticprivate

Definition at line 137 of file EventContainer.h.

Referenced by EventContainer().