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

#include <PixelClusterOnTrackErrorData.h>

Collaboration diagram for PixelCalib::PixelClusterOnTrackErrorData:

Public Member Functions

 PixelClusterOnTrackErrorData ()
 ~PixelClusterOnTrackErrorData ()
int getVersion () const
 Methods to access the calibration data.
void setVersion (int version)
int getNumberOfPhiBarrelBins () const
int getNumberOfEtaBarrelBins () const
int getNumberOfPhiIBLBins () const
int getNumberOfEtaIBLBins () const
const std::vector< float > & getClusterSizeBinsX () const
const std::vector< float > & getClusterSizeBinsY () const
const std::vector< float > & getEtaBins () const
const std::vector< float > & getIncidenceAngleBins () const
const std::vector< float > & getEtaIBLBins () const
const std::vector< float > & getIncidenceAngleIBLBins () const
float getPixelBarrelEtaError (int ibin) const
float getPixelBarrelPhiError (int ibin) const
float getPixelIBLEtaError (int ibin) const
float getPixelIBLPhiError (int ibin) const
void setParameters (const int ncsx, const int ncsy, const int neta, const int nalpha, int offset, const std::vector< float > &constants)
void setPixelBarrelPhiError (int ibin, double error)
void setPixelBarrelEtaError (int ibin, double error)
void setPixelIBLPhiError (int ibin, double error)
void setPixelIBLEtaError (int ibin, double error)
int getBarrelBinPhi (double angle, int phiClusterSize) const
int getBarrelBinEta (double eta, int etaClusterSize, int phiClusterSize) const
int getIBLBinPhi (double angle, int phiClusterSize) const
int getIBLBinEta (double eta, int etaClusterSize) const
void Print (const std::string &file) const
void Load (const std::string &file)
int getIBLcsxbins () const
int getIBLcsybins () const
int getIBLetabins () const
int getIBLphibins () const
void setIBLcsxbins (int icsx)
void setIBLcsybins (int icsy)
void setIBLetabins (int ieta)
void setIBLphibins (int iphi)

Static Public Member Functions

static double getPixelBarrelPhiError (double ang, int phiClusterSize)

Private Member Functions

void Initialize ()

Private Attributes

int m_version {}
std::vector< float > m_barrelphierror
std::vector< float > m_barreletaerror
std::vector< float > m_endcapphierror
std::vector< float > m_endcapetaerror
std::vector< float > m_csx
std::vector< float > m_csy
std::vector< float > m_etaref
std::vector< float > m_phibins
int m_csxbinsibl {}
int m_csybinsibl {}
int m_etabinsibl {}
int m_phibinsibl {}
std::vector< float > m_ibletaref
std::vector< float > m_iblphibins
std::vector< float > m_iblphierror
std::vector< float > m_ibletaerror

Detailed Description

Definition at line 25 of file PixelClusterOnTrackErrorData.h.

Constructor & Destructor Documentation

◆ PixelClusterOnTrackErrorData()

PixelClusterOnTrackErrorData::PixelClusterOnTrackErrorData ( )

Definition at line 17 of file PixelClusterOnTrackErrorData.cxx.

17 {
18 Initialize();
19 }

◆ ~PixelClusterOnTrackErrorData()

PixelClusterOnTrackErrorData::~PixelClusterOnTrackErrorData ( )
default

Member Function Documentation

◆ getBarrelBinEta()

int PixelClusterOnTrackErrorData::getBarrelBinEta ( double eta,
int etaClusterSize,
int phiClusterSize ) const

Definition at line 166 of file PixelClusterOnTrackErrorData.cxx.

167 {
168
169 int ieta=0;
170 int neta = m_etaref.size();
171 for(int i=0; i<neta; i++){
172 if(eta>m_etaref[i]) ieta=i;
173 }
174 int iphi=0;
175 int nphi = m_csx.size();
176 for(int i=0; i<nphi; i++){
177 if(phiClusterSize>m_csx[i]) iphi=i;
178 }
179
180 int iz=0;
181 int nz = m_csy.size();
182 for(int i=0; i<nz; i++){
183 if(etaClusterSize>m_csy[i]) iz=i;
184 }
185
186 return nz*nphi*ieta+nz*iphi+iz;
187}
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83

