ATLAS Offline Software
CTPFilesLoader.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 //
7 //NAME: CTPFilesLoader.cpp
8 //PACKAGE: TrigConfStorage
9 //
10 //AUTHOR: D.Berge (CERN) berge@cern.ch
11 //CREATED: 04. Aug. 2008
12 //
13 //PURPOSE: This Loader loads the CTPFiles Object from the TriggerDB
14 //
16 
18 // TODO:
19 // =====
20 // 2. load smx files, too
21 // 3. try and use proper stringstreams for string parsing -> speed?
22 //
24 
25 #include "./CTPFilesLoader.h"
26 #include "./DBHelper.h"
27 
28 #include <CoralBase/Attribute.h>
29 #include <CoralBase/AttributeList.h>
30 
31 #include "RelationalAccess/SchemaException.h"
32 #include "RelationalAccess/ITransaction.h"
33 #include "RelationalAccess/ITable.h"
34 #include "RelationalAccess/ISchema.h"
35 #include "RelationalAccess/ICursor.h"
36 #include "RelationalAccess/IQuery.h"
37 
38 #include "TrigConfL1Data/CTPFiles.h"
39 
40 #include <stdexcept>
41 #include <sstream>
42 #include <typeinfo>
43 
44 using namespace std;
45 
46 bool TrigConf::CTPFilesLoader::load( CTPFiles& data) {
47  bool retVal = true;
48  triggerDBSchemaVersion();
49  if(isRun1()) {
50  data.setFileSizes(1);
51  } else {
52  data.setFileSizes(2);
53  }
54 
55  if( data.loadCtpcoreFiles() ) retVal &= loadCtpcoreData(data);
56  if( data.loadCtpinFiles() ) retVal &= loadCtpinData(data);
57  if( data.loadCtpmonFiles() ) retVal &= loadCtpmonData(data);
58  return retVal;
59 }
60 
61 // could make a templated function to be used by everybody for all
62 // fields of the master table...
63 int TrigConf::CTPFilesLoader::getMenuIdFromMaster(int mid) {
64 
65  unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_MASTER_TABLE").newQuery() );
66  query->setRowCacheSize( 5 );
67 
68  //Binding
69  coral::AttributeList emptyBindVariableList0;
70  std::string condition = "L1MT_ID = :mtId";
71  emptyBindVariableList0.extend<int>("mtId");
72  emptyBindVariableList0[0].data<int>() = mid;
73  query->setCondition( condition, emptyBindVariableList0 );
74 
75  coral::AttributeList attList;
76  attList.extend<int>( "L1MT_TRIGGER_MENU_ID" );
77  fillQuery(query.get(),attList);
78 
79  coral::ICursor& cursor = query->execute();
80  if ( ! cursor.next() ) {
81  TRG_MSG_ERROR("No such Master_Table exists " << mid);
82  commitSession();
83  throw std::runtime_error( "CTPFilesLoader" );
84  }
85  const coral::AttributeList& row = cursor.currentRow();
86  int menuid = row["L1MT_TRIGGER_MENU_ID"].data<int>();
87  if ( cursor.next() ) {
88  TRG_MSG_ERROR("More than one Master_Table exists " << mid);
89  commitSession();
90  throw std::runtime_error( "CTPFilesLoader >> Master_Table not available" );
91  }
92  return menuid;
93 }
94 
95 
96 
97 long TrigConf::CTPFilesLoader::getFilesIdFromMenu(int mid) {
98  coral::ITable& table = m_session.nominalSchema().tableHandle( "L1_TRIGGER_MENU");
99  coral::IQuery* query = table.newQuery();
100  query->setRowCacheSize( 5 );
101 
102  //Binding
103  coral::AttributeList emptyBindVariableList0;
104  std::string condition = "L1TM_ID = :tmId";
105  emptyBindVariableList0.extend<int>("tmId");
106  emptyBindVariableList0[0].data<int>() = mid;
107  query->setCondition( condition, emptyBindVariableList0 );
108 
109  coral::AttributeList attList;
110  attList.extend<int>( "L1TM_CTP_FILES_ID" );
111  query->defineOutput(attList);
112  query->addToOutputList( "L1TM_CTP_FILES_ID" );
113 
114  coral::ICursor& cursor = query->execute();
115  if ( ! cursor.next() ) {
116  TRG_MSG_ERROR("No such Trigger_Menu exists " << mid);
117  delete query;
118  commitSession();
119  throw std::runtime_error( "CTPFilesLoader" );
120  }
121  const coral::AttributeList& row = cursor.currentRow();
122  return static_cast<long>(row["L1TM_CTP_FILES_ID"].data<int>());
123 }
124 
125 
126 
127 long TrigConf::CTPFilesLoader::getSmxIdFromMenu(int mid) {
128  coral::ITable& table = m_session.nominalSchema().tableHandle( "L1_TRIGGER_MENU");
129  coral::IQuery* query = table.newQuery();
130  query->setRowCacheSize( 5 );
131 
132  //Binding
133  coral::AttributeList emptyBindVariableList0;
134  std::string condition = "L1TM_ID = :tmId";
135  emptyBindVariableList0.extend<int>("tmId");
136  emptyBindVariableList0[0].data<int>() = mid;
137  query->setCondition( condition, emptyBindVariableList0 );
138 
139  coral::AttributeList attList;
140  attList.extend<int>( "L1TM_CTP_SMX_ID" );
141  query->defineOutput(attList);
142  query->addToOutputList( "L1TM_CTP_SMX_ID" );
143 
144  coral::ICursor& cursor = query->execute();
145  if ( ! cursor.next() ) {
146  TRG_MSG_ERROR("No such Trigger_Menu exists " << mid);
147  delete query;
148  commitSession();
149  throw std::runtime_error( "CTPFilesLoader" );
150  }
151  const coral::AttributeList& row = cursor.currentRow();
152  return static_cast<long>(row["L1TM_CTP_SMX_ID"].data<int>());
153 }
154 
155 
156 
157 bool
158 TrigConf::CTPFilesLoader::loadCtpcoreData( CTPFiles& ctpFiles) {
159 
160  TRG_MSG_INFO("start loading CTPCORE data");
161  try {
162  startSession();
163  // first check if we need to obtain the CTP files ID, or if it
164  // was passed in
165  if(ctpFiles.id() <= 0) {
166  int l1id = ctpFiles.lvl1MasterTableId();
167  int menuid = getMenuIdFromMaster(l1id);
168  long filesid = getFilesIdFromMenu(menuid);
169  ctpFiles.setId(filesid);
170  }
171 
172  unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_CTP_FILES").newQuery() );
173  query->setRowCacheSize( 10 );
174 
175  //Binding
176  coral::AttributeList emptyBindVariableList0;
177  emptyBindVariableList0.extend<long>("fId");
178  emptyBindVariableList0[0].data<long>() = ctpFiles.id();
179  query->setCondition( "L1CF_ID = :fId", emptyBindVariableList0 );
180 
181  coral::AttributeList attList;
182  attList.extend<std::string>( "L1CF_NAME" );
183  attList.extend<int>( "L1CF_VERSION" );
184  attList.extend<std::string>( "L1CF_LUT" );
185  attList.extend<std::string>( "L1CF_CAM" );
186  fillQuery(query.get(),attList);
187 
188  coral::ICursor& cursor = query->execute();
189 
190  if ( ! cursor.next() ) {
191  TRG_MSG_ERROR("No such L1_CTP_Files exists " << ctpFiles.id());
192  commitSession();
193  throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
194  }
195 
196  const coral::AttributeList& row = cursor.currentRow();
197  std::string name = row["L1CF_NAME"].data<std::string>();
198  int version = row["L1CF_VERSION"].data<int>();
199  std::string ctpcoreLUT_str = row["L1CF_LUT"].data<std::string>();
200  std::string ctpcoreCAM_str = row["L1CF_CAM"].data<std::string>();
201 
202  if ( cursor.next() ) {
203  TRG_MSG_ERROR("More than one GetFile exists " << ctpFiles.id());
204  commitSession();
205  throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
206  }
207 
208  std::vector<u_int> lutVec(CTPFiles::ALL_CTPCORELUT_SIZE);
209  TRG_MSG_INFO("Loading LUT of size " << lutVec.size());
210  parseHexString(lutVec, ctpcoreLUT_str, true);
211 
212  std::vector<u_int> camVec(CTPFiles::ALL_CTPCORECAM_SIZE);
213  TRG_MSG_INFO("Loading CAM of size " << camVec.size());
214  parseHexString(camVec,ctpcoreCAM_str);
215 
216  // Fill the object with data
217  ctpFiles.setName( name );
218  ctpFiles.setVersion( version );
219  ctpFiles.setCtpcoreLUT(lutVec);
220  ctpFiles.setCtpcoreCAM(camVec);
221 
222  commitSession();
223  } catch( const coral::Exception& e ) {
224  TRG_MSG_ERROR("coral::Exception: " << e.what());
225  commitSession();
226  throw;
227  }
228  return true;
229 }
230 
231 bool TrigConf::CTPFilesLoader::loadCtpinData( CTPFiles& ctpFiles) {
232  TRG_MSG_INFO("start loading CTPIN data");
233  try {
234  startSession();
235  // first check if we need to obtain the CTP files ID, or if it
236  // was passed in
237  if(ctpFiles.id() <= 0 || ctpFiles.smxId() <= 0) {
238  int l1id = ctpFiles.lvl1MasterTableId();
239  int menuid = getMenuIdFromMaster(l1id);
240  if(ctpFiles.id() <= 0) {
241  long filesid = getFilesIdFromMenu(menuid);
242  ctpFiles.setId(filesid);
243  }
244  if(ctpFiles.smxId() <= 0) {
245  long id = getSmxIdFromMenu(menuid);
246  ctpFiles.setSmxId(id);
247  }
248  }
249 
250  { // restrict scope to re-use variables
251  unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_CTP_FILES").newQuery() );
252  query->setRowCacheSize( 13 );
253 
254  //Binding
255  coral::AttributeList emptyBindVariableList0;
256  std::string condition = "L1CF_ID = :fId";
257  emptyBindVariableList0.extend<long>("fId");
258  emptyBindVariableList0[0].data<long>() = ctpFiles.id();
259  query->setCondition( condition, emptyBindVariableList0 );
260 
261  coral::AttributeList attList;
262  attList.extend<std::string>( "L1CF_NAME" );
263  attList.extend<int>( "L1CF_VERSION" );
264  attList.extend<std::string>( "L1CF_MON_SEL_SLOT7" );
265  attList.extend<std::string>( "L1CF_MON_SEL_SLOT8" );
266  attList.extend<std::string>( "L1CF_MON_SEL_SLOT9" );
267  attList.extend<std::string>( "L1CF_MON_DEC_SLOT7" );
268  attList.extend<std::string>( "L1CF_MON_DEC_SLOT8" );
269  attList.extend<std::string>( "L1CF_MON_DEC_SLOT9" );
270  fillQuery(query.get(),attList);
271 
272  coral::ICursor& cursor = query->execute();
273  if ( ! cursor.next() ) {
274  TRG_MSG_ERROR("No such L1_CTP_Files exists " << ctpFiles.id());
275  commitSession();
276  throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
277  }
278 
279  const coral::AttributeList& row = cursor.currentRow();
280  std::string name = row["L1CF_NAME"].data<std::string>();
281  int version = row["L1CF_VERSION"].data<int>();
282  std::string strMonSel7 = row["L1CF_MON_SEL_SLOT7"].data<std::string>();
283  std::string strMonSel8 = row["L1CF_MON_SEL_SLOT8"].data<std::string>();
284  std::string strMonSel9 = row["L1CF_MON_SEL_SLOT9"].data<std::string>();
285  std::string strMonDec7 = row["L1CF_MON_DEC_SLOT7"].data<std::string>();
286  std::string strMonDec8 = row["L1CF_MON_DEC_SLOT8"].data<std::string>();
287  std::string strMonDec9 = row["L1CF_MON_DEC_SLOT9"].data<std::string>();
288 
289  if ( cursor.next() ) {
290  TRG_MSG_ERROR("More than one GetFile exists " << ctpFiles.id());
291  commitSession();
292  throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
293  }
294 
295  std::vector<u_int> monDecSlot7(CTPFiles::ALL_CTPINMONDEC_SIZE);
296  TRG_MSG_INFO("Loading MON Slot7 of size " << monDecSlot7.size());
297  parseHexString(monDecSlot7,strMonDec7);
298  std::vector<u_int> monDecSlot8(CTPFiles::ALL_CTPINMONDEC_SIZE);
299  TRG_MSG_INFO("Loading MON Slot8 of size " << monDecSlot8.size());
300  parseHexString(monDecSlot8,strMonDec8);
301  std::vector<u_int> monDecSlot9(CTPFiles::ALL_CTPINMONDEC_SIZE);
302  TRG_MSG_INFO("Loading MON Slot9 of size " << monDecSlot9.size());
303  parseHexString(monDecSlot9,strMonDec9);
304 
305  std::vector<u_int> monSelSlot7(CTPFiles::ALL_CTPINMONSEL_SIZE);
306  TRG_MSG_INFO("Loading MON SEL Slot7 of size " << monSelSlot7.size());
307  parseHexString(monSelSlot7,strMonSel7);
308  std::vector<u_int> monSelSlot8(CTPFiles::ALL_CTPINMONSEL_SIZE);
309  TRG_MSG_INFO("Loading MON SEL Slot8 of size " << monSelSlot8.size());
310  parseHexString(monSelSlot8,strMonSel8);
311  std::vector<u_int> monSelSlot9(CTPFiles::ALL_CTPINMONSEL_SIZE);
312  TRG_MSG_INFO("Loading MON SEL Slot9 of size " << monSelSlot9.size());
313  parseHexString(monSelSlot9,strMonSel9);
314 
315  // Fill the object with data
316  ctpFiles.setName( name );
317  ctpFiles.setVersion( version );
318  ctpFiles.setCtpinMonDecoderSlot7(monDecSlot7);
319  ctpFiles.setCtpinMonDecoderSlot8(monDecSlot8);
320  ctpFiles.setCtpinMonDecoderSlot9(monDecSlot9);
321  ctpFiles.setCtpinMonSelectorSlot7(monSelSlot7);
322  ctpFiles.setCtpinMonSelectorSlot8(monSelSlot8);
323  ctpFiles.setCtpinMonSelectorSlot9(monSelSlot9);
324  }
325 
326  {
327  unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_CTP_SMX").newQuery() );
328  query->setRowCacheSize( 13 );
329 
330  //Binding
331  coral::AttributeList emptyBindVariableList0;
332  std::string condition = "L1SMX_ID = :sId";
333  emptyBindVariableList0.extend<long>("sId");
334  emptyBindVariableList0[0].data<long>() = ctpFiles.smxId();
335  query->setCondition( condition, emptyBindVariableList0 );
336 
337  coral::AttributeList attList;
338  attList.extend<std::string>( "L1SMX_NAME" );
339  attList.extend<std::string>( "L1SMX_OUTPUT" );
340  attList.extend<std::string>( "L1SMX_VHDL_SLOT7" );
341  attList.extend<std::string>( "L1SMX_VHDL_SLOT8" );
342  attList.extend<std::string>( "L1SMX_VHDL_SLOT9" );
343  attList.extend<std::string>( "L1SMX_SVFI_SLOT7" );
344  attList.extend<std::string>( "L1SMX_SVFI_SLOT8" );
345  attList.extend<std::string>( "L1SMX_SVFI_SLOT9" );
346  fillQuery(query.get(),attList);
347 
348  coral::ICursor& cursor = query->execute();
349  if ( ! cursor.next() ) {
350  TRG_MSG_ERROR("No such L1_CTP_SMX entry " << ctpFiles.smxId() << " exists");
351  commitSession();
352  throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
353  }
354 
355  const coral::AttributeList& row = cursor.currentRow();
356  ctpFiles.setSmxName(row["L1SMX_NAME"].data<std::string>());
357  ctpFiles.setCtpinSmxOutput(row["L1SMX_OUTPUT"].data<std::string>());
358 
359  ctpFiles.setCtpinSmxVhdlSlot7(row["L1SMX_VHDL_SLOT7"].data<std::string>());
360  ctpFiles.setCtpinSmxVhdlSlot8(row["L1SMX_VHDL_SLOT8"].data<std::string>());
361  ctpFiles.setCtpinSmxVhdlSlot9(row["L1SMX_VHDL_SLOT9"].data<std::string>());
362  ctpFiles.setCtpinSmxSvfiSlot7(row["L1SMX_SVFI_SLOT7"].data<std::string>());
363  ctpFiles.setCtpinSmxSvfiSlot8(row["L1SMX_SVFI_SLOT8"].data<std::string>());
364  ctpFiles.setCtpinSmxSvfiSlot9(row["L1SMX_SVFI_SLOT9"].data<std::string>());
365  }
366 
367  commitSession();
368  }
369  catch( const coral::Exception& e ) {
370  TRG_MSG_ERROR("coral::Exception: " << e.what());
371  commitSession();
372  throw;
373  }
374  return true;
375 }
376 
377 
378 
379 bool TrigConf::CTPFilesLoader::loadCtpmonData( CTPFiles& ctpFiles) {
380  TRG_MSG_INFO("start loading CTPMON data");
381  try {
382  startSession();
383  // first check if we need to obtain the CTP files ID, or if it
384  // was passed in
385  if(ctpFiles.id() <= 0) {
386  int l1id = ctpFiles.lvl1MasterTableId();
387  int menuid = getMenuIdFromMaster(l1id);
388  long filesid = getFilesIdFromMenu(menuid);
389  ctpFiles.setId(filesid);
390  }
391 
392  unique_ptr<coral::IQuery> query( m_session.nominalSchema().tableHandle( "L1_CTP_FILES").newQuery() );
393  query->setRowCacheSize( 13 );
394 
395  //Binding
396  coral::AttributeList emptyBindVariableList0;
397  std::string condition = "L1CF_ID = :fId";
398  emptyBindVariableList0.extend<long>("fId");
399  emptyBindVariableList0[0].data<long>() = ctpFiles.id();
400  query->setCondition( condition, emptyBindVariableList0 );
401 
402  coral::AttributeList attList;
403  attList.extend<std::string>( "L1CF_NAME" );
404  attList.extend<int>( "L1CF_VERSION" );
405  attList.extend<std::string>( "L1CF_MON_SEL_CTPMON" );
406  attList.extend<std::string>( "L1CF_MON_DEC_CTPMON" );
407  fillQuery(query.get(),attList);
408 
409 
410  coral::ICursor& cursor = query->execute();
411  if ( ! cursor.next() ) {
412  TRG_MSG_ERROR("No such L1_CTP_Files exists " << ctpFiles.id());
413  commitSession();
414  throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
415  }
416 
417  const coral::AttributeList& row = cursor.currentRow();
418 
419  std::string name = row["L1CF_NAME"].data<std::string>();
420  int version = row["L1CF_VERSION"].data<int>();
421  std::string ctpmonSelector_str = row["L1CF_MON_SEL_CTPMON"].data<std::string>();
422  std::string ctpmonDecoder_str = row["L1CF_MON_DEC_CTPMON"].data<std::string>();
423 
424  if ( cursor.next() ) {
425  TRG_MSG_ERROR("More than one GetFile exists " << ctpFiles.id());
426  commitSession();
427  throw std::runtime_error( "CTPFilesLoader >> CTPFiles not available" );
428  }
429 
430  std::vector<u_int> monDecVec(CTPFiles::ALL_CTPMONDECODER_SIZE);
431  TRG_MSG_INFO("Loading MON DEC vec of size " << monDecVec.size());
432  parseHexString(monDecVec,ctpmonDecoder_str);
433 
434  //Selector for CTPMON - note the different format requires
435  //different parsing here!
436  std::vector<u_int> monSelVec(CTPFiles::ALL_CTPMONSELECTOR_SIZE);
437  std::stringstream stream(ctpmonSelector_str);
438  std::string val;
439  u_int index = 0;
440  u_int data = 0;
441  while(stream >> val) {
442  // get rid of possible '0x'
443  std::string::size_type loc = val.find("0x");
444  if(loc != std::string::npos) val.replace(loc,2,"");
445  if(!convert_string<u_int>(data, val)) {
446  TRG_MSG_ERROR("Conversion of CTPMONSELECTOR no" << index << " failed!");
447  commitSession();
448  throw std::runtime_error( "CTPFilesLoader >> CTPMONSELECTOR conversion failed." );
449  }
450  if( index >= CTPFiles::ALL_CTPMONSELECTOR_SIZE) {
451  TRG_MSG_ERROR("CTPMON selector word no" << index << " out of bounds");
452  commitSession();
453  throw std::runtime_error( "CTPFilesLoader >> CTPMONSELECTOR conversion failed." );
454  }
455  monSelVec[index] = data;
456  ++index;
457  }
458 
459  // Fill the object with data
460  ctpFiles.setName( name );
461  ctpFiles.setVersion( version );
462  ctpFiles.setCtpmonDecoder(monDecVec);
463  ctpFiles.setCtpmonSelector(monSelVec);
464 
465  commitSession();
466  }
467  catch( const coral::Exception& e ) {
468  TRG_MSG_ERROR("coral::Exception: " << e.what());
469  commitSession();
470  throw;
471  }
472  return true;
473 }
474 
475 
476 void TrigConf::CTPFilesLoader::parseHexString(std::vector<u_int>& vec,const std::string& str, bool verbose) {
477  u_int data;
478  const static u_int significantBits = 8;
479  const static u_int preFix = 2;
480  const static u_int postFix = 1;
481  const static u_int wordsize = (preFix + significantBits + postFix);
482 
483  if(str.size() != 0) {
484  if(str.size() != wordsize * vec.size()) {
485  TRG_MSG_ERROR("File content from DB of size " << str.size() << ", but expects " << wordsize * vec.size() << " [11 * " << vec.size() << "]");
486  throw std::runtime_error( "CTPFilesLoader: file of unexpected size" );
487  }
488  } else {
489  TRG_MSG_INFO("DB File content is 0, which is expected for MC, Reprocessing, and ATN databases");
490  return;
491  }
492 
493  for(u_int i=0; i < vec.size(); ++i) {
494  if( ! convert_hex_string<u_int>(data, str.substr(i*wordsize+preFix,significantBits))) {
495  TRG_MSG_ERROR("Conversion no " << i << " failed!");
496  commitSession();
497  throw std::runtime_error( "CTPFilesLoader >> Conversion failed." );
498  }
499  if(verbose) {
500  //cout << "joerg " << str.substr(i*wordsize+preFix,significantBits) << " -----> " << i << " " << data << endl;
501  }
502  vec[i] = data;
503  }
504 }
505 
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
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
TrigConf::CTPFilesLoader::getFilesIdFromMenu
long getFilesIdFromMenu(int mid)
Definition: CTPFilesLoader.cxx:97
TrigConf::CTPFiles::setCtpcoreCAM
void setCtpcoreCAM(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:80
TrigConf::CTPFiles::setCtpmonSelector
void setCtpmonSelector(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:132
TrigConf::CTPFiles::setCtpinSmxSvfiSlot9
void setCtpinSmxSvfiSlot9(const std::string &str)
Definition: CTPFiles.h:99
TrigConf::CTPFiles::setCtpinSmxSvfiSlot8
void setCtpinSmxSvfiSlot8(const std::string &str)
Definition: CTPFiles.h:98
TrigConf::CTPFilesLoader::load
virtual bool load(CTPFiles &data) override
Definition: CTPFilesLoader.cxx:46
index
Definition: index.py:1
TrigConf::CTPFiles::setCtpinMonDecoderSlot7
void setCtpinMonDecoderSlot7(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:144
TrigConf::CTPFilesLoader::parseHexString
void parseHexString(std::vector< u_int > &vec, const std::string &str, bool verbose=false)
Definition: CTPFilesLoader.cxx:476
DBHelper.h
CTPFiles.h
TrigConf::fillQuery
void fillQuery(coral::IQuery *q, coral::AttributeList &attList)
Definition: DBHelper.cxx:13
TrigConf::CTPFilesLoader::loadCtpinData
bool loadCtpinData(CTPFiles &)
Definition: CTPFilesLoader.cxx:231
LArG4GenerateShowerLib.condition
condition
Definition: LArG4GenerateShowerLib.py:19
TrigConf::CTPFiles::setCtpinSmxOutput
void setCtpinSmxOutput(const std::string &str)
Definition: CTPFiles.h:100
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
TrigConf::CTPFilesLoader::getMenuIdFromMaster
int getMenuIdFromMaster(int mid)
Definition: CTPFilesLoader.cxx:63
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
TrigConf::CTPFiles::setCtpinSmxVhdlSlot8
void setCtpinSmxVhdlSlot8(const std::string &str)
Definition: CTPFiles.h:95
query
Definition: query.py:1
TrigConf::CTPFilesLoader::loadCtpcoreData
bool loadCtpcoreData(CTPFiles &)
Definition: CTPFilesLoader.cxx:158
TrigConf::CTPFiles::setCtpcoreLUT
void setCtpcoreLUT(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:67
TrigConf::CTPFilesLoader::getSmxIdFromMenu
long getSmxIdFromMenu(int mid)
Definition: CTPFilesLoader.cxx:127
TrigConf::CTPFiles::setCtpmonDecoder
void setCtpmonDecoder(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:182
TrigConf::CTPFiles::setCtpinMonDecoderSlot9
void setCtpinMonDecoderSlot9(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:169
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigConf::CTPFilesLoader::loadCtpmonData
bool loadCtpmonData(CTPFiles &)
Definition: CTPFilesLoader.cxx:379
TrigConf::CTPFiles::lvl1MasterTableId
int lvl1MasterTableId() const
Definition: CTPFiles.h:77
TrigConf::CTPFiles::setCtpinSmxSvfiSlot7
void setCtpinSmxSvfiSlot7(const std::string &str)
Definition: CTPFiles.h:97
TrigConf::CTPFiles::setCtpinMonSelectorSlot8
void setCtpinMonSelectorSlot8(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:105
TrigConf::TrigConfData::setId
void setId(unsigned int id)
Definition: TrigConfData.h:29
TrigConf::CTPFiles::setCtpinSmxVhdlSlot7
void setCtpinSmxVhdlSlot7(const std::string &str)
Definition: CTPFiles.h:94
query_example.query
query
Definition: query_example.py:15
TrigConf::name
Definition: HLTChainList.h:35
TRG_MSG_INFO
#define TRG_MSG_INFO(x)
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStreamMacros.h:27
TrigConf::CTPFiles::smxId
int smxId() const
Definition: CTPFiles.h:80
TrigConf::CTPFiles::setSmxId
void setSmxId(const int &id)
Definition: CTPFiles.h:81
TrigConf::TrigConfData::id
unsigned int id() const
Definition: TrigConfData.h:21
python.ext.table_printer.table
list table
Definition: table_printer.py:81
TrigConf::CTPFiles::setSmxName
void setSmxName(const std::string &str)
Definition: CTPFiles.h:84
get_generator_info.version
version
Definition: get_generator_info.py:33
DeMoScan.index
string index
Definition: DeMoScan.py:362
TrigConf::CTPFiles
Definition: CTPFiles.h:17
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
query_example.cursor
cursor
Definition: query_example.py:21
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
python.TriggerHandler.verbose
verbose
Definition: TriggerHandler.py:297
TrigConf::TrigConfData::setVersion
void setVersion(unsigned int version)
Definition: TrigConfData.h:31
TrigConf::CTPFiles::setCtpinMonSelectorSlot9
void setCtpinMonSelectorSlot9(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:118
str
Definition: BTagTrackIpAccessor.cxx:11
TrigConf::CTPFiles::setCtpinSmxVhdlSlot9
void setCtpinSmxVhdlSlot9(const std::string &str)
Definition: CTPFiles.h:96
TrigConf::CTPFiles::setCtpinMonDecoderSlot8
void setCtpinMonDecoderSlot8(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:156
TrigConf::CTPFiles::setCtpinMonSelectorSlot7
void setCtpinMonSelectorSlot7(const std::vector< u_int > &vec)
Definition: CTPFiles.cxx:93
CTPFilesLoader.h
Generated on Fri Jul 5 2024 21:13:32 for ATLAS Offline Software by   doxygen 1.8.18