Inheritance diagram for L1CaloHcalScaleConfigOnlineProd:

Public Member Functions
	L1CaloHcalScaleConfigOnlineProd (const edm::ParameterSet &iConfig)

std::unique_ptr< L1CaloHcalScale >	newObject (const std::string &objectKey) override

std::unique_ptr< L1CaloHcalScale >	produce (const L1CaloHcalScaleRcd &iRecord) override

	~L1CaloHcalScaleConfigOnlineProd () override

Public Member Functions inherited from L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >
	L1ConfigOnlineProdBase (const edm::ParameterSet &)

	~L1ConfigOnlineProdBase () 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)

Private Types
typedef std::vector< double >	RCTdecompression

Private Attributes
CaloTPGTranscoderULUT *	caloTPG

std::vector< RCTdecompression >	hcaluncomp

const HcalTrigTowerGeometry *	theTrigTowerGeometry

edm::ESGetToken< HcalTrigTowerGeometry, CaloGeometryRecord >	theTrigTowerGeometryToken

HcalTrigTowerDetId *	ttDetId

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 > >>

Protected Member Functions inherited from L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >
bool	getObjectKey (const L1CaloHcalScaleRcd &record, std::string &objectKey)

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 Attributes inherited from L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >
std::optional< edm::ESConsumesCollectorT< L1CaloHcalScaleRcd > >	m_consumesCollector

bool	m_copyFromCondDB

cond::persistency::Session	m_dbSession

bool	m_forceGeneration

l1t::OMDSReader	m_omdsReader

Detailed Description

Definition at line 39 of file L1CaloHcalScaleConfigOnlineProd.cc.

Member Typedef Documentation

◆ RCTdecompression

typedef std::vector<double> L1CaloHcalScaleConfigOnlineProd::RCTdecompression

private

Definition at line 52 of file L1CaloHcalScaleConfigOnlineProd.cc.

Constructor & Destructor Documentation

◆ L1CaloHcalScaleConfigOnlineProd()

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

Definition at line 73 of file L1CaloHcalScaleConfigOnlineProd.cc.

References caloTPG, L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >::m_consumesCollector, and theTrigTowerGeometryToken.

     : L1ConfigOnlineProdBase<L1CaloHcalScaleRcd, L1CaloHcalScale>(iConfig), theTrigTowerGeometry(nullptr) {
   theTrigTowerGeometryToken = m_consumesCollector->consumes();
   caloTPG = new CaloTPGTranscoderULUT();
 }

◆ ~L1CaloHcalScaleConfigOnlineProd()

L1CaloHcalScaleConfigOnlineProd::~L1CaloHcalScaleConfigOnlineProd ( )

override

Definition at line 79 of file L1CaloHcalScaleConfigOnlineProd.cc.

References caloTPG.

                                                                   {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 
   if (caloTPG != nullptr)
     delete caloTPG;
 }

Member Function Documentation

◆ newObject()

std::unique_ptr< L1CaloHcalScale > L1CaloHcalScaleConfigOnlineProd::newObject ( const std::string & objectKey )

overridevirtual

Implements L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >.

Definition at line 87 of file L1CaloHcalScaleConfigOnlineProd.cc.

