CMS 3D CMS Logo
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 &)
 
std::unique_ptr< L1RCTParameters > newObject (const std::string &objectKey) override
 
 ~L1RCTParametersOnlineProd () override
 
- Public Member Functions inherited from L1ConfigOnlineProdBase< L1RCTParametersRcd, L1RCTParameters >
 L1ConfigOnlineProdBase (const edm::ParameterSet &)
 
virtual std::unique_ptr< L1RCTParameters > produce (const L1RCTParametersRcd &iRecord)
 
 ~L1ConfigOnlineProdBase () override
 
- Public Member Functions inherited from edm::ESProducer
 ESProducer ()
 
ESProxyIndex const * getTokenIndices (unsigned int iIndex) const
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &) final
 
 ~ESProducer ()(false) override
 
- Public Member Functions inherited from edm::ESProxyFactoryProducer
 ESProxyFactoryProducer ()
 
void newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval) override
 overrides DataProxyProvider method More...
 
 ~ESProxyFactoryProducer () noexcept(false) override
 
- 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 () noexcept(false)
 

Additional Inherited Members

- Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair< DataKey, edm::propagate_const< std::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, std::string &objectKey)
 
- Protected Member Functions inherited from edm::ESProducer
 ESProducer (const ESProducer &)=delete
 
ESProducer const & operator= (const ESProducer &)=delete
 
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 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 eventsetup::EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())
 
void registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList) override
 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::persistency::Session m_dbSession
 
bool m_forceGeneration
 
l1t::OMDSReader m_omdsReader
 

Detailed Description

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

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

Definition at line 35 of file L1RCTParametersOnlineProd.cc.

Constructor & Destructor Documentation

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

Definition at line 68 of file L1RCTParametersOnlineProd.cc.

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

Definition at line 79 of file L1RCTParametersOnlineProd.cc.

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

Member Function Documentation

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

Definition at line 505 of file L1RCTParametersOnlineProd.cc.

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

Referenced by newObject().

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

Implements L1ConfigOnlineProdBase< L1RCTParametersRcd, L1RCTParameters >.

Definition at line 88 of file L1RCTParametersOnlineProd.cc.

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

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