◆ getBarrelBinPhi()

int PixelClusterOnTrackErrorData::getBarrelBinPhi ( double angle,
int phiClusterSize ) const

Definition at line 149 of file PixelClusterOnTrackErrorData.cxx.

150 {
151
152 int iang =0;
153 int nang = m_phibins.size();
154 for(int i=0; i<nang; i++){
155 if(angle > m_phibins[i]) iang=i;
156 }
157 int iphi=0;
158 int nphi = m_csx.size();
159 for(int i=0; i<nphi; i++){
160 if(phiClusterSize>m_csx[i]) iphi=i;
161 }
162
163 return nphi*iang+iphi;
164}
angle
double angle(const GeoTrf::Vector2D &a, const GeoTrf::Vector2D &b)
Definition TRTDetectorFactory_Full.cxx:71

◆ getClusterSizeBinsX()

const std::vector< float > & PixelCalib::PixelClusterOnTrackErrorData::getClusterSizeBinsX ( ) const
inline

Definition at line 47 of file PixelClusterOnTrackErrorData.h.

47{return m_csx;}

◆ getClusterSizeBinsY()

const std::vector< float > & PixelCalib::PixelClusterOnTrackErrorData::getClusterSizeBinsY ( ) const
inline

Definition at line 48 of file PixelClusterOnTrackErrorData.h.

48{return m_csy;}

◆ getEtaBins()

const std::vector< float > & PixelCalib::PixelClusterOnTrackErrorData::getEtaBins ( ) const
inline

Definition at line 49 of file PixelClusterOnTrackErrorData.h.

49{return m_etaref;}

◆ getEtaIBLBins()

const std::vector< float > & PixelCalib::PixelClusterOnTrackErrorData::getEtaIBLBins ( ) const
inline

Definition at line 52 of file PixelClusterOnTrackErrorData.h.

52{return m_ibletaref;}

◆ getIBLBinEta()

int PixelClusterOnTrackErrorData::getIBLBinEta ( double eta,
int etaClusterSize ) const

Definition at line 204 of file PixelClusterOnTrackErrorData.cxx.

204 {
205
206 if(m_version>-2) return -1;
207 int ieta=0;
208 int neta = m_ibletaref.size();
209 for(int i=0; i<neta; i++){
210 if(eta>m_ibletaref[i]) ieta=i;
211 }
212 int iz=0;
213 for(int i=0; i<m_csybinsibl; i++){
214 if(etaClusterSize>m_csy[i]) iz=i;
215 }
216 return m_csybinsibl*ieta+iz;
217}

◆ getIBLBinPhi()

int PixelClusterOnTrackErrorData::getIBLBinPhi ( double angle,
int phiClusterSize ) const

Definition at line 189 of file PixelClusterOnTrackErrorData.cxx.

190 {
191 if(m_version>-2) return -1;
192 int iang =0;
193 int nang = m_iblphibins.size();
194 for(int i=0; i<nang; i++){
195 if(angle > m_iblphibins[i]) iang=i;
196 }
197 int iphi=0;
198 for(int i=0; i<m_csxbinsibl; i++){
199 if(phiClusterSize>m_csx[i]) iphi=i;
200 }
201 return m_csxbinsibl*iang+iphi;
202}

◆ getIBLcsxbins()

int PixelCalib::PixelClusterOnTrackErrorData::getIBLcsxbins ( ) const
inline

Definition at line 93 of file PixelClusterOnTrackErrorData.h.

93{return m_csxbinsibl;}

◆ getIBLcsybins()

int PixelCalib::PixelClusterOnTrackErrorData::getIBLcsybins ( ) const
inline

Definition at line 94 of file PixelClusterOnTrackErrorData.h.

94{return m_csybinsibl;}

◆ getIBLetabins()

int PixelCalib::PixelClusterOnTrackErrorData::getIBLetabins ( ) const
inline

