ATLAS Offline Software
Loading...
Searching...
No Matches
MuonCalib::RpcCalibDBEntry Class Reference

representation of a db entry in rpc cond db. More...

#include <RpcCalibDBEntry.h>

Collaboration diagram for MuonCalib::RpcCalibDBEntry:

Public Member Functions

 RpcCalibDBEntry ()=default
 RpcCalibDBEntry (Identifier gapID, const std::string &etaRec, const std::string &etaDet, const std::string &phiRec1, const std::string &phiRec2, const std::string &phiDet1, const std::string &phiDet2)
 RpcCalibDBEntry (Identifier gapID, std::string_view payload)
void getColumns (std::string &recEta, std::string &detEta, std::string &recPhi1, std::string &recPhi2, std::string &detPhi1, std::string &detPhi2) const
 ~RpcCalibDBEntry ()=default
const IdentifiergetGapID () const
int getNEtaStrips () const
int getNPhiStrips () const

Private Member Functions

void initData (std::string_view etaRec, std::string_view etaDet, std::string_view phiRec1, std::string_view phiRec2, std::string_view phiDet1, std::string_view phiDet2)

Private Attributes

int m_nRecEta {-9999}
int m_nDetEta {-9999}
int m_nRecPhi1 {-9999}
int m_nRecPhi2 {-9999}
int m_nDetPhi1 {-9999}
int m_nDetPhi2 {-9999}
Identifier m_theGap {}
std::vector< std::unique_ptr< RpcCalibData > > m_thePhiData {}
std::vector< std::unique_ptr< RpcCalibData > > m_theEtaData {}

Detailed Description

representation of a db entry in rpc cond db.

Author
andre.nosp@m.a.di.nosp@m..simo.nosp@m.ne@c.nosp@m.ern.c.nosp@m.h

RPC calib db entry

Definition at line 29 of file RpcCalibDBEntry.h.

Constructor & Destructor Documentation

◆ RpcCalibDBEntry() [1/3]

MuonCalib::RpcCalibDBEntry::RpcCalibDBEntry ( )
default

◆ RpcCalibDBEntry() [2/3]

MuonCalib::RpcCalibDBEntry::RpcCalibDBEntry ( Identifier gapID,
const std::string & etaRec,
const std::string & etaDet,
const std::string & phiRec1,
const std::string & phiRec2,
const std::string & phiDet1,
const std::string & phiDet2 )

Definition at line 190 of file RpcCalibDBEntry.cxx.

191 {
192
193 this->initData(etaRec, etaDet,phiRec1,phiRec2,phiDet1,phiDet2);
194
195
196 }
void initData(std::string_view etaRec, std::string_view etaDet, std::string_view phiRec1, std::string_view phiRec2, std::string_view phiDet1, std::string_view phiDet2)

◆ RpcCalibDBEntry() [3/3]

MuonCalib::RpcCalibDBEntry::RpcCalibDBEntry ( Identifier gapID,
std::string_view payload )

Definition at line 59 of file RpcCalibDBEntry.cxx.

60 : m_theGap(gapID)
61{
62 auto take_until = [&](std::string_view& sv) -> std::string_view {
63 const std::string_view delim = "END ";
64 const auto pos = sv.find(delim);
65 if (pos == std::string_view::npos) {
66 throw std::runtime_error("RpcCalibDBEntry: malformed payload (missing 'END ')");
67 }
68 auto out = sv.substr(0, pos);
69 sv.remove_prefix(pos + delim.size()); // avoids overflow math
70 return out;
71 };
72
73 const auto etaRec = take_until(payLoad);
74 const auto etaDet = take_until(payLoad);
75 const auto phiRec1 = take_until(payLoad);
76 const auto phiRec2 = take_until(payLoad);
77 const auto phiDet1 = take_until(payLoad);
78 const auto phiDet2 = take_until(payLoad);
79
80 initData(std::string(etaRec), std::string(etaDet),
81 std::string(phiRec1), std::string(phiRec2),
82 std::string(phiDet1), std::string(phiDet2));
83}

