Inheritance diagram for L1CaloHcalScaleConfigOnlineProd:

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

virtual boost::shared_ptr < L1CaloHcalScale >	newObject (const std::string &objectKey) override

	~L1CaloHcalScaleConfigOnlineProd ()

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

boost::shared_ptr < L1CaloHcalScale >	produce (const L1CaloHcalScaleRcd &iRecord)

	~L1ConfigOnlineProdBase ()

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

virtual	~ESProducer ()

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

virtual void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval)
	overrides DataProxyProvider method More...

virtual	~ESProxyFactoryProducer ()

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider ()

Private Types
typedef std::vector< double >	RCTdecompression

Private Attributes
CaloTPGTranscoderULUT *	caloTPG

L1CaloHcalScale *	hcalScale

std::vector< RCTdecompression >	hcaluncomp

HcalTrigTowerGeometry *	theTrigTowerGeometry

HcalTrigTowerDetId *	ttDetId

Additional Inherited Members
Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair < DataKey, boost::shared_ptr < DataProxy > > >	KeyedProxies

typedef std::vector < EventSetupRecordKey >	Keys

typedef std::map < EventSetupRecordKey, KeyedProxies >	RecordProxies

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

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

Protected Member Functions inherited from edm::ESProducer
template<typename T >
void	setWhatProduced (T *iThis, const es::Label &iLabel=es::Label())

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

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

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

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

template<typename T , typename TReturn , typename TRecord , typename TArg >
void	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel=es::Label())

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

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

virtual void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList)
	override DataProxyProvider method More...

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

Protected Attributes inherited from L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >
bool	m_copyFromCondDB

cond::persistency::Session	m_dbSession

bool	m_forceGeneration

l1t::OMDSReader	m_omdsReader

Detailed Description

Definition at line 38 of file L1CaloHcalScaleConfigOnlineProd.cc.

Member Typedef Documentation

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

private

Definition at line 53 of file L1CaloHcalScaleConfigOnlineProd.cc.

Constructor & Destructor Documentation

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

Definition at line 75 of file L1CaloHcalScaleConfigOnlineProd.cc.

References caloTPG, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), hcalScale, HcalTopologyMode::LHC, alignBH_cfg::mode, geometryXMLtoCSV::parser, AlCaHLTBitMon_QueryRunRegistry::string, and theTrigTowerGeometry.

   : L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >( iConfig )
 {
   hcalScale = new L1CaloHcalScale(0);
   caloTPG = new CaloTPGTranscoderULUT();
   
   HcalTopologyMode::Mode mode = HcalTopologyMode::LHC;
   int maxDepthHB = 2;
   int maxDepthHE = 3;
   if( iConfig.exists( "hcalTopologyConstants" ))
   {
     const edm::ParameterSet hcalTopoConsts = iConfig.getParameter<edm::ParameterSet>( "hcalTopologyConstants" );
     StringToEnumParser<HcalTopologyMode::Mode> parser;
     mode = (HcalTopologyMode::Mode) parser.parseString(hcalTopoConsts.getParameter<std::string>("mode"));
     maxDepthHB = hcalTopoConsts.getParameter<int>("maxDepthHB");
     maxDepthHE = hcalTopoConsts.getParameter<int>("maxDepthHE");
   }
   
   theTrigTowerGeometry = new HcalTrigTowerGeometry( new HcalTopology( mode, maxDepthHB, maxDepthHE ));
 }

L1CaloHcalScaleConfigOnlineProd::~L1CaloHcalScaleConfigOnlineProd ( )

Definition at line 98 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 != 0)
     delete caloTPG;
 }

Member Function Documentation

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

overridevirtual

Implements L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >.

Definition at line 108 of file L1CaloHcalScaleConfigOnlineProd.cc.

References funct::abs(), l1t::OMDSReader::QueryResults::attributeLists(), l1t::OMDSReader::basicQuery(), l1t::OMDSReader::basicQueryView(), caloTPG, gather_cfg::cout, l1t::DataManager::dbSession(), end, l1t::OMDSReader::QueryResults::fillVariableFromRow(), HcalTrigTowerGeometry::firstHFTower(), CaloTPGTranscoderULUT::getOutputLUTId(), hcalScale, hcaluncomp, CaloTPGTranscoderULUT::HTvalid(), i, relval_steps::k, create_public_lumi_plots::log, L1ConfigOnlineProdBase< L1CaloHcalScaleRcd, L1CaloHcalScale >::m_omdsReader, min(), L1CaloHcalScale::nBinEta, L1CaloHcalScale::nBinRank, l1t::OMDSReader::QueryResults::numberRows(), summarizeEdmComparisonLogfiles::objectName, funct::pow(), L1CaloHcalScale::print(), o2o::query, l1t::OMDSReader::QueryResults::queryFailed(), cond::DbSession::schema(), python.IdGenerator::schema, L1CaloHcalScale::setBin(), l1t::OMDSReader::singleAttribute(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, theTrigTowerGeometry, dtDQMClient_cfg::threshold, HcalTrigTowerGeometry::towerEtaBounds(), and ecaldqm::zside().

 {
      using namespace edm::es;
  
      std:: cout << "object Key " << objectKey <<std::endl <<std::flush;
 
      if(objectKey == "NULL" || objectKey == "")  // return default blank ecal scale  
        return boost::shared_ptr< L1CaloHcalScale >( hcalScale );
      if(objectKey == "IDENTITY"){  // return identity ecal scale  
        
        delete hcalScale;
        
        hcalScale = new L1CaloHcalScale(1);
        
        return boost::shared_ptr< L1CaloHcalScale >( hcalScale);
      }
   
      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 boost::shared_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()->schema( schemaName ) ;
     coral::IQuery* query = schema.newQuery(); ;
 
      
     std::vector< std::string > channelStrings;
     channelStrings.push_back("IPHI");
     channelStrings.push_back("IETA");
     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("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 boost::shared_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, lutGranularity, threshold;
      
      
      chanResults.fillVariableFromRow("LUT_GRANULARITY",i,lutGranularity);
      chanResults.fillVariableFromRow("IPHI",i,iphi);
      chanResults.fillVariableFromRow("IETA",i,ieta);
      chanResults.fillVariableFromRow("OUTPUT_LUT_THRESHOLD",i,threshold);
      
 
      unsigned int outputLut[1024];
 
      uint32_t lutId = caloTPG->getOutputLUTId(ieta,iphi);
 
      double eta_low = 0., eta_high = 0.;
      theTrigTowerGeometry->towerEtaBounds(ieta,eta_low,eta_high); 
      double cosh_ieta = fabs(cosh((eta_low + eta_high)/2.));
 
 
      if (!caloTPG->HTvalid(ieta, iphi)) continue;
      double factor = 0.;
      if (abs(ieta) >= theTrigTowerGeometry->firstHFTower())
        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()) ? 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;
        }
      }
      
 
 
      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))
            continue;
          uint32_t lutId = caloTPG->getOutputLUTId(ieta,iphi);
          nphi++;
          etvalue += (double) hcaluncomp[lutId][irank];
 
        } // phi
        if (nphi > 0) etvalue /= nphi;
        
        hcalScale->setBin(irank, ieta, zside, etvalue);
 
      } // rank
        } // zside
      }// eta
 
      std::cout << std::setprecision(10);
      hcalScale->print(std::cout);
 // ------------ method called to produce the data  ------------
      return boost::shared_ptr< L1CaloHcalScale >( hcalScale );
 
 }