#include <CachingVariable.h>

Inheritance diagram for VariableComputer:

Public Member Functions
void	assign (std::string var, double &value) const

virtual void	compute (const edm::Event &iEvent) const =0

void	declare (std::string var, edm::ConsumesCollector &iC)

void	doesNotCompute () const

void	doesNotCompute (std::string var) const

const std::string &	name () const

bool	notSeenThisEventAlready (const edm::Event &iEvent) const

	VariableComputer (const CachingVariable::CachingVariableFactoryArg &arg, edm::ConsumesCollector &iC)

virtual	~VariableComputer ()

Protected Attributes
const CachingVariable::CachingVariableFactoryArg &	arg_

edm::Event::CacheIdentifier_t	eventCacheID_ = 0

std::map< std::string, const ComputedVariable * >	iCompute_

std::string	method_

std::string	name_

std::string	separator_

Detailed Description

Definition at line 115 of file CachingVariable.h.

Constructor & Destructor Documentation

VariableComputer::VariableComputer	(	const CachingVariable::CachingVariableFactoryArg &	arg,
		edm::ConsumesCollector &	iC
	)

Definition at line 44 of file CachingVariable.cc.

References arg_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), CachingVariable::CachingVariableFactoryArg::iConfig, method_, CachingVariable::CachingVariableFactoryArg::n, name_, separator_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : arg_(arg) {
   if (arg_.iConfig.exists("separator"))
     separator_ = arg_.iConfig.getParameter<std::string>("separator");
   else
     separator_ = "_";
 
   name_ = arg_.n;
   method_ = arg_.iConfig.getParameter<std::string>("computer");
 }

virtual VariableComputer::~VariableComputer ( )

inlinevirtual

Definition at line 118 of file CachingVariable.h.

118 {}

Member Function Documentation

void VariableComputer::assign	(	std::string	var,
		double &	value
	)		const

Definition at line 66 of file CachingVariable.cc.

References iCompute_, and contentValuesCheck::ss.

Referenced by RazorComputer::compute(), L1BitComputer::compute(), HLTBitComputer::compute(), and VariableComputerTest::compute().

                                                                 {
   std::map<std::string, const ComputedVariable*>::const_iterator it = iCompute_.find(var);
   if (it == iCompute_.end()) {
     std::stringstream ss;
     ss << "cannot assign: " << var << ". List of variable declared:\n";
     for (std::map<std::string, const ComputedVariable*>::const_iterator it = iCompute_.begin(); it != iCompute_.end();
          ++it)
       ss << it->first << std::endl;
     edm::LogError("VariableComputer") << ss.str();
   } else
     it->second->setCache(value);
 }

virtual void VariableComputer::compute ( const edm::Event & iEvent ) const

pure virtual

Implemented in VariableComputerTest, HLTBitComputer, L1BitComputer, and RazorComputer.

void VariableComputer::declare	(	std::string	var,
		edm::ConsumesCollector &	iC
	)

Definition at line 55 of file CachingVariable.cc.

References arg_, iCompute_, CachingVariable::CachingVariableFactoryArg::iConfig, CachingVariable::CachingVariableFactoryArg::m, method_, name_, separator_, AlCaHLTBitMon_QueryRunRegistry::string, and isotrackApplyRegressor::var.

Referenced by HLTBitComputer::HLTBitComputer(), L1BitComputer::L1BitComputer(), RazorComputer::RazorComputer(), and VariableComputerTest::VariableComputerTest().

                                                                       {
   std::string aName = name_ + separator_ + var;
   ComputedVariable* newVar = new ComputedVariable(method_, aName, arg_.iConfig, this, iC);
   if (iCompute_.find(var) != iCompute_.end()) {
     edm::LogError("VariableComputer") << "redeclaring: " << var << " skipping.";
     delete newVar;
     return;
   }
   iCompute_[var] = newVar;
   arg_.m.insert(std::make_pair(aName, newVar));
 }

void VariableComputer::doesNotCompute ( ) const

Definition at line 79 of file CachingVariable.cc.

References iCompute_.

Referenced by L1BitComputer::compute(), HLTBitComputer::compute(), and VariableComputerTest::compute().

                                             {
   for (std::map<std::string, const ComputedVariable*>::const_iterator it = iCompute_.begin(); it != iCompute_.end();
        ++it)
     it->second->setNotCompute();
 }

void VariableComputer::doesNotCompute ( std::string var ) const

Definition at line 84 of file CachingVariable.cc.

References iCompute_, and contentValuesCheck::ss.

                                                          {
   std::map<std::string, const ComputedVariable*>::const_iterator it = iCompute_.find(var);
   if (it == iCompute_.end()) {
     std::stringstream ss;
     ss << "cannot act on: " << var << ". List of variable declared:\n";
     for (std::map<std::string, const ComputedVariable*>::const_iterator it = iCompute_.begin(); it != iCompute_.end();
          ++it)
       ss << it->first << std::endl;
     edm::LogError("VariableComputer") << ss.str();
   } else
     it->second->setNotCompute();
 }

const std::string& VariableComputer::name ( void ) const

inline

Definition at line 121 of file CachingVariable.h.

References name_.

Referenced by config.CFG::__str__(), geometryComparison.GeometryComparison::createScript(), validation.Sample::digest(), primaryVertexResolution.PrimaryVertexResolution::getRepMap(), primaryVertexValidation.PrimaryVertexValidation::getRepMap(), and zMuMuValidation.ZMuMuValidation::getRepMap().

121 { return name_; }

VariableComputer::name_

std::string name_

Definition: CachingVariable.h:138

bool VariableComputer::notSeenThisEventAlready ( const edm::Event & iEvent ) const

inline

Definition at line 127 of file CachingVariable.h.

References edm::Event::cacheIdentifier(), eventCacheID_, and SiStripPI::max.

                                                              {
     bool retValue = (std::numeric_limits<edm::Event::CacheIdentifier_t>::max() != eventCacheID_ and
                      eventCacheID_ != iEvent.cacheIdentifier());
     if (retValue) {
       eventCacheID_ = iEvent.cacheIdentifier();
     }
     return retValue;
   }