Inheritance diagram for L1CaloEcalScaleConfigOnlineProd:

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

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

	~L1CaloEcalScaleConfigOnlineProd () override

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

virtual std::unique_ptr< L1CaloEcalScale >	produce (const L1CaloEcalScaleRcd &iRecord)

	~L1ConfigOnlineProdBase () override

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

	ESProducer (const ESProducer &)=delete

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

ESProducer const &	operator= (const ESProducer &)=delete

template<typename Record >
void	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer () noexcept(false) override

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

	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete

const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete

	~ESProxyFactoryProducer () noexcept(false) override

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

	DataProxyProvider ()

	DataProxyProvider (const DataProxyProvider &)=delete

const ComponentDescription &	description () const

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

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

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Private Attributes
std::map< int, std::vector< int > * >	groupInfo

EcalTPGGroups *	lutGrpMap

const EcalElectronicsMapping *	theMapping_

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

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

Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>

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

Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &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 TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

Protected Member Functions inherited from edm::ESProxyFactoryProducer
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::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override

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

void	usingRecordWithKey (const EventSetupRecordKey &key)

Protected Attributes inherited from L1ConfigOnlineProdBase< L1CaloEcalScaleRcd, L1CaloEcalScale >
bool	m_copyFromCondDB

cond::persistency::Session	m_dbSession

bool	m_forceGeneration

l1t::OMDSReader	m_omdsReader

Detailed Description

Definition at line 37 of file L1CaloEcalScaleConfigOnlineProd.cc.

Constructor & Destructor Documentation

◆ L1CaloEcalScaleConfigOnlineProd()

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

Definition at line 50 of file L1CaloEcalScaleConfigOnlineProd.cc.

     : L1ConfigOnlineProdBase<L1CaloEcalScaleRcd, L1CaloEcalScale>(iConfig) {
   theMapping_ = new EcalElectronicsMapping();
   lutGrpMap = new EcalTPGGroups();
 }

References lutGrpMap, and theMapping_.

◆ ~L1CaloEcalScaleConfigOnlineProd()

L1CaloEcalScaleConfigOnlineProd::~L1CaloEcalScaleConfigOnlineProd ( )

override

Definition at line 56 of file L1CaloEcalScaleConfigOnlineProd.cc.

                                                                   {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
   delete theMapping_;
  
   //  delete lutGrpMap;
   groupInfo.clear();
 }

References groupInfo, and theMapping_.

Member Function Documentation

◆ newObject()

std::unique_ptr< L1CaloEcalScale > L1CaloEcalScaleConfigOnlineProd::newObject ( const std::string & objectKey )

overridevirtual

Implements L1ConfigOnlineProdBase< L1CaloEcalScaleRcd, L1CaloEcalScale >.

