ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | List of all members
MuonCalib::CalibRtDbOperations Class Reference

#include <CalibRtDbOperations.h>

Collaboration diagram for MuonCalib::CalibRtDbOperations:

Public Member Functions

 CalibRtDbOperations (CalibDbConnection &db_conn)
virtual ~CalibRtDbOperations ()=default
bool LoadRt (const NtupleStationId &id, int head_id, bool validated, const std::string &, std::vector< SamplePoint > &points, RtFullInfo *full_info)
bool WriteUpdateRt (const NtupleStationId &id, int head_id, const std::string &, const std::vector< SamplePoint > &points, int validflag, const RtFullInfo *full_info)
bool SetValidflag (int validflag, bool commit=true)
bool ReadForConditions (const std::string &, int head_id, IConditionsStorage &storage)

Private Member Functions

bool getRtId (bool validated, RtFullInfo *full_info)
bool readRTS (std::vector< SamplePoint > &points)
bool updateFullInfo (const RtFullInfo *full_info, const int &validflag, const int &n_points)
bool updateRTSable (const std::vector< SamplePoint > &points)
bool insertFullInfo (const RtFullInfo *full_info, const int &validflag, const int &n_points)
bool insertRTSable (const std::vector< SamplePoint > &points)
void fullInfoInitData (const RtFullInfo *full_info, const int &validflag, coral::AttributeList &updateData, const int &n_bins, const bool &for_insert)
void rtTableInitData (coral::AttributeList &rowBuffer)
bool getRTMapTId ()
bool checkRtPresent (const int &head_id, const std::string &, const NtupleStationId &id, const int &validflag)

Private Attributes

CalibDbConnection & m_db_conn
coral::IQuery * m_query
int m_rt_id
int m_rt_map_t_id
int m_head_id
int m_region_id
std::string m_prev_algs
int m_n_points

Detailed Description

Definition at line 25 of file CalibRtDbOperations.h.

Constructor & Destructor Documentation

◆ CalibRtDbOperations()

MuonCalib::CalibRtDbOperations::CalibRtDbOperations ( CalibDbConnection & db_conn)

Definition at line 37 of file CalibRtDbOperations.cxx.

37 :
38 m_db_conn(db_conn), m_rt_id(-1), m_rt_map_t_id(-1), m_head_id(-1), m_region_id(-1), m_n_points(0) {
39 m_query = nullptr;
40 }

◆ ~CalibRtDbOperations()

virtual MuonCalib::CalibRtDbOperations::~CalibRtDbOperations ( )
virtualdefault

Member Function Documentation

◆ checkRtPresent()

bool MuonCalib::CalibRtDbOperations::checkRtPresent ( const int & head_id,
const std::string & ,
const NtupleStationId & id,
const int & validflag )
inlineprivate

Definition at line 505 of file CalibRtDbOperations.cxx.

506 {
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 }
data
char data[hepevt_bytes_allocation_ATLAS]
Definition HepEvt.cxx:11
al
static Double_t al
Definition LArPhysWaveHECTool.cxx:38

◆ fullInfoInitData()

void MuonCalib::CalibRtDbOperations::fullInfoInitData ( const RtFullInfo * full_info,
const int & validflag,
coral::AttributeList & updateData,
const int & n_bins,
const bool & for_insert )
inlineprivate

Definition at line 411 of file CalibRtDbOperations.cxx.

412 {
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 }
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition getMessageSvc.cxx:20

◆ getRtId()

bool MuonCalib::CalibRtDbOperations::getRtId ( bool validated,
RtFullInfo * full_info )
private

Definition at line 212 of file CalibRtDbOperations.cxx.

212 {
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 }

◆ getRTMapTId()

bool MuonCalib::CalibRtDbOperations::getRTMapTId ( )
inlineprivate

◆ insertFullInfo()

bool MuonCalib::CalibRtDbOperations::insertFullInfo ( const RtFullInfo * full_info,
const int & validflag,
const int & n_points )
inlineprivate

Definition at line 382 of file CalibRtDbOperations.cxx.

382 {
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 }
MuonCalib::CalibRtDbOperations::getRtId
bool getRtId(bool validated, RtFullInfo *full_info)
Definition CalibRtDbOperations.cxx:212
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

◆ insertRTSable()

bool MuonCalib::CalibRtDbOperations::insertRTSable ( const std::vector< SamplePoint > & points)
inlineprivate

