ATLAS Offline Software
ThresholdConfigLoader.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "./ThresholdConfigLoader.h"
6 #include "./TriggerThresholdLoader.h"
7 #include "./CaloJetInputLoader.h"
8 #include "./CaloSinCosLoader.h"
9 #include "./CaloInfoLoader.h"
10 #include "./DBHelper.h"
11 #include "TrigConfStorage/StorageMgr.h"
12 
13 #include <CoralBase/Attribute.h>
14 #include <CoralBase/AttributeList.h>
15 
16 #include "RelationalAccess/SchemaException.h"
17 #include "RelationalAccess/ITransaction.h"
18 #include "RelationalAccess/ITable.h"
19 #include "RelationalAccess/ISchema.h"
20 #include "RelationalAccess/ICursor.h"
21 #include "RelationalAccess/IQuery.h"
22 
23 #include "TrigConfL1Data/ThresholdConfig.h"
24 #include "TrigConfL1Data/TriggerThreshold.h"
25 #include "TrigConfL1Data/CaloJetInput.h"
26 #include "TrigConfL1Data/CaloSinCos.h"
27 #include "TrigConfL1Data/ClusterThresholdValue.h"
28 #include "TrigConfL1Data/JetThresholdValue.h"
29 #include "TrigConfL1Data/HelperFunctions.h"
30 
31 
32 #include "TrigConfL1Data/NimThresholdValue.h"
33 
34 #include <sstream>
35 #include <iostream>
36 #include <stdexcept>
37 #include <typeinfo>
38 
39 #include "boost/lexical_cast.hpp"
40 
41 using namespace std;
42 
43 bool TrigConf::ThresholdConfigLoader::load( ThresholdConfig& thrConfig ) {
44 
45  const unsigned int schema_version_with_zb_fields = 9;
46 
47  TRG_MSG_DEBUG("Loading ThresholdConfig object attached to Lvl1 master ID " << thrConfig.lvl1MasterTableId());
48  TRG_MSG_DEBUG("Current number of thresholds: " << thrConfig.size());
49 
50  long caloinfoid = 0;
51 
52  try {
53  startSession();
54  // get menu id and caloinfo id from thrConfig.m_MasterTableId and the table L1_MASTER_TABLE
55  int menuid = 0;
56 
57  unique_ptr<coral::IQuery> query0(m_session.nominalSchema().tableHandle( "L1_MASTER_TABLE").newQuery());
58  query0->setRowCacheSize( 5 );
59 
60  //Bind list
61  coral::AttributeList bindList0;
62  bindList0.extend<int>("mtId");
63  std::string cond0 = "L1MT_ID = :mtId";
64  bindList0[0].data<int>() = thrConfig.lvl1MasterTableId();
65  query0->setCondition( cond0, bindList0 );
66 
67  //Output and types
68  coral::AttributeList attList0;
69  attList0.extend<int>( "L1MT_TRIGGER_MENU_ID" );
70  attList0.extend<long>( "L1MT_CALO_INFO_ID" );
71  query0->defineOutput(attList0);
72  query0->addToOutputList( "L1MT_TRIGGER_MENU_ID" );
73  query0->addToOutputList( "L1MT_CALO_INFO_ID" );
74  coral::ICursor& cursor0 = query0->execute();
75 
76  if ( ! cursor0.next() ) {
77  TRG_MSG_ERROR("ThresholdConfigLoader >> No such Master_Table exists " << thrConfig.lvl1MasterTableId());
78  commitSession();
79  throw std::runtime_error( "ThresholdConfigLoader >> ThresholdConfig not available" );
80  }
81 
82  const coral::AttributeList& row0 = cursor0.currentRow();
83  menuid = row0["L1MT_TRIGGER_MENU_ID"].data<int>();
84  caloinfoid = row0["L1MT_CALO_INFO_ID"].data<long>();
85 
86  if ( cursor0.next() ) {
87 
88  TRG_MSG_ERROR("ThresholdConfigLoader >> More than one Master_Table exists "
89  << thrConfig.lvl1MasterTableId());
90  commitSession();
91  throw std::runtime_error( "ThresholdConfigLoader >> Master_Table not available" );
92  }
93 
94  //=====================================================
95  // get Thresholds WITH trigger threshold values
96 
97  coral::AttributeList emptyBindVariableList;
98 
99  unique_ptr<coral::IQuery> query(m_session.nominalSchema().newQuery());
100 
101  // Set the tables that are used
102  query->addToTableList ( "L1_TM_TO_TT", "TM2TT" );
103  query->addToTableList ( "L1_TRIGGER_THRESHOLD", "TT" );
104  query->addToTableList ( "L1_TT_TO_TTV", "TT2TTV" );
105  query->addToTableList ( "L1_TRIGGER_THRESHOLD_VALUE", "TTV" );
106 
107  // Bind list
108  coral::AttributeList bindList;
109  bindList.extend<int>("menuId");
110  bindList[0].data<int>() = menuid;
111  std::string theCondition = "";
112  theCondition += std::string( " TM2TT.L1TM2TT_TRIGGER_MENU_ID = :menuId" );
113  theCondition += std::string( " AND TM2TT.L1TM2TT_TRIGGER_THRESHOLD_ID = TT.L1TT_ID" );
114  theCondition += std::string( " AND TT2TTV.L1TT2TTV_TRIGGER_THRESHOLD_ID = TT.L1TT_ID" );
115  theCondition += std::string( " AND TT2TTV.L1TT2TTV_TRIG_THRES_VALUE_ID = TTV.L1TTV_ID" );
116  query->setCondition( theCondition, bindList );
117 
118  // Output data and types
119  coral::AttributeList attList;
120  attList.extend<std::string>( "TM2TT.L1TM2TT_CABLE_NAME" );
121  attList.extend<std::string>( "TM2TT.L1TM2TT_CABLE_CTPIN" );
122  attList.extend<std::string>( "TM2TT.L1TM2TT_CABLE_CONNECTOR" );
123  attList.extend<int> ( "TM2TT.L1TM2TT_CABLE_START" );
124  attList.extend<int> ( "TM2TT.L1TM2TT_CABLE_END" );
125  if(isRun2()) {
126  attList.extend<int> ( "TM2TT.L1TM2TT_CABLE_CLOCK" );
127  }
128  attList.extend<int> ( "TT.L1TT_ID" );
129  attList.extend<std::string>( "TT.L1TT_NAME" );
130  attList.extend<int> ( "TT.L1TT_VERSION" );
131  attList.extend<std::string>( "TT.L1TT_TYPE" );
132  attList.extend<int> ( "TT.L1TT_ACTIVE" );
133  attList.extend<int> ( "TT.L1TT_MAPPING" );
134  attList.extend<int> ( "TT.L1TT_BITNUM" );
135  attList.extend<int> ( "TTV.L1TTV_ID" );
136  attList.extend<std::string>( "TTV.L1TTV_NAME" );
137  attList.extend<int> ( "TTV.L1TTV_VERSION" );
138  attList.extend<std::string>( "TTV.L1TTV_TYPE" );
139  attList.extend<std::string>( "TTV.L1TTV_PT_CUT" );
140  attList.extend<int> ( "TTV.L1TTV_ETA_MIN" );
141  attList.extend<int> ( "TTV.L1TTV_ETA_MAX" );
142  attList.extend<int> ( "TTV.L1TTV_PHI_MIN" );
143  attList.extend<int> ( "TTV.L1TTV_PHI_MAX" );
144  attList.extend<std::string>( "TTV.L1TTV_EM_ISOLATION" );
145  attList.extend<std::string>( "TTV.L1TTV_HAD_ISOLATION" );
146  attList.extend<std::string>( "TTV.L1TTV_HAD_VETO" );
147  attList.extend<int> ( "TTV.L1TTV_WINDOW" );
148  attList.extend<std::string>( "TTV.L1TTV_PRIORITY" );
149  fillQuery(query.get(), attList);
150 
151  // the ordering
152  std::string theOrder = "";
153  theOrder += " TT.L1TT_MAPPING ASC";
154  theOrder += ", TT.L1TT_ID ASC";
155  theOrder += ", TTV.L1TTV_PRIORITY ASC";
156  theOrder += ", TTV.L1TTV_ETA_MAX ASC";
157  query->addToOrderList( theOrder );
158 
159  //query->setRowCacheSize(1000);
160  query->setRowCacheSize(500);
161 
162  coral::ICursor& cursor = query->execute();
163 
164  unsigned int schema_version = triggerDBSchemaVersion();
165  //unsigned int numberofvalues = 0;
166  TriggerThreshold* tt = 0;
167  int nRowsLoop1 = -2009;
168  int nRowsLoop2 = -2010;
169 
170  while (cursor.next()) {
171 
172  const coral::AttributeList& row = cursor.currentRow();
173 
174  nRowsLoop1 = row["TT.L1TT_ID"].data<int>();
175  if (nRowsLoop1 != nRowsLoop2) {
176 
177  if (tt != 0) {
178  // trigger thresholds sorted by type
179  thrConfig.addTriggerThreshold(tt);
180  tt = new TriggerThreshold();
181  //numberofvalues = 0;
182  } else {
183  tt = new TriggerThreshold();
184  //numberofvalues = 0;
185  }
186 
187  //==================================================
188  // now get the cable info from TM_TT
189 
190  string cableName = row["TM2TT.L1TM2TT_CABLE_NAME"].data<std::string>();
191  tt->setCableName (cableName);
192  tt->setCableCtpin (row["TM2TT.L1TM2TT_CABLE_CTPIN"].data<std::string>());
193  tt->setCableConnector(row["TM2TT.L1TM2TT_CABLE_CONNECTOR"].data<std::string>());
194  tt->setCableStart (row["TM2TT.L1TM2TT_CABLE_START"].data<int>());
195  tt->setCableEnd (row["TM2TT.L1TM2TT_CABLE_END"].data<int>());
196 
197  int clock = 0;
198  if(isRun2()) {
199  clock = row["TM2TT.L1TM2TT_CABLE_CLOCK"].data<int>();
200  }
201  if(clock >= 0) {
202  tt->setClock(clock);
203  }
204  tt->setId (row["TT.L1TT_ID"].data<int>());
205  tt->setName (row["TT.L1TT_NAME"].data<std::string>());
206  tt->setVersion(row["TT.L1TT_VERSION"].data<int>());
207  string thrtype(row["TT.L1TT_TYPE"].data<std::string>());
208  tt->setType (thrtype);
209  tt->setActive (row["TT.L1TT_ACTIVE"].data<int>());
210  tt->setMapping(row["TT.L1TT_MAPPING"].data<int>());
211  tt->setBitnum(row["TT.L1TT_BITNUM"].data<int>());
212  tt->setInput ( (thrtype=="TOPO" || thrtype=="ALFA") ? "ctpcore" : "ctpin" );
213 
214  TRG_MSG_VERBOSE("ThresholdConfigLoader loading threshold with ID = " << tt->id() << " for MenuId = " << menuid << ": ");
215  }
216 
217  if(tt->type() == L1DataDef::rndmType() ||
218  tt->type() == L1DataDef::pclkType() ||
219  tt->type() == L1DataDef::bgrpType() ) {
220  } else {
221 
222  TriggerThresholdValue* ttv = tt->createThresholdValue(row["TT.L1TT_TYPE"].data<std::string>());
223 
224  ttv->setId (row["TTV.L1TTV_ID"].data<int>());
225 
226  // Fill the value common for all threshold_value
227  ttv->setName (row["TTV.L1TTV_NAME"].data<std::string>());
228  ttv->setVersion (row["TTV.L1TTV_VERSION"].data<int>());
229  ttv->setType (row["TTV.L1TTV_TYPE"].data<std::string>());
230  float ptcut = boost::lexical_cast<float,std::string>(row["TTV.L1TTV_PT_CUT"].data<std::string>());
231  string emisolation = row["TTV.L1TTV_EM_ISOLATION"].data<std::string>();
232  string hadisolation = row["TTV.L1TTV_HAD_ISOLATION"].data<std::string>();
233  string hadveto = row["TTV.L1TTV_HAD_VETO"].data<std::string>();
234  float priority = boost::lexical_cast<float,std::string>(row["TTV.L1TTV_PRIORITY"].data<std::string>());
235  ttv->setPtcut (ptcut);
236  ttv->setPriority (priority);
237 
238  //is it a cluster_threshold_value?
239  try {
240  ClusterThresholdValue& ctv = dynamic_cast<ClusterThresholdValue&>(*ttv);
241  if (ttv->type() != L1DataDef::emType() &&
242  ttv->type() != L1DataDef::tauType()) {
243  msg() << "ThresholdConfigLoader >> No type match for ttv_id = "
244  << ctv.id() << " " << ttv->type() << std::endl;
245  throw std::runtime_error( "ThresholdConfigLoader >> ClusterThresholdValue not available" );
246  }
247 
248  if(hadveto=="USEISOBITS" || boost::lexical_cast<int,std::string>(hadveto)==99 ) {
249  ctv.setEmIsolation( 63 );
250  ctv.setHadIsolation( 63 );
251  ctv.setHadVeto( 99 );
252  ctv.setIsolationMask( TrigConf::bin2uint(emisolation) );
253  ctv.setUseIsolationMask();
254  } else {
255  ctv.setEmIsolation( boost::lexical_cast<float,std::string>(emisolation) );
256  ctv.setHadIsolation( boost::lexical_cast<float,std::string>(hadisolation) );
257  ctv.setHadVeto( boost::lexical_cast<float,std::string>(hadveto) );
258  ctv.setUseIsolationMask( false );
259  }
260 
261  } catch (std::bad_cast& ex) { }
262 
263  //is it a jet_threshold_value?
264  try {
265  JetThresholdValue& jtv = dynamic_cast<JetThresholdValue&>(*ttv);
266  if (ttv->type() != L1DataDef::jetType() &&
267  ttv->type() != L1DataDef::jbType() &&
268  ttv->type() != L1DataDef::jfType()) {
269  TRG_MSG_ERROR("No type match for ttv_id = " << jtv.id() << ttv->type());
270  throw std::runtime_error( "ThresholdConfigLoader >> TriggerThresholdValue not available" );
271  }
272  // jtv.setPhiMin(row["TTV.L1TTV_PHI_MIN"].data<int>());
273  // jtv.setPhiMax(row["TTV.L1TTV_PHI_MAX"].data<int>());
274  // jtv.setEtaMin(row["TTV.L1TTV_ETA_MIN"].data<int>());
275  // jtv.setEtaMax(row["TTV.L1TTV_ETA_MAX"].data<int>());
276  // jtv.setWindow(row["TTV.L1TTV_WINDOW"].data<int>());
277  } catch (std::bad_cast& ex) { }
278 
279  ttv->setPhiMin(row["TTV.L1TTV_PHI_MIN"].data<int>());
280  ttv->setPhiMax(row["TTV.L1TTV_PHI_MAX"].data<int>());
281  ttv->setEtaMin(row["TTV.L1TTV_ETA_MIN"].data<int>());
282  ttv->setEtaMax(row["TTV.L1TTV_ETA_MAX"].data<int>());
283  ttv->setWindow(row["TTV.L1TTV_WINDOW"].data<int>());
284  tt->addThresholdValue(ttv);
285  //++numberofvalues;
286  TRG_MSG_DEBUG("ThresholdConfigLoader loading thresholdvalue with ID = " << ttv->id() << ": " << ttv->name());
287  }
288 
289  nRowsLoop2 = row["TT.L1TT_ID"].data<int>();
290 
291  }
292 
293  // trigger thresholds sorted by type
294  thrConfig.addTriggerThreshold(tt);
295 
296  //===========================================
297  // now get the Thresholds WITHOUT trigger threshold values
298  // we are aware that some code is duplicated below
299  // it is done this way because most Thresholds are WITH trigger threshold values
300 
301  if (!m_session.transaction().isActive()) m_session.transaction().start();
302  unique_ptr<coral::IQuery> query1(m_session.nominalSchema().newQuery());
303 
304  // Set the tables that are used
305  query1->addToTableList ( "L1_TM_TO_TT", "TM2TT" );
306  query1->addToTableList ( "L1_TRIGGER_THRESHOLD", "TT" );
307 
308  // Bind list
309  coral::AttributeList bindList1;
310  bindList1.extend<int>("menuId");
311  bindList1[0].data<int>() = menuid;
312  std::string theCondition1 = "";
313  theCondition1 += std::string( " TM2TT.L1TM2TT_TRIGGER_MENU_ID = :menuId" );
314  theCondition1 += std::string( " AND TM2TT.L1TM2TT_TRIGGER_THRESHOLD_ID = TT.L1TT_ID" );
315  query1->setCondition( theCondition1, bindList1 );
316 
317  // Output data and types
318  coral::AttributeList attList1;
319  attList1.extend<std::string>( "TM2TT.L1TM2TT_CABLE_NAME" );
320  attList1.extend<std::string>( "TM2TT.L1TM2TT_CABLE_CTPIN" );
321  attList1.extend<std::string>( "TM2TT.L1TM2TT_CABLE_CONNECTOR" );
322  attList1.extend<int> ( "TM2TT.L1TM2TT_CABLE_START" );
323  attList1.extend<int> ( "TM2TT.L1TM2TT_CABLE_END" );
324  if(isRun2()) {
325  attList1.extend<int> ( "TM2TT.L1TM2TT_CABLE_CLOCK" );
326  }
327  attList1.extend<int> ( "TT.L1TT_ID" );
328  attList1.extend<std::string>( "TT.L1TT_NAME" );
329  attList1.extend<int> ( "TT.L1TT_VERSION" );
330  attList1.extend<std::string>( "TT.L1TT_TYPE" );
331  attList1.extend<int> ( "TT.L1TT_ACTIVE" );
332  attList1.extend<int> ( "TT.L1TT_MAPPING" );
333  if( isRun2() || (schema_version >= schema_version_with_zb_fields) ) {
334  attList1.extend<int> ( "TT.L1TT_BCDELAY" );
335  attList1.extend<std::string>( "TT.L1TT_SEED" );
336  attList1.extend<int> ( "TT.L1TT_SEED_MULTI" );
337  }
338  fillQuery(query1.get(), attList1);
339 
340  // the ordering
341  std::string theOrder1 = "";
342  theOrder1 += " TT.L1TT_ID ASC";
343  query1->addToOrderList( theOrder1 );
344 
345  //query->setRowCacheSize(1000);
346  query1->setRowCacheSize(500);
347 
348  coral::ICursor& cursor1 = query1->execute();
349 
350  //numberofvalues = 0;
351  tt = 0;
352  nRowsLoop1 = -2009;
353  nRowsLoop2 = -2010;
354 
355  while (cursor1.next()) {
356 
357  const coral::AttributeList& row = cursor1.currentRow();
358 
359  nRowsLoop1 = row["TT.L1TT_ID"].data<int>();
360  tt = thrConfig.findTriggerThreshold(nRowsLoop1);
361  if (tt) continue;
362  if (nRowsLoop1 != nRowsLoop2) {
363 
364  if (tt != 0) {
365  //tt->setNumberofValues(numberofvalues);
366  // trigger thresholds sorted by type
367  thrConfig.addTriggerThreshold(tt);
368  tt = new TriggerThreshold();
369  //numberofvalues = 0;
370  } else {
371  tt = new TriggerThreshold();
372  //numberofvalues = 0;
373  }
374 
375  //==================================================
376  // now get the cable info from TM_TT
377 
378  // ttldr.setLoadCableInfo(true); will be moved from tt to thrcfg loader
379 
380  string cableName = row["TM2TT.L1TM2TT_CABLE_NAME"].data<std::string>();
381  tt->setCableName(cableName);
382  tt->setCableCtpin (row["TM2TT.L1TM2TT_CABLE_CTPIN"].data<std::string>());
383  tt->setCableConnector(row["TM2TT.L1TM2TT_CABLE_CONNECTOR"].data<std::string>());
384  tt->setCableStart (row["TM2TT.L1TM2TT_CABLE_START"].data<int>());
385  tt->setCableEnd (row["TM2TT.L1TM2TT_CABLE_END"].data<int>());
386 
387  int clock = 0;
388  if(isRun2()) {
389  clock = row["TM2TT.L1TM2TT_CABLE_CLOCK"].data<int>();
390  }
391  if(clock >= 0) {
392  tt->setClock(clock);
393  }
394  tt->setId (row["TT.L1TT_ID"].data<int>());
395  tt->setName (row["TT.L1TT_NAME"].data<std::string>());
396  tt->setVersion(row["TT.L1TT_VERSION"].data<int>());
397  string thrtype(row["TT.L1TT_TYPE"].data<std::string>());
398  tt->setType (thrtype);
399  tt->setActive (row["TT.L1TT_ACTIVE"].data<int>());
400  tt->setMapping(row["TT.L1TT_MAPPING"].data<int>());
401  tt->setInput ( (thrtype=="TOPO" || thrtype=="ALFA") ? "ctpcore" : "ctpin" );
402 
403 
404  // zero bias related
405  int bcdelay(-1), seed_multi(-1);
406  std::string seed("");
407  if( isRun2() || (schema_version >= schema_version_with_zb_fields) ) {
408  bcdelay = row["TT.L1TT_BCDELAY"].data<int>();
409  seed = row["TT.L1TT_SEED"].data<std::string>();
410  seed_multi = row["TT.L1TT_SEED_MULTI"].data<int>();
411  }
412  tt->setBCDelay (bcdelay);
413  tt->setZBSeedingThresholdName (seed);
414  tt->setZBSeedingThresholdMulti(seed_multi);
415 
416  TRG_MSG_VERBOSE("ThresholdConfigLoader loading threshold with ID = " << tt->id() << " for MenuId = " << menuid << ": ");
417  //tt->setNumberofValues(numberofvalues);
418  // trigger thresholds sorted by type
419  thrConfig.addTriggerThreshold(tt);
420  tt = nullptr;
421  }
422 
423  nRowsLoop2 = row["TT.L1TT_ID"].data<int>();
424 
425  }
426  commitSession();
427  }
428  catch( const coral::Exception& e ) {
429  TRG_MSG_ERROR("Caught coral exception: " << e.what() );
430  throw;
431  }
432  catch( const std::exception& e ) {
433  TRG_MSG_ERROR("Caught standard exception: " << e.what() );
434  throw;
435  }
436 
437  loadCaloInfo(thrConfig, caloinfoid);
438 
439  // create TIPs from TOPO and ALFA TriggerThresholds
440 
441  return true;
442 
443 }
444 
445 
446 
447 void
448 TrigConf::ThresholdConfigLoader::loadCaloInfo( ThresholdConfig& thrConfig, long caloInfoId ) {
449  //============================================
450  // get CaloInfo
451  //============================================
452  try {
453  startSession();
454  CaloInfoLoader& cildr = dynamic_cast<CaloInfoLoader&>
455  ((dynamic_cast<StorageMgr&>(m_storageMgr)).caloInfoLoader());
456  cildr.setLevel(outputLevel());
457  CaloInfo ci;
458  ci.setId(caloInfoId);
459  if ( !cildr.load( ci )) {
460  TRG_MSG_ERROR("loading CaloInfo " << ci.id());
461  throw runtime_error( "ThresholdConfigLoader: Error loading CaloInfo" );
462  }
463  thrConfig.setCaloInfo(ci);
464  TriggerThresholdValue::setCaloInfo(ci);
465  commitSession();
466  }
467  catch( const coral::Exception& e ) {
468  TRG_MSG_ERROR("Caught coral exception: " << e.what() );
469  throw;
470  }
471  catch( const std::exception& e ) {
472  TRG_MSG_ERROR("Caught standard exception: " << e.what() );
473  throw;
474  }
475 }
476 
477 
TrigConf::TriggerThresholdValue
Definition: TriggerThresholdValue.h:22
TrigConf::TrigConfData::setName
void setName(const std::string &name)
Definition: TrigConfData.h:30
TRG_MSG_ERROR
#define TRG_MSG_ERROR(x)
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStreamMacros.h:29
query_example.row
row
Definition: query_example.py:24
TrigConf::ThresholdConfigLoader::load
virtual bool load(ThresholdConfig &data) override
Definition: ThresholdConfigLoader.cxx:43
TrigConf::ThresholdConfig
Definition: ThresholdConfig.h:17
TrigConf::TriggerThresholdValue::setPtcut
void setPtcut(float pt)
Definition: TriggerThresholdValue.h:58
TrigConf::TrigConfData::name
const std::string & name() const
Definition: TrigConfData.h:22
CaloInfoLoader.h
TrigConf::ClusterThresholdValue::setUseIsolationMask
void setUseIsolationMask(bool use=true)
Definition: ClusterThresholdValue.h:43
TrigConf::TriggerThresholdValue::setPhiMax
void setPhiMax(int value)
Definition: TriggerThresholdValue.h:62
ThresholdConfigLoader.h
TRG_MSG_VERBOSE
#define TRG_MSG_VERBOSE(x)
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStreamMacros.h:24
DBHelper.h
TrigConf::ClusterThresholdValue::setHadVeto
void setHadVeto(float v)
Definition: ClusterThresholdValue.h:40
TrigConf::fillQuery
void fillQuery(coral::IQuery *q, coral::AttributeList &attList)
Definition: DBHelper.cxx:13
python.selector.AtlRunQuerySelectorLhcOlc.priority
priority
Definition: AtlRunQuerySelectorLhcOlc.py:611
TrigConf::bin2uint
uint32_t bin2uint(const std::string &binary)
Definition: Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx:321
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
TrigConf::TriggerThresholdValue::setWindow
void setWindow(int value)
Definition: TriggerThresholdValue.h:60
TrigConf::DBLoader::setLevel
virtual void setLevel(MSGTC::Level lvl) override
access to output stream
Definition: DBLoader.cxx:60
TrigConf::ClusterThresholdValue
Definition: ClusterThresholdValue.h:13
Pythia8_A14_NNPDF23LO_forMGHT_EvtGen.ptcut
float ptcut
Definition: Pythia8_A14_NNPDF23LO_forMGHT_EvtGen.py:9
HelperFunctions.h
TrigConf::StorageMgr
Database Storage Manager, controls the database session and the different loader classes for DB acces...
Definition: StorageMgr.h:23
TrigConf::ThresholdConfig::size
size_t size() const
Definition: ThresholdConfig.h:44
CaloJetInput.h
ThresholdConfig.h
TrigConf::ThresholdConfigLoader::loadCaloInfo
void loadCaloInfo(ThresholdConfig &thrConfig, long caloInfoId)
Definition: ThresholdConfigLoader.cxx:448
query
Definition: query.py:1
TrigConf::L1DataBaseclass::lvl1MasterTableId
unsigned int lvl1MasterTableId() const
Definition: L1DataBaseclass.h:30
CaloSinCos.h
CaloJetInputLoader.h
StorageMgr.h
TrigConf::ClusterThresholdValue::setHadIsolation
void setHadIsolation(float v)
Definition: ClusterThresholdValue.h:39
TrigConf::CaloInfo
Definition: CaloInfo.h:35
calibdata.exception
exception
Definition: calibdata.py:496
TriggerThresholdLoader.h
JetThresholdValue.h
TrigConf::TriggerThresholdValue::type
const std::string & type() const
Definition: TriggerThresholdValue.h:44
TriggerThreshold.h
TrigConf::ThresholdConfig::findTriggerThreshold
TriggerThreshold * findTriggerThreshold(unsigned int id)
Definition: ThresholdConfig.cxx:264
CaloSinCosLoader.h
TrigConf::TrigConfData::setId
void setId(unsigned int id)
Definition: TrigConfData.h:29
TrigConf::ThresholdConfig::setCaloInfo
void setCaloInfo(const CaloInfo &ci)
Definition: ThresholdConfig.h:65
query_example.query
query
Definition: query_example.py:15
TrigConf::CaloInfoLoader::load
virtual bool load(CaloInfo &data) override
Definition: CaloInfoLoader.cxx:55
python.TrigConfigSvcUtils.isRun2
def isRun2(cursor, schemaname)
Definition: TrigConfigSvcUtils.py:290
NimThresholdValue.h
TrigConf::TrigConfData::id
unsigned int id() const
Definition: TrigConfData.h:21
TrigConf::CaloInfoLoader
TriggerDB loader of the LVL1 calorimeter trigger configuration.
Definition: CaloInfoLoader.h:29
TrigConf::TriggerThresholdValue::setEtaMin
void setEtaMin(int value)
Definition: TriggerThresholdValue.h:63
python.TrigPSCPythonDbSetup.outputLevel
outputLevel
Definition: TrigPSCPythonDbSetup.py:30
TrigConf::TriggerThresholdValue::setPhiMin
void setPhiMin(int value)
Definition: TriggerThresholdValue.h:61
ConvertOldUJHistosToNewHistos.jetType
string jetType
Definition: ConvertOldUJHistosToNewHistos.py:121
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
query_example.cursor
cursor
Definition: query_example.py:21
ClusterThresholdValue.h
TrigConf::TriggerThresholdValue::setPriority
void setPriority(float prio)
Definition: TriggerThresholdValue.h:59
TrigConf::JetThresholdValue
Definition: JetThresholdValue.h:12
TrigConf::ClusterThresholdValue::setEmIsolation
void setEmIsolation(float v)
Definition: ClusterThresholdValue.h:38
TrigConf::TrigConfData::setVersion
void setVersion(unsigned int version)
Definition: TrigConfData.h:31
TrigConf::ThresholdConfig::addTriggerThreshold
bool addTriggerThreshold(TriggerThreshold *value)
Definition: ThresholdConfig.cxx:75
TrigConf::TriggerThresholdValue::setEtaMax
void setEtaMax(int value)
Definition: TriggerThresholdValue.h:64
TrigConf::ClusterThresholdValue::setIsolationMask
void setIsolationMask(uint16_t mask)
Definition: ClusterThresholdValue.h:46
TrigConf::TriggerThreshold
Definition: TriggerThreshold.h:20
TileDCSDataPlotter.tt
tt
Definition: TileDCSDataPlotter.py:874
TrigConf::TriggerThresholdValue::setType
void setType(const std::string &type)
Definition: TriggerThresholdValue.h:57
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
TRG_MSG_DEBUG
#define TRG_MSG_DEBUG(x)
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStreamMacros.h:25
Generated on Fri Jul 5 2024 21:28:46 for ATLAS Offline Software by   doxygen 1.8.18