Definition at line 65 of file L1CaloEcalScaleConfigOnlineProd.cc.

                                                                                                     {
   std::cout << "object Key " << objectKey << std::endl;
  
   if (objectKey == "NULL" || objectKey.empty()) {  // return default blank ecal scale
     return std::make_unique<L1CaloEcalScale>(0);
   }
   if (objectKey == "IDENTITY") {  // return identity ecal scale
     return std::make_unique<L1CaloEcalScale>(1);
   }
  
   double ee_lsb = 0.;
   double eb_lsb = 0.;
  
   std::vector<std::string> mainStrings;
  
   // ~~~~~~~~~ Cut values ~~~~~~~~~
  
   std::vector<std::string> paramStrings;
   paramStrings.push_back("LOGIC_ID");  // EB/EE
   paramStrings.push_back("ETSAT");     //Only object needed
  
   std::vector<std::string> IDStrings;
   IDStrings.push_back("NAME");
   IDStrings.push_back("ID1");
   IDStrings.push_back("ID2");
   IDStrings.push_back("maps_to");
  
   l1t::OMDSReader::QueryResults paramResults = m_omdsReader.basicQuery(paramStrings,
                                                                        "CMS_ECAL_CONF",
                                                                        "FE_CONFIG_LUTPARAM_DAT",
                                                                        "FE_CONFIG_LUTPARAM_DAT.LUT_CONF_ID",
                                                                        m_omdsReader.singleAttribute(objectKey));
  
   if (paramResults.queryFailed() || (paramResults.numberRows() == 0))  // check query successful
   {
     edm::LogError("L1-O2O") << "Problem with L1CaloEcalScale key.  Unable to find lutparam dat table";
     return std::unique_ptr<L1CaloEcalScale>();
   }
  
   for (int i = 0; i < paramResults.numberRows(); i++) {
     //EcalTPGPhysicsConst::Item item;
     float etSat;
     paramResults.fillVariableFromRow("ETSAT", i, etSat);
  
     std::string ecid_name;
     int logic_id;
     paramResults.fillVariableFromRow("LOGIC_ID", i, logic_id);
  
     l1t::OMDSReader::QueryResults logicID = m_omdsReader.basicQuery(
         IDStrings, "CMS_ECAL_COND", "CHANNELVIEW", "CHANNELVIEW.LOGIC_ID", m_omdsReader.singleAttribute(logic_id));
  
     logicID.fillVariable("NAME", ecid_name);
  
     if (ecid_name == "EB")
       eb_lsb = etSat / 1024;
     else if ("EE" == ecid_name)
       ee_lsb = etSat / 1024;
     else {
       edm::LogError("L1-O2O")
           << "Problem with L1CaloEcalScale  LOGIC_ID.  unable to find channel view with appropiate logic id";
       return std::unique_ptr<L1CaloEcalScale>();
     }
   }
   //     std::cout << " eb lsb " << eb_lsb << " ee_lsb " << ee_lsb << std::endl;
  
   std::vector<std::string> grpLUT;
   grpLUT.push_back("GROUP_ID");
   grpLUT.push_back("LUT_ID");
   grpLUT.push_back("LUT_VALUE");
  
   l1t::OMDSReader::QueryResults lutGrpResults = m_omdsReader.basicQuery(grpLUT,
                                                                         "CMS_ECAL_CONF",
                                                                         "FE_LUT_PER_GROUP_DAT",
                                                                         "FE_LUT_PER_GROUP_DAT.LUT_CONF_ID",
                                                                         m_omdsReader.singleAttribute(objectKey));
  
   if (lutGrpResults.queryFailed() || (lutGrpResults.numberRows() % 1024 != 0))  // check query successful
   {
     edm::LogError("L1-O2O") << "Problem with L1CaloEcalScale key.  No group info";
     return std::unique_ptr<L1CaloEcalScale>();
   }
  
   int nEntries = lutGrpResults.numberRows();
   for (int i = 0; i < nEntries; i++) {
     int group, lutID;
     float lutValue;
  
     lutGrpResults.fillVariableFromRow("GROUP_ID", i, group);
     if (groupInfo.find(group) == groupInfo.end()) {
       groupInfo[group] = new std::vector<int>;
       (groupInfo[group])->resize(1024);
     }
  
     lutGrpResults.fillVariableFromRow("LUT_ID", i, lutID);
     lutGrpResults.fillVariableFromRow("LUT_VALUE", i, lutValue);
     groupInfo[group]->at(lutID) = (int)lutValue;
   }
  
   std::map<int, std::vector<int> > tpgValueMap;
  
   std::map<int, std::vector<int>*>::iterator grpIt;
   for (grpIt = groupInfo.begin(); grpIt != groupInfo.end(); ++grpIt) {
     const std::vector<int>* lut_ = grpIt->second;
  
     std::vector<int> tpgValue;
     tpgValue.resize(256);
     int lastValue = 0;
     for (int tpg = 0; tpg < 256; tpg++) {
       for (int i = 0; i < 1024; i++) {
         if (tpg == (0xff & (lut_->at(i)))) {
           tpgValue[tpg] = i;
           lastValue = i;
           break;
         }
         tpgValue[tpg] = lastValue;
       }
     }
     tpgValueMap[grpIt->first] = tpgValue;
   }
  
   std::vector<std::string> groupMap;
   groupMap.push_back("LOGIC_ID");
   groupMap.push_back("GROUP_ID");
  
   l1t::OMDSReader::QueryResults grpMapResults = m_omdsReader.basicQuery(groupMap,
                                                                         "CMS_ECAL_CONF",
                                                                         "FE_CONFIG_LUT_DAT",
                                                                         "FE_CONFIG_LUT_DAT.LUT_CONF_ID",
                                                                         m_omdsReader.singleAttribute(objectKey));
   if (grpMapResults.queryFailed() || (grpMapResults.numberRows() == 0))  // check query successful
   {
     edm::LogError("L1-O2O") << "Problem with L1CaloEcalScale key. No fe_config_lut_dat info";
     return std::unique_ptr<L1CaloEcalScale>();
   }
  
   nEntries = grpMapResults.numberRows();
   for (int i = 0; i < nEntries; ++i) {
     std::string ecid_name;
     int logic_id;
     grpMapResults.fillVariableFromRow("LOGIC_ID", i, logic_id);
     int group_id;
     grpMapResults.fillVariableFromRow("GROUP_ID", i, group_id);
     //       if(logic_id >= 2100001901 && logic_id <= 2100001916)
     //   std::cout<< "missing logic id found " <<logic_id <<std::endl;
     l1t::OMDSReader::QueryResults IDResults = m_omdsReader.basicQuery(
         IDStrings, "CMS_ECAL_COND", "CHANNELVIEW", "CHANNELVIEW.LOGIC_ID", m_omdsReader.singleAttribute(logic_id));
     if (paramResults.queryFailed() || (paramResults.numberRows() == 0))  // check query successful
     {
       edm::LogError("L1-O2O") << "Problem with L1CaloEcalScale key.  Unable to find logic_id channel view";
       return std::unique_ptr<L1CaloEcalScale>();
     }
     for (int j = 0; j < IDResults.numberRows(); j++) {
       std::string ecid_name, maps_to;
  
       IDResults.fillVariableFromRow("NAME", j, ecid_name);
       IDResults.fillVariableFromRow("maps_to", j, maps_to);
       if (logic_id >= 2100001901 && logic_id <= 2100001916)
         //     std::cout << " name " << ecid_name << " maps to " << maps_to <<std::endl;
         if (ecid_name != maps_to) {
           continue;  // make sure they match
         }
       if (ecid_name == "EB_trigger_tower" || ecid_name == "EE_trigger_tower") {
         int id1, id2;
         IDResults.fillVariableFromRow("ID1", j, id1);
         IDResults.fillVariableFromRow("ID2", j, id2);
  
         if (ecid_name == "EB_trigger_tower")
           id1 += 36;  //lowest TCC for barrel 37
         EcalTrigTowerDetId temp = theMapping_->getTrigTowerDetId(id1, id2);
         /*     if(ecid_name == "EE_trigger_tower"){
          int testID = theMapping_->TCCid(temp);
  
          if( testID != id1 ){
                    std::cout << " unmatched mapping testID " <<testID <<std::endl;
            std::cout << "id1 " << id1 << " id2 " <<id2<< " iphi " << temp.iphi() <<"  ieta " << temp.ieta() <<std::endl;
          }
        }
        if(ecid_name == "EB_trigger_tower"){
          int testID = theMapping_->TCCid(temp);
          if( testID != id1 ){
            std::cout << " unmatched mapping testID " <<testID <<std::endl;
            std::cout << "id1 " << id1 << " id2 " <<id2<< " iphi " << temp.iphi() <<"  ieta " << temp.ieta() <<std::endl;
          }
        }
        */
         //     if(temp.ieta() == -18 || temp.ietaAbs() == 28)
         //     if(logic_id >= 2100001901 && logic_id <= 2100001916)
  
         lutGrpMap->setValue(temp, group_id);  // assume ee has less than 68 tt
         break;
       }
     }
   }
  
   const EcalTPGGroups::EcalTPGGroupsMap& gMap = lutGrpMap->getMap();
  
   auto ecalScale = std::make_unique<L1CaloEcalScale>(0);
  
   for (unsigned short ieta = 1; ieta <= L1CaloEcalScale::nBinEta; ++ieta) {
     EcalSubdetector subdet = (ieta <= 17) ? EcalBarrel : EcalEndcap;
     double et_lsb = (ieta <= 17) ? eb_lsb : ee_lsb;
     for (int pos = 0; pos <= 1; pos++) {
       int zside = (int)pow(-1, pos);
  
       //     std::cout << "ieta " <<zside*ieta ;
       for (int iphi = 1; iphi <= 72; iphi++) {
         if (!EcalTrigTowerDetId::validDetId(zside, subdet, ieta, iphi))
           continue;
         EcalTrigTowerDetId test(zside, subdet, ieta, iphi);
         EcalTPGGroups::EcalTPGGroupsMapItr itLut = gMap.find(test);
         if (itLut != gMap.end()) {
           //         std::cout << " non mapped section iphi " << iphi << " ieta " <<ieta << " tccid " << theMapping_->TCCid(test) << " iTT " << theMapping_->iTT(test)<< std::endl;
           std::vector<int> tpgValue = tpgValueMap[itLut->second];
  
           for (unsigned short irank = 0; irank < L1CaloEcalScale::nBinRank; ++irank) {
             ecalScale->setBin(irank, ieta, zside, et_lsb * tpgValue[irank]);
  
             //       std::cout << " irank " << irank << " etValue " << et_lsb*tpgValue[irank] << std::endl;
           }
  
           break;
         }
       }
     }
   }
  
   //     ecalScale->print(std::cout);
  
   // ------------ method called to produce the data  ------------
   return ecalScale;
 }