#include <RecoLuminosity/LumiProducer/src/DIPLumiProducer.cc>

Inheritance diagram for DIPLumiProducer:

Public Types
typedef std::shared_ptr< const DIPLumiDetail >	ReturnDetailType

typedef std::shared_ptr< const DIPLumiSummary >	ReturnSummaryType

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

ReturnDetailType	produceDetail (const DIPLuminosityRcd &)

ReturnSummaryType	produceSummary (const DIPLuminosityRcd &)

	~DIPLumiProducer () override

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

	ESProducer (const ESProducer &)=delete

	ESProducer (ESProducer &&)=delete

ESResolverIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer &	operator= (const ESProducer &)=delete

ESProducer &	operator= (ESProducer &&)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final

	~ESProducer () noexcept(false) override

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

	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete

const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete

	~ESProductResolverFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () noexcept(false)

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool	concurrentFinder () const

const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

	EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete

std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const

const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)

bool	nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const

const EventSetupRecordIntervalFinder &	operator= (const EventSetupRecordIntervalFinder &)=delete

void	resetInterval (const eventsetup::EventSetupRecordKey &)

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder () noexcept(false)

Protected Member Functions
void	setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override

Protected Member Functions inherited from edm::ESProducer
ESConsumesInfo *	consumesInfoPushBackNew ()

unsigned int	consumesInfoSize () const

template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList , const TRecord iRecord, const es::Label &iLabel)

template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null , const TRecord , const es::Label &)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TDecorator >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Private Member Functions
void	filldetailcache (unsigned int runnumber, unsigned int startlsnum)

void	fillsummarycache (unsigned int runnumber, unsigned int startlsnum)

unsigned int	maxavailableLSforRun (coral::ISchema &schema, const std::string &tablename, unsigned int runnumber)

Private Attributes
unsigned int	m_cachesize

std::string	m_connectStr

std::map< unsigned int, std::shared_ptr< const DIPLumiDetail > >	m_detailcache

unsigned int	m_detailcachedrun

std::shared_ptr< const DIPLumiDetail >	m_detailresult

bool	m_isNullRun

const edm::IOVSyncValue *	m_pcurrentTime

std::map< unsigned int, std::shared_ptr< const DIPLumiSummary > >	m_summarycache

unsigned int	m_summarycachedrun

std::shared_ptr< const DIPLumiSummary >	m_summaryresult

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>

Detailed Description

HF Luminosity numbers from DIP. Only exist if stable beam. No data available for other beam status

Description: A essource/esproducer for lumi values from DIP via runtime logger DB

Definition at line 22 of file DIPLumiProducer.h.

Member Typedef Documentation

◆ ReturnDetailType

typedef std::shared_ptr<const DIPLumiDetail> DIPLumiProducer::ReturnDetailType

Definition at line 27 of file DIPLumiProducer.h.

◆ ReturnSummaryType

typedef std::shared_ptr<const DIPLumiSummary> DIPLumiProducer::ReturnSummaryType

Definition at line 25 of file DIPLumiProducer.h.

Constructor & Destructor Documentation

◆ DIPLumiProducer()

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

Definition at line 59 of file DIPLumiProducer.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), m_cachesize, m_connectStr, produceDetail(), produceSummary(), edm::ESProducer::setWhatProduced(), and AlCaHLTBitMon_QueryRunRegistry::string.

     : m_connectStr(""), m_summarycachedrun(0), m_detailcachedrun(0), m_cachesize(0) {
   setWhatProduced(this, &DIPLumiProducer::produceSummary);
   setWhatProduced(this, &DIPLumiProducer::produceDetail);
   findingRecord<DIPLuminosityRcd>();
   m_connectStr = iConfig.getParameter<std::string>("connect");
   m_cachesize = iConfig.getUntrackedParameter<unsigned int>("ncacheEntries", 3);
 }

◆ ~DIPLumiProducer()

DIPLumiProducer::~DIPLumiProducer ( )

override

Definition at line 342 of file DIPLumiProducer.cc.

342 {}

Member Function Documentation

◆ filldetailcache()

