CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions
L1RCTParametersOnlineProd Class Reference
Inheritance diagram for L1RCTParametersOnlineProd:
L1ConfigOnlineProdBase< L1RCTParametersRcd, L1RCTParameters > edm::ESProducer edm::ESProxyFactoryProducer edm::eventsetup::DataProxyProvider

Public Member Functions

void fillScaleFactors (const l1t::OMDSReader::QueryResults &results, std::vector< double > &output, int nfactor=1)
 
 L1RCTParametersOnlineProd (const edm::ParameterSet &)
 
virtual boost::shared_ptr
< L1RCTParameters > 		newObject (const std::string &objectKey)
 
 ~L1RCTParametersOnlineProd ()
 
- Public Member Functions inherited from L1ConfigOnlineProdBase< L1RCTParametersRcd, L1RCTParameters >
 L1ConfigOnlineProdBase (const edm::ParameterSet &)
 
boost::shared_ptr
< L1RCTParameters > 		produce (const L1RCTParametersRcd &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 ()
 

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< L1RCTParametersRcd, L1RCTParameters >
bool getObjectKey (const L1RCTParametersRcd &record, boost::shared_ptr< L1RCTParameters > 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< L1RCTParametersRcd, L1RCTParameters >
bool m_copyFromCondDB
 
cond::DbConnection m_dbConnection
 
cond::DbSession m_dbSession
 
bool m_forceGeneration
 
l1t::OMDSReader m_omdsReader
 

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 36 of file L1RCTParametersOnlineProd.cc.

Constructor & Destructor Documentation

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

Definition at line 69 of file L1RCTParametersOnlineProd.cc.

71  : L1ConfigOnlineProdBase< L1RCTParametersRcd, L1RCTParameters >( iConfig )
72 {
73  //the following line is needed to tell the framework what
74  // data is being produced
75 
76  //now do what ever other initialization is needed
77 }
L1RCTParametersOnlineProd::~L1RCTParametersOnlineProd ( )

Definition at line 80 of file L1RCTParametersOnlineProd.cc.

81 {
82 
83  // do anything here that needs to be done at desctruction time
84  // (e.g. close files, deallocate resources etc.)
85 
86 }

Member Function Documentation

void L1RCTParametersOnlineProd::fillScaleFactors ( const l1t::OMDSReader::QueryResults &  results,
std::vector< double > &  output,
int  nfactor = 1 
)

Definition at line 508 of file L1RCTParametersOnlineProd.cc.

References l1t::OMDSReader::QueryResults::fillVariableFromRow(), i, and l1t::OMDSReader::QueryResults::numberRows().

Referenced by newObject().

511 {
512  if( (nfactors < 1) || (nfactors > 6)){
513  edm::LogError( "L1-O2O" ) <<"invalid number of factors in scale factors fill";
514  return;
515  }
516 
517  std::vector< std::string > scaleFactorQuery6Strings ;
518  scaleFactorQuery6Strings.push_back( "SCALEFACTOR" ) ;
519  scaleFactorQuery6Strings.push_back( "SF2" ) ;
520  scaleFactorQuery6Strings.push_back( "SF3" ) ;
521  scaleFactorQuery6Strings.push_back( "SF4" ) ;
522  scaleFactorQuery6Strings.push_back( "SF5" ) ;
523  scaleFactorQuery6Strings.push_back( "SF6" ) ;
524  // Store scale factors in temporary array to get ordering right.
525  // Reserve space for 100 bins.
526 
527  // static const int reserve = 100 ;
528  std::vector <double> sfTmp[100] ;
529  /*
530  for( int i = 0 ; i < reserve ; ++i )
531  {
532  sfTmp[ i ] = 0. ;
533  }
534  */
535  short maxBin = 0 ;
536  for( int i = 0 ; i < results.numberRows() ; ++i )
537  {
538  double sf[6] ;
539  for(int nf = 0; nf < nfactors; nf++){
540  results.fillVariableFromRow( scaleFactorQuery6Strings.at(nf), i, sf[nf] ) ;
541  }
542  short ieta = 0;
543  results.fillVariableFromRow( "FK_RCT_ETA", i, ieta ) ;
544 
545  for(int nf = 0; nf< nfactors; nf++)
546  // sfTmp[ ieta-1 ] = sf ; // eta bins start at 1.
547  sfTmp[ieta-1].push_back(sf[nf]);
548 
549  if( ieta > maxBin )
550  {
551  maxBin = ieta ;
552  }
553  }
554 
555 
556  for( short i = 0 ; i < maxBin ; ++i )
557  {
558  for( short nf = 0; nf < nfactors; nf++)
559  output.push_back( sfTmp[ i ].at(nf) ) ;
560 
561  }
562 }
i
int i
Definition: DBlmapReader.cc:9
l1t::OMDSReader::QueryResults::fillVariableFromRow
bool fillVariableFromRow(const std::string &columnName, int rowNumber, T &outputVariable) const
Definition: OMDSReader.h:319
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
boost::shared_ptr< L1RCTParameters > L1RCTParametersOnlineProd::newObject ( const std::string &  objectKey)
virtual

Implements L1ConfigOnlineProdBase< L1RCTParametersRcd, L1RCTParameters >.

Definition at line 89 of file L1RCTParametersOnlineProd.cc.

References l1t::OMDSReader::basicQuery(), fillScaleFactors(), L1ConfigOnlineProdBase< L1RCTParametersRcd, L1RCTParameters >::m_omdsReader, l1t::OMDSReader::QueryResults::queryFailed(), l1t::OMDSReader::singleAttribute(), and AlCaHLTBitMon_QueryRunRegistry::string.

90 {
91  using namespace edm::es;
92 
93  std::string rctSchema = "CMS_RCT" ;
94  const l1t::OMDSReader::QueryResults paremKeyResults =
95  m_omdsReader.singleAttribute( objectKey ) ;
96 
97  // ~~~~~~~~~ Cut values ~~~~~~~~~
98 
99  // select egamma_lsb, jetmet_lsb, e_min_for_fg_cut, e_max_for_fg_cut,
100  // h_ove r_e_cut, e_min_for_h_over_e_cut, e_max_for_h_over_e_cut,
101  // h_min_for_h_over_e_cut, e_activity_cut, h_activity_cut,
102  // eic_isolation_threshold, jsc_quiet_threshold_barrel,
103  // jsc_quiet_threshold_endcap, noisevetohb, noisevetoheplus,
104  // noisevetoheminus from parem_conf where parem_conf.parem_key =
105  // (select rct_parameter from rct_conf where rct_conf.rct_key =
106  // 'rct_cmssw_def');
107 
108  std::vector< std::string > queryStrings ;
109  queryStrings.push_back( "EGAMMA_LSB" ) ;
110  queryStrings.push_back( "JETMET_LSB" ) ;
111  queryStrings.push_back( "E_MIN_FOR_FG_CUT" ) ;
112  queryStrings.push_back( "E_MAX_FOR_FG_CUT" ) ;
113  queryStrings.push_back( "H_OVER_E_CUT" ) ;
114  queryStrings.push_back( "E_MIN_FOR_H_OVER_E_CUT" ) ;
115  queryStrings.push_back( "E_MAX_FOR_H_OVER_E_CUT" ) ;
116  queryStrings.push_back( "H_MIN_FOR_H_OVER_E_CUT" ) ;
117  queryStrings.push_back( "E_ACTIVITY_CUT" ) ;
118  queryStrings.push_back( "H_ACTIVITY_CUT" ) ;
119  queryStrings.push_back( "EIC_ISOLATION_THRESHOLD" ) ;
120  queryStrings.push_back( "JSC_QUIET_THRESHOLD_BARREL" ) ;
121  queryStrings.push_back( "JSC_QUIET_THRESHOLD_ENDCAP" ) ;
122  queryStrings.push_back( "NOISEVETOHB" ) ;
123  queryStrings.push_back( "NOISEVETOHEPLUS" ) ;
124  queryStrings.push_back( "NOISEVETOHEMINUS" ) ;
125  queryStrings.push_back( "USECORR" );
126  l1t::OMDSReader::QueryResults paremResults =
127  m_omdsReader.basicQuery( queryStrings,
128  rctSchema,
129  "PAREM_CONF",
130  "PAREM_CONF.PAREM_KEY",
131  paremKeyResults ) ;
132 
133  if( paremResults.queryFailed() ||
134  paremResults.numberRows() != 1 ) // check query successful
135  {
136  edm::LogError( "L1-O2O" ) << "Problem with L1RCTParameters key." ;
137  return boost::shared_ptr< L1RCTParameters >() ;
138  }
139 
140  double eGammaLSB, jetMETLSB, eMinForFGCut, eMaxForFGCut, hOeCut ;
141  double eMinForHoECut, eMaxForHoECut, hMinForHoECut ;
142  double eActivityCut, hActivityCut ;
143  double jscQuietThreshBarrel, jscQuietThreshEndcap, eicIsolationThreshold ;
144  bool noiseVetoHB, noiseVetoHEplus, noiseVetoHEminus, useCorr ;
145 
146  paremResults.fillVariable( "EGAMMA_LSB", eGammaLSB ) ;
147  paremResults.fillVariable( "JETMET_LSB", jetMETLSB ) ;
148  paremResults.fillVariable( "E_MIN_FOR_FG_CUT", eMinForFGCut ) ;
149  paremResults.fillVariable( "E_MAX_FOR_FG_CUT", eMaxForFGCut ) ;
150  paremResults.fillVariable( "H_OVER_E_CUT", hOeCut ) ;
151  paremResults.fillVariable( "E_MIN_FOR_H_OVER_E_CUT", eMinForHoECut ) ;
152  paremResults.fillVariable( "E_MAX_FOR_H_OVER_E_CUT", eMaxForHoECut ) ;
153  paremResults.fillVariable( "H_MIN_FOR_H_OVER_E_CUT", hMinForHoECut ) ;
154  paremResults.fillVariable( "E_ACTIVITY_CUT", eActivityCut ) ;
155  paremResults.fillVariable( "H_ACTIVITY_CUT", hActivityCut ) ;
156  paremResults.fillVariable( "JSC_QUIET_THRESHOLD_BARREL",
157  jscQuietThreshBarrel ) ;
158  paremResults.fillVariable( "JSC_QUIET_THRESHOLD_ENDCAP",
159  jscQuietThreshEndcap ) ;
160  paremResults.fillVariable( "EIC_ISOLATION_THRESHOLD",
161  eicIsolationThreshold ) ;
162  paremResults.fillVariable( "NOISEVETOHB", noiseVetoHB ) ;
163  paremResults.fillVariable( "NOISEVETOHEPLUS", noiseVetoHEplus ) ;
164  paremResults.fillVariable( "NOISEVETOHEMINUS", noiseVetoHEminus ) ;
165  paremResults.fillVariable( "USECORR", useCorr ) ;
166 // std::cout << "eGammaLSB = " << eGammaLSB << std::endl ;
167 // std::cout << "jetMETLSB = " << jetMETLSB << std::endl ;
168 // std::cout << "eMinForFGCut = " << eMinForFGCut << std::endl ;
169 // std::cout << "eMaxForFGCut = " << eMaxForFGCut << std::endl ;
170 // std::cout << "hOeCut = " << hOeCut << std::endl ;
171 // std::cout << "eMinForHoECut = " << eMinForHoECut << std::endl ;
172 // std::cout << "eMaxForHoECut = " << eMaxForHoECut << std::endl ;
173 // std::cout << "hMinForHoECut = " << hMinForHoECut << std::endl ;
174 // std::cout << "eActivityCut = " << eActivityCut << std::endl ;
175 // std::cout << "hActivityCut = " << hActivityCut << std::endl ;
176 // std::cout << "eicIsolationThreshold = " << eicIsolationThreshold << std::endl ;
177 // std::cout << "jscQuietThreshBarrel = " << jscQuietThreshBarrel << std::endl ;
178 // std::cout << "jscQuietThreshEndcap = " << jscQuietThreshEndcap << std::endl ;
179 // std::cout << "noiseVetoHB = " << noiseVetoHB << std::endl ;
180 // std::cout << "noiseVetoHEplus = " << noiseVetoHEplus << std::endl ;
181 // std::cout << "noiseVetoHEminus = " << noiseVetoHEminus << std::endl ;
182 
183  // ~~~~~~~~~ EGamma ECAL scale factors ~~~~~~~~~
184 
185  // select scalefactor, fk_rct_eta from egamma_ecal_scalefactor where
186  // egamma_ecal_scalefactor.fk_version =
187  // (select egamma_ecal from parem_conf where parem_conf.parem_key =
188  // (select rct_parameter from rct_conf where rct_conf.rct_key=
189  // 'rct_cmssw_def'));
190 
191  std::vector< std::string > scaleFactorQueryStrings ;
192  scaleFactorQueryStrings.push_back( "SCALEFACTOR" ) ;
193  scaleFactorQueryStrings.push_back( "FK_RCT_ETA" ) ;
194 
195  l1t::OMDSReader::QueryResults egammaEcalResults =
196  m_omdsReader.basicQuery(
197  scaleFactorQueryStrings,
198  rctSchema,
199  "EGAMMA_ECAL_SCALEFACTOR",
200  "EGAMMA_ECAL_SCALEFACTOR.FK_VERSION",
201  m_omdsReader.basicQuery( "EGAMMA_ECAL",
202  rctSchema,
203  "PAREM_CONF",
204  "PAREM_CONF.PAREM_KEY",
205  paremKeyResults ) ) ;
206 
207  if( egammaEcalResults.queryFailed() ) // check query successful
208  {
209  edm::LogError( "L1-O2O" ) << "Problem with EgammaEcal key." ;
210  return boost::shared_ptr< L1RCTParameters >() ;
211  }
212 
213 // std::cout << "egammaEcal " ;
214  std::vector< double > egammaEcalScaleFactors ;
215  fillScaleFactors( egammaEcalResults, egammaEcalScaleFactors ) ;
216 
217  // ~~~~~~~~~ EGamma HCAL scale factors ~~~~~~~~~
218 
219  // select scalefactor, fk_rct_eta from egamma_hcal_scalefactor where
220  // egamma_hcal_scalefactor.fk_version =
221  // (select egamma_hcal from parem_conf where parem_conf.parem_key =
222  // (select rct_parameter from rct_conf where rct_conf.rct_key=
223  // 'rct_cmssw_def'));
224 
225  l1t::OMDSReader::QueryResults egammaHcalResults =
226  m_omdsReader.basicQuery(
227  scaleFactorQueryStrings,
228  rctSchema,
229  "EGAMMA_HCAL_SCALEFACTOR",
230  "EGAMMA_HCAL_SCALEFACTOR.FK_VERSION",
231  m_omdsReader.basicQuery( "EGAMMA_HCAL",
232  rctSchema,
233  "PAREM_CONF",
234  "PAREM_CONF.PAREM_KEY",
235  paremKeyResults ) ) ;
236 
237  if( egammaHcalResults.queryFailed() ) // check query successful
238  {
239  edm::LogError( "L1-O2O" ) << "Problem with EgammaHcal key." ;
240  return boost::shared_ptr< L1RCTParameters >() ;
241  }
242 
243 // std::cout << "egammaHcal " ;
244  std::vector< double > egammaHcalScaleFactors ;
245  fillScaleFactors( egammaHcalResults, egammaHcalScaleFactors ) ;
246 
247  // ~~~~~~~~~ JetMET ECAL scale factors ~~~~~~~~~
248 
249  // select scalefactor, fk_rct_eta from jetmet_ecal_scalefactor where
250  // jetmet_ecal_scalefactor.fk_version =
251  // (select jetmet_ecal from parem_conf where parem_conf.parem_key =
252  // (select rct_parameter from rct_conf where rct_conf.rct_key=
253  // 'rct_cmssw_def'));
254 
255  l1t::OMDSReader::QueryResults jetmetEcalResults =
256  m_omdsReader.basicQuery(
257  scaleFactorQueryStrings,
258  rctSchema,
259  "JETMET_ECAL_SCALEFACTOR",
260  "JETMET_ECAL_SCALEFACTOR.FK_VERSION",
261  m_omdsReader.basicQuery( "JETMET_ECAL",
262  rctSchema,
263  "PAREM_CONF",
264  "PAREM_CONF.PAREM_KEY",
265  paremKeyResults ) ) ;
266 
267  if( jetmetEcalResults.queryFailed() ) // check query successful
268  {
269  edm::LogError( "L1-O2O" ) << "Problem with JetmetEcal key." ;
270  return boost::shared_ptr< L1RCTParameters >() ;
271  }
272 
273 // std::cout << "jetmetEcal " ;
274  std::vector< double > jetmetEcalScaleFactors ;
275  fillScaleFactors( jetmetEcalResults, jetmetEcalScaleFactors ) ;
276 
277  // ~~~~~~~~~ JetMET HCAL scale factors ~~~~~~~~~
278 
279  // select scalefactor, fk_rct_eta from jetmet_hcal_scalefactor where
280  // jetmet_hcal_scalefactor.fk_version =
281  // (select jetmet_hcal from parem_conf where parem_conf.parem_key =
282  // (select rct_parameter from rct_conf where rct_conf.rct_key=
283  // 'rct_cmssw_def'));
284 
285  l1t::OMDSReader::QueryResults jetmetHcalResults =
286  m_omdsReader.basicQuery(
287  scaleFactorQueryStrings,
288  rctSchema,
289  "JETMET_HCAL_SCALEFACTOR",
290  "JETMET_HCAL_SCALEFACTOR.FK_VERSION",
291  m_omdsReader.basicQuery( "JETMET_HCAL",
292  rctSchema,
293  "PAREM_CONF",
294  "PAREM_CONF.PAREM_KEY",
295  paremKeyResults ) ) ;
296 
297  if( jetmetHcalResults.queryFailed() ) // check query successful
298  {
299  edm::LogError( "L1-O2O" ) << "Problem with JetmetHcal key." ;
300  return boost::shared_ptr< L1RCTParameters >() ;
301  }
302 
303 // std::cout << "jetmetHcal " ;
304  std::vector< double > jetmetHcalScaleFactors ;
305  fillScaleFactors( jetmetHcalResults, jetmetHcalScaleFactors ) ;
306 
307 
308 
309  //Lindsay variables
310 
311  /*
312  std::vector< std::vector< double > > hcalCalibScaleFactors ;
313  std::vector< std::vector< double > > hcalCalibHighScaleFactors ;
314  std::vector< std::vector< double > > ecalCalibScaleFactors ;
315  std::vector< std::vector< double > > crossTermsScaleFactors ;
316  */
317  std::vector< double > lowHoverE_smear, highHoverE_smear ;
318  std::vector< double > hcalCalibScaleFactors,ecalCalibScaleFactors;
319  std::vector< double > hcalCalibHighScaleFactors,crossTermsScaleFactors;
320 
321  if(useCorr) { //lindsay corrections
322 
323  std::vector< std::string > scaleFactorQuery3Strings ;
324  scaleFactorQuery3Strings.push_back( "SCALEFACTOR" ) ;
325  scaleFactorQuery3Strings.push_back( "SF2" ) ;
326  scaleFactorQuery3Strings.push_back( "SF3" ) ;
327  scaleFactorQuery3Strings.push_back( "FK_RCT_ETA" ) ;
328 
329  l1t::OMDSReader::QueryResults hcalCalibResults =
330  m_omdsReader.basicQuery(
331  scaleFactorQuery3Strings,
332  rctSchema,
333  "HCAL_CALIB_FACTOR",
334  "HCAL_CALIB_FACTOR.VERSION",
335  m_omdsReader.basicQuery( "HCAL_CALIB_VERSION",
336  rctSchema,
337  "PAREM_CONF",
338  "PAREM_CONF.PAREM_KEY",
339  paremKeyResults ) ) ;
340 
341  if( hcalCalibResults.queryFailed() ) {// check query successful
342 
343  edm::LogError( "L1-O2O" ) << "Problem with JetmetHcal key." ;
344  return boost::shared_ptr< L1RCTParameters >() ;
345  }
346 
347 // std::cout << "jetmetHcal " ;
348 
349  fillScaleFactors( hcalCalibResults, hcalCalibScaleFactors, 3 ) ;
350 
351  l1t::OMDSReader::QueryResults hcalCalibHighResults =
352  m_omdsReader.basicQuery(
353  scaleFactorQuery3Strings,
354  rctSchema,
355  "HCAL_CALIB_HIGH_FACTOR",
356  "HCAL_CALIB_HIGH_FACTOR.VERSION",
357  m_omdsReader.basicQuery( "HCAL_CALIB_HIGH_VERSION",
358  rctSchema,
359  "PAREM_CONF",
360  "PAREM_CONF.PAREM_KEY",
361  paremKeyResults ) ) ;
362 
363  if( hcalCalibHighResults.queryFailed() ) // check query successful
364  {
365  edm::LogError( "L1-O2O" ) << "Problem with hcalHigh key." ;
366  return boost::shared_ptr< L1RCTParameters >() ;
367  }
368 
369 
370 
371  fillScaleFactors( hcalCalibHighResults, hcalCalibHighScaleFactors,3 ) ;
372 
373  l1t::OMDSReader::QueryResults ecalCalibResults =
374  m_omdsReader.basicQuery(
375  scaleFactorQuery3Strings,
376  rctSchema,
377  "ECAL_CALIB_FACTOR",
378  "ECAL_CALIB_FACTOR.VERSION",
379  m_omdsReader.basicQuery( "ECAL_CALIB_VERSION",
380  rctSchema,
381  "PAREM_CONF",
382  "PAREM_CONF.PAREM_KEY",
383  paremKeyResults ) ) ;
384 
385  if( ecalCalibResults.queryFailed() ) // check query successful
386  {
387  edm::LogError( "L1-O2O" ) << "Problem with ecal calib key." ;
388  return boost::shared_ptr< L1RCTParameters >() ;
389  }
390 
391 
392  fillScaleFactors( ecalCalibResults, ecalCalibScaleFactors,3 ) ;
393 
394 
395  std::vector< std::string > scaleFactorQuery6Strings ;
396  scaleFactorQuery6Strings.push_back( "SCALEFACTOR" ) ;
397  scaleFactorQuery6Strings.push_back( "SF2" ) ;
398  scaleFactorQuery6Strings.push_back( "SF3" ) ;
399  scaleFactorQuery6Strings.push_back( "SF4" ) ;
400  scaleFactorQuery6Strings.push_back( "SF5" ) ;
401  scaleFactorQuery6Strings.push_back( "SF6" ) ;
402  scaleFactorQuery6Strings.push_back( "FK_RCT_ETA" ) ;
403  l1t::OMDSReader::QueryResults crossTermResults =
404  m_omdsReader.basicQuery(
405  scaleFactorQuery6Strings,
406  rctSchema,
407  "CROSS_TERMS_FACTOR",
408  "CROSS_TERMS_FACTOR.VERSION",
409  m_omdsReader.basicQuery( "CROSS_TERMS_VERSION",
410  rctSchema,
411  "PAREM_CONF",
412  "PAREM_CONF.PAREM_KEY",
413  paremKeyResults ) ) ;
414 
415  if( crossTermResults.queryFailed() ) // check query successful
416  {
417  edm::LogError( "L1-O2O" ) << "Problem with crossTerms key." ;
418  return boost::shared_ptr< L1RCTParameters >() ;
419  }
420 
421  fillScaleFactors( crossTermResults, crossTermsScaleFactors,6 ) ;
422 
423  l1t::OMDSReader::QueryResults hoveresmearhighResults =
424  m_omdsReader.basicQuery(
425  scaleFactorQueryStrings,
426  rctSchema,
427  "H_OVER_E_SMEAR_HIGH_FACTOR",
428  "H_OVER_E_SMEAR_HIGH_FACTOR.FK_VERSION",
429  m_omdsReader.basicQuery( "H_OVER_E_SMEAR_HIGH_VERSION",
430  rctSchema,
431  "PAREM_CONF",
432  "PAREM_CONF.PAREM_KEY",
433  paremKeyResults ) ) ;
434 
435  if( hoveresmearhighResults.queryFailed() ) // check query successful
436  {
437  edm::LogError( "L1-O2O" ) << "Problem with low h over e smear key." ;
438  return boost::shared_ptr< L1RCTParameters >() ;
439  }
440 
441 // std::cout << "egammaEcal " ;
442  fillScaleFactors( hoveresmearhighResults, highHoverE_smear ) ;
443 
444 
445  l1t::OMDSReader::QueryResults hoveresmearlowResults =
446  m_omdsReader.basicQuery(
447  scaleFactorQueryStrings,
448  rctSchema,
449  "H_OVER_E_SMEAR_LOW_FACTOR",
450  "H_OVER_E_SMEAR_LOW_FACTOR.FK_VERSION",
451  m_omdsReader.basicQuery( "H_OVER_E_SMEAR_LOW_VERSION",
452  rctSchema,
453  "PAREM_CONF",
454  "PAREM_CONF.PAREM_KEY",
455  paremKeyResults ) ) ;
456 
457  if( hoveresmearlowResults.queryFailed() ) // check query successful
458  {
459  edm::LogError( "L1-O2O" ) << "Problem with low h over e smear key." ;
460  return boost::shared_ptr< L1RCTParameters >() ;
461  }
462 
463 // std::cout << "egammaEcal " ;
464  fillScaleFactors( hoveresmearlowResults, lowHoverE_smear ) ;
465  }
466 
467 
468  //~~~~~~~~~ Instantiate new L1RCTParameters object. ~~~~~~~~~
469 
470  // Default objects for Lindsey
471 
472  return boost::shared_ptr< L1RCTParameters >(
473  new L1RCTParameters( eGammaLSB,
474  jetMETLSB,
475  eMinForFGCut,
476  eMaxForFGCut,
477  hOeCut,
478  eMinForHoECut,
479  eMaxForHoECut,
480  hMinForHoECut,
481  eActivityCut,
482  hActivityCut,
483  (unsigned int) eicIsolationThreshold,
484  (int) jscQuietThreshBarrel,
485  (int) jscQuietThreshEndcap,
486  noiseVetoHB,
487  noiseVetoHEplus,
488  noiseVetoHEminus,
489  useCorr, // useLindsey
490  egammaEcalScaleFactors,
491  egammaHcalScaleFactors,
492  jetmetEcalScaleFactors,
493  jetmetHcalScaleFactors,
494  ecalCalibScaleFactors,
495  hcalCalibScaleFactors,
496  hcalCalibHighScaleFactors,
497  crossTermsScaleFactors,
498  lowHoverE_smear,
499  highHoverE_smear
500  ) ) ;
501 }
l1t::OMDSReader::singleAttribute
const QueryResults singleAttribute(const T &data) const
Definition: OMDSReader.h:295
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
L1RCTParametersOnlineProd::fillScaleFactors
void fillScaleFactors(const l1t::OMDSReader::QueryResults &results, std::vector< double > &output, int nfactor=1)
Definition: L1RCTParametersOnlineProd.cc:508
l1t::OMDSReader::basicQuery
const QueryResults basicQuery(const std::vector< std::string > &columnNames, const std::string &schemaName, const std::string &tableName, const std::string &conditionLHS="", const QueryResults conditionRHS=QueryResults(), const std::string &conditionRHSName="") const
Definition: OMDSReader.cc:87
Generated for CMSSW Reference Manual by doxygen 1.8.5