Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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  }

◆ 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  }

◆ 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.

◆ m_nDetPhi1

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

Definition at line 59 of file RpcCalibDBEntry.h.

◆ m_nDetPhi2

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

Definition at line 60 of file RpcCalibDBEntry.h.

◆ m_nRecEta

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

Definition at line 55 of file RpcCalibDBEntry.h.

◆ m_nRecPhi1

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

Definition at line 57 of file RpcCalibDBEntry.h.

◆ m_nRecPhi2

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

Definition at line 58 of file RpcCalibDBEntry.h.

◆ m_theEtaData

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

Definition at line 63 of file RpcCalibDBEntry.h.

◆ m_theGap

Identifier MuonCalib::RpcCalibDBEntry::m_theGap {}
private

Definition at line 61 of file RpcCalibDBEntry.h.

◆ m_thePhiData

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

Definition at line 62 of file RpcCalibDBEntry.h.

The documentation for this class was generated from the following files:
MuonCalib::RpcCalibDBEntry::m_nRecPhi2
int m_nRecPhi2
Definition: RpcCalibDBEntry.h:58
MuonCalib::RpcCalibDBEntry::m_theEtaData
std::vector< std::unique_ptr< RpcCalibData > > m_theEtaData
Definition: RpcCalibDBEntry.h:63
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
MuonCalib::RpcCalibDBEntry::m_nDetPhi1
int m_nDetPhi1
Definition: RpcCalibDBEntry.h:59
MuonCalib::RpcCalibDBEntry::m_nDetPhi2
int m_nDetPhi2
Definition: RpcCalibDBEntry.h:60
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
MuonCalib::RpcCalibDBEntry::m_thePhiData
std::vector< std::unique_ptr< RpcCalibData > > m_thePhiData
Definition: RpcCalibDBEntry.h:62
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
MuonCalib::RpcCalibDBEntry::m_nDetEta
int m_nDetEta
Definition: RpcCalibDBEntry.h:56
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
MuonCalib::RpcCalibDBEntry::m_theGap
Identifier m_theGap
Definition: RpcCalibDBEntry.h:61
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
MuonCalib::RpcCalibDBEntry::m_nRecPhi1
int m_nRecPhi1
Definition: RpcCalibDBEntry.h:57
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
MuonCalib::RpcCalibDBEntry::m_nRecEta
int m_nRecEta
Definition: RpcCalibDBEntry.h:55
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
fitman.k
k
Definition: fitman.py:528
Generated on Wed Apr 23 2025 22:01:43 for ATLAS Offline Software by   doxygen 1.8.18