void DIPLumiProducer::filldetailcache	(	unsigned int	runnumber,
		unsigned int	startlsnum
	)

private

Definition at line 262 of file DIPLumiProducer.cc.

References lumi::service::DBService::connectReadOnly(), Exception, edm::Service< T >::isAvailable(), B2GTnPMonitor_cfi::item, remoteMonitoring_LASER_era2018_cfg::lsmax, remoteMonitoring_LASER_era2018_cfg::lsmin, m_cachesize, m_connectStr, m_detailcache, m_detailcachedrun, m_summarycachedrun, maxavailableLSforRun(), eostools::move(), cond::runnumber, run_AlCaRecoTriggerBitsUpdateWorkflow::session, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by produceDetail().

                                                                                        {
   m_detailcache.clear();
   m_detailcachedrun = runnumber;
 
   std::map<unsigned int, std::unique_ptr<DIPLumiDetail> > detailcache;
   //
   //queries once per cache refill
   //
   //select lumisection,bunch,bunchlumi from cms_runtime_logger.bunch_lumi_sections where lumisection>=:lsmin and lumisection<:lsmax and runnumber=:runnumber ;
   //
   edm::Service<lumi::service::DBService> mydbservice;
   if (!mydbservice.isAvailable()) {
     throw cms::Exception("Non existing service lumi::service::DBService");
   }
   auto session = mydbservice->connectReadOnly(m_connectStr);
   coral::ITypeConverter& tconverter = session->typeConverter();
   tconverter.setCppTypeForSqlType(std::string("float"), std::string("FLOAT(63)"));
   tconverter.setCppTypeForSqlType(std::string("unsigned int"), std::string("NUMBER(10)"));
   unsigned int lsmin = 1;
   unsigned int lsmax = currentlsnum;
   try {
     session->transaction().start(true);
     coral::ISchema& schema = session->nominalSchema();
     unsigned int maxavailableLS = maxavailableLSforRun(schema, std::string("BUNCH_LUMI_SECTIONS"), m_summarycachedrun);
     if (maxavailableLS != 0 && maxavailableLS < currentlsnum) {
       lsmax = maxavailableLS;
     } else if (maxavailableLS == 0) {
       //this run not existing (yet)
       session->transaction().commit();
       return;
     }
     if (m_cachesize != 0) {
       lsmin = (lsmax - m_cachesize) > 0 ? (lsmax - m_cachesize + 1) : 1;
     }
     coral::AttributeList lumidetailBindVariables;
     lumidetailBindVariables.extend("lsmin", typeid(unsigned int));
     lumidetailBindVariables.extend("lsmax", typeid(unsigned int));
     lumidetailBindVariables.extend("runnumber", typeid(unsigned int));
     lumidetailBindVariables["runnumber"].data<unsigned int>() = m_detailcachedrun;
     lumidetailBindVariables["lsmin"].data<unsigned int>() = lsmin;
     lumidetailBindVariables["lsmax"].data<unsigned int>() = lsmax;
     std::string conditionStr("RUNNUMBER=:runnumber AND LUMISECTION>=:lsmin AND LUMISECTION<=:lsmax AND BUNCHLUMI>0 ");
     coral::AttributeList lumidetailOutput;
     lumidetailOutput.extend("LUMISECTION", typeid(unsigned int));
     lumidetailOutput.extend("BUNCH", typeid(unsigned int));
     lumidetailOutput.extend("BUNCHLUMI", typeid(float));
     coral::IQuery* lumidetailQuery = schema.newQuery();
     lumidetailQuery->addToTableList(std::string("BUNCH_LUMI_SECTIONS"));
     lumidetailQuery->addToOutputList("LUMISECTION");
     lumidetailQuery->addToOutputList("BUNCH");
     lumidetailQuery->addToOutputList("BUNCHLUMI");
     lumidetailQuery->setCondition(conditionStr, lumidetailBindVariables);
     lumidetailQuery->defineOutput(lumidetailOutput);
     coral::ICursor& lumidetailcursor = lumidetailQuery->execute();
     while (lumidetailcursor.next()) {
       const coral::AttributeList& row = lumidetailcursor.currentRow();
       unsigned int lsnum = row["LUMISECTION"].data<unsigned int>();
       if (detailcache.find(lsnum) == detailcache.end()) {
         detailcache.insert(std::make_pair(lsnum, std::make_unique<DIPLumiDetail>()));
         detailcache[lsnum]->setOrigin(m_detailcachedrun, lsnum);
       }
       if (!row["BUNCH"].isNull()) {
         unsigned int bxidx = row["BUNCH"].data<unsigned int>();
         float bxlumi = 0.0;
         if (!row["BUNCHLUMI"].isNull()) {
           bxlumi = row["BUNCHLUMI"].data<float>();  //Hz/ub
         }
         detailcache[lsnum]->fillbxdata(bxidx, bxlumi);
       }
     }
     for (auto& item : detailcache) {
       m_detailcache[item.first] = std::move(item.second);
     }
     delete lumidetailQuery;
     session->transaction().commit();
   } catch (const coral::Exception& er) {
     session->transaction().rollback();
     throw cms::Exception("DatabaseError ") << er.what();
   }
 }