◆ ~RpcCalibDBEntry()

MuonCalib::RpcCalibDBEntry::~RpcCalibDBEntry ( )
default

Member Function Documentation

◆ getColumns()

void MuonCalib::RpcCalibDBEntry::getColumns ( std::string & recEta,
std::string & detEta,
std::string & recPhi1,
std::string & recPhi2,
std::string & detPhi1,
std::string & detPhi2 ) const

Definition at line 204 of file RpcCalibDBEntry.cxx.

204 {
205
206
207 std::ostringstream recEta_str,detEta_str,recPhi1_str,recPhi2_str,detPhi1_str,detPhi2_str;
208
209 float eff, errEff, res1, res2, resX, errRes1, errRes2, errResX, time, errTime, noise, errNoise, noiseC, errNoiseC, cs, errCs;
210
211 recEta_str<<m_nRecEta<<' ';
212 detEta_str<<m_nDetEta<<' ';
213
214 recPhi1_str<<m_nRecPhi1<<' ';
215 detPhi1_str<<m_nDetPhi1<<' ';
216
217 recPhi2_str<<m_nRecPhi2<<' ';
218 detPhi2_str<<m_nDetPhi2<<' ';
219
220
221
222 for(int k=0;k<m_nRecEta;k++){
223
224 const auto& theData = m_theEtaData[k];
225
226 eff=theData->getEff();
227 errEff=theData->getErrEff();
228 res1=theData->getRes1();
229 res2=theData->getRes2();
230 resX=theData->getResX();
231 errRes1=theData->getErrRes1();
232 errRes2=theData->getErrRes2();
233 errResX=theData->getErrResX();
234 time=theData->getTime();
235 errTime=theData->getErrTime();
236 noise=theData->getNoise();
237 noiseC=theData->getNoiseC();
238 errNoise=theData->getErrNoise();
239 errNoiseC=theData->getErrNoiseC();
240 cs=theData->getCs();
241 errCs=theData->getErrCs();
242
243 recEta_str<< eff<< ' '<<errEff<< ' '<<res1<< ' '<<errRes1<< ' '<<res2<< ' '<<errRes2<< ' '<<resX<< ' '<<errResX<< ' '<<time<< ' '<<errTime<< ' ';
244 detEta_str<<noise<< ' '<<errNoise<< ' '<<noiseC<< ' '<<errNoiseC<< ' '<<cs<< ' '<<errCs<< ' ';
245
246
247 }
248
249 for(int k=0;k<m_nRecPhi1;k++){
250
251 const auto& theData = m_thePhiData[k];
252
253 eff=theData->getEff();
254 errEff=theData->getErrEff();
255 res1=theData->getRes1();
256 res2=theData->getRes2();
257 resX=theData->getResX();
258 errRes1=theData->getErrRes1();
259 errRes2=theData->getErrRes2();
260 errResX=theData->getErrResX();
261 time=theData->getTime();
262 errTime=theData->getErrTime();
263 noise=theData->getNoise();
264 noiseC=theData->getNoiseC();
265 errNoise=theData->getErrNoise();
266 errNoiseC=theData->getErrNoiseC();
267 cs=theData->getCs();
268 errCs=theData->getErrCs();
269
270 recPhi1_str<<eff<<' ' <<res1<<' ' <<res2<<' ' <<resX<<' ' <<time<< ' ';
271 recPhi2_str<<errEff<<' ' <<errRes1<<' ' <<errRes2<<' ' <<errResX<<' ' <<errTime<< ' ';
272 detPhi1_str<<noise<<' ' <<errNoise<<' ' <<noiseC<<' ' <<errNoiseC<<' ' <<cs<<' ' <<errCs<< ' ';
273
274
275 }
276
277 // give back strings
278
279 recEta=recEta_str.str();
280 detEta=detEta_str.str();
281 recPhi1=recPhi1_str.str();
282 recPhi2=recPhi2_str.str();
283 detPhi1=detPhi1_str.str();
284 detPhi2=detPhi2_str.str();
285
286 }
std::vector< std::unique_ptr< RpcCalibData > > m_thePhiData
std::vector< std::unique_ptr< RpcCalibData > > m_theEtaData
time(flags, cells_name, *args, **kw)