Definition at line 95 of file PixelClusterOnTrackErrorData.h.

95{return m_etabinsibl;}

◆ getIBLphibins()

int PixelCalib::PixelClusterOnTrackErrorData::getIBLphibins ( ) const
inline

Definition at line 96 of file PixelClusterOnTrackErrorData.h.

96{return m_phibinsibl;}

◆ getIncidenceAngleBins()

const std::vector< float > & PixelCalib::PixelClusterOnTrackErrorData::getIncidenceAngleBins ( ) const
inline

Definition at line 50 of file PixelClusterOnTrackErrorData.h.

50{return m_phibins;}

◆ getIncidenceAngleIBLBins()

const std::vector< float > & PixelCalib::PixelClusterOnTrackErrorData::getIncidenceAngleIBLBins ( ) const
inline

Definition at line 53 of file PixelClusterOnTrackErrorData.h.

53{return m_iblphibins;}

◆ getNumberOfEtaBarrelBins()

int PixelClusterOnTrackErrorData::getNumberOfEtaBarrelBins ( ) const

Definition at line 75 of file PixelClusterOnTrackErrorData.cxx.

75 {
76 return m_barreletaerror.size();
77}

◆ getNumberOfEtaIBLBins()

int PixelClusterOnTrackErrorData::getNumberOfEtaIBLBins ( ) const

Definition at line 84 of file PixelClusterOnTrackErrorData.cxx.

84 {
85 if(m_version>-2) return -1;
86 return m_ibletaerror.size();
87}

◆ getNumberOfPhiBarrelBins()

int PixelClusterOnTrackErrorData::getNumberOfPhiBarrelBins ( ) const

Definition at line 71 of file PixelClusterOnTrackErrorData.cxx.

71 {
72 return m_barrelphierror.size();
73}

◆ getNumberOfPhiIBLBins()

int PixelClusterOnTrackErrorData::getNumberOfPhiIBLBins ( ) const

Definition at line 79 of file PixelClusterOnTrackErrorData.cxx.

79 {
80 if(m_version>-2) return -1;
81 return m_iblphierror.size();
82}

◆ getPixelBarrelEtaError()

float PixelClusterOnTrackErrorData::getPixelBarrelEtaError ( int ibin) const

Definition at line 125 of file PixelClusterOnTrackErrorData.cxx.

125 {
126 if(ibin < 0) return -1;
127 if(static_cast<unsigned int>(ibin) >= m_barreletaerror.size()) return -2;
128 return m_barreletaerror[ibin];
129}

◆ getPixelBarrelPhiError() [1/2]

double PixelClusterOnTrackErrorData::getPixelBarrelPhiError ( double ang,
int phiClusterSize )
static

Definition at line 89 of file PixelClusterOnTrackErrorData.cxx.

90 {
91 double errphi=50*CLHEP::micrometer/std::pow(12,0.5);
92 // error on phi coordinate
93 if(deltax == 1){
94 // 1-row hit not expected - return conservative error estimate.
95 if(ang>12){ errphi = 50*CLHEP::micrometer/std::sqrt(12.); }
96 else{
97 // probability to get a 1-row cluster. Error basically proportional
98 // to this.
99 double frac = 0.8-0.6*ang/12;
100 errphi = frac*50*CLHEP::micrometer/std::sqrt(12.);
101 // Now account for some smearing w.r.t. ideal case
102 // tuned so that pulls turns out ok
103 // also some overall rescaling
104 double delta = 3*CLHEP::micrometer;
105 errphi = 1.1*std::sqrt(errphi*errphi+delta*delta);
106 }
107 }
108 else if(deltax == 2){
109 // Charge interpolation: good precision, weakly dependent on angle.
110 // Have not studied resolution yet for large angles (CTB, or very low
111 // pt tracks) - I put a conservative estimate here.
112 if(ang > 14){ errphi = 25*CLHEP::micrometer/std::sqrt(12); }
113 else{ errphi = 3*CLHEP::micrometer+2.5*CLHEP::micrometer*ang/14; }
114 }
115 else{
116 // Have not studied resolution yet for large angles (CTB, or very low
117 // pt tracks) - I put a conservative estimate here.
118 if(ang > 14){ errphi = 25*CLHEP::micrometer/std::sqrt(12); }
119 // at low angles do not expect large clusters - maybe a delta ray?
120 else{ errphi = deltax*50*CLHEP::micrometer/std::sqrt(12); }
121 }
122 return errphi;
123}