◆ fillsummarycache()

void DIPLumiProducer::fillsummarycache	(	unsigned int	runnumber,
		unsigned int	startlsnum
	)

private

Definition at line 141 of file DIPLumiProducer.cc.

References lumi::service::DBService::connectReadOnly(), Exception, edm::Service< T >::isAvailable(), remoteMonitoring_LASER_era2018_cfg::lsmax, remoteMonitoring_LASER_era2018_cfg::lsmin, m_cachesize, m_connectStr, m_summarycache, m_summarycachedrun, maxavailableLSforRun(), eostools::move(), cond::runnumber, run_AlCaRecoTriggerBitsUpdateWorkflow::session, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by produceSummary().

                                                                                         {
   m_summarycache.clear();
   m_summarycachedrun = runnumber;
   //
   // queries once per cache refill
   //
   // select max(lumi_sections) as maxavailable from  cms_runtime_logger.lumi_sections where runnumber=:runnumber;
   //
   // if maxavailable<currentls: get lsmax=maxavailable ; else: get lsmax=currentls
   // lsmin=lsmax-cachesize
   // select runnumber,lumisection,instlumi,delivlumi,livelumi from cms_runtime_logger.lumi_sections where lumisection>=:lsmin and lumisection<=:lsmax and runnumber=:runnumber;
   //
   edm::Service<lumi::service::DBService> mydbservice;
   if (!mydbservice.isAvailable()) {
     throw cms::Exception("Non existing service lumi::service::DBService");
   }
   auto session = mydbservice->connectReadOnly(m_connectStr);
   coral::ITypeConverter& tconverter = session->typeConverter();
   tconverter.setCppTypeForSqlType(std::string("float"), std::string("FLOAT(63)"));
   tconverter.setCppTypeForSqlType(std::string("unsigned int"), std::string("NUMBER(10)"));
   tconverter.setCppTypeForSqlType(std::string("unsigned short"), std::string("NUMBER(1)"));
   unsigned int lsmin = 1;
   unsigned int lsmax = currentlsnum;
   try {
     session->transaction().start(true);
     coral::ISchema& schema = session->nominalSchema();
     unsigned int maxavailableLS = maxavailableLSforRun(schema, std::string("LUMI_SECTIONS"), m_summarycachedrun);
     if (maxavailableLS != 0 && maxavailableLS < currentlsnum) {
       lsmax = maxavailableLS;
     } else if (maxavailableLS == 0) {
       //this run not existing (yet)
       session->transaction().commit();
       return;
     }
     if (m_cachesize != 0) {
       lsmin = (lsmax - m_cachesize) > 0 ? (lsmax - m_cachesize + 1) : 1;
     }
     //std::cout<<"lsmin "<<lsmin<<" lsmax "<<lsmax<<std::endl;
     coral::AttributeList lumisummaryBindVariables;
     lumisummaryBindVariables.extend("lsmin", typeid(unsigned int));
     lumisummaryBindVariables.extend("lsmax", typeid(unsigned int));
     lumisummaryBindVariables.extend("runnumber", typeid(unsigned int));
     lumisummaryBindVariables["runnumber"].data<unsigned int>() = m_summarycachedrun;
     lumisummaryBindVariables["lsmin"].data<unsigned int>() = lsmin;
     lumisummaryBindVariables["lsmax"].data<unsigned int>() = lsmax;
     std::string conditionStr("RUNNUMBER=:runnumber AND LUMISECTION>=:lsmin AND LUMISECTION<=:lsmax");
     coral::AttributeList lumisummaryOutput;
     lumisummaryOutput.extend("LUMISECTION", typeid(unsigned int));
     lumisummaryOutput.extend("INSTLUMI", typeid(float));
     lumisummaryOutput.extend("DELIVLUMISECTION", typeid(float));
     lumisummaryOutput.extend("LIVELUMISECTION", typeid(float));
     lumisummaryOutput.extend("CMS_ACTIVE", typeid(unsigned short));
     coral::IQuery* lumisummaryQuery = schema.newQuery();
     lumisummaryQuery->addToTableList(std::string("LUMI_SECTIONS"));
     lumisummaryQuery->addToOutputList("LUMISECTION");
     lumisummaryQuery->addToOutputList("INSTLUMI");
     lumisummaryQuery->addToOutputList("DELIVLUMISECTION");
     lumisummaryQuery->addToOutputList("LIVELUMISECTION");
     lumisummaryQuery->addToOutputList("CMS_ACTIVE");
     lumisummaryQuery->setCondition(conditionStr, lumisummaryBindVariables);
     lumisummaryQuery->defineOutput(lumisummaryOutput);
     coral::ICursor& lumisummarycursor = lumisummaryQuery->execute();
     while (lumisummarycursor.next()) {
       const coral::AttributeList& row = lumisummarycursor.currentRow();
       unsigned int lsnum = row["LUMISECTION"].data<unsigned int>();
       float instlumi = 0.0;
       if (!row["INSTLUMI"].isNull()) {
         instlumi = row["INSTLUMI"].data<float>();  //Hz/ub
       }
       float intgdellumi = 0.0;
       if (!row["DELIVLUMISECTION"].isNull()) {
         intgdellumi = row["DELIVLUMISECTION"].data<float>() * 1000.0;  //convert to /ub
       }
       float intgreclumi = 0.0;
       if (!row["LIVELUMISECTION"].isNull()) {
         intgreclumi = row["LIVELUMISECTION"].data<float>() * 1000.0;  //convert to /ub
       }
       unsigned short cmsalive = 0;
       if (!row["CMS_ACTIVE"].isNull()) {
         cmsalive = row["CMS_ACTIVE"].data<unsigned short>();
       }
       auto tmpls = std::make_unique<DIPLumiSummary>(instlumi, intgdellumi, intgreclumi, cmsalive);
       tmpls->setOrigin(m_summarycachedrun, lsnum);
       //std::cout<<"filling "<<lsnum<<std::endl;
       std::shared_ptr<const DIPLumiSummary> const_tmpls = std::move(tmpls);
       m_summarycache.insert(std::make_pair(lsnum, const_tmpls));
     }
     delete lumisummaryQuery;
     session->transaction().commit();
   } catch (const coral::Exception& er) {
     session->transaction().rollback();
     throw cms::Exception("DatabaseError ") << er.what();
   }
 }

