ATLAS Offline Software
Loading...
Searching...
No Matches
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
44using namespace std;
45
46bool 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...
63int 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
97long 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
127long 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
157bool
158TrigConf::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
231bool 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
379bool 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
476void 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
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
data
char data[hepevt_bytes_allocation_ATLAS]
Definition HepEvt.cxx:11
TrigConf::CTPFilesLoader::convert_string
bool convert_string(T &t, const std::string &s)
Definition CTPFilesLoader.h:71
TrigConf::CTPFilesLoader::loadCtpcoreData
bool loadCtpcoreData(CTPFiles &)
Definition CTPFilesLoader.cxx:158
TrigConf::CTPFilesLoader::convert_hex_string
bool convert_hex_string(T &t, const std::string &s)
Definition CTPFilesLoader.h:63
TrigConf::CTPFilesLoader::load
virtual bool load(CTPFiles &data) override
Definition CTPFilesLoader.cxx:46
TrigConf::CTPFilesLoader::loadCtpinData
bool loadCtpinData(CTPFiles &)
Definition CTPFilesLoader.cxx:231
TrigConf::CTPFilesLoader::parseHexString
void parseHexString(std::vector< u_int > &vec, const std::string &str, bool verbose=false)
Definition CTPFilesLoader.cxx:476
TrigConf::CTPFilesLoader::loadCtpmonData
bool loadCtpmonData(CTPFiles &)
Definition CTPFilesLoader.cxx:379
TrigConf::CTPFiles::setCtpinSmxSvfiSlot7
void setCtpinSmxSvfiSlot7(const std::string &str)
Definition CTPFiles.h:97
TrigConf::CTPFiles::smxId
int smxId() const
Definition CTPFiles.h:80
TrigConf::CTPFiles::setCtpinSmxVhdlSlot7
void setCtpinSmxVhdlSlot7(const std::string &str)
Definition CTPFiles.h:94
TrigConf::CTPFiles::setCtpcoreCAM
void setCtpcoreCAM(const std::vector< u_int > &vec)
Definition CTPFiles.cxx:80
TrigConf::CTPFiles::setCtpinMonDecoderSlot7
void setCtpinMonDecoderSlot7(const std::vector< u_int > &vec)
Definition CTPFiles.cxx:144
TrigConf::CTPFiles::setCtpinSmxSvfiSlot9
void setCtpinSmxSvfiSlot9(const std::string &str)
Definition CTPFiles.h:99
TrigConf::CTPFiles::setCtpmonSelector
void setCtpmonSelector(const std::vector< u_int > &vec)
Definition CTPFiles.cxx:132
TrigConf::CTPFiles::lvl1MasterTableId
int lvl1MasterTableId() const
Definition CTPFiles.h:77
TrigConf::CTPFiles::setCtpinMonSelectorSlot7
void setCtpinMonSelectorSlot7(const std::vector< u_int > &vec)
Definition CTPFiles.cxx:93
TrigConf::CTPFiles::setCtpinMonSelectorSlot8
void setCtpinMonSelectorSlot8(const std::vector< u_int > &vec)
Definition CTPFiles.cxx:105
TrigConf::CTPFiles::setCtpinSmxSvfiSlot8
void setCtpinSmxSvfiSlot8(const std::string &str)
Definition CTPFiles.h:98
TrigConf::CTPFiles::setCtpinSmxVhdlSlot8
void setCtpinSmxVhdlSlot8(const std::string &str)
Definition CTPFiles.h:95
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
TrigConf::CTPFiles::setCtpinMonSelectorSlot9
void setCtpinMonSelectorSlot9(const std::vector< u_int > &vec)
Definition CTPFiles.cxx:118
TrigConf::CTPFiles::setCtpinSmxVhdlSlot9
void setCtpinSmxVhdlSlot9(const std::string &str)
Definition CTPFiles.h:96
TrigConf::CTPFiles::setSmxId
void setSmxId(const int &id)
Definition CTPFiles.h:81
TrigConf::CTPFiles::setCtpcoreLUT
void setCtpcoreLUT(const std::vector< u_int > &vec)
Definition CTPFiles.cxx:67
TrigConf::CTPFiles::setCtpinSmxOutput
void setCtpinSmxOutput(const std::string &str)
Definition CTPFiles.h:100
TrigConf::CTPFiles::setCtpinMonDecoderSlot8
void setCtpinMonDecoderSlot8(const std::vector< u_int > &vec)
Definition CTPFiles.cxx:156
TrigConf::CTPFiles::setSmxName
void setSmxName(const std::string &str)
Definition CTPFiles.h:84
TrigConf::DBLoader::verbose
virtual int verbose() const override
Definition DBLoader.h:57
TrigConf::DBLoader::commitSession
void commitSession()
commit session if not already done
Definition DBLoader.cxx:45
TrigConf::DBLoader::m_session
coral::ISessionProxy & m_session
CORAL interface to database session.
Definition DBLoader.h:68
TrigConf::DBLoader::triggerDBSchemaVersion
unsigned int triggerDBSchemaVersion()
Definition DBLoader.cxx:76
TrigConf::DBLoader::startSession
void startSession()
start session if not already active
Definition DBLoader.cxx:35
TrigConf::TrigConfData::id
unsigned int id() const
Definition TrigConfData.h:21
TrigConf::TrigConfData::setId
void setId(unsigned int id)
Definition TrigConfData.h:29
TrigConf::TrigConfData::setName
void setName(const std::string &name)
Definition TrigConfData.h:30
TrigConf::TrigConfData::setVersion
void setVersion(unsigned int version)
Definition TrigConfData.h:31
TrigConf::fillQuery
void fillQuery(coral::IQuery *q, coral::AttributeList &attList)
Definition DBHelper.cxx:13
index
Definition index.py:1
query
Definition query.py:1
std
STL namespace.
Generated on for ATLAS Offline Software by doxygen 1.14.0