◆ getPixelBarrelPhiError() [2/2]

float PixelClusterOnTrackErrorData::getPixelBarrelPhiError ( int ibin) const

Definition at line 131 of file PixelClusterOnTrackErrorData.cxx.

131 {
132 if(ibin < 0){ return -1; }
133 if(static_cast<unsigned int>(ibin) >= m_barrelphierror.size()){ return -2;}
134 return m_barrelphierror[ibin];
135}

◆ getPixelIBLEtaError()

float PixelClusterOnTrackErrorData::getPixelIBLEtaError ( int ibin) const

Definition at line 137 of file PixelClusterOnTrackErrorData.cxx.

137 {
138 if(ibin < 0||m_version>-2) return -1;
139 if(static_cast<unsigned int>(ibin) >= m_ibletaerror.size()) return -2;
140 return m_ibletaerror[ibin];
141}

◆ getPixelIBLPhiError()

float PixelClusterOnTrackErrorData::getPixelIBLPhiError ( int ibin) const

Definition at line 143 of file PixelClusterOnTrackErrorData.cxx.

143 {
144 if(ibin < 0||m_version>-2){ return -1; }
145 if(static_cast<unsigned int>(ibin) >= m_iblphierror.size()){ return -2;}
146 return m_iblphierror[ibin];
147}

◆ getVersion()

int PixelClusterOnTrackErrorData::getVersion ( ) const

Methods to access the calibration data.

Definition at line 296 of file PixelClusterOnTrackErrorData.cxx.

296{ return m_version; }

◆ Initialize()

void PixelClusterOnTrackErrorData::Initialize ( )
private

Definition at line 24 of file PixelClusterOnTrackErrorData.cxx.

24 {
25
26 // Bins of cluster size parametrizations
27 m_version = 0;
28 m_csx.reserve(3);
29 m_csx.push_back(0.5);
30 m_csx.push_back(1.5);
31 m_csx.push_back(2.5);
32 m_csy.reserve(4);
33 m_csy.push_back(0.5);
34 m_csy.push_back(1.5);
35 m_csy.push_back(2.5);
36 m_csy.push_back(3.5);
37
38 // Bins of eta parametrization for barrel
39 m_etaref.reserve(5);
40 m_etaref.push_back(0.00);
41 m_etaref.push_back(0.55);
42 m_etaref.push_back(0.87);
43 m_etaref.push_back(1.32);
44 m_etaref.push_back(2.00);
45
46 // alfa (Rphi incidence angle) bins: [-6., -4., ... ,14]
47 int nphibins = 10;
48 for(int i=0; i<nphibins+1; i++){
49 m_phibins.push_back(-6+2*i);
50 }
51
52 // load defaults
53 int nbiny = m_csx.size()*m_csy.size()*m_etaref.size();
54 m_barreletaerror.reserve(nbiny);
55 for(int i = 0; i<nbiny; i++){
56 m_barreletaerror.push_back(115.4*CLHEP::micrometer);
57 }
58
59 int nbinx = m_csx.size()*m_phibins.size();
60 m_barrelphierror.reserve(nbinx);
61 for(int i = 0; i<nbinx; i++){
62 m_barrelphierror.push_back(14.4*CLHEP::micrometer);
63 }
64 // IBL
65 m_csxbinsibl = 0;
66 m_csybinsibl = 0;
67 m_etabinsibl = 0;
68 m_phibinsibl = 0;
69}

◆ Load()

void PixelClusterOnTrackErrorData::Load ( const std::string & file)

Definition at line 374 of file PixelClusterOnTrackErrorData.cxx.

374 {
375 std::ifstream infile(file.c_str());
376
377 // number of bins of parametrization
378 int ncsx; // cluster size in x
379 int ncsy; // cluster size in y
380 int neta = 0; // pseudorapidity
381 int nalpha; // incidence angle
382 m_csxbinsibl = 0;
383 m_csybinsibl = 0;
384 m_etabinsibl = 0;
385 m_phibinsibl = 0;
386 int nxbinsibl(0);
387 int nybinsibl(0);
388
389 infile >> m_version;
390 if(m_version >= 0){ // very first format, without version number in file
391 ncsx = m_version;
392 m_version = 0;
393 infile >> ncsy >> neta >> nalpha;
394 }
395 else{
396 if(m_version<-1){ // IBL version
397 infile>> ncsx >> ncsy >> neta >> nalpha>>m_csxbinsibl>>m_csybinsibl>>m_etabinsibl>>m_phibinsibl;
398 nxbinsibl = m_csxbinsibl*m_phibinsibl;
399 nybinsibl = m_csybinsibl*m_etabinsibl;
400 }
401 else{
402 infile >> ncsx >> ncsy >> neta >> nalpha;
403 }
404 }
405
406 // read bins of parametrization
407
408 float value;
409 if(ncsx<0)ncsx = 0;
410 if(ncsx>nmax) ncsx=nmax;
411 m_csx.clear();
412 m_csx.reserve(ncsx);
413 for(int i=0; i<ncsx && !infile.eof(); i++){
414 infile >> value;
415 m_csx.push_back(value);
416 }
417 if(ncsy<0)ncsy=0;
418 if(ncsy>nmax) ncsy=nmax;
419 m_csy.clear();
420 m_csy.reserve(ncsy);
421 for(int i=0; i<ncsy && !infile.eof(); i++){
422 infile >> value;
423 m_csy.push_back(value);
424 }
425 if(m_etabinsibl>0 && m_phibinsibl >0 ){ // IBL
426 m_ibletaref.clear();
427 if(m_etabinsibl>nmax) m_etabinsibl=nmax;
428 m_ibletaref.reserve(m_etabinsibl+1);
429 for(int i=0; i<m_etabinsibl+1; i++){
430 infile >> value;
431 m_ibletaref.push_back(value);
432 }
433 m_iblphibins.clear();
434 if(m_phibinsibl>nmax) m_phibinsibl=nmax;
435 m_iblphibins.reserve(m_phibinsibl+1);
436 for(int i=0; i<m_phibinsibl+1; i++){
437 infile >> value;
438 m_iblphibins.push_back(value);
439 }
440 }
441 if(neta<0)neta=0;
442 if(neta>nmax) neta=nmax;
443 m_etaref.clear();
444 m_etaref.reserve(neta);
445 for(int i=0; i<neta && !infile.eof(); i++){
446 infile >> value;
447 m_etaref.push_back(value);
448 }
449 if(nalpha<0)nalpha = 0;
450 if(nalpha>nmax) nalpha=nmax;
451 m_phibins.clear();
452 m_phibins.reserve(nalpha);
453 for(int i=0; i<nalpha && !infile.eof(); i++){
454 infile >> value;
455 m_phibins.push_back(value);
456 }
457 if(nxbinsibl>0){ // IBL
458 if(nxbinsibl>nmax) nxbinsibl=nmax;
459 m_iblphierror.clear();
460 m_iblphierror.reserve(nxbinsibl);
461 for(int ib1=0; ib1<nxbinsibl; ib1++){
462 infile >> value;
463 m_iblphierror.push_back(value);
464 }
465 }
466 int nb1=ncsx*nalpha; // number of barrel phi bins
467 int nb2=ncsx*ncsy*neta; // number of barrel eta bins
468 m_barrelphierror.clear();
469 m_barreletaerror.clear();
470 m_barrelphierror.reserve(nb1);
471 m_barreletaerror.reserve(nb2);
472 for(int ib1=0; ib1<nb1; ib1++){
473 infile >> value;
474 m_barrelphierror.push_back(value);
475 }
476 if(nybinsibl>0){ // IBL
477 if(nybinsibl>nmax) nybinsibl=nmax;
478 m_ibletaerror.clear();
479 m_ibletaerror.reserve(nybinsibl);
480 for(int ib1=0; ib1<nybinsibl; ib1++){
481 infile >> value;
482 m_ibletaerror.push_back(value);
483 }
484 }
485 for(int ib2=0; ib2<nb2; ib2++){
486 infile >> value;
487 m_barreletaerror.push_back(value);
488 }
489 infile.close();
490}
nmax
const int nmax(200)
run.infile
str infile
Definition run.py:13
file
TFile * file
Definition tile_monitor.h:29

