ATLAS Offline Software
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. More...
 
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, 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 }

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

◆ 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/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/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/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*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/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/sqrt(12); }
119  // at low angles do not expect large clusters - maybe a delta ray?
120  else{ errphi = deltax*50*CLHEP::micrometer/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 }

◆ 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,
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/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./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./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./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; }

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

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.

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

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

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

◆ m_version

int PixelCalib::PixelClusterOnTrackErrorData::m_version {}
private

Definition at line 106 of file PixelClusterOnTrackErrorData.h.

The documentation for this class was generated from the following files:
PixelCalib::PixelClusterOnTrackErrorData::m_iblphierror
std::vector< float > m_iblphierror
Definition: PixelClusterOnTrackErrorData.h:125
run.infile
string infile
Definition: run.py:13
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
PixelCalib::PixelClusterOnTrackErrorData::Initialize
void Initialize()
Definition: PixelClusterOnTrackErrorData.cxx:24
PixelCalib::PixelClusterOnTrackErrorData::m_ibletaerror
std::vector< float > m_ibletaerror
Definition: PixelClusterOnTrackErrorData.h:126
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
athena.value
value
Definition: athena.py:122
PixelCalib::PixelClusterOnTrackErrorData::m_phibinsibl
int m_phibinsibl
Definition: PixelClusterOnTrackErrorData.h:122
PixelCalib::PixelClusterOnTrackErrorData::m_ibletaref
std::vector< float > m_ibletaref
Definition: PixelClusterOnTrackErrorData.h:123
nmax
const int nmax(200)
lumiFormat.i
int i
Definition: lumiFormat.py:92
checkxAOD.frac
frac
Definition: Tools/PyUtils/bin/checkxAOD.py:256
angle
double angle(const GeoTrf::Vector2D &a, const GeoTrf::Vector2D &b)
Definition: TRTDetectorFactory_Full.cxx:73
PixelCalib::PixelClusterOnTrackErrorData::m_csx
std::vector< float > m_csx
Definition: PixelClusterOnTrackErrorData.h:114
file
TFile * file
Definition: tile_monitor.h:29
PixelCalib::PixelClusterOnTrackErrorData::m_barreletaerror
std::vector< float > m_barreletaerror
Definition: PixelClusterOnTrackErrorData.h:109
python.SystemOfUnits.micrometer
int micrometer
Definition: SystemOfUnits.py:71
PixelCalib::PixelClusterOnTrackErrorData::m_csxbinsibl
int m_csxbinsibl
Definition: PixelClusterOnTrackErrorData.h:119
PixelCalib::PixelClusterOnTrackErrorData::m_csybinsibl
int m_csybinsibl
Definition: PixelClusterOnTrackErrorData.h:120
PixelCalib::PixelClusterOnTrackErrorData::m_etabinsibl
int m_etabinsibl
Definition: PixelClusterOnTrackErrorData.h:121
PixelCalib::PixelClusterOnTrackErrorData::m_barrelphierror
std::vector< float > m_barrelphierror
Definition: PixelClusterOnTrackErrorData.h:108
Rtt_histogram.n1
n1
Definition: Rtt_histogram.py:21
get_generator_info.version
version
Definition: get_generator_info.py:33
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
PixelCalib::PixelClusterOnTrackErrorData::m_etaref
std::vector< float > m_etaref
Definition: PixelClusterOnTrackErrorData.h:116
PixelCalib::PixelClusterOnTrackErrorData::m_version
int m_version
Definition: PixelClusterOnTrackErrorData.h:106
PixelCalib::PixelClusterOnTrackErrorData::m_phibins
std::vector< float > m_phibins
Definition: PixelClusterOnTrackErrorData.h:117
get_generator_info.error
error
Definition: get_generator_info.py:40
PixelCalib::PixelClusterOnTrackErrorData::m_csy
std::vector< float > m_csy
Definition: PixelClusterOnTrackErrorData.h:115
PrepareReferenceFile.outfile
outfile
Definition: PrepareReferenceFile.py:42
python.compressB64.c
def c
Definition: compressB64.py:93
PixelCalib::PixelClusterOnTrackErrorData::m_iblphibins
std::vector< float > m_iblphibins
Definition: PixelClusterOnTrackErrorData.h:124
Generated on Tue Jul 2 2024 22:24:09 for ATLAS Offline Software by   doxygen 1.8.18