CMS 3D CMS Logo
L1TriggerScalerRead.cc
Go to the documentation of this file.
1 #include "CondTools/RunInfo/interface/L1TriggerScalerRead.h"
2 
3 #include "RelationalAccess/ISession.h"
4 #include "RelationalAccess/ITransaction.h"
5 #include "RelationalAccess/ISchema.h"
6 #include "RelationalAccess/ITable.h"
7 #include "RelationalAccess/ITableDataEditor.h"
8 #include "RelationalAccess/TableDescription.h"
9 #include "RelationalAccess/IQuery.h"
10 #include "RelationalAccess/ICursor.h"
11 #include "CoralBase/AttributeList.h"
12 #include "CoralBase/Attribute.h"
13 #include "CoralBase/AttributeSpecification.h"
14 //#include "SealBase/TimeInfo.h"
15 
16 #include "CondCore/CondDB/interface/Time.h"
17 
18 #include "CoralBase/TimeStamp.h"
19 
20 #include "boost/date_time/posix_time/posix_time.hpp"
21 #include "boost/date_time.hpp"
22 
23 #include <iostream>
24 #include <stdexcept>
25 #include <vector>
26 #include <cmath>
27 
28 L1TriggerScalerRead::L1TriggerScalerRead(
29 
30  const std::string& connectionString, const std::string& user, const std::string& pass)
31  : TestBase(),
32 
33  m_connectionString(connectionString),
34  m_user(user),
35  m_pass(pass) {
36  m_tableToDrop = "";
37  // m_tableToRead="";
38  //m_columnToRead="";
39 }
40 
41 L1TriggerScalerRead::~L1TriggerScalerRead() {}
42 
43 void L1TriggerScalerRead::run() {}
44 
45 void L1TriggerScalerRead::dropTable(const std::string& table) {
46  m_tableToDrop = table;
47  coral::ISession* session = this->connect(m_connectionString, m_user, m_pass);
48  session->transaction().start();
49  std::cout << "connected succesfully to omds" << std::endl;
50  coral::ISchema& schema = session->nominalSchema();
51  schema.dropIfExistsTable(m_tableToDrop);
52 }
53 
54 std::vector<L1TriggerScaler::Lumi> L1TriggerScalerRead::readData(const int r_number) {
55  // m_tableToRead = table; // to be cms_runinfo.runsession_parameter
56  // m_columnToRead= column; // to be string_value;
57 
58  /* query to execute
59 select * from runsession_parameter where string_value like '%[%' and name like 'CMS.TR%' order by time;
60 
61 % gets you the parameters of l1 trg
62 select * from runsession_parameter where string_value like '%[%' and name like 'CMS.TR%' and runnumber=51384 order by time;
63 
64 %what is the type?
65 select * from runsession_parameter_meta where name like 'CMS.TRG:GTLumiSegInfo';
66 
67 %what is the table for that type?
68 select * from runsession_type_meta where type like 'rcms.fm.fw.parameter.type.VectorT';
69 
70 % give me the data... value_id is the parent_id for the element
71 select * from runsession_vector where runsession_parameter_id = 3392114;
72 
73 % where is the table for that element type?
74 select * from runsession_type_meta where type like 'rcms.fm.fw.parameter.type.IntegerT';
75 
76 % what is the value of the element (of the vector)
77 select * from runsession_integer where parent_id = 3392118;
78 
79 */
80 
81  /* let's begin with a query to obtain the number of lumi section and the corresponding string value:
82 select string_value from runsession_parameter where string_value like '%[51384]' and name='CMS.TRG:GTLumiSegInfo' and runnumber=51384 order by time;
83 
84 */
85 
86  std::cout << "entering readData" << std::endl;
87  coral::ISession* session = this->connect(m_connectionString, m_user, m_pass);
88  session->transaction().start();
89  std::cout << "starting session " << std::endl;
90  coral::ISchema& schema = session->nominalSchema();
91  std::cout << " accessing schema " << std::endl;
92 
93  // queryI to access the string_format_value
94  coral::IQuery* query0 = schema.tableHandle("RUNSESSION_PARAMETER").newQuery();
95  std::cout << "table handling " << std::endl;
96  query0->addToOutputList("RUNSESSION_PARAMETER.STRING_VALUE", "STRING_VALUE");
97 
98  std::string condition0 =
99  "RUNSESSION_PARAMETER.RUNNUMBER=:n_run AND RUNSESSION_PARAMETER.NAME='CMS.TRG:GTLumiSegInfo_format'";
100  coral::AttributeList conditionData0;
101  conditionData0.extend<int>("n_run");
102  query0->setCondition(condition0, conditionData0);
103  conditionData0[0].data<int>() = r_number;
104  coral::ICursor& cursor0 = query0->execute();
105 
106  std::vector<L1TriggerScaler::Lumi> l1triggerscaler_array;
107 
108  std::string string_format;
109  while (cursor0.next() != 0) {
110  const coral::AttributeList& row = cursor0.currentRow();
111  std::cout << " entering the query == " << std::endl;
112  string_format = row["STRING_VALUE"].data<std::string>();
113 
114  std::cout << " string value extracted == " << string_format << std::endl;
115  }
116 
117  // queryI to access the id_value
118  coral::IQuery* queryI = schema.tableHandle("RUNSESSION_PARAMETER").newQuery();
119 
120  // queryI->addToTableList( m_tableToRead );
121  std::cout << "table handling " << std::endl;
122  // implemating the query here.......
123  // queryI->addToOutputList("RUNSESSION_PARAMETER.STRING_VALUE" , "STRING_VALUE");
124  queryI->addToOutputList("RUNSESSION_PARAMETER.ID", "ID");
125  // to add the starting time of the lumisection
126  queryI->addToOutputList("RUNSESSION_PARAMETER.TIME", "TIME");
127 
128  // condition
129  std::string condition =
130  "RUNSESSION_PARAMETER.RUNNUMBER=:n_run AND RUNSESSION_PARAMETER.NAME LIKE 'CMS.TRG:GTLumiSegInfo%' ORDER BY "
131  "TIME "; //AND RUNSESSION_PARAMETER.STRING_VALUE LIKE '%[%' ORDER BY TIME";
132  // controllare...................
133  coral::AttributeList conditionData;
134  conditionData.extend<int>("n_run");
135  queryI->setCondition(condition, conditionData);
136  conditionData[0].data<int>() = r_number;
137  coral::ICursor& cursorI = queryI->execute();
138 
139  std::vector<std::pair<int, long long> >
140  v_vid; // parent_id for value_id corresponding to each memeber of the lumi object, paired with his corresponding index to diceded the type
141 
142  if (cursorI.next() == 0) {
143  std::cout << " run " << r_number << " not full " << std::endl;
144  }
145  while (cursorI.next() != 0) {
146  // 1 cicle for each lumi
147  L1TriggerScaler::Lumi Itemp;
148  // if cursor is null setting null values
149  Itemp.m_runnumber = r_number;
150  // initializing the date string ...
151  Itemp.m_date = "0";
152  Itemp.m_string_format = string_format;
153  const coral::AttributeList& row = cursorI.currentRow();
154  std::cout << " entering the query == " << std::endl;
155  // Itemp.m_string_value= row["STRING_VALUE"].data<std::string>();
156 
157  // std::cout<< " string value extracted == " << Itemp.m_string_value << std::endl;
158  Itemp.m_lumi_id = row["ID"].data<long long>();
159  std::cout << " id value extracted == " << Itemp.m_lumi_id
160  << std::endl; // now we have the id and we can search and fill the lumi odject
161  // retrieving all the value_id one for each member of the lumi scaler
162 
163  coral::TimeStamp st = row["TIME"].data<coral::TimeStamp>();
164  int year = st.year();
165  int month = st.month();
166  int day = st.day();
167  int hour = st.hour();
168 
169  int minute = st.minute();
170  int second = st.second();
171  long nanosecond = st.nanosecond();
172  std::cout << " start time time extracted == "
173  << "-->year " << year << "-- month " << month << "-- day " << day << "-- hour " << hour << "-- minute "
174  << minute << "-- second " << second << std::endl;
175  boost::gregorian::date dt(year, month, day);
176  boost::posix_time::time_duration td(hour, minute, second, nanosecond / 1000);
177  boost::posix_time::ptime pt(dt, td);
178  Itemp.m_start_time = boost::posix_time::to_iso_extended_string(pt);
179  std::cout << " time extracted == " << Itemp.m_start_time << std::endl;
180 
181  coral::IQuery* queryII = schema.newQuery();
182  queryII->addToOutputList("RUNSESSION_VECTOR.VALUE_ID", "VALUE_ID");
183  queryII->addToOutputList("RUNSESSION_VECTOR.VALUE_INDEX", "VALUE_INDEX");
184 
185  queryII->addToTableList("RUNSESSION_VECTOR");
186  std::string condition2 = "RUNSESSION_VECTOR.PARENT_ID=:n_vid";
187  coral::AttributeList conditionData2;
188  conditionData2.extend<long>("n_vid");
189  queryII->setCondition(condition2, conditionData2);
190  conditionData2[0].data<long>() = Itemp.m_lumi_id + 1;
191  coral::ICursor& cursorII = queryII->execute();
192  while (cursorII.next() != 0) {
193  const coral::AttributeList& row = cursorII.currentRow();
194  std::cout << " entering the queryII == " << std::endl;
195  long long vid_val = row["VALUE_ID"].data<long long>();
196  int vid_id = (int)row["VALUE_INDEX"].data<long long>();
197  v_vid.push_back(std::make_pair(vid_id, vid_val));
198  std::cout << " value_id index extracted == " << v_vid.back().first << std::endl;
199  std::cout << " value_id value extracted == " << v_vid.back().second << std::endl;
200  // depending from the index, fill the object....
201 
202  coral::AttributeList conditionData3;
203  conditionData3.extend<int>("n_vid_val");
204  conditionData3[0].data<int>() = vid_val;
205  switch (vid_id) {
206  case 0: {
207  std::cout << " caso 0" << std::endl;
208  coral::IQuery* queryIII = schema.newQuery();
209  queryIII->addToOutputList("RUNSESSION_INTEGER.VALUE", "VALUE");
210  queryIII->addToTableList("RUNSESSION_INTEGER");
211  std::string condition3 = "RUNSESSION_INTEGER.PARENT_ID=:n_vid_val";
212  queryIII->setCondition(condition3, conditionData3);
213  coral::ICursor& cursorIII = queryIII->execute();
214 
215  while (cursorIII.next() != 0) {
216  const coral::AttributeList& row = cursorIII.currentRow();
217  // std::cout<< " entering the queryIII " << std::endl;
218  Itemp.m_rn = row["VALUE"].data<long long>();
219  std::cout << " run extracted == " << Itemp.m_rn << std::endl;
220  }
221  delete queryIII;
222  } break;
223  case 1: {
224  std::cout << " caso 1" << std::endl;
225  coral::IQuery* queryIII = schema.newQuery();
226  queryIII->addToOutputList("RUNSESSION_INTEGER.VALUE", "VALUE");
227  queryIII->addToTableList("RUNSESSION_INTEGER");
228  std::string condition3 = "RUNSESSION_INTEGER.PARENT_ID=:n_vid_val";
229  queryIII->setCondition(condition3, conditionData3);
230  coral::ICursor& cursorIII = queryIII->execute();
231  while (cursorIII.next() != 0) {
232  const coral::AttributeList& row = cursorIII.currentRow();
233  std::cout << " entering the queryIII " << std::endl;
234  Itemp.m_lumisegment = row["VALUE"].data<long long>();
235  std::cout << " lumisegment extracted == " << Itemp.m_lumisegment << std::endl;
236  }
237  delete queryIII;
238  } break;
239  case 2: {
240  std::cout << " caso 2" << std::endl;
241  /*
242  coral::IQuery* queryIII = schema.newQuery();
243  queryIII->addToOutputList("RUNSESSION_STRING.VALUE" , "VALUE");
244  queryIII->addToTableList("RUNSESSION_STRING");
245  std::string condition3 = "RUNSESSION_STRING.PARENT_ID=:n_vid_val";
246  queryIII->setCondition( condition3, conditionData3 );
247  coral::ICursor& cursorIII = queryIII->execute();
248  while ( cursorIII.next()!=0 ) {
249  const coral::AttributeList& row = cursorIII.currentRow();
250  std::cout<< " entering the queryIII " << std::endl;
251  Itemp.m_version = row["VALUE"].data<std::string>();
252  std::cout<< "version extracted == " << Itemp.m_version << std::endl;
253 
254  }
255  delete queryIII;
256  */
257  } break;
258  case 3: {
259  std::cout << " caso 3" << std::endl;
260  /*
261  coral::IQuery* queryIII = schema.newQuery();
262  queryIII->addToOutputList("RUNSESSION_STRING.VALUE" , "VALUE");
263  queryIII->addToTableList("RUNSESSION_STRING");
264  std::string condition3 = "RUNSESSION_STRING.PARENT_ID=:n_vid_val";
265  queryIII->setCondition( condition3, conditionData3 );
266  coral::ICursor& cursorIII = queryIII->execute();
267  while ( cursorIII.next()!=0 ) {
268  const coral::AttributeList& row = cursorIII.currentRow();
269  std::cout<< " entering the queryIII " << std::endl;
270  Itemp.m_context = row["VALUE"].data<std::string>();
271  std::cout<< " context extracted == " << Itemp.m_context << std::endl;
272 
273  }
274  delete queryIII;
275  */
276  } break;
277  case 4: {
278  std::cout << " caso 4" << std::endl;
279  coral::IQuery* queryIII = schema.newQuery();
280  queryIII->addToOutputList("RUNSESSION_DATE.VALUE", "VALUE");
281  queryIII->addToTableList("RUNSESSION_DATE");
282  std::string condition3 = "RUNSESSION_DATE.PARENT_ID=:n_vid_val";
283  queryIII->setCondition(condition3, conditionData3);
284  coral::ICursor& cursorIII = queryIII->execute();
285  if (cursorIII.next() != 0) {
286  const coral::AttributeList& row = cursorIII.currentRow();
287  std::cout << " entering the queryIII " << std::endl;
288  coral::TimeStamp ts = row["VALUE"].data<coral::TimeStamp>();
289  int year = ts.year();
290  int month = ts.month();
291  int day = ts.day();
292  int hour = ts.hour();
293 
294  int minute = ts.minute();
295  int second = ts.second();
296  long nanosecond = ts.nanosecond();
297  std::cout << " start time time extracted == "
298  << "-->year " << year << "-- month " << month << "-- day " << day << "-- hour " << hour
299  << "-- minute " << minute << "-- second " << second << std::endl;
300  boost::gregorian::date dt(year, month, day);
301  boost::posix_time::time_duration td(hour, minute, second, nanosecond / 1000);
302  boost::posix_time::ptime pt(dt, td);
303  Itemp.m_date = boost::posix_time::to_iso_extended_string(pt);
304  std::cout << " date extracted == " << Itemp.m_date << std::endl;
305  } else {
306  std::cout << "date extracted == " << Itemp.m_date << std::endl;
307  }
308  delete queryIII;
309  } break;
310  case 5: {
311  std::cout << " caso 5" << std::endl;
312  coral::IQuery* queryIII = schema.newQuery();
313  queryIII->addToOutputList("RUNSESSION_INTEGER.VALUE", "VALUE");
314  queryIII->addToTableList("RUNSESSION_INTEGER");
315  std::string condition3 = "RUNSESSION_INTEGER.PARENT_ID=:n_vid_val";
316  queryIII->setCondition(condition3, conditionData3);
317  coral::ICursor& cursorIII = queryIII->execute();
318  int i = 0;
319  while (cursorIII.next() != 0) {
320  const coral::AttributeList& row = cursorIII.currentRow();
321  std::cout << " entering the queryIII " << std::endl;
322  int v = (int)row["VALUE"].data<long long>();
323  Itemp.m_GTAlgoCounts.push_back(v);
324  // std::cout<< " m_GTAlgoCounts["<< i << "]" << " extracted == " << v << std::endl;
325  i++;
326  }
327 
328  delete queryIII;
329 
330  }
331 
332  break;
333  case 6: {
334  std::cout << " caso 6" << std::endl;
335  coral::IQuery* queryIII = schema.newQuery();
336  queryIII->addToOutputList("RUNSESSION_FLOAT.VALUE", "VALUE");
337  queryIII->addToTableList("RUNSESSION_FLOAT");
338  std::string condition3 = "RUNSESSION_FLOAT.PARENT_ID=:n_vid_val";
339  queryIII->setCondition(condition3, conditionData3);
340  coral::ICursor& cursorIII = queryIII->execute();
341  int i = 0;
342  while (cursorIII.next() != 0) {
343  const coral::AttributeList& row = cursorIII.currentRow();
344  std::cout << " entering the queryIII " << std::endl;
345  float v = (float)row["VALUE"].data<double>();
346  Itemp.m_GTAlgoRates.push_back(v);
347  // std::cout<< " m_GTAlgoRates["<< i << "]" << " extracted == " << v << std::endl;
348  i++;
349  }
350 
351  delete queryIII;
352 
353  }
354 
355  break;
356 
357  case 7: {
358  std::cout << " caso 7" << std::endl;
359  coral::IQuery* queryIII = schema.newQuery();
360  queryIII->addToOutputList("RUNSESSION_INTEGER.VALUE", "VALUE");
361  queryIII->addToTableList("RUNSESSION_INTEGER");
362  std::string condition3 = "RUNSESSION_INTEGER.PARENT_ID=:n_vid_val";
363  queryIII->setCondition(condition3, conditionData3);
364  coral::ICursor& cursorIII = queryIII->execute();
365  int i = 0;
366  while (cursorIII.next() != 0) {
367  const coral::AttributeList& row = cursorIII.currentRow();
368  std::cout << " entering the queryIII " << std::endl;
369  int v = (int)row["VALUE"].data<long long>();
370  Itemp.m_GTAlgoPrescaling.push_back(v);
371  // std::cout<< " m_GTAlgoPrescaling["<< i << "]" << " extracted == " << v << std::endl;
372  i++;
373  }
374 
375  delete queryIII;
376 
377  }
378 
379  break;
380  case 8: {
381  std::cout << " caso 8" << std::endl;
382  coral::IQuery* queryIII = schema.newQuery();
383  queryIII->addToOutputList("RUNSESSION_INTEGER.VALUE", "VALUE");
384  queryIII->addToTableList("RUNSESSION_INTEGER");
385  std::string condition3 = "RUNSESSION_INTEGER.PARENT_ID=:n_vid_val";
386  queryIII->setCondition(condition3, conditionData3);
387  coral::ICursor& cursorIII = queryIII->execute();
388  int i = 0;
389  while (cursorIII.next() != 0) {
390  const coral::AttributeList& row = cursorIII.currentRow();
391  std::cout << " entering the queryIII " << std::endl;
392  int v = (int)row["VALUE"].data<long long>();
393  Itemp.m_GTTechCounts.push_back(v);
394  // std::cout<< " m_GTTechCounts["<< i << "]" << " extracted == " << v << std::endl;
395  i++;
396  }
397 
398  delete queryIII;
399 
400  }
401 
402  break;
403  case 9: {
404  std::cout << " caso 9" << std::endl;
405  coral::IQuery* queryIII = schema.newQuery();
406  queryIII->addToOutputList("RUNSESSION_FLOAT.VALUE", "VALUE");
407  queryIII->addToTableList("RUNSESSION_FLOAT");
408  std::string condition3 = "RUNSESSION_FLOAT.PARENT_ID=:n_vid_val";
409  queryIII->setCondition(condition3, conditionData3);
410  coral::ICursor& cursorIII = queryIII->execute();
411  int i = 0;
412  while (cursorIII.next() != 0) {
413  const coral::AttributeList& row = cursorIII.currentRow();
414  std::cout << " entering the queryIII " << std::endl;
415  float v = (float)row["VALUE"].data<double>();
416  Itemp.m_GTTechRates.push_back(v);
417  // std::cout<< " m_GTTechRates["<< i << "]" << " extracted == " << v << std::endl;
418  i++;
419  }
420 
421  delete queryIII;
422 
423  }
424 
425  break;
426  case 10: {
427  std::cout << " caso 10" << std::endl;
428  coral::IQuery* queryIII = schema.newQuery();
429  queryIII->addToOutputList("RUNSESSION_INTEGER.VALUE", "VALUE");
430  queryIII->addToTableList("RUNSESSION_INTEGER");
431  std::string condition3 = "RUNSESSION_INTEGER.PARENT_ID=:n_vid_val";
432  queryIII->setCondition(condition3, conditionData3);
433  coral::ICursor& cursorIII = queryIII->execute();
434  int i = 0;
435  while (cursorIII.next() != 0) {
436  const coral::AttributeList& row = cursorIII.currentRow();
437  std::cout << " entering the queryIII " << std::endl;
438  int v = (int)row["VALUE"].data<long long>();
439  Itemp.m_GTTechPrescaling.push_back(v);
440  // std::cout<< " m_GTTechPrescaling["<< i << "]" << " extracted == " << v << std::endl;
441  i++;
442  }
443 
444  delete queryIII;
445 
446  }
447 
448  break;
449  case 11: {
450  std::cout << " caso 11" << std::endl;
451  coral::IQuery* queryIII = schema.newQuery();
452  queryIII->addToOutputList("RUNSESSION_INTEGER.VALUE", "VALUE");
453  queryIII->addToTableList("RUNSESSION_INTEGER");
454  std::string condition3 = "RUNSESSION_INTEGER.PARENT_ID=:n_vid_val";
455  queryIII->setCondition(condition3, conditionData3);
456  coral::ICursor& cursorIII = queryIII->execute();
457  int i = 0;
458  while (cursorIII.next() != 0) {
459  const coral::AttributeList& row = cursorIII.currentRow();
460  std::cout << " entering the queryIII " << std::endl;
461  int v = (int)row["VALUE"].data<long long>();
462  Itemp.m_GTPartition0TriggerCounts.push_back(v);
463  // std::cout<< " m_GTPartition0TriggerCounts"<< i << "]" << " extracted == " << v << std::endl;
464  i++;
465  }
466 
467  delete queryIII;
468 
469  }
470 
471  break;
472  case 12: {
473  std::cout << " caso 12" << std::endl;
474  coral::IQuery* queryIII = schema.newQuery();
475  queryIII->addToOutputList("RUNSESSION_FLOAT.VALUE", "VALUE");
476  queryIII->addToTableList("RUNSESSION_FLOAT");
477  std::string condition3 = "RUNSESSION_FLOAT.PARENT_ID=:n_vid_val";
478  queryIII->setCondition(condition3, conditionData3);
479  coral::ICursor& cursorIII = queryIII->execute();
480  int i = 0;
481  while (cursorIII.next() != 0) {
482  const coral::AttributeList& row = cursorIII.currentRow();
483  std::cout << " entering the queryIII " << std::endl;
484  float v = (float)row["VALUE"].data<double>();
485  Itemp.m_GTPartition0TriggerRates.push_back(v);
486  // std::cout<< " m_GTPartition0TriggerRates["<< i << "]" << " extracted == " << v << std::endl;
487  i++;
488  }
489 
490  delete queryIII;
491 
492  }
493 
494  break;
495  case 13: {
496  std::cout << " caso 13" << std::endl;
497  coral::IQuery* queryIII = schema.newQuery();
498  queryIII->addToOutputList("RUNSESSION_INTEGER.VALUE", "VALUE");
499  queryIII->addToTableList("RUNSESSION_INTEGER");
500  std::string condition3 = "RUNSESSION_INTEGER.PARENT_ID=:n_vid_val";
501  queryIII->setCondition(condition3, conditionData3);
502  coral::ICursor& cursorIII = queryIII->execute();
503  int i = 0;
504  while (cursorIII.next() != 0) {
505  const coral::AttributeList& row = cursorIII.currentRow();
506  std::cout << " entering the queryIII " << std::endl;
507  int v = (int)row["VALUE"].data<long long>();
508  Itemp.m_GTPartition0DeadTime.push_back(v);
509  // std::cout<< " m_GTPartition0DeadTime"<< i << "]" << " extracted == " << v << std::endl;
510  i++;
511  }
512 
513  delete queryIII;
514 
515  }
516 
517  break;
518  case 14: {
519  std::cout << " caso 14" << std::endl;
520  coral::IQuery* queryIII = schema.newQuery();
521  queryIII->addToOutputList("RUNSESSION_FLOAT.VALUE", "VALUE");
522  queryIII->addToTableList("RUNSESSION_FLOAT");
523  std::string condition3 = "RUNSESSION_FLOAT.PARENT_ID=:n_vid_val";
524  queryIII->setCondition(condition3, conditionData3);
525  coral::ICursor& cursorIII = queryIII->execute();
526  int i = 0;
527  while (cursorIII.next() != 0) {
528  const coral::AttributeList& row = cursorIII.currentRow();
529  std::cout << " entering the queryIII " << std::endl;
530  float v = (float)row["VALUE"].data<double>();
531  Itemp.m_GTPartition0DeadTimeRatio.push_back(v);
532  // std::cout<< " m_GTPartition0DeadTimeRatio["<< i << "]" << " extracted == " << v << std::endl;
533  i++;
534  }
535 
536  delete queryIII;
537 
538  }
539 
540  break;
541 
542  default:
543  std::cout << "index out of range" << std::endl;
544  break;
545  }
546 
547  // l1triggerscaler_array.push_back(Itemp);
548  }
549  delete queryII;
550 
551  l1triggerscaler_array.push_back(Itemp);
552  }
553 
554  delete queryI;
555 
556  session->transaction().commit();
557  delete session;
558 
559  // std::cout<<"filling the lumi array to pass to the object" << std::endl;
560 
561  return l1triggerscaler_array;
562 }
L1TriggerScaler::Lumi::m_runnumber
int m_runnumber
Definition: L1TriggerScaler.h:25
L1TriggerScaler::Lumi::m_GTTechCounts
std::vector< int > m_GTTechCounts
Definition: L1TriggerScaler.h:44
L1TriggerScalerRead::m_pass
std::string m_pass
Definition: L1TriggerScalerRead.h:25
mps_fire.i
i
Definition: mps_fire.py:428
dqmMemoryStats.float
float
Definition: dqmMemoryStats.py:127
L1TriggerScalerRead::m_tableToDrop
std::string m_tableToDrop
Definition: L1TriggerScalerRead.h:20
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
L1TriggerScaler::Lumi::m_GTPartition0DeadTime
std::vector< int > m_GTPartition0DeadTime
Definition: L1TriggerScaler.h:54
gather_cfg.cout
cout
Definition: gather_cfg.py:144
L1TriggerScalerRead::run
void run() override
Definition: L1TriggerScalerRead.cc:43
L1TriggerScaler::Lumi::m_rn
long m_rn
Definition: L1TriggerScaler.h:31
L1TriggerScaler::Lumi::m_GTAlgoPrescaling
std::vector< int > m_GTAlgoPrescaling
Definition: L1TriggerScaler.h:42
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
L1TriggerScalerRead.h
L1TriggerScaler::Lumi::m_GTTechRates
std::vector< float > m_GTTechRates
Definition: L1TriggerScaler.h:46
findQualityFiles.v
v
Definition: findQualityFiles.py:179
dt
float dt
Definition: AMPTWrapper.h:136
L1TriggerScaler::Lumi::m_GTTechPrescaling
std::vector< int > m_GTTechPrescaling
Definition: L1TriggerScaler.h:48
L1TriggerScaler::Lumi::m_string_format
std::string m_string_format
Definition: L1TriggerScaler.h:30
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Time.h
L1TriggerScaler::Lumi::m_GTAlgoRates
std::vector< float > m_GTAlgoRates
Definition: L1TriggerScaler.h:40
L1TriggerScaler::Lumi::m_lumisegment
int m_lumisegment
Definition: L1TriggerScaler.h:32
L1TriggerScalerRead::L1TriggerScalerRead
L1TriggerScalerRead(const std::string &connectionString, const std::string &user, const std::string &pass)
Definition: L1TriggerScalerRead.cc:28
L1TriggerScalerRead::m_connectionString
std::string m_connectionString
Definition: L1TriggerScalerRead.h:23
createfilelist.int
int
Definition: createfilelist.py:10
L1TriggerScaler::Lumi
Definition: L1TriggerScaler.h:22
util.getRunInfo.day
def day(string)
Definition: getRunInfo.py:11
goodZToMuMu_cfi.condition
condition
Definition: goodZToMuMu_cfi.py:37
L1TriggerScalerRead::~L1TriggerScalerRead
~L1TriggerScalerRead() override
Definition: L1TriggerScalerRead.cc:41
EnviromentSettings.user
user
Definition: EnviromentSettings.py:30
L1TriggerScaler::Lumi::m_GTAlgoCounts
std::vector< int > m_GTAlgoCounts
Definition: L1TriggerScaler.h:37
L1TriggerScalerRead::dropTable
void dropTable(const std::string &table)
Definition: L1TriggerScalerRead.cc:45
L1TriggerScaler::Lumi::m_GTPartition0TriggerRates
std::vector< float > m_GTPartition0TriggerRates
Definition: L1TriggerScaler.h:52
indexGen.date
date
Definition: indexGen.py:99
L1TriggerScalerRead::readData
std::vector< L1TriggerScaler::Lumi > readData(const int r_number)
Definition: L1TriggerScalerRead.cc:54
L1TriggerScaler::Lumi::m_lumi_id
long long m_lumi_id
Definition: L1TriggerScaler.h:26
L1TriggerScaler::Lumi::m_GTPartition0DeadTimeRatio
std::vector< float > m_GTPartition0DeadTimeRatio
Definition: L1TriggerScaler.h:56
L1TriggerScaler::Lumi::m_start_time
std::string m_start_time
Definition: L1TriggerScaler.h:27
L1TriggerScaler::Lumi::m_date
std::string m_date
Definition: L1TriggerScaler.h:35
TestBase
Definition: TestBase.h:21
TestBase::connect
coral::ISession * connect(const std::string &connectionString, const std::string &user, const std::string &password)
Definition: TestBase.cc:23
TableParser.table
table
Definition: TableParser.py:111
l1RCTOmdsFedVectorProducer_cfi.connectionString
connectionString
Definition: l1RCTOmdsFedVectorProducer_cfi.py:4
L1TriggerScaler::Lumi::m_GTPartition0TriggerCounts
std::vector< int > m_GTPartition0TriggerCounts
Definition: L1TriggerScaler.h:50
L1TriggerScalerRead::m_user
std::string m_user
Definition: L1TriggerScalerRead.h:24
Generated for CMSSW Reference Manual by doxygen 1.8.16