◆ getGapID()

const Identifier & MuonCalib::RpcCalibDBEntry::getGapID ( ) const

Definition at line 199 of file RpcCalibDBEntry.cxx.

199 {
200 return m_theGap;
201
202 }

◆ getNEtaStrips()

int MuonCalib::RpcCalibDBEntry::getNEtaStrips ( ) const
inline

Definition at line 52 of file RpcCalibDBEntry.h.

52{return m_nRecEta;}

◆ getNPhiStrips()

int MuonCalib::RpcCalibDBEntry::getNPhiStrips ( ) const
inline

Definition at line 53 of file RpcCalibDBEntry.h.

53{return m_nRecPhi1;}

◆ initData()

void MuonCalib::RpcCalibDBEntry::initData ( std::string_view etaRec,
std::string_view etaDet,
std::string_view phiRec1,
std::string_view phiRec2,
std::string_view phiDet1,
std::string_view phiDet2 )
private

Definition at line 86 of file RpcCalibDBEntry.cxx.

88 {
89 NumberParser etaRecParser{etaRec};
90 NumberParser etaDetParser{etaDet};
91 NumberParser phiRec1Parser{phiRec1};
92 NumberParser phiRec2Parser{phiRec2};
93 NumberParser phiDet1Parser{phiDet1};
94 NumberParser phiDet2Parser{phiDet2};
95
96 m_nRecEta = etaRecParser.next<int>();
97 m_nDetEta = etaDetParser.next<int>();
98 m_nRecPhi1 = phiRec1Parser.next<int>();
99 m_nRecPhi2 = phiRec2Parser.next<int>();
100 m_nDetPhi1 = phiDet1Parser.next<int>();
101 m_nDetPhi2 = phiDet2Parser.next<int>();
102
103 for (int k = 0; k < m_nRecEta; ++k) {
104 const float eff = etaRecParser.next<float>();
105 const float errEff = etaRecParser.next<float>();
106 const float res1 = etaRecParser.next<float>();
107 const float errRes1 = etaRecParser.next<float>();
108 const float res2 = etaRecParser.next<float>();
109 const float errRes2 = etaRecParser.next<float>();
110 const float resX = etaRecParser.next<float>();
111 const float errResX = etaRecParser.next<float>();
112 const float time = etaRecParser.next<float>();
113 const float errTime = etaRecParser.next<float>();
114
115 const float noise = etaDetParser.next<float>();
116 const float errNoise = etaDetParser.next<float>();
117 const float noiseC = etaDetParser.next<float>();
118 const float errNoiseC = etaDetParser.next<float>();
119 const float cs = etaDetParser.next<float>();
120 const float errCs = etaDetParser.next<float>();
121
122 auto etaData = std::make_unique<RpcCalibData>();
123
124 etaData->setId(k);
125 etaData->setEff(eff);
126 etaData->setErrEff(errEff);
127 etaData->setRes1(res1);
128 etaData->setRes2(res2);
129 etaData->setResX(resX);
130 etaData->setErrRes1(errRes1);
131 etaData->setErrRes2(errRes2);
132 etaData->setErrResX(errResX);
133 etaData->setTime(time);
134 etaData->setErrTime(errTime);
135 etaData->setNoise(noise);
136 etaData->setNoiseC(noiseC);
137 etaData->setErrNoise(errNoise);
138 etaData->setErrNoiseC(errNoiseC);
139 etaData->setCs(cs);
140 etaData->setErrCs(errCs);
141
142 m_theEtaData.push_back(std::move(etaData));
143 }
144
145 for (int k = 0; k < m_nRecPhi1; ++k) {
146 const float eff = phiRec1Parser.next<float>();
147 const float res1 = phiRec1Parser.next<float>();
148 const float res2 = phiRec1Parser.next<float>();
149 const float resX = phiRec1Parser.next<float>();
150 const float time = phiRec1Parser.next<float>();
151
152 const float errEff = phiRec2Parser.next<float>();
153 const float errRes1 = phiRec2Parser.next<float>();
154 const float errRes2 = phiRec2Parser.next<float>();
155 const float errResX = phiRec2Parser.next<float>();
156 const float errTime = phiRec2Parser.next<float>();
157
158 const float noise = phiDet1Parser.next<float>();
159 const float errNoise = phiDet1Parser.next<float>();
160 const float noiseC = phiDet1Parser.next<float>();
161 const float errNoiseC = phiDet1Parser.next<float>();
162 const float cs = phiDet1Parser.next<float>();
163 const float errCs = phiDet1Parser.next<float>();
164
165 auto phiData = std::make_unique<RpcCalibData>();
166
167 phiData->setId(k);
168 phiData->setEff(eff);
169 phiData->setErrEff(errEff);
170 phiData->setRes1(res1);
171 phiData->setRes2(res2);
172 phiData->setResX(resX);
173 phiData->setErrRes1(errRes1);
174 phiData->setErrRes2(errRes2);
175 phiData->setErrResX(errResX);
176 phiData->setTime(time);
177 phiData->setErrTime(errTime);
178 phiData->setNoise(noise);
179 phiData->setNoiseC(noiseC);
180 phiData->setErrNoise(errNoise);
181 phiData->setErrNoiseC(errNoiseC);
182 phiData->setCs(cs);
183 phiData->setErrCs(errCs);
184
185 m_thePhiData.push_back(std::move(phiData));
186 }
187 }

