Inheritance diagram for FTSLuminosityFromScalers:

Public Member Functions
	FTSLuminosityFromScalers (edm::ParameterSet const &)

	~FTSLuminosityFromScalers ()

Public Member Functions inherited from edm::global::EDAnalyzer<>
	EDAnalyzer ()=default

Public Member Functions inherited from edm::global::EDAnalyzerBase
	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::global::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
enum	Type { Type::InstantaneousLuminosity, Type::Pileup, Type::Invalid = -1 }

Private Member Functions
void	analyze (edm::StreamID sid, edm::Event const &event, const edm::EventSetup &setup) const override

Static Private Member Functions
static Type	parse (std::string const &type)

Private Attributes
unsigned int	m_lumi_id

edm::EDGetTokenT < LumiScalersCollection >	m_token

Type	m_type

Additional Inherited Members
Public Types inherited from edm::global::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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 ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 19 of file FTSLuminosityFromScalers.cc.

Member Enumeration Documentation

enum FTSLuminosityFromScalers::Type

strongprivate

Enumerator
InstantaneousLuminosity
Pileup
Invalid

Definition at line 27 of file FTSLuminosityFromScalers.cc.

                   {
     InstantaneousLuminosity,
     Pileup,
     Invalid = -1
   };

Constructor & Destructor Documentation

FTSLuminosityFromScalers::FTSLuminosityFromScalers ( edm::ParameterSet const & config )

explicit

Definition at line 49 of file FTSLuminosityFromScalers.cc.

References edm::ParameterSet::getParameter(), diffTwoXMLs::label, m_lumi_id, mergeVDriftHistosByStation::name, dtDQMClient_cfg::resolution, AlCaHLTBitMon_QueryRunRegistry::string, and indexGen::title.

                                                                                  :
   m_token(consumes<LumiScalersCollection>(config.getParameter<edm::InputTag>("source"))),
   m_type(parse(config.getParameter<std::string>("type"))),
   m_lumi_id((unsigned int) -1)
 {
   if (not edm::Service<FastTimerService>().isAvailable())
     return;
 
   std::string const & name  = config.getParameter<std::string>("name");
   std::string const & title = config.getParameter<std::string>("title");
   std::string const & label = config.getParameter<std::string>("label");
   double range              = config.getParameter<double>("range");
   double resolution         = config.getParameter<double>("resolution");
 
   m_lumi_id = edm::Service<FastTimerService>()->reserveLuminosityPlots(name, title, label, range, resolution);
 }

FTSLuminosityFromScalers::~FTSLuminosityFromScalers ( )

Definition at line 66 of file FTSLuminosityFromScalers.cc.

67 {

68 }

Member Function Documentation

void FTSLuminosityFromScalers::analyze	(	edm::StreamID	sid,
		edm::Event const &	event,
		const edm::EventSetup &	setup
	)		const

overrideprivatevirtual

Implements edm::global::EDAnalyzerBase.

Definition at line 71 of file FTSLuminosityFromScalers.cc.

References edm::Event::getByToken(), InstantaneousLuminosity, Invalid, m_lumi_id, m_token, m_type, Pileup, and relativeConstraints::value.

 {
   if (not edm::Service<FastTimerService>().isAvailable())
     return;
 
   double value = 0.;
   edm::Handle<LumiScalersCollection> h_luminosity;
   if (event.getByToken(m_token, h_luminosity) and not h_luminosity->empty()) {
     switch (m_type) {
       case Type::InstantaneousLuminosity:
         value = h_luminosity->front().instantLumi() * 1.e30;
         break;
       case Type::Pileup:
         value = h_luminosity->front().pileup();
         break;
       case Type::Invalid:
         value = 0.;
         break;
     }
   }
 
   edm::Service<FastTimerService>()->setLuminosity(sid, m_lumi_id, value);
 }

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

static

Definition at line 96 of file FTSLuminosityFromScalers.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                       {
   // instantaneous luminosity
   {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("source", edm::InputTag("scalersRawToDigi"));
     desc.add<std::string>("type",  "InstantaneousLuminosity");
     desc.add<std::string>("name",  "luminosity");
     desc.add<std::string>("title", "instantaneous luminosity");
     desc.add<std::string>("label", "instantaneous luminosity [cm^{-2}s^{-1}]");
     desc.add<double>("range",      8.e33);
     desc.add<double>("resolution", 1.e31);
     descriptions.add("ftsLuminosityFromScalers", desc);
   }
   // pileup
   {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("source", edm::InputTag("scalersRawToDigi"));
     desc.add<std::string>("type",  "Pileup");
     desc.add<std::string>("name",  "pileup");
     desc.add<std::string>("title", "pileup");
     desc.add<std::string>("label", "pileup");
     desc.add<double>("range",      40);
     desc.add<double>("resolution",  1);
     descriptions.add("ftsPileupFromScalers", desc);
   }
 }

static Type FTSLuminosityFromScalers::parse ( std::string const & type )

inlinestaticprivate

Definition at line 33 of file FTSLuminosityFromScalers.cc.

References InstantaneousLuminosity, Invalid, and Pileup.

                                             {
     if (type == "InstantaneousLuminosity")
       return Type::InstantaneousLuminosity;
     else if (type == "Pileup")
       return Type::Pileup;
     else
       return Type::Invalid;
   }