◆ Print()

void PixelClusterOnTrackErrorData::Print ( const std::string & file) const

Definition at line 301 of file PixelClusterOnTrackErrorData.cxx.

301 {
302
303 std::ofstream* outfile = new std::ofstream(file.c_str());
304
305 if(m_version<0)*outfile << m_version << std::endl;
306
307 int ncsx = m_csx.size(); // number of cluster size (x-direction) bins
308 int ncsy = m_csy.size(); // number of cluster size (x-direction) bins
309 int neta = m_etaref.size(); // number of eta values bins
310 int nalpha = m_phibins.size(); // number of incidence angle bins
311 if(m_version<-1){
312 *outfile <<ncsx<<" "<<ncsy<<" "<<neta<<" "<<nalpha<<" "<<m_csxbinsibl<<
313 " "<<m_csybinsibl<<" "<<m_etabinsibl<<" "<<m_phibinsibl<<std::endl;
314 }
315 else{
316 *outfile << ncsx << " " << ncsy << " " << neta << " " << nalpha << std::endl;
317 }
318
319 for(int i=0; i<ncsx; i++){
320 *outfile << m_csx[i] << " ";
321 }
322 *outfile << std::endl;
323 for(int i=0; i<ncsy; i++){
324 *outfile << m_csy[i] << " ";
325 }
326 *outfile << std::endl;
327 if(m_etabinsibl>0 && m_phibinsibl >0 ){ // IBL
328 for(float i : m_ibletaref){
329 *outfile << i << " ";
330 }
331 *outfile << std::endl;
332 for(float iblphibin : m_iblphibins){
333 *outfile << iblphibin << " ";
334 }
335 *outfile << std::endl;
336 }
337 for(int i=0; i<neta; i++){
338 *outfile << m_etaref[i] << " ";
339 }
340 *outfile << std::endl;
341 for(int i=0; i<nalpha; i++){
342 *outfile << m_phibins[i] << " ";
343 }
344 *outfile << std::endl;
345 int nxbinsibl = m_csxbinsibl*m_phibinsibl;
346 if(nxbinsibl>0){ // IBL
347 for(int ib1=0; ib1<nxbinsibl; ib1++){
348 *outfile <<m_iblphierror[ib1]<<std::endl;
349 }
350 }
351 int nb1=ncsx*nalpha; // number of barrel phi bins
352 int nb2=ncsx*ncsy*neta; // number of barrel eta bins
353 for(int ib1=0; ib1<nb1; ib1++){
354 *outfile << m_barrelphierror[ib1] << std::endl;
355 }
356 int nybinsibl = m_csybinsibl*m_etabinsibl;
357 if(nybinsibl>0){ // IBL
358 for(int ib1=0; ib1<nybinsibl; ib1++){
359 *outfile <<m_ibletaerror[ib1]<<std::endl;
360 }
361 }
362 for(int ib2=0; ib2<nb2; ib2++){
363 *outfile << m_barreletaerror[ib2] << std::endl;
364 }
365 outfile->close();
366 delete outfile;
367}

◆ setIBLcsxbins()

void PixelCalib::PixelClusterOnTrackErrorData::setIBLcsxbins ( int icsx)
inline

Definition at line 98 of file PixelClusterOnTrackErrorData.h.

98{m_csxbinsibl = icsx;}

◆ setIBLcsybins()

void PixelCalib::PixelClusterOnTrackErrorData::setIBLcsybins ( int icsy)
inline

Definition at line 99 of file PixelClusterOnTrackErrorData.h.

99{m_csybinsibl = icsy;}

◆ setIBLetabins()

void PixelCalib::PixelClusterOnTrackErrorData::setIBLetabins ( int ieta)
inline

Definition at line 100 of file PixelClusterOnTrackErrorData.h.

100{m_etabinsibl = ieta;}

◆ setIBLphibins()

void PixelCalib::PixelClusterOnTrackErrorData::setIBLphibins ( int iphi)
inline

Definition at line 101 of file PixelClusterOnTrackErrorData.h.

101{m_phibinsibl = iphi;}

◆ setParameters()

void PixelClusterOnTrackErrorData::setParameters ( const int ncsx,
const int ncsy,
const int neta,
const int nalpha,
int offset,
const std::vector< float > & constants )

Definition at line 219 of file PixelClusterOnTrackErrorData.cxx.

224 { // vector with bin values
225
226 m_csx.clear();
227 m_csy.clear();
228 m_etaref.clear();
229 m_phibins.clear();
230 m_csx.reserve(n1);
231 m_csy.reserve(n2);
232 m_etaref.reserve(n3);
233 m_phibins.reserve(n4);
234 for(int i=0; i<n1; i++){
235 m_csx.push_back(c.at(i+offset));
236 }
237 offset += n1;
238 for(int i=0; i<n2; i++){
239 m_csy.push_back(c.at(i+offset));
240 }
241 offset += n2;
242 if(m_etabinsibl>0){ // IBL eta
243 m_ibletaref.reserve(m_etabinsibl+1);
244 for(int i = 0; i<m_etabinsibl+1; i++){
245 m_ibletaref.push_back(c.at(i+offset));
246 }
247 offset +=m_etabinsibl+1;
248 }
249 if(m_phibinsibl>0){ // IBL phi
250 m_iblphibins.reserve(m_phibinsibl+1);
251 for(int i = 0; i<m_phibinsibl+1; i++){
252 m_iblphibins.push_back(c.at(i+offset));
253 }
254 offset +=m_phibinsibl+1;
255 }
256 for(int i=0; i<n3; i++){
257 m_etaref.push_back(c.at(i+offset));
258 }
259 offset += n3;
260 for(int i=0; i<n4; i++){
261 m_phibins.push_back(c.at(i+offset));
262 }
263 offset +=n4;
264 int nxbinsibl = m_csxbinsibl*m_phibinsibl;
265 if(nxbinsibl>0){ // IBL
266 m_iblphierror.clear();
267 m_iblphierror.reserve(nxbinsibl);
268 for(int i = 0; i<nxbinsibl; i++){
269 m_iblphierror.push_back(50.0/std::sqrt(12)*CLHEP::micrometer);
270 }
271 }
272 int nybinsibl = m_csybinsibl*m_etabinsibl;
273 if(nybinsibl>0){ // IBL
274 m_ibletaerror.clear();
275 m_ibletaerror.reserve(nybinsibl);
276 for(int ib1=0; ib1<nybinsibl; ib1++){
277 m_ibletaerror.push_back(250./std::sqrt(12)*CLHEP::micrometer);
278 }
279 }
280 int nbiny = m_csx.size()*m_csy.size()*m_etaref.size();
281 m_barreletaerror.clear();
282 m_barreletaerror.reserve(nbiny);
283 for(int i = 0; i<nbiny; i++){
284 m_barreletaerror.push_back(400./std::sqrt(12)*CLHEP::micrometer);
285 }
286 int nbinx = m_csx.size()*m_phibins.size();
287 m_barrelphierror.clear();
288 m_barrelphierror.reserve(nbinx);
289 for(int i = 0; i<nbinx; i++){
290 m_barrelphierror.push_back(50./std::sqrt(12)*CLHEP::micrometer);
291 }
292 }

◆ setPixelBarrelEtaError()

void PixelCalib::PixelClusterOnTrackErrorData::setPixelBarrelEtaError ( int ibin,
double error )
inline

Definition at line 70 of file PixelClusterOnTrackErrorData.h.

70 {
71 m_barreletaerror[ibin] = error; }
get_generator_info.error
error
Definition get_generator_info.py:40

◆ setPixelBarrelPhiError()

void PixelCalib::PixelClusterOnTrackErrorData::setPixelBarrelPhiError ( int ibin,
double error )
inline

Definition at line 68 of file PixelClusterOnTrackErrorData.h.

68 {
69 m_barrelphierror[ibin] = error; }

◆ setPixelIBLEtaError()

void PixelCalib::PixelClusterOnTrackErrorData::setPixelIBLEtaError ( int ibin,
double error )
inline

Definition at line 75 of file PixelClusterOnTrackErrorData.h.

75 {
76 m_ibletaerror[ibin] = error; }

◆ setPixelIBLPhiError()

void PixelCalib::PixelClusterOnTrackErrorData::setPixelIBLPhiError ( int ibin,
double error )
inline

Definition at line 73 of file PixelClusterOnTrackErrorData.h.

73 {
74 m_iblphierror[ibin] = error; }

◆ setVersion()

void PixelClusterOnTrackErrorData::setVersion ( int version)

Definition at line 294 of file PixelClusterOnTrackErrorData.cxx.

294{ m_version = version; }
get_generator_info.version
version
Definition get_generator_info.py:33

Member Data Documentation

◆ m_barreletaerror

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_barreletaerror
private

Definition at line 109 of file PixelClusterOnTrackErrorData.h.

◆ m_barrelphierror

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_barrelphierror
private

Definition at line 108 of file PixelClusterOnTrackErrorData.h.

◆ m_csx

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_csx
private

Definition at line 114 of file PixelClusterOnTrackErrorData.h.

◆ m_csxbinsibl

int PixelCalib::PixelClusterOnTrackErrorData::m_csxbinsibl {}
private

Definition at line 119 of file PixelClusterOnTrackErrorData.h.

119{}; // IBL csx bins

◆ m_csy

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_csy
private

Definition at line 115 of file PixelClusterOnTrackErrorData.h.

◆ m_csybinsibl

int PixelCalib::PixelClusterOnTrackErrorData::m_csybinsibl {}
private

Definition at line 120 of file PixelClusterOnTrackErrorData.h.

120{}; // IBL csy bins

◆ m_endcapetaerror

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_endcapetaerror
private

Definition at line 111 of file PixelClusterOnTrackErrorData.h.

◆ m_endcapphierror

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_endcapphierror
private

Definition at line 110 of file PixelClusterOnTrackErrorData.h.

◆ m_etabinsibl

int PixelCalib::PixelClusterOnTrackErrorData::m_etabinsibl {}
private

Definition at line 121 of file PixelClusterOnTrackErrorData.h.

121{}; // IBL eta bins

◆ m_etaref

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_etaref
private

Definition at line 116 of file PixelClusterOnTrackErrorData.h.

◆ m_ibletaerror

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_ibletaerror
private

Definition at line 126 of file PixelClusterOnTrackErrorData.h.

◆ m_ibletaref

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_ibletaref
private

Definition at line 123 of file PixelClusterOnTrackErrorData.h.

◆ m_iblphibins

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_iblphibins
private

Definition at line 124 of file PixelClusterOnTrackErrorData.h.

◆ m_iblphierror

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_iblphierror
private

Definition at line 125 of file PixelClusterOnTrackErrorData.h.

◆ m_phibins

std::vector<float> PixelCalib::PixelClusterOnTrackErrorData::m_phibins
private

Definition at line 117 of file PixelClusterOnTrackErrorData.h.

◆ m_phibinsibl

int PixelCalib::PixelClusterOnTrackErrorData::m_phibinsibl {}
private

Definition at line 122 of file PixelClusterOnTrackErrorData.h.

122{}; // IBL phi bins

◆ m_version

int PixelCalib::PixelClusterOnTrackErrorData::m_version {}
private

Definition at line 106 of file PixelClusterOnTrackErrorData.h.

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