Member Data Documentation

◆ m_nDetEta

int MuonCalib::RpcCalibDBEntry::m_nDetEta {-9999}
private

Definition at line 60 of file RpcCalibDBEntry.h.

60{-9999};

◆ m_nDetPhi1

int MuonCalib::RpcCalibDBEntry::m_nDetPhi1 {-9999}
private

Definition at line 63 of file RpcCalibDBEntry.h.

63{-9999};

◆ m_nDetPhi2

int MuonCalib::RpcCalibDBEntry::m_nDetPhi2 {-9999}
private

Definition at line 64 of file RpcCalibDBEntry.h.

64{-9999};

◆ m_nRecEta

int MuonCalib::RpcCalibDBEntry::m_nRecEta {-9999}
private

Definition at line 59 of file RpcCalibDBEntry.h.

59{-9999};

◆ m_nRecPhi1

int MuonCalib::RpcCalibDBEntry::m_nRecPhi1 {-9999}
private

Definition at line 61 of file RpcCalibDBEntry.h.

61{-9999};

◆ m_nRecPhi2

int MuonCalib::RpcCalibDBEntry::m_nRecPhi2 {-9999}
private

Definition at line 62 of file RpcCalibDBEntry.h.

62{-9999};

◆ m_theEtaData

std::vector<std::unique_ptr<RpcCalibData> > MuonCalib::RpcCalibDBEntry::m_theEtaData {}
private

Definition at line 67 of file RpcCalibDBEntry.h.

67{};

◆ m_theGap

Identifier MuonCalib::RpcCalibDBEntry::m_theGap {}
private

Definition at line 65 of file RpcCalibDBEntry.h.

65{};

◆ m_thePhiData

std::vector<std::unique_ptr<RpcCalibData> > MuonCalib::RpcCalibDBEntry::m_thePhiData {}
private

Definition at line 66 of file RpcCalibDBEntry.h.

66{};

The documentation for this class was generated from the following files: