File indexing completed on 2023-03-17 11:19:58
0001 #ifndef RecoLuminosity_LumiProducer_TRGScalers2DB_h
0002 #define RecoLuminosity_LumiProducer_TRGScalers2DB_h
0003 #include "CoralBase/AttributeList.h"
0004 #include "CoralBase/Attribute.h"
0005 #include "CoralBase/AttributeSpecification.h"
0006 #include "CoralBase/Blob.h"
0007 #include "CoralBase/Exception.h"
0008 #include "RelationalAccess/ConnectionService.h"
0009 #include "RelationalAccess/ISessionProxy.h"
0010 #include "RelationalAccess/ITransaction.h"
0011 #include "RelationalAccess/ITypeConverter.h"
0012 #include "RelationalAccess/IQuery.h"
0013 #include "RelationalAccess/ICursor.h"
0014 #include "RelationalAccess/ISchema.h"
0015 #include "RelationalAccess/IView.h"
0016 #include "RelationalAccess/ITable.h"
0017 #include "RelationalAccess/ITableDataEditor.h"
0018 #include "RelationalAccess/IBulkOperation.h"
0019 #include "RecoLuminosity/LumiProducer/interface/DataPipe.h"
0020 #include "RecoLuminosity/LumiProducer/interface/LumiNames.h"
0021 #include "RecoLuminosity/LumiProducer/interface/idDealer.h"
0022 #include "RecoLuminosity/LumiProducer/interface/Exception.h"
0023 #include "RecoLuminosity/LumiProducer/interface/DBConfig.h"
0024 #include "RecoLuminosity/LumiProducer/interface/ConstantDef.h"
0025 #include "RecoLuminosity/LumiProducer/interface/RevisionDML.h"
0026 #include <cstring>
0027 #include <cstdlib>
0028 #include <iostream>
0029 #include <sstream>
0030 #include <stdexcept>
0031 #include <map>
0032 namespace lumi {
0033 class TRGScalers2DB : public DataPipe {
0034 public:
0035 const static unsigned int COMMITLSINTERVAL = 150;
0036 const static unsigned int COMMITLSTRGINTERVAL = 550;
0037 explicit TRGScalers2DB(const std::string& dest);
0038 unsigned long long retrieveData(unsigned int runnumber) override;
0039 const std::string dataType() const override;
0040 const std::string sourceType() const override;
0041 ~TRGScalers2DB() override;
0042
0043
0044 typedef std::vector<std::string> TriggerNameResult_Algo;
0045 typedef std::vector<std::string> TriggerNameResult_Tech;
0046
0047 typedef unsigned long long DEADCOUNT;
0048 typedef float DEADFRAC;
0049 typedef std::vector<DEADCOUNT> TriggerDeadCountResult;
0050 typedef std::vector<DEADFRAC> TriggerDeadFracResult;
0051 typedef std::vector<unsigned int> BITCOUNT;
0052 typedef std::vector<BITCOUNT> TriggerCountResult_Algo;
0053 typedef std::vector<BITCOUNT> TriggerCountResult_Tech;
0054 typedef std::map<unsigned int, std::vector<unsigned int> > PrescaleResult_Algo;
0055 typedef std::map<unsigned int, std::vector<unsigned int> > PrescaleResult_Tech;
0056
0057 std::string int2str(unsigned int t, unsigned int width);
0058 unsigned int str2int(const std::string& s);
0059 void writeTrgData(coral::ISessionProxy* session,
0060 unsigned int runnumber,
0061 const std::string& source,
0062 TriggerDeadCountResult::iterator deadtimesBeg,
0063 TriggerDeadCountResult::iterator deadtimesEnd,
0064 TRGScalers2DB::TriggerDeadFracResult& deadfracs,
0065 TriggerNameResult_Algo& algonames,
0066 TriggerNameResult_Tech& technames,
0067 TriggerCountResult_Algo& algocounts,
0068 TriggerCountResult_Tech& techcounts,
0069 PrescaleResult_Algo& prescalealgo,
0070 PrescaleResult_Tech& prescaletech,
0071 unsigned int commitintv);
0072 unsigned long long writeTrgDataToSchema2(coral::ISessionProxy* session,
0073 unsigned int runnumber,
0074 const std::string& source,
0075 TriggerDeadCountResult::iterator deadtimesBeg,
0076 TriggerDeadCountResult::iterator deadtimesEnd,
0077 TRGScalers2DB::TriggerDeadFracResult& deadfracs,
0078 TriggerNameResult_Algo& algonames,
0079 TriggerNameResult_Tech& technames,
0080 TriggerCountResult_Algo& algocounts,
0081 TriggerCountResult_Tech& techcounts,
0082 PrescaleResult_Algo& prescalealgo,
0083 PrescaleResult_Tech& prescaletech,
0084 unsigned int commitintv);
0085 };
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111 TRGScalers2DB::TRGScalers2DB(const std::string& dest) : DataPipe(dest) {}
0112 unsigned long long TRGScalers2DB::retrieveData(unsigned int runnumber) {
0113 std::string runnumberstr = int2str(runnumber, 6);
0114
0115 coral::ConnectionService* svc = new coral::ConnectionService;
0116 lumi::DBConfig dbconf(*svc);
0117 if (!m_authpath.empty()) {
0118 dbconf.setAuthentication(m_authpath);
0119 }
0120
0121 coral::ISessionProxy* trgsession = svc->connect(m_source, coral::ReadOnly);
0122 coral::ITypeConverter& tpc = trgsession->typeConverter();
0123 tpc.setCppTypeForSqlType("unsigned int", "NUMBER(7)");
0124 tpc.setCppTypeForSqlType("unsigned int", "NUMBER(10)");
0125 tpc.setCppTypeForSqlType("unsigned long long", "NUMBER(20)");
0126 std::string gtmonschema("CMS_GT_MON");
0127 std::string algoviewname("V_SCALERS_FDL_ALGO");
0128 std::string techviewname("V_SCALERS_FDL_TECH");
0129 std::string deadviewname("V_SCALERS_TCS_DEADTIME");
0130 std::string lstablename("LUMI_SECTIONS");
0131
0132 std::string gtschema("CMS_GT");
0133 std::string runtechviewname("GT_RUN_TECH_VIEW");
0134 std::string runalgoviewname("GT_RUN_ALGO_VIEW");
0135 std::string runprescalgoviewname("GT_RUN_PRESC_ALGO_VIEW");
0136 std::string runpresctechviewname("GT_RUN_PRESC_TECH_VIEW");
0137
0138
0139 lumi::TRGScalers2DB::PrescaleResult_Algo algoprescale;
0140 lumi::TRGScalers2DB::PrescaleResult_Tech techprescale;
0141 lumi::TRGScalers2DB::BITCOUNT mybitcount_algo;
0142 mybitcount_algo.reserve(lumi::N_TRGALGOBIT);
0143 lumi::TRGScalers2DB::BITCOUNT mybitcount_tech;
0144 mybitcount_tech.reserve(lumi::N_TRGTECHBIT);
0145 lumi::TRGScalers2DB::TriggerNameResult_Algo algonames;
0146 algonames.reserve(lumi::N_TRGALGOBIT);
0147 lumi::TRGScalers2DB::TriggerNameResult_Tech technames;
0148 technames.reserve(lumi::N_TRGTECHBIT);
0149 lumi::TRGScalers2DB::TriggerCountResult_Algo algocount;
0150
0151 lumi::TRGScalers2DB::TriggerCountResult_Tech techcount;
0152
0153 lumi::TRGScalers2DB::TriggerDeadFracResult deadfracresult;
0154 deadfracresult.reserve(500);
0155 lumi::TRGScalers2DB::TriggerDeadCountResult deadtimeresult;
0156 deadtimeresult.reserve(500);
0157 coral::ITransaction& transaction = trgsession->transaction();
0158 transaction.start(true);
0159
0160
0161
0162
0163 coral::ISchema& gtmonschemaHandle = trgsession->schema(gtmonschema);
0164 if (!gtmonschemaHandle.existsView(algoviewname)) {
0165 throw lumi::Exception(std::string("non-existing view ") + algoviewname, "retrieveData", "TRGScalers2DB");
0166 }
0167 if (!gtmonschemaHandle.existsView(techviewname)) {
0168 throw lumi::Exception(std::string("non-existing view ") + techviewname, "retrieveData", "TRGScalers2DB");
0169 }
0170 if (!gtmonschemaHandle.existsView(deadviewname)) {
0171 throw lumi::Exception(std::string("non-existing view ") + deadviewname, "retrieveData", "TRGScalers2DB");
0172 }
0173
0174
0175
0176
0177
0178
0179 coral::AttributeList bindVariableList;
0180 bindVariableList.extend("runnumber", typeid(unsigned int));
0181 bindVariableList["runnumber"].data<unsigned int>() = runnumber;
0182
0183 coral::IQuery* Queryalgoview = gtmonschemaHandle.newQuery();
0184 Queryalgoview->addToTableList(algoviewname);
0185 coral::AttributeList qalgoOutput;
0186 qalgoOutput.extend("COUNT_BX", typeid(unsigned int));
0187 qalgoOutput.extend("LUMI_SECTION", typeid(unsigned int));
0188 qalgoOutput.extend("SCALER_INDEX", typeid(unsigned int));
0189 Queryalgoview->addToOutputList("COUNT_BX");
0190 Queryalgoview->addToOutputList("LUMI_SECTION");
0191 Queryalgoview->addToOutputList("SCALER_INDEX");
0192 Queryalgoview->setCondition("RUN_NUMBER=:runnumber", bindVariableList);
0193 Queryalgoview->addToOrderList("LUMI_SECTION");
0194 Queryalgoview->addToOrderList("SCALER_INDEX");
0195 Queryalgoview->defineOutput(qalgoOutput);
0196 coral::ICursor& c = Queryalgoview->execute();
0197
0198 unsigned int s = 0;
0199 while (c.next()) {
0200 const coral::AttributeList& row = c.currentRow();
0201
0202 unsigned int lsnr = row["LUMI_SECTION"].data<unsigned int>();
0203 unsigned int count = row["COUNT_BX"].data<unsigned int>();
0204 unsigned int algobit = row["SCALER_INDEX"].data<unsigned int>();
0205 mybitcount_algo.push_back(count);
0206 if (algobit == (lumi::N_TRGALGOBIT - 1)) {
0207 ++s;
0208 while (s != lsnr) {
0209 std::cout << "ALGO COUNT alert: found hole in LS range " << s << std::endl;
0210 std::cout << " fill all algocount 0 for LS " << s << std::endl;
0211 std::vector<unsigned int> tmpzero(lumi::N_TRGALGOBIT, 0);
0212 algocount.push_back(tmpzero);
0213 ++s;
0214 }
0215 algocount.push_back(mybitcount_algo);
0216 mybitcount_algo.clear();
0217 }
0218 }
0219 if (s == 0) {
0220 c.close();
0221 delete Queryalgoview;
0222 transaction.commit();
0223 throw lumi::Exception(std::string("requested run ") + runnumberstr + std::string(" doesn't exist for algocounts"),
0224 "retrieveData",
0225 "TRGScalers2DB");
0226 }
0227 delete Queryalgoview;
0228
0229
0230
0231
0232
0233
0234 coral::IQuery* Querytechview = gtmonschemaHandle.newQuery();
0235 Querytechview->addToTableList(techviewname);
0236 coral::AttributeList qtechOutput;
0237 qtechOutput.extend("COUNT_BX", typeid(unsigned int));
0238 qtechOutput.extend("LUMI_SECTION", typeid(unsigned int));
0239 qtechOutput.extend("SCALER_INDEX", typeid(unsigned int));
0240 Querytechview->addToOutputList("COUNT_BX");
0241 Querytechview->addToOutputList("LUMI_SECTION");
0242 Querytechview->addToOutputList("SCALER_INDEX");
0243 Querytechview->setCondition("RUN_NUMBER=:runnumber", bindVariableList);
0244 Querytechview->addToOrderList("LUMI_SECTION");
0245 Querytechview->addToOrderList("SCALER_INDEX");
0246 Querytechview->defineOutput(qtechOutput);
0247 coral::ICursor& techcursor = Querytechview->execute();
0248 s = 0;
0249 while (techcursor.next()) {
0250 const coral::AttributeList& row = techcursor.currentRow();
0251
0252 unsigned int lsnr = row["LUMI_SECTION"].data<unsigned int>();
0253 unsigned int count = row["COUNT_BX"].data<unsigned int>();
0254 unsigned int techbit = row["SCALER_INDEX"].data<unsigned int>();
0255 mybitcount_tech.push_back(count);
0256 if (techbit == (lumi::N_TRGTECHBIT - 1)) {
0257 ++s;
0258 while (s != lsnr) {
0259 std::cout << "TECH COUNT alert: found hole in LS range " << s << std::endl;
0260 std::cout << " fill all techcount with 0 for LS " << s << std::endl;
0261 std::vector<unsigned int> tmpzero(lumi::N_TRGTECHBIT, 0);
0262 techcount.push_back(tmpzero);
0263 ++s;
0264 }
0265 techcount.push_back(mybitcount_tech);
0266 mybitcount_tech.clear();
0267 }
0268 }
0269 if (s == 0) {
0270 techcursor.close();
0271 delete Querytechview;
0272 transaction.commit();
0273 throw lumi::Exception(std::string("requested run ") + runnumberstr + std::string(" doesn't exist for techcounts"),
0274 "retrieveData",
0275 "TRGScalers2DB");
0276 }
0277 delete Querytechview;
0278
0279
0280
0281
0282
0283
0284 coral::IQuery* Querydeadview = gtmonschemaHandle.newQuery();
0285 Querydeadview->addToTableList(deadviewname);
0286 coral::AttributeList qdeadOutput;
0287 qdeadOutput.extend("FRACTION", typeid(float));
0288 qdeadOutput.extend("LUMI_SECTION", typeid(unsigned int));
0289 qdeadOutput.extend("COUNT_BX", typeid(unsigned int));
0290 Querydeadview->addToOutputList("FRACTION");
0291 Querydeadview->addToOutputList("LUMI_SECTION");
0292 Querydeadview->addToOutputList("COUNT_BX");
0293 coral::AttributeList bindVariablesDead;
0294 bindVariablesDead.extend("runnumber", typeid(int));
0295 bindVariablesDead.extend("scalername", typeid(std::string));
0296 bindVariablesDead["runnumber"].data<int>() = runnumber;
0297 bindVariablesDead["scalername"].data<std::string>() = std::string("DeadtimeBeamActive");
0298 Querydeadview->setCondition("RUN_NUMBER=:runnumber AND SCALER_NAME=:scalername", bindVariablesDead);
0299 Querydeadview->addToOrderList("LUMI_SECTION");
0300 Querydeadview->defineOutput(qdeadOutput);
0301 coral::ICursor& deadcursor = Querydeadview->execute();
0302 s = 0;
0303 while (deadcursor.next()) {
0304 const coral::AttributeList& row = deadcursor.currentRow();
0305
0306 ++s;
0307 unsigned int lsnr = row["LUMI_SECTION"].data<unsigned int>();
0308 float dfrac = 1.0;
0309 unsigned int count = 0;
0310 while (s != lsnr) {
0311 std::cout << "DEADTIME alert: found hole in LS range" << s << std::endl;
0312 std::cout << " fill deadtimefraction 0%, deadtimebeamactive 0 for LS " << s << std::endl;
0313 deadfracresult.push_back(dfrac);
0314 deadtimeresult.push_back(count);
0315 ++s;
0316 }
0317 if (!row["FRACTION"].isNull()) {
0318 dfrac = row["FRACTION"].data<float>();
0319 } else {
0320 std::cout << "DEADTIME fraction alert: undefined fraction , assume 100% , LS " << lsnr << std::endl;
0321 }
0322 if (dfrac > 1.0) {
0323 std::cout << "DEADTIME fraction alert: overflow dead fraction , force to 100% , LS " << lsnr << std::endl;
0324 dfrac = 1.0;
0325 }
0326 deadfracresult.push_back(dfrac);
0327 count = row["COUNT_BX"].data<unsigned int>();
0328 deadtimeresult.push_back(count);
0329 }
0330 if (s == 0) {
0331 deadcursor.close();
0332 delete Querydeadview;
0333 transaction.commit();
0334 throw lumi::Exception(std::string("requested run ") + runnumberstr + std::string(" doesn't exist for deadcounts"),
0335 "retrieveData",
0336 "TRGScalers2DB");
0337 return 0;
0338 }
0339 delete Querydeadview;
0340
0341
0342
0343
0344 std::vector<int> prescidx;
0345 coral::IQuery* allpsidxQuery = gtmonschemaHandle.newQuery();
0346 allpsidxQuery->addToTableList(lstablename);
0347 coral::AttributeList allpsidxOutput;
0348 allpsidxOutput.extend("psidx", typeid(int));
0349 allpsidxQuery->addToOutputList("distinct(PRESCALE_INDEX)", "psidx");
0350 coral::AttributeList bindVariablesAllpsidx;
0351 bindVariablesAllpsidx.extend("runnumber", typeid(int));
0352 bindVariablesAllpsidx["runnumber"].data<int>() = runnumber;
0353 allpsidxQuery->setCondition("RUN_NUMBER =:runnumber", bindVariablesAllpsidx);
0354 allpsidxQuery->defineOutput(allpsidxOutput);
0355 coral::ICursor& allpsidxCursor = allpsidxQuery->execute();
0356 while (allpsidxCursor.next()) {
0357 const coral::AttributeList& row = allpsidxCursor.currentRow();
0358 int psidx = row["psidx"].data<int>();
0359 prescidx.push_back(psidx);
0360 }
0361 delete allpsidxQuery;
0362 std::map<int, std::vector<unsigned int> > algoprescMap;
0363 std::map<int, std::vector<unsigned int> > techprescMap;
0364 std::vector<int>::iterator prescidxIt;
0365 std::vector<int>::iterator prescidxItBeg = prescidx.begin();
0366 std::vector<int>::iterator prescidxItEnd = prescidx.end();
0367 for (prescidxIt = prescidxItBeg; prescidxIt != prescidxItEnd; ++prescidxIt) {
0368 std::vector<unsigned int> algopres;
0369 algopres.reserve(lumi::N_TRGALGOBIT);
0370 std::vector<unsigned int> techpres;
0371 techpres.reserve(lumi::N_TRGTECHBIT);
0372 algoprescMap.insert(std::make_pair(*prescidxIt, algopres));
0373 techprescMap.insert(std::make_pair(*prescidxIt, techpres));
0374 }
0375
0376
0377
0378
0379 std::map<unsigned int, int> lsprescmap;
0380 coral::IQuery* lstoprescQuery = gtmonschemaHandle.newQuery();
0381 lstoprescQuery->addToTableList(lstablename);
0382 coral::AttributeList lstoprescOutput;
0383 lstoprescOutput.extend("lumisection", typeid(unsigned int));
0384 lstoprescOutput.extend("psidx", typeid(int));
0385 lstoprescQuery->addToOutputList("LUMI_SECTION", "lumisection");
0386 lstoprescQuery->addToOutputList("PRESCALE_INDEX", "psidx");
0387 coral::AttributeList bindVariablesLstopresc;
0388 bindVariablesLstopresc.extend("runnumber", typeid(int));
0389 bindVariablesLstopresc["runnumber"].data<int>() = runnumber;
0390 lstoprescQuery->setCondition("RUN_NUMBER =:runnumber", bindVariablesLstopresc);
0391 lstoprescQuery->defineOutput(lstoprescOutput);
0392 unsigned int lsprescount = 0;
0393 unsigned int lastpresc = 0;
0394 coral::ICursor& lstoprescCursor = lstoprescQuery->execute();
0395 while (lstoprescCursor.next()) {
0396 ++lsprescount;
0397 const coral::AttributeList& row = lstoprescCursor.currentRow();
0398 unsigned int lumisection = row["lumisection"].data<unsigned int>();
0399 while (lsprescount != lumisection) {
0400 std::cout << "PRESCALE_INDEX COUNT alert: found hole in LS range " << lsprescount << std::endl;
0401 std::cout << " fill this prescale from last availabl prescale " << lastpresc << std::endl;
0402 unsigned int guesspsidx = lastpresc;
0403 lsprescmap.insert(std::make_pair(lsprescount, guesspsidx));
0404 ++lsprescount;
0405 }
0406 int psidx = row["psidx"].data<int>();
0407 lsprescmap.insert(std::make_pair(lumisection, psidx));
0408 lastpresc = psidx;
0409 }
0410 if (lsprescount == 0) {
0411 lstoprescCursor.close();
0412 delete lstoprescQuery;
0413 transaction.commit();
0414 throw lumi::Exception(
0415 std::string("requested run ") + runnumberstr + std::string(" doesn't exist for prescale_index"),
0416 "retrieveData",
0417 "TRG2DB");
0418 }
0419 delete lstoprescQuery;
0420
0421 for (prescidxIt = prescidxItBeg; prescidxIt != prescidxItEnd; ++prescidxIt) {
0422 std::vector<unsigned int> algopres;
0423 algopres.reserve(lumi::N_TRGALGOBIT);
0424 std::vector<unsigned int> techpres;
0425 techpres.reserve(lumi::N_TRGTECHBIT);
0426 algoprescMap.insert(std::make_pair(*prescidxIt, algopres));
0427 techprescMap.insert(std::make_pair(*prescidxIt, techpres));
0428 }
0429
0430
0431
0432
0433
0434
0435 coral::ISchema& gtschemaHandle = trgsession->schema(gtschema);
0436 if (!gtschemaHandle.existsView(runtechviewname)) {
0437 throw lumi::Exception(std::string("non-existing view ") + runtechviewname, "str2int", "TRG2DB");
0438 }
0439 if (!gtschemaHandle.existsView(runalgoviewname)) {
0440 throw lumi::Exception(std::string("non-existing view ") + runalgoviewname, "str2int", "TRG2DB");
0441 }
0442 if (!gtschemaHandle.existsView(runprescalgoviewname)) {
0443 throw lumi::Exception(std::string("non-existing view ") + runprescalgoviewname, "str2int", "TRG2DB");
0444 }
0445 if (!gtschemaHandle.existsView(runpresctechviewname)) {
0446 throw lumi::Exception(std::string("non-existing view ") + runpresctechviewname, "str2int", "TRG2DB");
0447 }
0448
0449
0450
0451 std::map<unsigned int, std::string> triggernamemap;
0452 coral::IQuery* QueryName = gtschemaHandle.newQuery();
0453 QueryName->addToTableList(runalgoviewname);
0454 coral::AttributeList qAlgoNameOutput;
0455 qAlgoNameOutput.extend("ALGO_INDEX", typeid(unsigned int));
0456 qAlgoNameOutput.extend("ALIAS", typeid(std::string));
0457 QueryName->addToOutputList("ALGO_INDEX");
0458 QueryName->addToOutputList("ALIAS");
0459 QueryName->setCondition("RUNNUMBER=:runnumber", bindVariableList);
0460
0461 QueryName->defineOutput(qAlgoNameOutput);
0462 coral::ICursor& algonamecursor = QueryName->execute();
0463 while (algonamecursor.next()) {
0464 const coral::AttributeList& row = algonamecursor.currentRow();
0465
0466 unsigned int algo_index = row["ALGO_INDEX"].data<unsigned int>();
0467 std::string algo_name = row["ALIAS"].data<std::string>();
0468 triggernamemap.insert(std::make_pair(algo_index, algo_name));
0469 }
0470 delete QueryName;
0471
0472
0473
0474
0475 std::map<unsigned int, std::string> techtriggernamemap;
0476 coral::IQuery* QueryTechName = gtschemaHandle.newQuery();
0477 QueryTechName->addToTableList(runtechviewname);
0478 coral::AttributeList qTechNameOutput;
0479 qTechNameOutput.extend("TECHTRIG_INDEX", typeid(unsigned int));
0480 qTechNameOutput.extend("NAME", typeid(std::string));
0481 QueryTechName->addToOutputList("TECHTRIG_INDEX");
0482 QueryTechName->addToOutputList("NAME");
0483 QueryTechName->setCondition("RUNNUMBER=:runnumber", bindVariableList);
0484
0485 QueryTechName->defineOutput(qTechNameOutput);
0486 coral::ICursor& technamecursor = QueryTechName->execute();
0487 while (technamecursor.next()) {
0488 const coral::AttributeList& row = technamecursor.currentRow();
0489
0490 unsigned int tech_index = row["TECHTRIG_INDEX"].data<unsigned int>();
0491 std::string tech_name = row["NAME"].data<std::string>();
0492 techtriggernamemap.insert(std::make_pair(tech_index, tech_name));
0493 }
0494 delete QueryTechName;
0495
0496
0497
0498
0499
0500
0501 std::vector<int>::iterator presIt;
0502 std::vector<int>::iterator presItBeg = prescidx.begin();
0503 std::vector<int>::iterator presItEnd = prescidx.end();
0504 for (presIt = presItBeg; presIt != presItEnd; ++presIt) {
0505 coral::IQuery* QueryAlgoPresc = gtschemaHandle.newQuery();
0506 QueryAlgoPresc->addToTableList(runprescalgoviewname);
0507 coral::AttributeList qAlgoPrescOutput;
0508 std::string algoprescBase("PRESCALE_FACTOR_ALGO_");
0509 for (unsigned int bitidx = 0; bitidx < lumi::N_TRGALGOBIT; ++bitidx) {
0510 std::string algopresc = algoprescBase + int2str(bitidx, 3);
0511 qAlgoPrescOutput.extend(algopresc, typeid(unsigned int));
0512 }
0513 for (unsigned int bitidx = 0; bitidx < lumi::N_TRGALGOBIT; ++bitidx) {
0514 std::string algopresc = algoprescBase + int2str(bitidx, 3);
0515 QueryAlgoPresc->addToOutputList(algopresc);
0516 }
0517 coral::AttributeList PrescbindVariable;
0518 PrescbindVariable.extend("runnumber", typeid(int));
0519 PrescbindVariable.extend("prescaleindex", typeid(int));
0520 PrescbindVariable["runnumber"].data<int>() = runnumber;
0521 PrescbindVariable["prescaleindex"].data<int>() = *presIt;
0522 QueryAlgoPresc->setCondition("RUNNR=:runnumber AND PRESCALE_INDEX=:prescaleindex", PrescbindVariable);
0523 QueryAlgoPresc->defineOutput(qAlgoPrescOutput);
0524 coral::ICursor& algopresccursor = QueryAlgoPresc->execute();
0525 while (algopresccursor.next()) {
0526 const coral::AttributeList& row = algopresccursor.currentRow();
0527 for (unsigned int bitidx = 0; bitidx < lumi::N_TRGALGOBIT; ++bitidx) {
0528 std::string algopresc = algoprescBase + int2str(bitidx, 3);
0529 algoprescMap[*presIt].push_back(row[algopresc].data<unsigned int>());
0530 }
0531 }
0532 delete QueryAlgoPresc;
0533 }
0534
0535
0536
0537 for (presIt = presItBeg; presIt != presItEnd; ++presIt) {
0538 coral::IQuery* QueryTechPresc = gtschemaHandle.newQuery();
0539 QueryTechPresc->addToTableList(runpresctechviewname);
0540 coral::AttributeList qTechPrescOutput;
0541 std::string techprescBase("PRESCALE_FACTOR_TT_");
0542 for (unsigned int bitidx = 0; bitidx < lumi::N_TRGTECHBIT; ++bitidx) {
0543 std::string techpresc = techprescBase + this->int2str(bitidx, 3);
0544 qTechPrescOutput.extend(techpresc, typeid(unsigned int));
0545 }
0546 for (unsigned int bitidx = 0; bitidx < lumi::N_TRGTECHBIT; ++bitidx) {
0547 std::string techpresc = techprescBase + int2str(bitidx, 3);
0548 QueryTechPresc->addToOutputList(techpresc);
0549 }
0550 coral::AttributeList TechPrescbindVariable;
0551 TechPrescbindVariable.extend("runnumber", typeid(int));
0552 TechPrescbindVariable.extend("prescaleindex", typeid(int));
0553 TechPrescbindVariable["runnumber"].data<int>() = runnumber;
0554 TechPrescbindVariable["prescaleindex"].data<int>() = *presIt;
0555 QueryTechPresc->setCondition("RUNNR=:runnumber AND PRESCALE_INDEX=:prescaleindex", TechPrescbindVariable);
0556 QueryTechPresc->defineOutput(qTechPrescOutput);
0557 coral::ICursor& techpresccursor = QueryTechPresc->execute();
0558 while (techpresccursor.next()) {
0559 const coral::AttributeList& row = techpresccursor.currentRow();
0560
0561 for (unsigned int bitidx = 0; bitidx < lumi::N_TRGTECHBIT; ++bitidx) {
0562 std::string techpresc = techprescBase + int2str(bitidx, 3);
0563 techprescMap[*presIt].push_back(row[techpresc].data<unsigned int>());
0564 }
0565 }
0566 delete QueryTechPresc;
0567 }
0568 transaction.commit();
0569 delete trgsession;
0570
0571 std::map<unsigned int, int>::iterator lsprescmapIt;
0572 std::map<unsigned int, int>::iterator lsprescmapItBeg = lsprescmap.begin();
0573 std::map<unsigned int, int>::iterator lsprescmapItEnd = lsprescmap.end();
0574 for (lsprescmapIt = lsprescmapItBeg; lsprescmapIt != lsprescmapItEnd; ++lsprescmapIt) {
0575 unsigned int ls = lsprescmapIt->first;
0576 int preidx = lsprescmapIt->second;
0577 algoprescale.insert(std::make_pair(ls, algoprescMap[preidx]));
0578 techprescale.insert(std::make_pair(ls, techprescMap[preidx]));
0579 }
0580 algoprescMap.clear();
0581 techprescMap.clear();
0582
0583
0584
0585 for (size_t algoidx = 0; algoidx < lumi::N_TRGALGOBIT; ++algoidx) {
0586 std::map<unsigned int, std::string>::iterator pos = triggernamemap.find(algoidx);
0587 if (pos != triggernamemap.end()) {
0588 algonames.push_back(pos->second);
0589 } else {
0590 algonames.push_back("False");
0591 }
0592 }
0593
0594
0595
0596 std::stringstream ss;
0597 for (size_t techidx = 0; techidx < lumi::N_TRGTECHBIT; ++techidx) {
0598 ss << techidx;
0599 technames.push_back(ss.str());
0600 ss.str("");
0601 }
0602
0603
0604
0605 if (algonames.size() != lumi::N_TRGALGOBIT || technames.size() != lumi::N_TRGTECHBIT) {
0606 throw lumi::Exception("wrong number of bits", "retrieveData", "TRG2DB");
0607 }
0608
0609
0610
0611 if (deadtimeresult.size() != deadfracresult.size() || deadtimeresult.size() != algocount.size() ||
0612 deadtimeresult.size() != techcount.size() || deadtimeresult.size() != algoprescale.size() ||
0613 deadtimeresult.size() != techprescale.size()) {
0614
0615 std::cout
0616 << "[WARNING] inconsistent number of LS of deadtimecounter,deadfrac,algo,tech,prescalealgo,prescaletech "
0617 << deadtimeresult.size() << " " << deadfracresult.size() << " " << algocount.size() << " " << techcount.size()
0618 << " " << algoprescale.size() << " " << techprescale.size() << std::endl;
0619 TRGScalers2DB::TriggerDeadCountResult::iterator dIt;
0620 TRGScalers2DB::TriggerDeadCountResult::iterator dBeg = deadtimeresult.begin();
0621 TRGScalers2DB::TriggerDeadCountResult::iterator dEnd = deadtimeresult.end();
0622 unsigned int dcnt = 0;
0623 for (dIt = dBeg; dIt != dEnd; ++dIt) {
0624 try {
0625 deadfracresult.at(dcnt);
0626 } catch (std::out_of_range& er) {
0627 std::cout << "[WARNING] filling FAKE deadfrac=0.0 at LS " << dcnt << std::endl;
0628 deadfracresult[dcnt] = 0.0;
0629 }
0630 try {
0631 algocount.at(dcnt);
0632 } catch (std::out_of_range& er) {
0633 std::vector<unsigned int> tmpzero(lumi::N_TRGALGOBIT, 0);
0634 std::cout << "[WARNING] filling FAKE algocount at LS " << dcnt << std::endl;
0635 algocount[dcnt] = tmpzero;
0636 }
0637 try {
0638 techcount.at(dcnt);
0639 } catch (std::out_of_range& er) {
0640 std::vector<unsigned int> tmpzero(lumi::N_TRGTECHBIT, 0);
0641 std::cout << "[WARNING] filling FAKE techcount at LS " << dcnt << std::endl;
0642 techcount[dcnt] = tmpzero;
0643 }
0644 if (algoprescale.find(dcnt + 1) == algoprescale.end()) {
0645 std::vector<unsigned int> tmpzero(lumi::N_TRGALGOBIT, 1);
0646 std::cout << "[WARNING] filling FAKE 1 algoprescale at LS " << dcnt + 1 << std::endl;
0647 algoprescale[dcnt + 1] = tmpzero;
0648 }
0649 if (techprescale.find(dcnt + 1) == techprescale.end()) {
0650 std::vector<unsigned int> tmpzero(lumi::N_TRGTECHBIT, 1);
0651 std::cout << "[WARNING] filling FAKE 1 techprescale at LS " << dcnt + 1 << std::endl;
0652 techprescale[dcnt + 1] = tmpzero;
0653 }
0654 ++dcnt;
0655 }
0656 }
0657
0658
0659
0660 unsigned long long trgdataid = 0;
0661 coral::ISessionProxy* lumisession = svc->connect(m_dest, coral::Update);
0662 coral::ITypeConverter& lumitpc = lumisession->typeConverter();
0663 lumitpc.setCppTypeForSqlType("unsigned int", "NUMBER(7)");
0664 lumitpc.setCppTypeForSqlType("unsigned int", "NUMBER(10)");
0665 lumitpc.setCppTypeForSqlType("unsigned long long", "NUMBER(20)");
0666 try {
0667 if (m_mode == "loadoldschema") {
0668 std::cout << "writing trg data to old trg table " << std::endl;
0669 writeTrgData(lumisession,
0670 runnumber,
0671 m_source,
0672 deadtimeresult.begin(),
0673 deadtimeresult.end(),
0674 deadfracresult,
0675 algonames,
0676 technames,
0677 algocount,
0678 techcount,
0679 algoprescale,
0680 techprescale,
0681 COMMITLSINTERVAL);
0682 std::cout << "done" << std::endl;
0683 }
0684 std::cout << "writing trg data to new lstrg table " << std::endl;
0685 trgdataid = writeTrgDataToSchema2(lumisession,
0686 runnumber,
0687 m_source,
0688 deadtimeresult.begin(),
0689 deadtimeresult.end(),
0690 deadfracresult,
0691 algonames,
0692 technames,
0693 algocount,
0694 techcount,
0695 algoprescale,
0696 techprescale,
0697 COMMITLSTRGINTERVAL);
0698 std::cout << "done" << std::endl;
0699 delete lumisession;
0700 delete svc;
0701 } catch (const coral::Exception& er) {
0702 std::cout << "database error " << er.what() << std::endl;
0703 lumisession->transaction().rollback();
0704 delete lumisession;
0705 delete svc;
0706 throw er;
0707 }
0708 return trgdataid;
0709 }
0710 void TRGScalers2DB::writeTrgData(coral::ISessionProxy* lumisession,
0711 unsigned int runnumber,
0712 const std::string& source,
0713 TRGScalers2DB::TriggerDeadCountResult::iterator deadtimesBeg,
0714 TRGScalers2DB::TriggerDeadCountResult::iterator deadtimesEnd,
0715 TRGScalers2DB::TriggerDeadFracResult& deadfracs,
0716 TRGScalers2DB::TriggerNameResult_Algo& algonames,
0717 TRGScalers2DB::TriggerNameResult_Tech& technames,
0718 TRGScalers2DB::TriggerCountResult_Algo& algocounts,
0719 TRGScalers2DB::TriggerCountResult_Tech& techcounts,
0720 TRGScalers2DB::PrescaleResult_Algo& prescalealgo,
0721 TRGScalers2DB::PrescaleResult_Tech& prescaletech,
0722 unsigned int commitintv) {
0723 TRGScalers2DB::TriggerDeadCountResult::iterator deadIt;
0724
0725 unsigned int totalcmsls = std::distance(deadtimesBeg, deadtimesEnd);
0726 std::cout << "inserting totalcmsls " << totalcmsls << std::endl;
0727 std::map<unsigned long long, std::vector<unsigned long long> > idallocationtable;
0728 std::cout << "\t allocating total ids " << totalcmsls * lumi::N_TRGBIT << std::endl;
0729 lumisession->transaction().start(false);
0730 lumi::idDealer idg(lumisession->nominalSchema());
0731 unsigned long long trgID = idg.generateNextIDForTable(LumiNames::trgTableName(), totalcmsls * lumi::N_TRGBIT) -
0732 totalcmsls * lumi::N_TRGBIT;
0733
0734 unsigned int trglscount = 0;
0735 for (deadIt = deadtimesBeg; deadIt != deadtimesEnd; ++deadIt, ++trglscount) {
0736 std::vector<unsigned long long> bitvec;
0737 bitvec.reserve(lumi::N_TRGBIT);
0738 const BITCOUNT& algoinbits = algocounts[trglscount];
0739 const BITCOUNT& techinbits = techcounts[trglscount];
0740 BITCOUNT::const_iterator algoBitIt;
0741 BITCOUNT::const_iterator algoBitBeg = algoinbits.begin();
0742 BITCOUNT::const_iterator algoBitEnd = algoinbits.end();
0743 for (algoBitIt = algoBitBeg; algoBitIt != algoBitEnd; ++algoBitIt, ++trgID) {
0744 bitvec.push_back(trgID);
0745 }
0746 BITCOUNT::const_iterator techBitIt;
0747 BITCOUNT::const_iterator techBitBeg = techinbits.begin();
0748 BITCOUNT::const_iterator techBitEnd = techinbits.end();
0749 for (techBitIt = techBitBeg; techBitIt != techBitEnd; ++techBitIt, ++trgID) {
0750 bitvec.push_back(trgID);
0751 }
0752 idallocationtable.insert(std::make_pair(trglscount, bitvec));
0753 }
0754 std::cout << "\t all ids allocated" << std::endl;
0755 coral::AttributeList trgData;
0756 trgData.extend<unsigned long long>("TRG_ID");
0757 trgData.extend<unsigned int>("RUNNUM");
0758 trgData.extend<unsigned int>("CMSLSNUM");
0759 trgData.extend<unsigned int>("BITNUM");
0760 trgData.extend<std::string>("BITNAME");
0761 trgData.extend<unsigned int>("TRGCOUNT");
0762 trgData.extend<unsigned long long>("DEADTIME");
0763 trgData.extend<float>("DEADFRAC");
0764 trgData.extend<unsigned int>("PRESCALE");
0765
0766 unsigned long long& trg_id = trgData["TRG_ID"].data<unsigned long long>();
0767 unsigned int& trgrunnum = trgData["RUNNUM"].data<unsigned int>();
0768 unsigned int& cmslsnum = trgData["CMSLSNUM"].data<unsigned int>();
0769 unsigned int& bitnum = trgData["BITNUM"].data<unsigned int>();
0770 std::string& bitname = trgData["BITNAME"].data<std::string>();
0771 unsigned int& count = trgData["TRGCOUNT"].data<unsigned int>();
0772 unsigned long long& deadtime = trgData["DEADTIME"].data<unsigned long long>();
0773 float& deadfrac = trgData["DEADFRAC"].data<float>();
0774 unsigned int& prescale = trgData["PRESCALE"].data<unsigned int>();
0775
0776 trglscount = 0;
0777 coral::IBulkOperation* trgInserter = nullptr;
0778 unsigned int comittedls = 0;
0779 for (deadIt = deadtimesBeg; deadIt != deadtimesEnd; ++deadIt, ++trglscount) {
0780 unsigned int cmslscount = trglscount + 1;
0781 float dfra = deadfracs[trglscount];
0782 const BITCOUNT& algoinbits = algocounts[trglscount];
0783 const BITCOUNT& techinbits = techcounts[trglscount];
0784 unsigned int trgbitcount = 0;
0785 BITCOUNT::const_iterator algoBitIt;
0786 BITCOUNT::const_iterator algoBitBeg = algoinbits.begin();
0787 BITCOUNT::const_iterator algoBitEnd = algoinbits.end();
0788 if (!lumisession->transaction().isActive()) {
0789 lumisession->transaction().start(false);
0790 coral::ITable& trgtable = lumisession->nominalSchema().tableHandle(LumiNames::trgTableName());
0791 trgInserter = trgtable.dataEditor().bulkInsert(trgData, 2048);
0792 } else {
0793 if (deadIt == deadtimesBeg) {
0794 coral::ITable& trgtable = lumisession->nominalSchema().tableHandle(LumiNames::trgTableName());
0795 trgInserter = trgtable.dataEditor().bulkInsert(trgData, 2048);
0796 }
0797 }
0798 for (algoBitIt = algoBitBeg; algoBitIt != algoBitEnd; ++algoBitIt, ++trgbitcount) {
0799 trg_id = idallocationtable[trglscount].at(trgbitcount);
0800 deadtime = *deadIt;
0801 deadfrac = dfra;
0802 trgrunnum = runnumber;
0803 cmslsnum = cmslscount;
0804 bitnum = trgbitcount;
0805 bitname = algonames[trgbitcount];
0806 count = *algoBitIt;
0807 prescale = prescalealgo[cmslscount].at(trgbitcount);
0808
0809 trgInserter->processNextIteration();
0810 }
0811 BITCOUNT::const_iterator techBitIt;
0812 BITCOUNT::const_iterator techBitBeg = techinbits.begin();
0813 BITCOUNT::const_iterator techBitEnd = techinbits.end();
0814 for (techBitIt = techBitBeg; techBitIt != techBitEnd; ++techBitIt, ++trgbitcount) {
0815 trg_id = idallocationtable[trglscount].at(trgbitcount);
0816 deadtime = *deadIt;
0817 deadfrac = dfra;
0818 trgrunnum = runnumber;
0819 cmslsnum = cmslscount;
0820 bitnum = trgbitcount;
0821 bitname = technames[trgbitcount - lumi::N_TRGALGOBIT];
0822 count = *techBitIt;
0823 prescale = prescaletech[cmslsnum][trgbitcount - lumi::N_TRGALGOBIT];
0824 trgInserter->processNextIteration();
0825 }
0826 trgInserter->flush();
0827 ++comittedls;
0828 if (comittedls == commitintv) {
0829 std::cout << "\t committing in LS chunck " << comittedls << std::endl;
0830 delete trgInserter;
0831 trgInserter = nullptr;
0832 lumisession->transaction().commit();
0833 comittedls = 0;
0834 std::cout << "\t committed " << std::endl;
0835 } else if (trglscount == (totalcmsls - 1)) {
0836 std::cout << "\t committing at the end" << std::endl;
0837 delete trgInserter;
0838 trgInserter = nullptr;
0839 lumisession->transaction().commit();
0840 std::cout << "\t done" << std::endl;
0841 }
0842 }
0843 }
0844 unsigned long long TRGScalers2DB::writeTrgDataToSchema2(coral::ISessionProxy* lumisession,
0845 unsigned int irunnumber,
0846 const std::string& source,
0847 TriggerDeadCountResult::iterator deadtimesBeg,
0848 TriggerDeadCountResult::iterator deadtimesEnd,
0849 TRGScalers2DB::TriggerDeadFracResult& deadfracs,
0850 TRGScalers2DB::TriggerNameResult_Algo& algonames,
0851 TRGScalers2DB::TriggerNameResult_Tech& technames,
0852 TRGScalers2DB::TriggerCountResult_Algo& algocounts,
0853 TRGScalers2DB::TriggerCountResult_Tech& techcounts,
0854 TRGScalers2DB::PrescaleResult_Algo& prescalealgo,
0855 TRGScalers2DB::PrescaleResult_Tech& prescaletech,
0856 unsigned int commitintv) {
0857 TRGScalers2DB::TriggerDeadCountResult::iterator deadIt;
0858 unsigned int totalcmsls = std::distance(deadtimesBeg, deadtimesEnd);
0859 std::cout << "inserting totalcmsls " << totalcmsls << std::endl;
0860 coral::AttributeList lstrgData;
0861 lstrgData.extend<unsigned long long>("DATA_ID");
0862 lstrgData.extend<unsigned int>("RUNNUM");
0863 lstrgData.extend<unsigned int>("CMSLSNUM");
0864 lstrgData.extend<unsigned long long>("DEADTIMECOUNT");
0865 lstrgData.extend<unsigned int>("BITZEROCOUNT");
0866 lstrgData.extend<unsigned int>("BITZEROPRESCALE");
0867 lstrgData.extend<float>("DEADFRAC");
0868 lstrgData.extend<coral::Blob>("PRESCALEBLOB");
0869 lstrgData.extend<coral::Blob>("TRGCOUNTBLOB");
0870
0871 unsigned long long& data_id = lstrgData["DATA_ID"].data<unsigned long long>();
0872 unsigned int& trgrunnum = lstrgData["RUNNUM"].data<unsigned int>();
0873 unsigned int& cmslsnum = lstrgData["CMSLSNUM"].data<unsigned int>();
0874 unsigned long long& deadtime = lstrgData["DEADTIMECOUNT"].data<unsigned long long>();
0875 unsigned int& bitzerocount = lstrgData["BITZEROCOUNT"].data<unsigned int>();
0876 unsigned int& bitzeroprescale = lstrgData["BITZEROPRESCALE"].data<unsigned int>();
0877 float& deadfrac = lstrgData["DEADFRAC"].data<float>();
0878 coral::Blob& prescaleblob = lstrgData["PRESCALEBLOB"].data<coral::Blob>();
0879 coral::Blob& trgcountblob = lstrgData["TRGCOUNTBLOB"].data<coral::Blob>();
0880
0881 unsigned long long branch_id = 3;
0882 std::string branch_name("DATA");
0883 lumi::RevisionDML revisionDML;
0884 lumi::RevisionDML::TrgEntry trgrundata;
0885 std::stringstream op;
0886 op << irunnumber;
0887 std::string runnumberStr = op.str();
0888 lumisession->transaction().start(false);
0889 trgrundata.entry_name = runnumberStr;
0890 trgrundata.source = source;
0891 trgrundata.runnumber = irunnumber;
0892 std::string bitnames;
0893 TriggerNameResult_Algo::iterator bitnameIt;
0894 TriggerNameResult_Algo::iterator bitnameItBeg = algonames.begin();
0895 TriggerNameResult_Algo::iterator bitnameItEnd = algonames.end();
0896 for (bitnameIt = bitnameItBeg; bitnameIt != bitnameItEnd; ++bitnameIt) {
0897 if (bitnameIt != bitnameItBeg) {
0898 bitnames += std::string(",");
0899 }
0900 bitnames += *bitnameIt;
0901 }
0902 TriggerNameResult_Tech::iterator techbitnameIt;
0903 TriggerNameResult_Tech::iterator techbitnameItBeg = technames.begin();
0904 TriggerNameResult_Tech::iterator techbitnameItEnd = technames.end();
0905 for (techbitnameIt = techbitnameItBeg; techbitnameIt != techbitnameItEnd; ++techbitnameIt) {
0906 bitnames += std::string(",");
0907 bitnames += *techbitnameIt;
0908 }
0909 std::cout << "\tbitnames " << bitnames << std::endl;
0910 trgrundata.bitzeroname = technames[4];
0911 trgrundata.bitnames = bitnames;
0912 trgrundata.entry_id = revisionDML.getEntryInBranchByName(
0913 lumisession->nominalSchema(), lumi::LumiNames::trgdataTableName(), runnumberStr, branch_name);
0914 if (trgrundata.entry_id == 0) {
0915 revisionDML.bookNewEntry(lumisession->nominalSchema(), LumiNames::trgdataTableName(), trgrundata);
0916 std::cout << "trgrundata revision_id " << trgrundata.revision_id << " entry_id " << trgrundata.entry_id
0917 << " data_id " << trgrundata.data_id << std::endl;
0918 revisionDML.addEntry(
0919 lumisession->nominalSchema(), LumiNames::trgdataTableName(), trgrundata, branch_id, branch_name);
0920 } else {
0921 revisionDML.bookNewRevision(lumisession->nominalSchema(), LumiNames::trgdataTableName(), trgrundata);
0922 std::cout << "trgrundata revision_id " << trgrundata.revision_id << " entry_id " << trgrundata.entry_id
0923 << " data_id " << trgrundata.data_id << std::endl;
0924 revisionDML.addRevision(
0925 lumisession->nominalSchema(), LumiNames::trgdataTableName(), trgrundata, branch_id, branch_name);
0926 }
0927 std::cout << "inserting trgrundata " << std::endl;
0928 revisionDML.insertTrgRunData(lumisession->nominalSchema(), trgrundata);
0929 std::cout << "inserting lstrg data" << std::endl;
0930
0931 unsigned int trglscount = 0;
0932
0933 coral::IBulkOperation* lstrgInserter = nullptr;
0934 unsigned int comittedls = 0;
0935 for (deadIt = deadtimesBeg; deadIt != deadtimesEnd; ++deadIt, ++trglscount) {
0936 unsigned int cmslscount = trglscount + 1;
0937 if (!lumisession->transaction().isActive()) {
0938 lumisession->transaction().start(false);
0939 coral::ITable& lstrgtable = lumisession->nominalSchema().tableHandle(LumiNames::lstrgTableName());
0940 lstrgInserter = lstrgtable.dataEditor().bulkInsert(lstrgData, 2048);
0941 } else {
0942 if (deadIt == deadtimesBeg) {
0943 coral::ITable& lstrgtable = lumisession->nominalSchema().tableHandle(LumiNames::lstrgTableName());
0944 lstrgInserter = lstrgtable.dataEditor().bulkInsert(lstrgData, 2048);
0945 }
0946 }
0947 data_id = trgrundata.data_id;
0948 trgrunnum = irunnumber;
0949 cmslsnum = cmslscount;
0950 deadtime = *deadIt;
0951 deadfrac = deadfracs[trglscount];
0952
0953
0954 bitzerocount = techcounts[trglscount][4];
0955 bitzeroprescale = prescaletech[cmslsnum][4];
0956 std::vector<unsigned int> fullprescales;
0957 fullprescales.reserve(prescalealgo[cmslsnum].size() + prescaletech[cmslsnum].size());
0958 fullprescales.insert(fullprescales.end(), prescalealgo[cmslsnum].begin(), prescalealgo[cmslsnum].end());
0959 fullprescales.insert(fullprescales.end(), prescaletech[cmslsnum].begin(), prescaletech[cmslsnum].end());
0960
0961 prescaleblob.resize(sizeof(unsigned int) * (fullprescales.size()));
0962 void* prescaleblob_StartAddress = prescaleblob.startingAddress();
0963 std::memmove(prescaleblob_StartAddress, &fullprescales[0], sizeof(unsigned int) * (fullprescales.size()));
0964
0965 std::vector<unsigned int> fullcounts;
0966 fullcounts.reserve(algocounts[trglscount].size() + techcounts[trglscount].size());
0967 fullcounts.insert(fullcounts.end(), algocounts[trglscount].begin(), algocounts[trglscount].end());
0968 fullcounts.insert(fullcounts.end(), techcounts[trglscount].begin(), techcounts[trglscount].end());
0969 trgcountblob.resize(sizeof(unsigned int) * (fullcounts.size()));
0970 void* trgcountblob_StartAddress = trgcountblob.startingAddress();
0971 std::memmove(trgcountblob_StartAddress, &fullcounts[0], sizeof(unsigned int) * (fullcounts.size()));
0972
0973 lstrgInserter->processNextIteration();
0974 lstrgInserter->flush();
0975 ++comittedls;
0976 if (comittedls == commitintv) {
0977 std::cout << "\t committing in LS chunck " << comittedls << std::endl;
0978 delete lstrgInserter;
0979 lstrgInserter = nullptr;
0980 lumisession->transaction().commit();
0981 comittedls = 0;
0982 std::cout << "\t committed " << std::endl;
0983 } else if (trglscount == (totalcmsls - 1)) {
0984 std::cout << "\t committing at the end" << std::endl;
0985 delete lstrgInserter;
0986 lstrgInserter = nullptr;
0987 lumisession->transaction().commit();
0988 std::cout << "\t done" << std::endl;
0989 }
0990 }
0991
0992 return trgrundata.data_id;
0993 }
0994 const std::string TRGScalers2DB::dataType() const { return "TRG"; }
0995 const std::string TRGScalers2DB::sourceType() const { return "DB"; }
0996
0997 std::string TRGScalers2DB::int2str(unsigned int t, unsigned int width) {
0998 std::stringstream ss;
0999 ss.width(width);
1000 ss.fill('0');
1001 ss << t;
1002 return ss.str();
1003 }
1004 unsigned int TRGScalers2DB::str2int(const std::string& s) {
1005 std::istringstream myStream(s);
1006 unsigned int i;
1007 if (myStream >> i) {
1008 return i;
1009 } else {
1010 throw lumi::Exception(std::string("str2int error"), "str2int", "TRGScalers2DB");
1011 }
1012 }
1013 TRGScalers2DB::~TRGScalers2DB() {}
1014 }
1015 #include "RecoLuminosity/LumiProducer/interface/DataPipeFactory.h"
1016 DEFINE_EDM_PLUGIN(lumi::DataPipeFactory, lumi::TRGScalers2DB, "TRGScalers2DB");
1017 #endif