ATLAS Offline Software
Loading...
Searching...
No Matches
CalibRtDbOperations.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
3*/
4
5#include "MuonCalibDbOperations/CalibRtDbOperations.h"
6
7#include "AthenaKernel/getMessageSvc.h"
8#include "CoralBase/Attribute.h"
9#include "CoralBase/AttributeList.h"
10#include "CoralBase/AttributeSpecification.h"
11#include "CoralKernel/Context.h"
12#include "GaudiKernel/MsgStream.h"
13#include "MdtCalibData/RtFullInfo.h"
14#include "MuonCalibDbOperations/CalibDbConnection.h"
15#include "MuonCalibDbOperations/IConditionsStorage.h"
16#include "MuonCalibMath/SamplePoint.h"
17#include "MuonCalibStandAloneBase/MdtStationT0Container.h"
18#include "MuonCalibStandAloneBase/NtupleStationId.h"
19#include "RelationalAccess/IAuthenticationCredentials.h"
20#include "RelationalAccess/IAuthenticationService.h"
21#include "RelationalAccess/IBulkOperation.h"
22#include "RelationalAccess/ICursor.h"
23#include "RelationalAccess/IQuery.h"
24#include "RelationalAccess/IRelationalDomain.h"
25#include "RelationalAccess/IRelationalService.h"
26#include "RelationalAccess/ISchema.h"
27#include "RelationalAccess/ITable.h"
28#include "RelationalAccess/ITableDataEditor.h"
29#include "RelationalAccess/ITransaction.h"
30#include "RelationalAccess/SchemaException.h"
31#include "cmath"
32#include "sstream"
33#include "string"
34
35namespace MuonCalib {
36
41
42 bool CalibRtDbOperations::LoadRt(const NtupleStationId& id, int head_id, bool validated, const std::string& /*site_name*/,
43 std::vector<SamplePoint>& points, RtFullInfo* full_info) {
44 m_head_id = head_id;
45 m_region_id = id.FixedId();
46 try {
47 points.clear();
48 m_db_conn.OpenTransaction();
49 m_rt_id = -1;
50 if (!getRtId(validated, full_info)) {
51 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
52 log << MSG::WARNING << "Header query failed!" << endmsg;
53 m_db_conn.Rollback();
54 return false;
55 }
56 if (m_rt_id < 0) {
57 m_db_conn.Rollback();
58 return false;
59 }
60 if (!readRTS(points)) {
61 m_db_conn.Rollback();
62 return false;
63 }
64 return true;
65 } catch (coral::SchemaException& e) {
66 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
67 log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
68 return false;
69 }
70 }
71
72 bool CalibRtDbOperations::WriteUpdateRt(const NtupleStationId& id, int head_id, const std::string& /*site_name*/,
73 const std::vector<SamplePoint>& points, int validflag, const RtFullInfo* full_info) {
74 m_prev_algs = "";
75 m_head_id = head_id;
76 m_region_id = id.FixedId();
77 try {
78 m_db_conn.OpenTransaction();
79 if (!getRtId((validflag > 1), nullptr)) {
80 m_db_conn.Rollback();
81 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
82 log << MSG::WARNING << "Questing RT header failed!" << endmsg;
83 return false;
84 }
85 if (m_rt_id >= 0) {
86 if (!updateFullInfo(full_info, validflag, static_cast<int>(points.size()))) {
87 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
88 log << MSG::WARNING << "Failed update header" << endmsg;
89 m_db_conn.Rollback();
90 return false;
91 }
92 if (!updateRTSable(points)) {
93 m_db_conn.Rollback();
94 return false;
95 }
96
97 } else {
98 if (!insertFullInfo(full_info, validflag, static_cast<int>(points.size()))) {
99 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
100 log << MSG::WARNING << "Failed update header" << endmsg;
101 m_db_conn.Rollback();
102 return false;
103 }
104 if (!insertRTSable(points)) {
105 m_db_conn.Rollback();
106 return false;
107 }
108 }
109 m_db_conn.Commit();
110 return true;
111 } catch (coral::SchemaException& e) {
112 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
113 log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
114 m_db_conn.Rollback();
115 return false;
116 }
117 }
118
119 bool CalibRtDbOperations::SetValidflag(int validflag, bool commit) {
120 if (m_rt_id < 0) {
121 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
122 log << MSG::WARNING << "No current rt!" << endmsg;
123 return false;
124 }
125 try {
126 m_db_conn.OpenTransaction();
127 coral::ITableDataEditor& editor = m_db_conn.GetTableEditor("MDT_RT");
128 std::string updateAction = "VALIDFLAG=:val";
129 std::string updateCondition = "HEAD_ID=:hid and REGION_ID=:rid and CALIBFLAG=:rtid";
130 coral::AttributeList updateData;
131 updateData.extend<int>("val");
132 updateData[0].data<int>() = validflag;
133 updateData.extend<int>("rtid");
134 updateData["rtid"].data<int>() = m_rt_id;
135 updateData.extend<int>("hid");
136 updateData["hid"].data<int>() = m_head_id;
137 updateData.extend<int>("rid");
138 updateData["rid"].data<int>() = m_region_id;
139
140 int n_rows = editor.updateRows(updateAction, updateCondition, updateData);
141 if (n_rows != 1) {
142 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
143 log << MSG::WARNING << "Invalid number of rows updated in MDT_RT! " << n_rows << " instead of 1" << endmsg;
144 m_db_conn.Rollback();
145 return false;
146 }
147 if (commit) m_db_conn.Commit();
148 return true;
149 } catch (coral::SchemaException& e) {
150 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
151 log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
152 m_db_conn.Rollback();
153 return false;
154 }
155 }
156
157 bool CalibRtDbOperations::ReadForConditions(const std::string& /*site_name*/, int head_id, IConditionsStorage& storage) {
158 try {
159 m_db_conn.OpenTransaction();
160 m_query = m_db_conn.GetQuery();
161 m_query->addToTableList("MDT_RT");
162 m_query->addToTableList("MDT_RT_MAP");
163 coral::AttributeList conditionData;
164 conditionData.extend<int>("hid");
165 conditionData[0].data<int>() = head_id;
166 std::string condition =
167 "MDT_RT.HEAD_ID=:hid and MDT_RT_MAP.HEAD_ID=:hid and MDT_RT.REGION_ID = MDT_RT_MAP.REGION_ID and MDT_RT.CALIBFLAG = "
168 "MDT_RT_MAP.CALIBFLAG and MDT_RT.VALIDFLAG>1";
169 m_query->setCondition(condition, conditionData);
170 m_query->addToOrderList("MDT_RT.REGION_ID");
171 m_query->addToOutputList("MDT_RT.REGION_ID", "REGION_ID");
172 m_query->addToOutputList("MDT_RT_MAP.POINT_NR", "POINT_NR");
173 m_query->addToOutputList("MDT_RT_MAP.T", "T");
174 m_query->addToOutputList("MDT_RT_MAP.R", "R");
175 m_query->addToOutputList("MDT_RT_MAP.S", "S");
176 m_query->setRowCacheSize(100000);
177 // execute query
178 int last_region_id(-1);
179 std::map<int, SamplePoint> points;
180 coral::ICursor& cursor = m_query->execute();
181 while (cursor.next()) {
182 const coral::AttributeList& al = cursor.currentRow();
183 int rt_id = static_cast<int>(al["REGION_ID"].data<float>());
184 if (last_region_id > 0 && rt_id != last_region_id) {
185 if (!storage.StoreRtChamber(last_region_id, points)) {
186 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
187 log << MSG::WARNING << "Storage_failed" << endmsg;
188 return false;
189 }
190 points.clear();
191 }
192 last_region_id = rt_id;
193 SamplePoint pt(al["T"].data<float>(), al["R"].data<float>(), al["S"].data<float>());
194 points[static_cast<int>(al["POINT_NR"].data<short>())] = pt;
195 }
196 if (last_region_id > 0) {
197 if (!storage.StoreRtChamber(last_region_id, points)) {
198 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
199 log << MSG::WARNING << "Storage_failed" << endmsg;
200 return false;
201 }
202 }
203 return true;
204 } catch (coral::SchemaException& e) {
205 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
206 log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
207 m_db_conn.Rollback();
208 return false;
209 }
210 }
211
212 bool CalibRtDbOperations::getRtId(bool validated, RtFullInfo* full_info) {
213 // select MDT_RT, ... from MDT_RT where head_id=:hid and site_name=:sn and region_id=:rid and [and validflag>0| and validflag=0]
214 m_query = m_db_conn.GetQuery();
215 m_query->addToTableList("MDT_RT");
216 coral::AttributeList conditionData;
217 conditionData.extend<int>("hid");
218 conditionData[0].data<int>() = m_head_id;
219 conditionData.extend<int>("rid");
220 conditionData[1].data<int>() = m_region_id;
221 m_prev_algs = "";
222 std::string condition = "HEAD_ID=:hid and REGION_ID=:rid";
223 if (validated) {
224 condition += " and VALIDFLAG>1";
225 } else {
226 condition += " and VALIDFLAG=0";
227 }
228 m_query->setCondition(condition, conditionData);
229 m_query->addToOutputList("CALIBFLAG");
230 m_query->addToOutputList("BINS");
231 m_query->addToOutputList("ALGO_FLAG");
232 if (full_info != nullptr) {
233 m_query->addToOutputList("N_SEGS");
234 m_query->addToOutputList("AVER_ANGLE");
235 m_query->addToOutputList("DELTA_AVER_ANGLE");
236 m_query->addToOutputList("AVER_SPREAD");
237 m_query->addToOutputList("DELTA_AVER_SPREAD");
238 m_query->addToOutputList("CONVERGENCE");
239 m_query->addToOutputList("B_AVER");
240 m_query->addToOutputList("T_AVER");
241 }
242 coral::ICursor& cursor = m_query->execute();
243 int n_rows = 0;
244 m_rt_id = -9999;
245 while (cursor.next()) {
246 n_rows++;
247 const coral::AttributeList& al = cursor.currentRow();
248 m_rt_id = al["CALIBFLAG"].data<short>();
249 m_n_points = static_cast<int>(al["BINS"].data<short>());
250 m_prev_algs = al["ALGO_FLAG"].data<std::string>();
251 if (full_info != nullptr) {
252 full_info->setNumSeg(static_cast<int>(al["N_SEGS"].data<int>()));
253 full_info->setMeanAng(al["AVER_ANGLE"].data<float>());
254 full_info->setRmsAng(al["DELTA_AVER_ANGLE"].data<float>());
255 full_info->setMeanPos(al["AVER_SPREAD"].data<float>());
256 full_info->setRmsPos(al["DELTA_AVER_SPREAD"].data<float>());
257 full_info->setConvEst(al["CONVERGENCE"].data<float>());
258 full_info->setImplementation(m_prev_algs);
259 }
260 }
261 if (n_rows > 1) {
262 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
263 log << MSG::WARNING << "Found " << n_rows << " in MDT_RT instead of 0 or 1" << endmsg;
264 return false;
265 }
266 m_db_conn.DestroyQuery(m_query);
267 return true;
268 }
269
270 inline bool CalibRtDbOperations ::readRTS(std::vector<SamplePoint>& points) {
271 m_query = m_db_conn.GetQuery();
272 m_query->addToTableList("MDT_RT_MAP");
273 coral::AttributeList conditionData;
274 conditionData.extend<int>("rtid");
275 conditionData[0].data<int>() = m_rt_id;
276 conditionData.extend<int>("hid");
277 conditionData[1].data<int>() = m_head_id;
278 conditionData.extend<int>("rid");
279 conditionData[2].data<int>() = m_region_id;
280 std::string condition = "HEAD_ID=:hid and REGION_ID=:rid and CALIBFLAG=:rtid";
281 m_query->setCondition(condition, conditionData);
282 m_query->addToOutputList("MDT_RT_MAP.POINT_NR", "POINT_NR");
283 m_query->addToOutputList("MDT_RT_MAP.R", "R");
284 m_query->addToOutputList("MDT_RT_MAP.T", "T");
285 m_query->addToOutputList("MDT_RT_MAP.S", "S");
286 m_query->addToOrderList("MDT_RT_MAP.POINT_NR");
287 m_query->setRowCacheSize(100);
288 coral::ICursor& cursor = m_query->execute();
289 points.clear();
290 points.resize(m_n_points);
291 int count(0);
292 while (cursor.next()) {
293 const coral::AttributeList& al = cursor.currentRow();
294 int pt_nr(static_cast<int>(al["POINT_NR"].data<short>()));
295 if (pt_nr >= m_n_points) {
296 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
297 log << MSG::WARNING << "Illegal point number " << pt_nr << endmsg;
298 return false;
299 }
300 SamplePoint point(al["T"].data<float>(), al["R"].data<float>(), al["S"].data<float>());
301 points[pt_nr] = point;
302 count++;
303 }
304 if (count != m_n_points) {
305 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
306 log << MSG::WARNING << m_n_points << " points expected, " << count << " found!" << endmsg;
307 return false;
308 }
309 m_db_conn.DestroyQuery(m_query);
310 return true;
311 }
312
313 inline bool CalibRtDbOperations ::updateFullInfo(const RtFullInfo* full_info, const int& validflag, const int& n_points) {
314 coral::ITableDataEditor& editor = m_db_conn.GetTableEditor("MDT_RT");
315 std::string updateAction =
316 "N_SEGS = :N_SEGS, AVER_ANGLE = :AVER_ANGLE, DELTA_AVER_ANGLE = :DELTA_AVER_ANGLE, AVER_SPREAD = :AVER_SPREAD, "
317 "DELTA_AVER_SPREAD = :DELTA_AVER_SPREAD, CONVERGENCE = :CONVERGENCE, VALIDFLAG=:VALIDFLAG, BINS=:BINS, ALGO_FLAG=:ALGO_FLAG";
318 std::string updateCondition = "HEAD_ID=:hid and REGION_ID=:rid and CALIBFLAG=:rtid";
319 coral::AttributeList updateData;
320 fullInfoInitData(full_info, validflag, updateData, n_points, false);
321 updateData.extend<int>("rtid");
322 updateData["rtid"].data<int>() = m_rt_id;
323 updateData.extend<int>("hid");
324 updateData["hid"].data<int>() = m_head_id;
325 updateData.extend<int>("rid");
326 updateData["rid"].data<int>() = m_region_id;
327 if (editor.updateRows(updateAction, updateCondition, updateData) != 1) {
328 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
329 log << MSG::WARNING << "Invalid number of rows updated in MDT_RT!" << endmsg;
330 return false;
331 }
332 return true;
333 }
334
335 inline bool CalibRtDbOperations ::updateRTSable(const std::vector<SamplePoint>& points) {
336 coral::ITableDataEditor& editor = m_db_conn.GetTableEditor("MDT_RT_MAP");
337 // check if there are now less points than before
338 if (static_cast<int>(points.size()) < m_n_points) {
339 std::string deleteCondition = "HEAD_ID = :hid and REGION_ID=:rid and CALIBFLAG=:rtid and POINT_NR>=:max_point";
340 coral::AttributeList deleteData;
341 deleteData.extend<int>("hid");
342 deleteData[0].data<int>() = m_head_id;
343 deleteData.extend<int>("rid");
344 deleteData[1].data<int>() = m_region_id;
345 deleteData.extend<int>("rtid");
346 deleteData[2].data<int>() = m_rt_id;
347 deleteData.extend<int>("max_point");
348 deleteData[3].data<int>() = static_cast<int>(points.size());
349 long rowsDeleted = editor.deleteRows(deleteCondition, deleteData);
350 if (rowsDeleted != m_n_points - static_cast<int>(points.size())) {
351 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
352 log << MSG::WARNING << rowsDeleted << " Points removed instead of " << m_n_points - static_cast<int>(points.size())
353 << "! Rolling back!" << endmsg;
354 return false;
355 }
356 }
357 coral::AttributeList table_data;
358 rtTableInitData(table_data);
359 table_data["CALIBFLAG"].data<int>() = m_rt_id;
360 table_data["HEAD_ID"].data<int>() = m_head_id;
361 table_data["REGION_ID"].data<int>() = m_region_id;
362 for (int i = 0; i < static_cast<int>(points.size()); i++) {
363 table_data["POINT_NR"].data<int>() = i;
364 table_data["T"].data<float>() = points[i].x1();
365 table_data["R"].data<float>() = points[i].x2();
366 table_data["S"].data<float>() = points[i].error();
367 if (i < m_n_points) {
368 std::string updateAction = "R=:R, T=:T, S=:S";
369 std::string updateCondition = "CALIBFLAG=:CALIBFLAG and POINT_NR=:POINT_NR and HEAD_ID=:HEAD_ID and REGION_ID=:REGION_ID";
370 if (editor.updateRows(updateAction, updateCondition, table_data) != 1) {
371 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
372 log << MSG::WARNING << "Wrong number of points updated!" << endmsg;
373 return false;
374 }
375 } else {
376 editor.insertRow(table_data);
377 }
378 }
379 return true;
380 }
381
382 inline bool CalibRtDbOperations ::insertFullInfo(const RtFullInfo* full_info, const int& validflag, const int& n_points) {
383 coral::ITableDataEditor& editor = m_db_conn.GetTableEditor("MDT_RT");
384 coral::AttributeList rowBuffer;
385 fullInfoInitData(full_info, validflag, rowBuffer, n_points, true);
386 editor.insertRow(rowBuffer);
387 return getRtId((validflag > 1), nullptr);
388 }
389
390 inline bool CalibRtDbOperations ::insertRTSable(const std::vector<SamplePoint>& points) {
391 coral::ITableDataEditor& editor = m_db_conn.GetTableEditor("MDT_RT_MAP");
392 coral::AttributeList table_data;
393 rtTableInitData(table_data);
394 table_data["CALIBFLAG"].data<int>() = m_rt_id;
395 table_data["HEAD_ID"].data<int>() = m_head_id;
396 table_data["REGION_ID"].data<int>() = m_region_id;
397 coral::IBulkOperation* bulk_inserter = editor.bulkInsert(table_data, 100);
398 // use trigger to fill in MDT_RT_ID
399 for (int i = 0; i < static_cast<int>(points.size()); i++) {
400 table_data["POINT_NR"].data<int>() = i;
401 table_data["T"].data<float>() = points[i].x1();
402 table_data["R"].data<float>() = points[i].x2();
403 table_data["S"].data<float>() = points[i].error();
404 bulk_inserter->processNextIteration();
405 }
406 bulk_inserter->flush();
407 delete bulk_inserter;
408 return true;
409 }
410
411 inline void CalibRtDbOperations::fullInfoInitData(const RtFullInfo* full_info, const int& validflag, coral::AttributeList& updateData,
412 const int& n_bins, const bool& for_insert) {
413 if (for_insert) {
414 updateData.extend<int>("REGION_ID");
415 updateData["REGION_ID"].data<int>() = m_region_id;
416 updateData.extend<int>("HEAD_ID");
417 updateData["HEAD_ID"].data<int>() = m_head_id;
418 updateData.extend<int>("LOWRUN");
419 updateData["LOWRUN"].data<int>() = 0;
420 updateData.extend<int>("UPRUN");
421 updateData["UPRUN"].data<int>() = 1;
422 updateData.extend<std::string>("HISTOGRAM");
423 updateData["HISTOGRAM"].data<std::string>() = "DUMMY";
424 }
425 if (m_prev_algs != "") { m_prev_algs += ":"; }
426 if (full_info->implementation() == "RtCalibrationIntegration") {
427 m_prev_algs += "Int";
428 } else if (full_info->implementation() == "RtCalibrationCruved") {
429 m_prev_algs += "Cur";
430 } else if (full_info->implementation() == "RtCalibrationAnalytic") {
431 m_prev_algs += "Ana";
432 } else if (full_info->implementation() == "RtCalibrationAnalyticExt") {
433 m_prev_algs += "AnaExt";
434 } else if (full_info->implementation() == "Validation") {
435 m_prev_algs += "Val";
436 } else {
437 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
438 log << MSG::WARNING << "Unknown implementation '" << full_info->implementation() << "'!" << endmsg;
439 m_prev_algs += "UU";
440 }
441 if (m_prev_algs.size() > 25) {
442 MsgStream log(Athena::getMessageSvc(), "CalibRtDbOperations");
443 log << MSG::WARNING << "m_prev_algs exceeds size: " << m_prev_algs << endmsg;
444 m_prev_algs = "..";
445 }
446 updateData.extend<std::string>("ALGO_FLAG");
447 updateData["ALGO_FLAG"].data<std::string>() = m_prev_algs;
448 updateData.extend<int>("N_SEGS");
449 updateData["N_SEGS"].data<int>() = full_info->numSeg();
450 updateData.extend<float>("AVER_ANGLE");
451 updateData["AVER_ANGLE"].data<float>() = full_info->meanAng();
452 if (std::abs(full_info->meanAng()) > 9.9999) {
453 updateData["AVER_ANGLE"].data<float>() = ((full_info->meanAng() < 0) ? -1 : 1) * 9.9999;
454 }
455 updateData.extend<float>("DELTA_AVER_ANGLE");
456 updateData["DELTA_AVER_ANGLE"].data<float>() = full_info->rmsAng();
457 if (std::abs(full_info->rmsAng()) > 9.9999) {
458 updateData["DELTA_AVER_ANGLE"].data<float>() = ((full_info->rmsAng() < 0) ? -1 : 1) * 9.9999;
459 }
460 updateData.extend<float>("AVER_SPREAD");
461 updateData["AVER_SPREAD"].data<float>() = full_info->meanPos();
462 if (std::abs(full_info->meanPos()) > 9.9999) {
463 updateData["AVER_SPREAD"].data<float>() = ((full_info->meanPos() < 0) ? -1 : 1) * 9.9999;
464 }
465 updateData.extend<float>("DELTA_AVER_SPREAD");
466 updateData["DELTA_AVER_SPREAD"].data<float>() = full_info->rmsPos();
467 if (std::abs(full_info->rmsPos()) > 9.9999) {
468 updateData["DELTA_AVER_SPREAD"].data<float>() = ((full_info->rmsPos() < 0) ? -1 : 1) * 9.9999;
469 }
470 updateData.extend<float>("CONVERGENCE");
471 updateData["CONVERGENCE"].data<float>() = full_info->convEst();
472 if (std::abs(full_info->convEst()) > 999.999) {
473 updateData["CONVERGENCE"].data<float>() = ((full_info->convEst() < 0) ? -1 : 1) * 999.999;
474 }
475 if (for_insert) {
476 updateData.extend<float>("B_AVER");
477 updateData["B_AVER"].data<float>() = 0.;
478 updateData.extend<float>("T_AVER");
479 updateData["T_AVER"].data<float>() = 0.;
480 updateData.extend<float>("HV");
481 updateData["HV"].data<float>() = 0.;
482 updateData.extend<float>("CURR");
483 updateData["CURR"].data<float>() = 0.;
484 updateData.extend<float>("GAS");
485 updateData["GAS"].data<float>() = 0.;
486 updateData.extend<int>("CALIBFLAG");
487 updateData["CALIBFLAG"].data<int>() = static_cast<int>(validflag > 3);
488 }
489 updateData.extend<int>("VALIDFLAG");
490 updateData["VALIDFLAG"].data<int>() = validflag;
491 updateData.extend<short>("BINS");
492 updateData["BINS"].data<short>() = n_bins;
493 }
494
495 inline void CalibRtDbOperations::rtTableInitData(coral::AttributeList& rowBuffer) {
496 rowBuffer.extend<int>("HEAD_ID");
497 rowBuffer.extend<int>("REGION_ID");
498 rowBuffer.extend<int>("CALIBFLAG");
499 rowBuffer.extend<int>("POINT_NR");
500 rowBuffer.extend<float>("T");
501 rowBuffer.extend<float>("R");
502 rowBuffer.extend<float>("S");
503 }
504
505 inline bool CalibRtDbOperations::checkRtPresent(const int& head_id, const std::string& /*site_name*/, const NtupleStationId& id,
506 const int& validflag) {
507 m_query = m_db_conn.GetQuery();
508 // select count(MDT_RT.MDT_RT_ID) as N_TUBES, MDT_RT.VALIDFLAG as VALIDFLAG from MDT_RT where MDT_RT.HEAD_ID = :hid and
509 // MDT_RT.REGION_ID = :chamb and SITE_NAME=:sn group by MDT_RT.VALIDFLAG;
510 m_query->addToTableList("MDT_RT");
511 coral::AttributeList conditionData;
512 conditionData.extend<int>("hid");
513 conditionData[0].data<int>() = head_id;
514 // as long as the chamber id is stored as a string, it is more efficient to pass the chamber id as a string in the query
515 std::ostringstream ostr;
516 ostr << id.FixedId();
517 conditionData.extend<std::string>("chamb");
518 conditionData[1].data<std::string>() = ostr.str();
519 std::string condition = "MDT_RT.HEAD_ID = :hid and MDT_RT.REGION_ID = :chamb";
520 m_query->setCondition(condition, conditionData);
521 m_query->addToOutputList("count(MDT_RT.CALIBFLAG)", "N_RTS");
522 m_query->addToOutputList("MDT_RT.VALIDFLAG", "VALIDFLAG");
523 m_query->groupBy("MDT_RT.VALIDFLAG");
524 coral::ICursor& cursor = m_query->execute();
525 bool has_unvalidated(false), has_validated(false);
526 while (cursor.next()) {
527 const coral::AttributeList& al = cursor.currentRow();
528 if (al["VALIDFLAG"].data<short>() > 0) {
529 if (al["N_RTS"].data<double>() > 0) { has_validated = true; }
530 } else {
531 if (al["N_RTS"].data<double>() > 0) { has_unvalidated = true; }
532 }
533 }
534 if (validflag == 0 && has_unvalidated) return false;
535 if (validflag > 0 && has_validated) return false;
536 return true;
537 }
538
539} // namespace MuonCalib
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
data
char data[hepevt_bytes_allocation_ATLAS]
Definition HepEvt.cxx:11
al
static Double_t al
Definition LArPhysWaveHECTool.cxx:38
MuonCalib::CalibRtDbOperations::WriteUpdateRt
bool WriteUpdateRt(const NtupleStationId &id, int head_id, const std::string &, const std::vector< SamplePoint > &points, int validflag, const RtFullInfo *full_info)
Definition CalibRtDbOperations.cxx:72
MuonCalib::CalibRtDbOperations::updateRTSable
bool updateRTSable(const std::vector< SamplePoint > &points)
Definition CalibRtDbOperations.cxx:335
MuonCalib::CalibRtDbOperations::CalibRtDbOperations
CalibRtDbOperations(CalibDbConnection &db_conn)
Definition CalibRtDbOperations.cxx:37
MuonCalib::CalibRtDbOperations::rtTableInitData
void rtTableInitData(coral::AttributeList &rowBuffer)
Definition CalibRtDbOperations.cxx:495
MuonCalib::CalibRtDbOperations::checkRtPresent
bool checkRtPresent(const int &head_id, const std::string &, const NtupleStationId &id, const int &validflag)
Definition CalibRtDbOperations.cxx:505
MuonCalib::CalibRtDbOperations::LoadRt
bool LoadRt(const NtupleStationId &id, int head_id, bool validated, const std::string &, std::vector< SamplePoint > &points, RtFullInfo *full_info)
Definition CalibRtDbOperations.cxx:42
MuonCalib::CalibRtDbOperations::readRTS
bool readRTS(std::vector< SamplePoint > &points)
Definition CalibRtDbOperations.cxx:270
MuonCalib::CalibRtDbOperations::getRtId
bool getRtId(bool validated, RtFullInfo *full_info)
Definition CalibRtDbOperations.cxx:212
MuonCalib::CalibRtDbOperations::insertFullInfo
bool insertFullInfo(const RtFullInfo *full_info, const int &validflag, const int &n_points)
Definition CalibRtDbOperations.cxx:382
MuonCalib::CalibRtDbOperations::insertRTSable
bool insertRTSable(const std::vector< SamplePoint > &points)
Definition CalibRtDbOperations.cxx:390
MuonCalib::CalibRtDbOperations::fullInfoInitData
void fullInfoInitData(const RtFullInfo *full_info, const int &validflag, coral::AttributeList &updateData, const int &n_bins, const bool &for_insert)
Definition CalibRtDbOperations.cxx:411
MuonCalib::CalibRtDbOperations::ReadForConditions
bool ReadForConditions(const std::string &, int head_id, IConditionsStorage &storage)
Definition CalibRtDbOperations.cxx:157
MuonCalib::CalibRtDbOperations::SetValidflag
bool SetValidflag(int validflag, bool commit=true)
Definition CalibRtDbOperations.cxx:119
MuonCalib::CalibRtDbOperations::updateFullInfo
bool updateFullInfo(const RtFullInfo *full_info, const int &validflag, const int &n_points)
Definition CalibRtDbOperations.cxx:313
MuonCalib::IConditionsStorage::StoreRtChamber
virtual bool StoreRtChamber(const int &chamber, const std::map< int, SamplePoint > &points)=0
MuonCalib::NtupleStationId
Station Identifier for sorting calibration data.
Definition NtupleStationId.h:36
MuonCalib::RtFullInfo
addiitonal information used in validation of a rt-relation
Definition RtFullInfo.h:15
MuonCalib::RtFullInfo::meanPos
double meanPos() const
Definition RtFullInfo.h:37
MuonCalib::RtFullInfo::rmsAng
double rmsAng() const
Definition RtFullInfo.h:36
MuonCalib::RtFullInfo::setRmsPos
void setRmsPos(double a)
Definition RtFullInfo.h:48
MuonCalib::RtFullInfo::meanAng
double meanAng() const
Definition RtFullInfo.h:35
MuonCalib::RtFullInfo::setMeanPos
void setMeanPos(double a)
Definition RtFullInfo.h:47
MuonCalib::RtFullInfo::implementation
const std::string & implementation() const
Definition RtFullInfo.h:32
MuonCalib::RtFullInfo::setNumSeg
void setNumSeg(int n)
Definition RtFullInfo.h:44
MuonCalib::RtFullInfo::setRmsAng
void setRmsAng(double a)
Definition RtFullInfo.h:46
MuonCalib::RtFullInfo::setConvEst
void setConvEst(double a)
Definition RtFullInfo.h:49
MuonCalib::RtFullInfo::setMeanAng
void setMeanAng(double a)
Definition RtFullInfo.h:45
MuonCalib::RtFullInfo::setImplementation
void setImplementation(const std::string &i)
Definition RtFullInfo.h:42
MuonCalib::RtFullInfo::rmsPos
double rmsPos() const
Definition RtFullInfo.h:38
MuonCalib::RtFullInfo::convEst
double convEst() const
Definition RtFullInfo.h:39
MuonCalib::SamplePoint
This class provides a sample point for the BaseFunctionFitter.
Definition SamplePoint.h:15
getMessageSvc.h
singleton-like access to IMessageSvc via open function and helper
count
int count(std::string s, const std::string &regx)
count how many occurances of a regx are in a string
Definition hcg.cxx:146
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition getMessageSvc.cxx:20
MuonCalib
CscCalcPed - algorithm that finds the Cathode Strip Chamber pedestals from an RDO.
Definition CscCalcPed.cxx:22
Generated on for ATLAS Offline Software by doxygen 1.14.0