ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | List of all members
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 Identifier & getGapID () const
int getNEtaStrips () const
int getNPhiStrips () const

Private Member Functions

void initData (std::string etaRec, std::string etaDet, std::string phiRec1, std::string phiRec2, std::string phiDet1, std::string 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 27 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 162 of file RpcCalibDBEntry.cxx.

162 :m_nRecEta(0),m_nDetEta(0), m_nRecPhi1(0),m_nRecPhi2(0),m_nDetPhi1(0),m_nDetPhi2(0),m_theGap(gapID)
163 {
164
165 this->initData(etaRec, etaDet,phiRec1,phiRec2,phiDet1,phiDet2);
166
167
168 }
MuonCalib::RpcCalibDBEntry::initData
void initData(std::string etaRec, std::string etaDet, std::string phiRec1, std::string phiRec2, std::string phiDet1, std::string phiDet2)
Definition RpcCalibDBEntry.cxx:48

◆ RpcCalibDBEntry() [3/3]

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

Definition at line 17 of file RpcCalibDBEntry.cxx.

17 :
18 m_theGap(gapID) {
19
20
21 std::string::size_type end=payLoad.find("END ");
22 std::string_view etaRec=payLoad.substr(0,end);
23 payLoad=payLoad.substr(end+4,payLoad.size()-end-4);
24
25 end=payLoad.find("END ");
26 std::string_view etaDet=payLoad.substr(0,end);
27 payLoad=payLoad.substr(end+4,payLoad.size()-end-4);
28
29 end=payLoad.find("END ");
30 std::string_view phiRec1=payLoad.substr(0,end);
31 payLoad=payLoad.substr(end+4,payLoad.size()-end-4);
32
33 end=payLoad.find("END ");
34 std::string_view phiRec2=payLoad.substr(0,end);
35 payLoad=payLoad.substr(end+4,payLoad.size()-end-4);
36
37 end=payLoad.find("END ");
38 std::string_view phiDet1=payLoad.substr(0,end);
39 payLoad=payLoad.substr(end+4,payLoad.size()-end-4);
40
41 end=payLoad.find("END ");
42 std::string_view phiDet2=payLoad.substr(0,end);
43
44 this->initData(std::string(etaRec), std::string(etaDet),std::string(phiRec1),std::string(phiRec2),std::string(phiDet1),std::string(phiDet2));
45
46 }

◆ ~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 176 of file RpcCalibDBEntry.cxx.

176 {
177
178
179 std::ostringstream recEta_str,detEta_str,recPhi1_str,recPhi2_str,detPhi1_str,detPhi2_str;
180
181 float eff, errEff, res1, res2, resX, errRes1, errRes2, errResX, time, errTime, noise, errNoise, noiseC, errNoiseC, cs, errCs;
182
183 recEta_str<<m_nRecEta<<' ';
184 detEta_str<<m_nDetEta<<' ';
185
186 recPhi1_str<<m_nRecPhi1<<' ';
187 detPhi1_str<<m_nDetPhi1<<' ';
188
189 recPhi2_str<<m_nRecPhi2<<' ';
190 detPhi2_str<<m_nDetPhi2<<' ';
191
192
193
194 for(int k=0;k<m_nRecEta;k++){
195
196 const auto& theData = m_theEtaData[k];
197
198 eff=theData->getEff();
199 errEff=theData->getErrEff();
200 res1=theData->getRes1();
201 res2=theData->getRes2();
202 resX=theData->getResX();
203 errRes1=theData->getErrRes1();
204 errRes2=theData->getErrRes2();
205 errResX=theData->getErrResX();
206 time=theData->getTime();
207 errTime=theData->getErrTime();
208 noise=theData->getNoise();
209 noiseC=theData->getNoiseC();
210 errNoise=theData->getErrNoise();
211 errNoiseC=theData->getErrNoiseC();
212 cs=theData->getCs();
213 errCs=theData->getErrCs();
214
215 recEta_str<< eff<< ' '<<errEff<< ' '<<res1<< ' '<<errRes1<< ' '<<res2<< ' '<<errRes2<< ' '<<resX<< ' '<<errResX<< ' '<<time<< ' '<<errTime<< ' ';
216 detEta_str<<noise<< ' '<<errNoise<< ' '<<noiseC<< ' '<<errNoiseC<< ' '<<cs<< ' '<<errCs<< ' ';
217
218
219 }
220
221 for(int k=0;k<m_nRecPhi1;k++){
222
223 const auto& theData = m_thePhiData[k];
224
225 eff=theData->getEff();
226 errEff=theData->getErrEff();
227 res1=theData->getRes1();
228 res2=theData->getRes2();
229 resX=theData->getResX();
230 errRes1=theData->getErrRes1();
231 errRes2=theData->getErrRes2();
232 errResX=theData->getErrResX();
233 time=theData->getTime();
234 errTime=theData->getErrTime();
235 noise=theData->getNoise();
236 noiseC=theData->getNoiseC();
237 errNoise=theData->getErrNoise();
238 errNoiseC=theData->getErrNoiseC();
239 cs=theData->getCs();
240 errCs=theData->getErrCs();
241
242 recPhi1_str<<eff<<' ' <<res1<<' ' <<res2<<' ' <<resX<<' ' <<time<< ' ';
243 recPhi2_str<<errEff<<' ' <<errRes1<<' ' <<errRes2<<' ' <<errResX<<' ' <<errTime<< ' ';
244 detPhi1_str<<noise<<' ' <<errNoise<<' ' <<noiseC<<' ' <<errNoiseC<<' ' <<cs<<' ' <<errCs<< ' ';
245
246
247 }
248
249 // give back strings
250
251 recEta=recEta_str.str();
252 detEta=detEta_str.str();
253 recPhi1=recPhi1_str.str();
254 recPhi2=recPhi2_str.str();
255 detPhi1=detPhi1_str.str();
256 detPhi2=detPhi2_str.str();
257
258 }
MuonCalib::RpcCalibDBEntry::m_thePhiData
std::vector< std::unique_ptr< RpcCalibData > > m_thePhiData
Definition RpcCalibDBEntry.h:62
MuonCalib::RpcCalibDBEntry::m_theEtaData
std::vector< std::unique_ptr< RpcCalibData > > m_theEtaData
Definition RpcCalibDBEntry.h:63
CaloSwCorrections.time
time(flags, cells_name, *args, **kw)
Definition CaloSwCorrections.py:242
dqt_zlumi_alleff_HIST.eff
int eff
Definition dqt_zlumi_alleff_HIST.py:113

◆ getGapID()

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

Definition at line 171 of file RpcCalibDBEntry.cxx.

171 {
172 return m_theGap;
173
174 }

◆ getNEtaStrips()

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

Definition at line 50 of file RpcCalibDBEntry.h.

50{return m_nRecEta;}

◆ getNPhiStrips()

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

Definition at line 51 of file RpcCalibDBEntry.h.

51{return m_nRecPhi1;}

◆ initData()

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

Definition at line 48 of file RpcCalibDBEntry.cxx.

48 {
49
50
51 unsigned long int pos = 0;
52 std::string::size_type start = etaRec.find_first_not_of(' ',pos);
53 if(start == std::string::npos) {
54 std::cout << "RpcCalibDBEntry::initData -- problems extracting m_nRecEta -- crashing." << std::endl;
55 std::abort();
56 }
57 std::string::size_type stop = etaRec.find_first_of(' ',start+1);
58 if (stop == std::string::npos) stop = etaRec.size();
59 m_nRecEta = std::stoi(etaRec.substr(start,stop-start),nullptr);
60 etaRec.erase(pos,stop-pos);
61
62 pos = 0;
63 start = phiRec1.find_first_not_of(' ',pos);
64 if(start == std::string::npos) {
65 std::cout << "RpcCalibDBEntry::initData -- problems extracting m_nRecPhi1 -- crashing." << std::endl;
66 std::abort();
67 }
68 stop = phiRec1.find_first_of(' ',start+1);
69 if (stop == std::string::npos) stop = phiRec1.size();
70 m_nRecPhi1 = std::stoi(phiRec1.substr(start,stop-start),nullptr);
71 phiRec1.erase(pos,stop-pos);
72
73 std::istringstream etaRec_str;
74 std::istringstream etaDet_str;
75 std::istringstream phiRec1_str;
76 std::istringstream phiRec2_str;
77 std::istringstream phiDet1_str;
78 std::istringstream phiDet2_str;
79
80 etaRec_str.str(etaRec);
81 etaDet_str.str(etaDet);
82 phiRec1_str.str(phiRec1);
83 phiRec2_str.str(phiRec2);
84 phiDet1_str.str(phiDet1);
85 phiDet2_str.str(phiDet2);
86
87 etaDet_str>>m_nDetEta;
88 phiRec2_str>>m_nRecPhi2;
89 phiDet1_str>>m_nDetPhi1;
90 phiDet2_str>>m_nDetPhi2;
91
92 float eff, errEff, res1, res2, resX, errRes1, errRes2, errResX, time, errTime, noise, errNoise, noiseC, errNoiseC, cs, errCs;
93
94 // start with eta processing, 41 strips
95
96 for(int k=0;k<m_nRecEta;k++){
97
98 etaRec_str>>eff>>errEff>>res1>>errRes1>>res2>>errRes2>>resX>>errResX>>time>>errTime;
99 etaDet_str>>noise>>errNoise>>noiseC>>errNoiseC>>cs>>errCs;
100
101 auto etaData= std::make_unique<RpcCalibData>();
102
103 etaData->setId(k);
104 etaData->setEff(eff);
105 etaData->setErrEff(errEff);
106 etaData->setRes1(res1);
107 etaData->setRes2(res2);
108 etaData->setResX(resX);
109 etaData->setErrRes1(errRes1);
110 etaData->setErrRes2(errRes2);
111 etaData->setErrResX(errResX);
112 etaData->setTime(time);
113 etaData->setErrTime(errTime);
114 etaData->setNoise(noise);
115 etaData->setNoiseC(noiseC);
116 etaData->setErrNoise(errNoise);
117 etaData->setErrNoiseC(errNoiseC);
118 etaData->setCs(cs);
119 etaData->setErrCs(errCs);
120
121 m_theEtaData.push_back(std::move(etaData));
122
123 }
124
125 // now phi
126
127 for(int k=0;k<m_nRecPhi1;k++){
128
129 phiRec1_str>>eff>>res1>>res2>>resX>>time;
130 phiRec2_str>>errEff>>errRes1>>errRes2>>errResX>>errTime;
131 phiDet1_str>>noise>>errNoise>>noiseC>>errNoiseC>>cs>>errCs;
132
133 auto phiData= std::make_unique<RpcCalibData>();
134
135 phiData->setId(k);
136 phiData->setEff(eff);
137 phiData->setErrEff(errEff);
138 phiData->setRes1(res1);
139 phiData->setRes2(res2);
140 phiData->setResX(resX);
141 phiData->setErrRes1(errRes1);
142 phiData->setErrRes2(errRes2);
143 phiData->setErrResX(errResX);
144 phiData->setTime(time);
145 phiData->setErrTime(errTime);
146 phiData->setNoise(noise);
147 phiData->setNoiseC(noiseC);
148 phiData->setErrNoise(errNoise);
149 phiData->setErrNoiseC(errNoiseC);
150 phiData->setCs(cs);
151 phiData->setErrCs(errCs);
152
153 m_thePhiData.push_back(std::move(phiData));
154
155 }
156
157
158 }

Member Data Documentation

◆ m_nDetEta

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

Definition at line 56 of file RpcCalibDBEntry.h.

56{-9999};

◆ m_nDetPhi1

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

Definition at line 59 of file RpcCalibDBEntry.h.

59{-9999};

◆ m_nDetPhi2

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

Definition at line 60 of file RpcCalibDBEntry.h.

60{-9999};

◆ m_nRecEta

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

Definition at line 55 of file RpcCalibDBEntry.h.

55{-9999};

◆ m_nRecPhi1

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

Definition at line 57 of file RpcCalibDBEntry.h.

57{-9999};

◆ m_nRecPhi2

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

Definition at line 58 of file RpcCalibDBEntry.h.

58{-9999};

◆ m_theEtaData

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

Definition at line 63 of file RpcCalibDBEntry.h.

63{};

◆ m_theGap

Identifier MuonCalib::RpcCalibDBEntry::m_theGap {}
private

Definition at line 61 of file RpcCalibDBEntry.h.

61{};

◆ m_thePhiData

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

Definition at line 62 of file RpcCalibDBEntry.h.

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