◆ maxavailableLSforRun()

unsigned int DIPLumiProducer::maxavailableLSforRun	(	coral::ISchema &	schema,
		const std::string &	tablename,
		unsigned int	runnumber
	)

private

select max(lumisection) as maxavailable from cms_runtime_logger.lumi_sections where runnumber=:runnumber;

Definition at line 235 of file DIPLumiProducer.cc.

References inputsource_file_cfi::myQuery, mps_fire::result, cond::runnumber, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by filldetailcache(), and fillsummarycache().

                                                                            {
   unsigned int result = 0;
   coral::AttributeList bindVariables;
   bindVariables.extend("runnumber", typeid(unsigned int));
   bindVariables["runnumber"].data<unsigned int>() = runnumber;
   std::string conditionStr("RUNNUMBER=:runnumber");
   coral::AttributeList MyOutput;
   MyOutput.extend("maxavailablels", typeid(unsigned int));
   coral::IQuery* myQuery = schema.newQuery();
   myQuery->addToTableList(tablename);
   myQuery->addToOutputList("max(LUMISECTION)", "maxavailablels");
   myQuery->setCondition(conditionStr, bindVariables);
   myQuery->defineOutput(MyOutput);
   coral::ICursor& mycursor = myQuery->execute();
   while (mycursor.next()) {
     const coral::AttributeList& row = mycursor.currentRow();
     if (!row["maxavailablels"].isNull()) {
       result = row["maxavailablels"].data<unsigned int>();
     }
   }
   return result;
 }