References funct::abs(), cms::cuda::assert(), l1t::OMDSReader::QueryResults::attributeLists(), l1t::OMDSReader::basicQuery(), l1t::OMDSReader::basicQueryView(), caloTPG, l1t::OMDSReader::QueryResults::columnNames(), cond::persistency::Session::coralSession(), l1t::DataManager::dbSession(), hcalRecHitTable_cff::depth, mps_fire::end, l1t::OMDSReader::QueryResults::fillVariable(), l1t::OMDSReader::QueryResults::fillVariableFromRow(), HcalTrigTowerGeometry::firstHFTower(), CaloTPGTranscoderULUT::getOutputLUTId(), hcaluncomp, CaloTPGTranscoderULUT::HTvalid(), mps_fire::i, hcalRecHitTable_cff::ieta, createfilelist::int, hcalRecHitTable_cff::iphi, dqmdumpme::k, dqm-mbProfile::log, LaserClient_cfi::low, L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >::m_omdsReader, SiStripPI::min, L1CaloHcalScale::nBinEta, L1CaloHcalScale::nBinRank, nphi, l1t::OMDSReader::QueryResults::numberRows(), summarizeEdmComparisonLogfiles::objectName, funct::pow(), contentValuesFiles::query, l1t::OMDSReader::QueryResults::queryFailed(), alignCSCRings::s, l1t::OMDSReader::singleAttribute(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, theTrigTowerGeometry, DiMuonV_cfg::threshold, HcalTrigTowerGeometry::towerEtaBounds(), and ecaldqm::zside().

                                                                                                     {
   assert(theTrigTowerGeometry != nullptr);
 
   edm::LogInfo("L1CaloHcalScaleConfigOnlineProd") << "object Key " << objectKey;
 
   if (objectKey == "NULL" || objectKey.empty()) {  // return default blank ecal scale
     return std::make_unique<L1CaloHcalScale>(0);
   }
   if (objectKey == "IDENTITY") {  // return identity ecal scale
     return std::make_unique<L1CaloHcalScale>(1);
   }
 
   std::vector<unsigned int> analyticalLUT(1024, 0);
   std::vector<unsigned int> identityLUT(1024, 0);
 
   // Compute compression LUT
   for (unsigned int i = 0; i < 1024; i++) {
     analyticalLUT[i] = (unsigned int)(sqrt(14.94 * log(1. + i / 14.94) * i) + 0.5);
     identityLUT[i] = std::min(i, 0xffu);
   }
 
   hcaluncomp.clear();
   for (int i = 0; i < 4176; i++) {
     RCTdecompression decompressionTable(256, 0);
     hcaluncomp.push_back(decompressionTable);
   }
 
   std::vector<std::string> mainStrings;
   mainStrings.push_back("HCAL_LUT_METADATA");
   mainStrings.push_back("HCAL_LUT_CHAN_DATA");
 
   // ~~~~~~~~~ Cut values ~~~~~~~~~
 
   std::vector<std::string> metaStrings;
   metaStrings.push_back("RCTLSB");
   metaStrings.push_back("NOMINAL_GAIN");
 
   l1t::OMDSReader::QueryResults paramResults =
       m_omdsReader.basicQueryView(metaStrings,
                                   "CMS_HCL_HCAL_COND",
                                   "V_HCAL_LUT_METADATA_V1",
                                   "V_HCAL_LUT_METADATA_V1.TAG_NAME",
                                   m_omdsReader.basicQuery("HCAL_LUT_METADATA",
                                                           "CMS_RCT",
                                                           "HCAL_SCALE_KEY",
                                                           "HCAL_SCALE_KEY.HCAL_TAG",
                                                           m_omdsReader.singleAttribute(objectKey)));
 
   if (paramResults.queryFailed() || (paramResults.numberRows() != 1))  // check query successful
   {
     edm::LogError("L1-O2O") << "Problem with L1CaloHcalScale key.  Unable to find lutparam dat table";
     return std::unique_ptr<L1CaloHcalScale>();
   }
 
   double hcalLSB, nominal_gain;
   paramResults.fillVariable("RCTLSB", hcalLSB);
   paramResults.fillVariable("NOMINAL_GAIN", nominal_gain);
 
   float rctlsb = hcalLSB;
 
   l1t::OMDSReader::QueryResults chanKey = m_omdsReader.basicQuery("HCAL_LUT_CHAN_DATA",
                                                                   "CMS_RCT",
                                                                   "HCAL_SCALE_KEY",
                                                                   "HCAL_SCALE_KEY.HCAL_TAG",
                                                                   m_omdsReader.singleAttribute(objectKey));
 
   //coral::AttributeList myresult;
   //    myresult.extend(
 
   std::string schemaName("CMS_HCL_HCAL_COND");
   coral::ISchema& schema = m_omdsReader.dbSession().coralSession().schema(schemaName);
   coral::IQuery* query = schema.newQuery();
   ;
 
   std::vector<std::string> channelStrings;
   channelStrings.push_back("IPHI");
   channelStrings.push_back("IETA");
   channelStrings.push_back("DEPTH");
   channelStrings.push_back("LUT_GRANULARITY");
   channelStrings.push_back("OUTPUT_LUT_THRESHOLD");
   channelStrings.push_back("OBJECTNAME");
 
   std::vector<std::string>::const_iterator it = channelStrings.begin();
   std::vector<std::string>::const_iterator end = channelStrings.end();
   for (; it != end; ++it) {
     query->addToOutputList(*it);
   }
 
   std::string ob = "OBJECTNAME";
   coral::AttributeList myresult;
   myresult.extend("IPHI", typeid(int));
   myresult.extend("IETA", typeid(int));
   myresult.extend("DEPTH", typeid(int));
   myresult.extend("LUT_GRANULARITY", typeid(int));
   myresult.extend("OUTPUT_LUT_THRESHOLD", typeid(int));
   myresult.extend(ob, typeid(std::string));  //, typeid(std::string));
 
   query->defineOutput(myresult);
 
   query->addToTableList("V_HCAL_LUT_CHAN_DATA_V1");
 
   query->setCondition("V_HCAL_LUT_CHAN_DATA_V1.TAG_NAME = :" + chanKey.columnNames().front(),
                       chanKey.attributeLists().front());
 
   coral::ICursor& cursor = query->execute();
 
   // when the query goes out of scope.
   std::vector<coral::AttributeList> atts;
   while (cursor.next()) {
     atts.push_back(cursor.currentRow());
   };
 
   delete query;
 
   l1t::OMDSReader::QueryResults chanResults(channelStrings, atts);
   if (chanResults.queryFailed() || (chanResults.numberRows() == 0))  // check query successful
   {
     edm::LogError("L1-O2O") << "Problem with L1CaloHcalScale key.  Unable to find lutparam dat table nrows"
                             << chanResults.numberRows();
     return std::unique_ptr<L1CaloHcalScale>();
   }
 
   chanResults.attributeLists();
   for (int i = 0; i < chanResults.numberRows(); ++i) {
     std::string objectName;
     chanResults.fillVariableFromRow("OBJECTNAME", i, objectName);
     //       int
     if (objectName == "HcalTrigTowerDetId") {  //trig tower
       int ieta, iphi, depth, lutGranularity, threshold;
 
       chanResults.fillVariableFromRow("LUT_GRANULARITY", i, lutGranularity);
       chanResults.fillVariableFromRow("IPHI", i, iphi);
       chanResults.fillVariableFromRow("IETA", i, ieta);
       chanResults.fillVariableFromRow("DEPTH", i, depth);
       chanResults.fillVariableFromRow("OUTPUT_LUT_THRESHOLD", i, threshold);
 
       unsigned int outputLut[1024];
 
       const int tp_version = depth / 10;
       uint32_t lutId = caloTPG->getOutputLUTId(ieta, iphi, tp_version);
 
       double eta_low = 0., eta_high = 0.;
       theTrigTowerGeometry->towerEtaBounds(ieta, tp_version, eta_low, eta_high);
       double cosh_ieta = fabs(cosh((eta_low + eta_high) / 2.));
 
       if (!caloTPG->HTvalid(ieta, iphi, tp_version))
         continue;
       double factor = 0.;
       if (abs(ieta) >= theTrigTowerGeometry->firstHFTower(tp_version))
         factor = rctlsb;
       else
         factor = nominal_gain / cosh_ieta * lutGranularity;
       for (int k = 0; k < threshold; ++k)
         outputLut[k] = 0;
 
       for (unsigned int k = threshold; k < 1024; ++k)
         outputLut[k] = (abs(ieta) < theTrigTowerGeometry->firstHFTower(tp_version)) ? analyticalLUT[k] : identityLUT[k];
 
       // tpg - compressed value
       unsigned int tpg = outputLut[0];
 
       int low = 0;
 
       for (unsigned int k = 0; k < 1024; ++k) {
         if (outputLut[k] != tpg) {
           unsigned int mid = (low + k) / 2;
           hcaluncomp[lutId][tpg] = (tpg == 0 ? low : factor * mid);
           low = k;
           tpg = outputLut[k];
         }
       }
       hcaluncomp[lutId][tpg] = factor * low;
     }
   }
 
   auto hcalScale = std::make_unique<L1CaloHcalScale>(0);
 
   // XXX L1CaloHcalScale is only setup for 2x3 TP
   const int tp_version = 0;
   for (unsigned short ieta = 1; ieta <= L1CaloHcalScale::nBinEta; ++ieta) {
     for (int pos = 0; pos <= 1; pos++) {
       for (unsigned short irank = 0; irank < L1CaloHcalScale::nBinRank; ++irank) {
         int zside = (int)pow(-1, pos);
         int nphi = 0;
         double etvalue = 0.;
 
         for (int iphi = 1; iphi <= 72; iphi++) {
           if (!caloTPG->HTvalid(ieta, iphi, tp_version))
             continue;
           uint32_t lutId = caloTPG->getOutputLUTId(ieta, iphi, tp_version);
           nphi++;
           etvalue += (double)hcaluncomp[lutId][irank];
 
         }  // phi
         if (nphi > 0)
           etvalue /= nphi;
 
         hcalScale->setBin(irank, ieta, zside, etvalue);
 
       }  // rank
     }    // zside
   }      // eta
 
   std::stringstream s;
   s << std::setprecision(10);
   hcalScale->print(s);
   edm::LogInfo("L1CaloHcalScaleConfigOnlineProd") << s.str();
   // ------------ method called to produce the data  ------------
   return hcalScale;
 }

◆ produce()

std::unique_ptr< L1CaloHcalScale > L1CaloHcalScaleConfigOnlineProd::produce ( const L1CaloHcalScaleRcd & iRecord )

overridevirtual

Reimplemented from L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >.

Definition at line 298 of file L1CaloHcalScaleConfigOnlineProd.cc.

References edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), theTrigTowerGeometry, and theTrigTowerGeometryToken.

                                                                                                          {
   theTrigTowerGeometry = &iRecord.get(theTrigTowerGeometryToken);
 
   return (L1ConfigOnlineProdBase<L1CaloHcalScaleRcd, L1CaloHcalScale>::produce(iRecord));
 }