Definition at line 390 of file CalibRtDbOperations.cxx.

390 {
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 }
MuonCalib::CalibRtDbOperations::rtTableInitData
void rtTableInitData(coral::AttributeList &rowBuffer)
Definition CalibRtDbOperations.cxx:495
get_generator_info.error
error
Definition get_generator_info.py:40

◆ LoadRt()

bool MuonCalib::CalibRtDbOperations::LoadRt ( const NtupleStationId & id,
int head_id,
bool validated,
const std::string & ,
std::vector< SamplePoint > & points,
RtFullInfo * full_info )

Definition at line 42 of file CalibRtDbOperations.cxx.

43 {
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 }
MuonCalib::CalibRtDbOperations::readRTS
bool readRTS(std::vector< SamplePoint > &points)
Definition CalibRtDbOperations.cxx:270

◆ ReadForConditions()

bool MuonCalib::CalibRtDbOperations::ReadForConditions ( const std::string & ,
int head_id,
IConditionsStorage & storage )

Definition at line 157 of file CalibRtDbOperations.cxx.

157 {
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 }
test_pyathena.pt
pt
Definition test_pyathena.py:11

◆ readRTS()

bool MuonCalib::CalibRtDbOperations::readRTS ( std::vector< SamplePoint > & points)
inlineprivate

Definition at line 270 of file CalibRtDbOperations.cxx.

270 {
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 }
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

◆ rtTableInitData()

void MuonCalib::CalibRtDbOperations::rtTableInitData ( coral::AttributeList & rowBuffer)
inlineprivate

Definition at line 495 of file CalibRtDbOperations.cxx.

495 {
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 }

◆ SetValidflag()

bool MuonCalib::CalibRtDbOperations::SetValidflag ( int validflag,
bool commit = true )

Definition at line 119 of file CalibRtDbOperations.cxx.

119 {
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 }

◆ updateFullInfo()

bool MuonCalib::CalibRtDbOperations::updateFullInfo ( const RtFullInfo * full_info,
const int & validflag,
const int & n_points )
inlineprivate

Definition at line 313 of file CalibRtDbOperations.cxx.

313 {
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 }

◆ updateRTSable()

bool MuonCalib::CalibRtDbOperations::updateRTSable ( const std::vector< SamplePoint > & points)
inlineprivate

Definition at line 335 of file CalibRtDbOperations.cxx.

335 {
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 }

◆ WriteUpdateRt()

bool MuonCalib::CalibRtDbOperations::WriteUpdateRt ( const NtupleStationId & id,
int head_id,
const std::string & ,
const std::vector< SamplePoint > & points,
int validflag,
const RtFullInfo * full_info )

Definition at line 72 of file CalibRtDbOperations.cxx.

73 {
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 }
MuonCalib::CalibRtDbOperations::updateRTSable
bool updateRTSable(const std::vector< SamplePoint > &points)
Definition CalibRtDbOperations.cxx:335
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::updateFullInfo
bool updateFullInfo(const RtFullInfo *full_info, const int &validflag, const int &n_points)
Definition CalibRtDbOperations.cxx:313

Member Data Documentation

◆ m_db_conn

CalibDbConnection& MuonCalib::CalibRtDbOperations::m_db_conn
private

Definition at line 45 of file CalibRtDbOperations.h.

◆ m_head_id

int MuonCalib::CalibRtDbOperations::m_head_id
private

Definition at line 48 of file CalibRtDbOperations.h.

◆ m_n_points

int MuonCalib::CalibRtDbOperations::m_n_points
private

Definition at line 50 of file CalibRtDbOperations.h.

◆ m_prev_algs

std::string MuonCalib::CalibRtDbOperations::m_prev_algs
private

Definition at line 49 of file CalibRtDbOperations.h.

◆ m_query

coral::IQuery* MuonCalib::CalibRtDbOperations::m_query
private

Definition at line 46 of file CalibRtDbOperations.h.

◆ m_region_id

int MuonCalib::CalibRtDbOperations::m_region_id
private

Definition at line 48 of file CalibRtDbOperations.h.

◆ m_rt_id

int MuonCalib::CalibRtDbOperations::m_rt_id
private

Definition at line 48 of file CalibRtDbOperations.h.

◆ m_rt_map_t_id

int MuonCalib::CalibRtDbOperations::m_rt_map_t_id
private

Definition at line 48 of file CalibRtDbOperations.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0