◆ produceDetail()

DIPLumiProducer::ReturnDetailType DIPLumiProducer::produceDetail ( const DIPLuminosityRcd & )

Definition at line 100 of file DIPLumiProducer.cc.

References dqmiodumpmetadata::currentrun, edm::IOVSyncValue::eventID(), filldetailcache(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::IOVSyncValue::luminosityBlockNumber(), m_detailcache, m_detailcachedrun, m_detailresult, m_pcurrentTime, genParticles_cff::map, edm::EventID::run(), and findQualityFiles::v.

Referenced by DIPLumiProducer().

                                                                                       {
   unsigned int currentrun = m_pcurrentTime->eventID().run();
   unsigned int currentls = m_pcurrentTime->luminosityBlockNumber();
   if (currentls == 0 || currentls == 4294967295) {
     return std::make_shared<const DIPLumiDetail>();
   }
   if (m_detailcachedrun != currentrun) {                         //i'm in a new run
     filldetailcache(currentrun, currentls);                      //starting ls
   } else {                                                       //i'm in an known run
     if (m_detailcache.find(currentls) == m_detailcache.end()) {  //i'm in a unknown ls
       filldetailcache(currentrun, currentls);                    //cache all ls>=currentls
     }
   }
   if (m_detailcache.empty()) {
     return std::make_shared<const DIPLumiDetail>();
   }
   if (m_detailcache.find(currentls) == m_detailcache.end()) {
     std::vector<unsigned int> v;
     for (std::map<unsigned int, std::shared_ptr<const DIPLumiDetail> >::iterator it = m_detailcache.begin();
          it != m_detailcache.end();
          ++it) {
       v.push_back(it->first);
     }
     m_detailresult = m_detailcache[v.back()];
   } else {
     m_detailresult = m_detailcache[currentls];
   }
   if (m_detailresult.get() == nullptr) {
     return std::make_shared<const DIPLumiDetail>();
   }
   return m_detailresult;
 }

◆ produceSummary()

DIPLumiProducer::ReturnSummaryType DIPLumiProducer::produceSummary ( const DIPLuminosityRcd & )

Definition at line 68 of file DIPLumiProducer.cc.

References dqmiodumpmetadata::currentrun, edm::IOVSyncValue::eventID(), fillsummarycache(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::IOVSyncValue::luminosityBlockNumber(), m_pcurrentTime, m_summarycache, m_summarycachedrun, m_summaryresult, genParticles_cff::map, edm::EventID::run(), and findQualityFiles::v.

Referenced by DIPLumiProducer().

                                                                                         {
   unsigned int currentrun = m_pcurrentTime->eventID().run();
   unsigned int currentls = m_pcurrentTime->luminosityBlockNumber();
   if (currentls == 0 || currentls == 4294967295) {
     return std::make_shared<const DIPLumiSummary>();
   }
   if (m_summarycachedrun != currentrun) {                          //i'm in a new run
     fillsummarycache(currentrun, currentls);                       //starting ls
   } else {                                                         //i'm in an old run
     if (m_summarycache.find(currentls) == m_summarycache.end()) {  //i'm not cached
       fillsummarycache(currentrun, currentls);                     //
     }
   }
   if (m_summarycache.empty()) {
     return std::make_shared<const DIPLumiSummary>();
   }
   if (m_summarycache.find(currentls) == m_summarycache.end()) {
     std::vector<unsigned int> v;
     for (std::map<unsigned int, std::shared_ptr<const DIPLumiSummary> >::iterator it = m_summarycache.begin();
          it != m_summarycache.end();
          ++it) {
       v.push_back(it->first);
     }
     m_summaryresult = m_summarycache[v.back()];
   } else {
     m_summaryresult = m_summarycache[currentls];
   }
   if (m_summaryresult.get() == nullptr) {
     return std::make_shared<const DIPLumiSummary>();
   }
   return m_summaryresult;
 }

◆ setIntervalFor()

void DIPLumiProducer::setIntervalFor	(	const edm::eventsetup::EventSetupRecordKey &	iKey,
		const edm::IOVSyncValue &	iTime,
		edm::ValidityInterval &	oValidity
	)

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 133 of file DIPLumiProducer.cc.

References m_pcurrentTime, edm::ValidityInterval::setFirst(), and edm::ValidityInterval::setLast().

                                                                      {
   m_pcurrentTime = &iTime;
   oValidity.setFirst(iTime);
   oValidity.setLast(iTime);
 }

Member Data Documentation

◆ m_cachesize

unsigned int DIPLumiProducer::m_cachesize

private

Definition at line 46 of file DIPLumiProducer.h.

Referenced by DIPLumiProducer(), filldetailcache(), and fillsummarycache().

◆ m_connectStr

std::string DIPLumiProducer::m_connectStr

private

Definition at line 40 of file DIPLumiProducer.h.

Referenced by DIPLumiProducer(), filldetailcache(), and fillsummarycache().

◆ m_detailcache

std::map<unsigned int, std::shared_ptr<const DIPLumiDetail> > DIPLumiProducer::m_detailcache

private

Definition at line 42 of file DIPLumiProducer.h.

Referenced by filldetailcache(), and produceDetail().

◆ m_detailcachedrun

unsigned int DIPLumiProducer::m_detailcachedrun

private

Definition at line 45 of file DIPLumiProducer.h.

Referenced by filldetailcache(), and produceDetail().

◆ m_detailresult

std::shared_ptr<const DIPLumiDetail> DIPLumiProducer::m_detailresult

private

Definition at line 48 of file DIPLumiProducer.h.

Referenced by produceDetail().

◆ m_isNullRun

bool DIPLumiProducer::m_isNullRun

private

Definition at line 43 of file DIPLumiProducer.h.

◆ m_pcurrentTime

const edm::IOVSyncValue* DIPLumiProducer::m_pcurrentTime

private

Definition at line 49 of file DIPLumiProducer.h.

Referenced by produceDetail(), produceSummary(), and setIntervalFor().

◆ m_summarycache

std::map<unsigned int, std::shared_ptr<const DIPLumiSummary> > DIPLumiProducer::m_summarycache

private

Definition at line 41 of file DIPLumiProducer.h.

Referenced by fillsummarycache(), and produceSummary().

◆ m_summarycachedrun

unsigned int DIPLumiProducer::m_summarycachedrun

private

Definition at line 44 of file DIPLumiProducer.h.

Referenced by filldetailcache(), fillsummarycache(), and produceSummary().

◆ m_summaryresult

std::shared_ptr<const DIPLumiSummary> DIPLumiProducer::m_summaryresult

private

Definition at line 47 of file DIPLumiProducer.h.

Referenced by produceSummary().

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ReturnDetailType

◆ ReturnSummaryType

Constructor & Destructor Documentation

◆ DIPLumiProducer()

◆ ~DIPLumiProducer()

Member Function Documentation

◆ filldetailcache()

◆ fillsummarycache()

◆ maxavailableLSforRun()

◆ produceDetail()

◆ produceSummary()

◆ setIntervalFor()

Member Data Documentation

◆ m_cachesize

◆ m_connectStr

◆ m_detailcache

◆ m_detailcachedrun

◆ m_detailresult

◆ m_isNullRun

◆ m_pcurrentTime

◆ m_summarycache

◆ m_summarycachedrun

◆ m_summaryresult