ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
PixelCalib::PixelOfflineCalibData Class Reference

#include <PixelOfflineCalibData.h>

Collaboration diagram for PixelCalib::PixelOfflineCalibData:

Public Member Functions

 PixelOfflineCalibData ()
 Constructor: More...
 
 PixelOfflineCalibData (const PixelOfflineCalibData &rhs)=delete
 
PixelOfflineCalibData & operator= (const PixelOfflineCalibData &rhs)=delete
 
 ~PixelOfflineCalibData ()
 default destructor More...
 
bool update (const PixelClusterErrorData &idat)
 
bool update (const PixelChargeInterpolationParameters &idat)
 
bool update (const PixelClusterOnTrackErrorData &idat)
 
int size () const
 
PixelClusterErrorData * getPixelClusterErrorData ()
 
PixelChargeInterpolationParameters * getPixelChargeInterpolationParameters ()
 
PixelClusterOnTrackErrorData * getPixelClusterOnTrackErrorData ()
 
const PixelClusterErrorData * getPixelClusterErrorData () const
 
const PixelChargeInterpolationParameters * getPixelChargeInterpolationParameters () const
 
const PixelClusterOnTrackErrorData * getPixelClusterOnTrackErrorData () const
 
int GetNumberOfConstants () const
 
std::vector< float > GetConstants () const
 
void SetConstants (const std::vector< float > &constants)
 
void Dump ()
 

Private Attributes

PixelClusterErrorData * m_clustererrordata
 
PixelChargeInterpolationParameters * m_chargeinterpolationparameters
 
PixelClusterOnTrackErrorData * m_clusterontrackerrordata
 

Detailed Description

Definition at line 31 of file PixelOfflineCalibData.h.

Constructor & Destructor Documentation

◆ PixelOfflineCalibData() [1/2]

PixelOfflineCalibData::PixelOfflineCalibData ( )
inline

Constructor:

Definition at line 73 of file PixelOfflineCalibData.h.

73  {
74  m_clustererrordata = new PixelClusterErrorData();
75  m_clusterontrackerrordata = new PixelClusterOnTrackErrorData();
76  m_chargeinterpolationparameters = new PixelChargeInterpolationParameters();
77 }

◆ PixelOfflineCalibData() [2/2]

PixelCalib::PixelOfflineCalibData::PixelOfflineCalibData ( const PixelOfflineCalibData &  rhs)
delete

◆ ~PixelOfflineCalibData()

PixelOfflineCalibData::~PixelOfflineCalibData ( )
inline

default destructor

Definition at line 125 of file PixelOfflineCalibData.h.

125  {
126 delete m_clustererrordata;
127 delete m_chargeinterpolationparameters;
128 delete m_clusterontrackerrordata;
129 }

Member Function Documentation

◆ Dump()

void PixelOfflineCalibData::Dump ( )

Definition at line 158 of file PixelOfflineCalibData.cxx.

158  {
159  m_clustererrordata->Print("PixelClusterDump.txt");
160  m_clusterontrackerrordata->Print("PixelClusterOnTrackDump.txt");
161  m_chargeinterpolationparameters->Print("PixelChargeInterpolationParametersDump.txt");
162 }

◆ GetConstants()

std::vector< float > PixelOfflineCalibData::GetConstants ( ) const

Definition at line 15 of file PixelOfflineCalibData.cxx.

15  {
16 
17  // format version of parametrizations (note it is an increasing NEGATIVE number)
18  int v1 = m_clustererrordata->getVersion();
19  int v2 = m_clusterontrackerrordata->getVersion();
20  int v3 = m_chargeinterpolationparameters->getVersion();
21 
22  int n1 = m_clustererrordata->getNumberOfBarrelBins();
23  int n2 = m_clustererrordata->getNumberOfEndcapBins();
24  // get the bins of the cluster on track error data parametrization
25  const std::vector<float> &csx = m_clusterontrackerrordata->getClusterSizeBinsX();
26  const std::vector<float> &csy = m_clusterontrackerrordata->getClusterSizeBinsY();
27  const std::vector<float> &eta = m_clusterontrackerrordata->getEtaBins();
28  const std::vector<float> &alpha = m_clusterontrackerrordata->getIncidenceAngleBins();
29  //IBL
30  const std::vector<float> &etaibl = m_clusterontrackerrordata->getEtaIBLBins();
31  const std::vector<float> &alphaibl = m_clusterontrackerrordata->getIncidenceAngleIBLBins();
32  //
33  // number of bins
34  // Since the upper value is always implicit, numer of bins is the size of the vector
35  int ncsx = csx.size();
36  int ncsy = csy.size();
37  int neta = eta.size();
38  int nalpha = alpha.size();
39  int ncsx_ibl = m_clusterontrackerrordata->getIBLcsxbins();
40  int ncsy_ibl = m_clusterontrackerrordata->getIBLcsybins();
41  int netaibl = m_clusterontrackerrordata->getIBLetabins();
42  int nalphaibl =m_clusterontrackerrordata->getIBLphibins();
43  // get the bins of the charge interpolation parametrization
44  const std::vector<float> &csx2 = m_chargeinterpolationparameters->getClusterSizeXBins();
45  const std::vector<float> &csy2 = m_chargeinterpolationparameters->getClusterSizeYBins();
46  const std::vector<float> &eta2 = m_chargeinterpolationparameters->getEtaBins();
47  const std::vector<float> &alpha2 = m_chargeinterpolationparameters->getAngleBins();
48  // IBL
49  const std::vector<float> &etaibl2 = m_chargeinterpolationparameters->getIBLEtaBins() ;
50  const std::vector<float> &alphaibl2 = m_chargeinterpolationparameters->getIBLAngleBins() ;
51  //
52  // number of bins
53  // The upper limit is not implicit, we must subtract one!
54  int ncsx2 = csx2.size()-1;
55  int ncsy2 = csy2.size()-1;
56  int neta2 = eta2.size()-1;
57  int nalpha2 = alpha2.size()-1;
58  int ncsx2_ibl = m_chargeinterpolationparameters->getIBLcsxbins();
59  int ncsy2_ibl = m_chargeinterpolationparameters->getIBLcsybins();
60  int netaibl2 =m_chargeinterpolationparameters->getIBLetabins();
61  int nalphaibl2 = m_chargeinterpolationparameters->getIBLphibins();
62 
63  // Compute the overall number of values to store
64 
65  int n3a = ncsx*nalpha; // ClusterErrorOnTrack - number of barrel phi bins
66  int n3b = ncsx*ncsy*neta; // ClusterErrorOnTrack - number of barrel eta bins
67  int n3c = ncsx_ibl*nalphaibl;
68  int n3d = ncsy_ibl*netaibl;
69  int n4 = 6*ncsx2*nalpha2; // ChargeInterpolation - number of barrel phi bins
70  int n5 = 6*ncsy2*neta2; // ChargeInterpolation - number of barrel eta bins
71  int n6 = ncsx2_ibl*nalphaibl2;
72  int n7 = ncsy2_ibl*netaibl2;
73  int datasize =
74  2*n1+2*n2 // number of ClusterError values
75  +ncsx+ncsy+neta+nalpha // number of ClusterErrorOnTrack bin extremes values
76  +n3a+n3b // number of ClusterErrorOnTrack values
77  +ncsx2+1+ncsy2+1+neta2+1+nalpha2+1 // number of ChargeInterpolation bin extremes values
78  +n4+n5; // number of ChargeInterpolation values
79 
80  int offset = 13;
81  if(v1<-1||v2<-1||v3<-1) { // including IBL
82  offset +=8;
83  datasize +=2*n1 + netaibl+1 + nalphaibl+1 + n3c +n3d + netaibl2+1 + nalphaibl2+1 + n6 + n7;
84  }
85 
86  std::vector<float> constants;
87  constants.reserve(datasize+offset);
88  constants.push_back(v1);
89  constants.push_back(v2);
90  constants.push_back(v3);
91  constants.push_back(n1);
92  constants.push_back(n2);
93  constants.push_back(ncsx);
94  constants.push_back(ncsy);
95  constants.push_back(neta);
96  constants.push_back(nalpha);
97  constants.push_back(ncsx2);
98  constants.push_back(ncsy2);
99  constants.push_back(neta2);
100  constants.push_back(nalpha2);
101  if(offset>13){
102  constants.push_back(ncsx_ibl);
103  constants.push_back(ncsx_ibl);
104  constants.push_back(netaibl);
105  constants.push_back(nalphaibl);
106  constants.push_back(ncsx2_ibl);
107  constants.push_back(ncsy2_ibl);
108  constants.push_back(netaibl2);
109  constants.push_back(nalphaibl2);
110  }
111 
112  // set bins of cluster error on track parametrization (uppermost value implicit)
113  for(int i=0; i<ncsx; i++){ constants.push_back(csx[i]); }
114  for(int i=0; i<ncsy; i++){ constants.push_back(csy[i]); }
115  if(netaibl>0){
116  for(int i=0; i<netaibl+1; i++){ constants.push_back(etaibl[i]); }
117  }
118  if(nalphaibl>0){
119  for(int i=0; i<nalphaibl+1; i++){ constants.push_back(alphaibl[i]); }
120  }
121  for(int i=0; i<neta; i++){ constants.push_back(eta[i]); }
122  for(int i=0; i<nalpha; i++){ constants.push_back(alpha[i]); }
123  // set bins of charge interpolation parametrization (uppermost value stored)
124  for(int i=0; i<ncsx2+1; i++){ constants.push_back(csx2[i]); }
125  for(int i=0; i<ncsy2+1; i++){ constants.push_back(csy2[i]); }
126  if(netaibl2>0){
127  for(int i=0; i<netaibl2+1; i++){ constants.push_back(etaibl2[i]); }
128  }
129  if(nalphaibl2>0){
130  for(int i=0; i<nalphaibl2+1; i++){ constants.push_back(alphaibl2[i]); }
131  }
132  for(int i=0; i<neta2+1; i++){ constants.push_back(eta2[i]); }
133  for(int i=0; i<nalpha2+1; i++){ constants.push_back(alpha2[i]); }
134  // parametrization values
135  for(int i=0; i<n1; i++){ constants.push_back(m_clustererrordata->getPixelBarrelPhiError(i)); }
136  for(int i=0; i<n1; i++){ constants.push_back(m_clustererrordata->getPixelBarrelEtaError(i)); }
137  for(int i=0; i<n2; i++){ constants.push_back(m_clustererrordata->getPixelEndcapPhiError(i)); }
138  for(int i=0; i<n2; i++){ constants.push_back(m_clustererrordata->getPixelEndcapRError(i)); }
139  // IBL
140  if(v1<-1){
141  for(int i=0; i<n1; i++){ constants.push_back(m_clustererrordata->getPixelIBLPhiError(i)); }
142  for(int i=0; i<n1; i++){ constants.push_back(m_clustererrordata->getPixelIBLEtaError(i)); }
143  }
144  //IBL
145  if(n3c>0){
146  for(int i=0; i<n3c; i++){ constants.push_back(m_clusterontrackerrordata->getPixelIBLPhiError(i)); }
147  }
148  for(int i=0; i<n3a; i++){ constants.push_back(m_clusterontrackerrordata->getPixelBarrelPhiError(i)); }
149  if(n3d>0){
150  for(int i=0; i<n3d; i++){ constants.push_back(m_clusterontrackerrordata->getPixelIBLEtaError(i)); }
151  }
152  for(int i=0; i<n3b; i++){ constants.push_back(m_clusterontrackerrordata->getPixelBarrelEtaError(i)); }
153  for(int i=0; i<n6+n4; i++){ constants.push_back(m_chargeinterpolationparameters->getDeltaX(i)); }
154  for(int i=0; i<n7+n5; i++){ constants.push_back(m_chargeinterpolationparameters->getDeltaY(i)); }
155  return constants;
156 }

◆ GetNumberOfConstants()

int PixelCalib::PixelOfflineCalibData::GetNumberOfConstants ( ) const

◆ getPixelChargeInterpolationParameters() [1/2]

PixelChargeInterpolationParameters * PixelOfflineCalibData::getPixelChargeInterpolationParameters ( )
inline

Definition at line 101 of file PixelOfflineCalibData.h.

101  {
102  return m_chargeinterpolationparameters;
103 }

◆ getPixelChargeInterpolationParameters() [2/2]

const PixelChargeInterpolationParameters * PixelOfflineCalibData::getPixelChargeInterpolationParameters ( ) const
inline

Definition at line 114 of file PixelOfflineCalibData.h.

114  {
115  return m_chargeinterpolationparameters;
116 }

◆ getPixelClusterErrorData() [1/2]

PixelClusterErrorData * PixelOfflineCalibData::getPixelClusterErrorData ( )
inline

Definition at line 97 of file PixelOfflineCalibData.h.

97  {
98  return m_clustererrordata;
99 }

◆ getPixelClusterErrorData() [2/2]

const PixelClusterErrorData * PixelOfflineCalibData::getPixelClusterErrorData ( ) const
inline

Definition at line 110 of file PixelOfflineCalibData.h.

110  {
111  return m_clustererrordata;
112 }

◆ getPixelClusterOnTrackErrorData() [1/2]

PixelClusterOnTrackErrorData * PixelOfflineCalibData::getPixelClusterOnTrackErrorData ( )
inline

Definition at line 106 of file PixelOfflineCalibData.h.

106  {
107  return m_clusterontrackerrordata;
108 }

◆ getPixelClusterOnTrackErrorData() [2/2]

const PixelClusterOnTrackErrorData * PixelOfflineCalibData::getPixelClusterOnTrackErrorData ( ) const
inline

Definition at line 119 of file PixelOfflineCalibData.h.

119  {
120  return m_clusterontrackerrordata;
121 }

◆ operator=()

PixelOfflineCalibData& PixelCalib::PixelOfflineCalibData::operator= ( const PixelOfflineCalibData &  rhs)
delete

◆ SetConstants()

void PixelOfflineCalibData::SetConstants ( const std::vector< float > &  constants)

Definition at line 164 of file PixelOfflineCalibData.cxx.

164  {
165 
166  if(constants.at(0) > 0){ // old format
167  m_clustererrordata->setVersion(0);
168  m_clusterontrackerrordata->setVersion(0);
169  m_chargeinterpolationparameters->setVersion(0);
170 
171  const int n1 = int(constants.at(0)); // number of PixelClusterError barrel bins (60)
172  const int n2 = int(constants.at(1)); // number of PixelClusterError endcap bins (12)
173  const int ncsx = int(constants.at(2)); // number of PixelClusterOnTrackError cluster size bins (x direction)
174  const int ncsy = int(constants.at(3)); // number of PixelClusterOnTrackError cluster size bins (y direction)
175  const int neta = int(constants.at(4)); // number of PixelClusterOnTrackError eta bins (x direction)
176  const int nalpha = int(constants.at(5)); // number of PixelClusterOnTrackError incidence angle bins (y direction)
177  const int n4 = int(constants.at(6)); // number of charge interpolation constants (x direction)
178  const int n5 = int(constants.at(7)); // number of charge interpolation constants (y direction)
179  int ierr = 1; // error code
180  int offset = 8;
181  m_clusterontrackerrordata->setParameters(ncsx,ncsy,neta,nalpha,offset,constants);
182  offset += ncsx+ncsy+neta+nalpha;
183  for(int i=0; i<n1; i++){
184  ierr *= m_clustererrordata->setPixelBarrelPhiError(i,constants.at(i+offset));
185  ierr *= m_clustererrordata->setPixelBarrelEtaError(i,constants.at(i+n1+offset));
186  }
187  offset += 2*n1;
188  for(int i=0; i<n2; i++){
189  ierr *= m_clustererrordata->setPixelEndcapPhiError(i,constants.at(offset+i));
190  ierr *= m_clustererrordata->setPixelEndcapRError(i,constants.at(offset+n2+i));
191  }
192  offset += 2*n2;
193  int n3a = ncsx*nalpha; // number of barrel phi bins
194  int n3b = ncsx*ncsy*neta; // number of barrel eta bins
195  for(int i=0; i<n3a; i++){
196  m_clusterontrackerrordata->setPixelBarrelPhiError(i,constants.at(offset+i));
197  }
198  offset += n3a;
199  for(int i=0; i<n3b; i++){
200  m_clusterontrackerrordata->setPixelBarrelEtaError(i,constants.at(offset+i));
201  }
202  offset += n3b;
203  for(int i=0; i<n4; i++){
204  ierr *= m_chargeinterpolationparameters->setDeltaX(i,constants.at(offset+i));
205  }
206  offset += n4;
207  for(int i=0; i<n5; i++){
208  ierr *= m_chargeinterpolationparameters->setDeltaY(i,constants.at(offset+i));
209  }
210  m_chargeinterpolationparameters->setVersion(-1);
211  if(ierr == 0) std::cout << "something went wrong!" << std::endl;
212  return;
213 
214  }
215  else{
216 
217  const int v1 = int(constants.at(0)); // format version number for PixelClusterError
218  const int v2 = int(constants.at(1)); // format version number for PixelClusterOnTrackError
219  const int v3 = int(constants.at(2)); // format version number for PixelChargeInterpolation
220  m_clustererrordata->setVersion(v1);
221  m_clusterontrackerrordata->setVersion(v2);
222  m_chargeinterpolationparameters->setVersion(v3);
223 
224  const int n1 = int(constants.at(3)); // number of PixelClusterError barrel bins (60)
225  const int n2 = int(constants.at(4)); // number of PixelClusterError endcap bins (12)
226  const int ncsx = int(constants.at(5)); // number of PixelClusterOnTrackError cluster size bins (x direction)
227  const int ncsy = int(constants.at(6)); // number of PixelClusterOnTrackError cluster size bins (y direction)
228  const int neta = int(constants.at(7)); // number of PixelClusterOnTrackError eta bins (x direction)
229  const int nalpha = int(constants.at(8)); // number of PixelClusterOnTrackError incidence angle bins (y direction)
230  const int ncsx2 = int(constants.at(9)); // number of PixelClusterOnTrackError cluster size bins (x direction)
231  const int ncsy2 = int(constants.at(10)); // number of PixelClusterOnTrackError cluster size bins (y direction)
232  const int neta2 = int(constants.at(11)); // number of PixelClusterOnTrackError eta bins (x direction)
233  const int nalpha2 = int(constants.at(12)); // number of PixelClusterOnTrackError incidence angle bins (y direction)
234  int ierr = 1; // error code
235  int offset = 13;
236  if(v1<-1||v2<-1||v3<-1)offset +=8;
237  const int ncsx_ibl = offset>13 ? int(constants.at(13)) : 0;
238  const int ncsy_ibl = offset>13 ? int(constants.at(14)) : 0;
239  const int netaibl = offset>13 ? int(constants.at(15)) : 0;
240  const int nalphaibl = offset>13 ? int(constants.at(16)) : 0;
241  const int ncsx2_ibl = offset>13 ? int(constants.at(17)) : 0;
242  const int ncsy2_ibl = offset>13 ? int(constants.at(18)) : 0;
243  const int netaibl2 = offset>13 ? int(constants.at(19)) : 0;
244  const int nalphaibl2 = offset>13 ? int(constants.at(20)) : 0;
245  if(v2<-1){
246  m_clusterontrackerrordata->setIBLcsxbins(ncsx_ibl);
247  m_clusterontrackerrordata->setIBLcsybins(ncsy_ibl);
248  m_clusterontrackerrordata->setIBLetabins(netaibl);
249  m_clusterontrackerrordata->setIBLphibins(nalphaibl);
250  }
251  m_clusterontrackerrordata->setParameters(ncsx,ncsy,neta,nalpha,offset,constants);
252  offset += ncsx+ncsy+neta+nalpha; // check that offset is advanced or not
253  if(v2<-1) offset +=netaibl+1+nalphaibl+1;
254  if(v3<-1){
255  m_chargeinterpolationparameters->setIBLcsxbins(ncsx2_ibl);
256  m_chargeinterpolationparameters->setIBLcsybins(ncsy2_ibl);
257  m_chargeinterpolationparameters->setIBLetabins(netaibl2);
258  m_chargeinterpolationparameters->setIBLphibins(nalphaibl2);
259  }
260 
261  m_chargeinterpolationparameters->setParameters(ncsx2,ncsy2,neta2,nalpha2,offset,constants);
262  offset += (ncsx2+1)+(ncsy2+1)+(neta2+1)+(nalpha2+1);
263  if(v3<-1) offset += (netaibl2+1) + (nalphaibl2+1);
264  for(int i=0; i<n1; i++){
265  ierr *= m_clustererrordata->setPixelBarrelPhiError(i,constants.at(i+offset));
266  ierr *= m_clustererrordata->setPixelBarrelEtaError(i,constants.at(i+n1+offset));
267  }
268  offset += 2*n1;
269  for(int i=0; i<n2; i++){
270  ierr *= m_clustererrordata->setPixelEndcapPhiError(i,constants.at(offset+i));
271  ierr *= m_clustererrordata->setPixelEndcapRError(i,constants.at(offset+n2+i));
272  }
273  offset += 2*n2;
274  if(v1<-1){
275  for(int i=0; i<n1; i++){
276  ierr *= m_clustererrordata->setPixelIBLPhiError(i,constants.at(i+offset));
277  ierr *= m_clustererrordata->setPixelIBLEtaError(i,constants.at(i+n1+offset));
278  }
279  offset +=2*n1;
280  }
281  int n3a = ncsx*nalpha; // number of barrel phi bins
282  int n3b = ncsx*ncsy*neta; // number of barrel eta bins
283  int n3c = ncsx_ibl*nalphaibl;
284  int n3d = ncsy_ibl*netaibl;
285  if(n3c>0){
286  for(int i=0; i<n3c; i++){
287  m_clusterontrackerrordata->setPixelIBLPhiError(i,constants.at(offset+i));
288  }
289  offset += n3c;
290  }
291  for(int i=0; i<n3a; i++){
292  m_clusterontrackerrordata->setPixelBarrelPhiError(i,constants.at(offset+i));
293  }
294  offset += n3a;
295 
296  if(n3d>0){
297  for(int i=0; i<n3d; i++){
298  m_clusterontrackerrordata->setPixelIBLEtaError(i,constants.at(offset+i));
299  }
300  offset += n3d;
301  }
302 
303  for(int i=0; i<n3b; i++){
304  m_clusterontrackerrordata->setPixelBarrelEtaError(i,constants.at(offset+i));
305  }
306  offset += n3b;
307  const int n4 = 6*ncsx2*nalpha2; // number of charge interpolation constants (x direction)
308  const int n5 = 6*ncsy2*neta2; // number of charge interpolation constants (y direction)
309  const int n6 = ncsx2_ibl*nalphaibl2;
310  const int n7 = ncsy2_ibl*netaibl2;
311 
312  for(int i=0; i<n6+n4; i++){
313  ierr *= m_chargeinterpolationparameters->setDeltaX(i,constants.at(offset+i));
314  }
315  offset += n6+n4;
316  for(int i=0; i<n7+n5; i++){
317  ierr *= m_chargeinterpolationparameters->setDeltaY(i,constants.at(offset+i));
318  }
319  offset += n7+n5;
320 
321  if(ierr == 0) std::cout << "something went wrong!" << std::endl;
322  return;
323  }
324 }

◆ size()

int PixelCalib::PixelOfflineCalibData::size ( ) const

◆ update() [1/3]

bool PixelOfflineCalibData::update ( const PixelChargeInterpolationParameters &  idat)
inline

Definition at line 86 of file PixelOfflineCalibData.h.

87  {
88  *m_chargeinterpolationparameters = idat;
89  return true;
90 }

◆ update() [2/3]

bool PixelOfflineCalibData::update ( const PixelClusterErrorData &  idat)
inline

Definition at line 81 of file PixelOfflineCalibData.h.

81  {
82  *m_clustererrordata = idat;
83  return true;
84 }

◆ update() [3/3]

bool PixelOfflineCalibData::update ( const PixelClusterOnTrackErrorData &  idat)
inline

Definition at line 92 of file PixelOfflineCalibData.h.

92  {
93  *m_clusterontrackerrordata = idat;
94  return true;
95 }

Member Data Documentation

◆ m_chargeinterpolationparameters

PixelChargeInterpolationParameters* PixelCalib::PixelOfflineCalibData::m_chargeinterpolationparameters
private

Definition at line 67 of file PixelOfflineCalibData.h.

◆ m_clustererrordata

PixelClusterErrorData* PixelCalib::PixelOfflineCalibData::m_clustererrordata
private

Definition at line 66 of file PixelOfflineCalibData.h.

◆ m_clusterontrackerrordata

PixelClusterOnTrackErrorData* PixelCalib::PixelOfflineCalibData::m_clusterontrackerrordata
private

Definition at line 68 of file PixelOfflineCalibData.h.

The documentation for this class was generated from the following files:
PixelCalib::PixelClusterErrorData::setPixelEndcapRError
int setPixelEndcapRError(int ibin, float error)
Definition: PixelClusterErrorData.cxx:115
PixelClusterOnTrackErrorData
PixelCalib::PixelClusterErrorData::getNumberOfBarrelBins
int getNumberOfBarrelBins() const
Definition: PixelClusterErrorData.h:59
PixelCalib::PixelChargeInterpolationParameters::setDeltaY
int setDeltaY(int ieta, int iclustersize, int ilayer, float value)
Definition: PixelChargeInterpolationParameters.cxx:257
PixelCalib::PixelChargeInterpolationParameters::getIBLAngleBins
const std::vector< float > & getIBLAngleBins() const
Definition: PixelChargeInterpolationParameters.h:97
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
PixelCalib::PixelClusterOnTrackErrorData::setPixelBarrelPhiError
void setPixelBarrelPhiError(int ibin, double error)
Definition: PixelClusterOnTrackErrorData.h:68
PixelCalib::PixelChargeInterpolationParameters::setParameters
void setParameters(const int ncsx, const int ncsy, const int neta, const int nalpha, int offset, const std::vector< float > &constants)
Definition: PixelChargeInterpolationParameters.cxx:70
PixelCalib::PixelClusterOnTrackErrorData::getIBLcsxbins
int getIBLcsxbins() const
Definition: PixelClusterOnTrackErrorData.h:93
PixelCalib::PixelChargeInterpolationParameters::getIBLetabins
int getIBLetabins() const
Definition: PixelChargeInterpolationParameters.h:100
PixelCalib::PixelClusterOnTrackErrorData::getPixelBarrelPhiError
static double getPixelBarrelPhiError(double ang, int phiClusterSize)
Definition: PixelClusterOnTrackErrorData.cxx:89
PixelCalib::PixelClusterOnTrackErrorData::setPixelIBLEtaError
void setPixelIBLEtaError(int ibin, double error)
Definition: PixelClusterOnTrackErrorData.h:75
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
PixelCalib::PixelClusterOnTrackErrorData::setIBLetabins
void setIBLetabins(int ieta)
Definition: PixelClusterOnTrackErrorData.h:100
PixelCalib::PixelClusterErrorData::getPixelBarrelEtaError
float getPixelBarrelEtaError(int ibin) const
Definition: PixelClusterErrorData.cxx:89
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
PixelCalib::PixelClusterOnTrackErrorData::getEtaIBLBins
const std::vector< float > & getEtaIBLBins() const
Definition: PixelClusterOnTrackErrorData.h:52
PixelCalib::PixelClusterOnTrackErrorData::getClusterSizeBinsY
const std::vector< float > & getClusterSizeBinsY() const
Definition: PixelClusterOnTrackErrorData.h:48
PixelCalib::PixelOfflineCalibData::m_clusterontrackerrordata
PixelClusterOnTrackErrorData * m_clusterontrackerrordata
Definition: PixelOfflineCalibData.h:68
PixelCalib::PixelChargeInterpolationParameters::getDeltaY
float getDeltaY(int ieta, int iclustersize, int ilayer) const
Definition: PixelChargeInterpolationParameters.cxx:242
PixelCalib::PixelClusterOnTrackErrorData::getIBLphibins
int getIBLphibins() const
Definition: PixelClusterOnTrackErrorData.h:96
PixelCalib::PixelClusterErrorData::setPixelBarrelEtaError
int setPixelBarrelEtaError(int ibin, float error)
Definition: PixelClusterErrorData.cxx:129
PixelCalib::PixelChargeInterpolationParameters::getIBLcsxbins
int getIBLcsxbins() const
Definition: PixelChargeInterpolationParameters.h:98
PixelCalib::PixelChargeInterpolationParameters::getAngleBins
const std::vector< float > & getAngleBins() const
Definition: PixelChargeInterpolationParameters.h:85
PixelCalib::PixelClusterErrorData::setPixelIBLPhiError
int setPixelIBLPhiError(int ibin, float error)
Definition: PixelClusterErrorData.cxx:136
PixelCalib::PixelClusterOnTrackErrorData::Print
void Print(const std::string &file) const
Definition: PixelClusterOnTrackErrorData.cxx:301
PixelCalib::PixelClusterOnTrackErrorData::getIncidenceAngleBins
const std::vector< float > & getIncidenceAngleBins() const
Definition: PixelClusterOnTrackErrorData.h:50
PixelCalib::PixelClusterErrorData::getNumberOfEndcapBins
int getNumberOfEndcapBins() const
Definition: PixelClusterErrorData.h:60
PixelCalib::PixelChargeInterpolationParameters::getDeltaX
float getDeltaX(int iangle, int iclustersize, int ilayer) const
methods to get/set the calibration data as a function of the bin index for the various variables sepa...
Definition: PixelChargeInterpolationParameters.cxx:235
PixelCalib::PixelClusterErrorData::getPixelEndcapPhiError
float getPixelEndcapPhiError(int ibin) const
Definition: PixelClusterErrorData.cxx:71
PixelCalib::PixelClusterOnTrackErrorData::setIBLcsxbins
void setIBLcsxbins(int icsx)
Definition: PixelClusterOnTrackErrorData.h:98
PixelCalib::PixelClusterOnTrackErrorData::getVersion
int getVersion() const
Methods to access the calibration data.
Definition: PixelClusterOnTrackErrorData.cxx:296
PixelCalib::PixelChargeInterpolationParameters::getEtaBins
const std::vector< float > & getEtaBins() const
Definition: PixelChargeInterpolationParameters.h:84
PixelCalib::PixelClusterErrorData::setPixelEndcapPhiError
int setPixelEndcapPhiError(int ibin, float error)
Definition: PixelClusterErrorData.cxx:108
PixelCalib::PixelClusterErrorData::getPixelBarrelPhiError
float getPixelBarrelPhiError(int ibin) const
Definition: PixelClusterErrorData.cxx:83
PixelCalib::PixelOfflineCalibData::m_clustererrordata
PixelClusterErrorData * m_clustererrordata
Definition: PixelOfflineCalibData.h:66
PixelCalib::PixelChargeInterpolationParameters::getIBLphibins
int getIBLphibins() const
Definition: PixelChargeInterpolationParameters.h:101
PixelCalib::PixelChargeInterpolationParameters::setIBLcsybins
void setIBLcsybins(int icsy)
Definition: PixelChargeInterpolationParameters.h:103
PixelCalib::PixelClusterOnTrackErrorData::setIBLphibins
void setIBLphibins(int iphi)
Definition: PixelClusterOnTrackErrorData.h:101
lumiFormat.i
int i
Definition: lumiFormat.py:85
PixelCalib::PixelChargeInterpolationParameters::getClusterSizeYBins
const std::vector< float > & getClusterSizeYBins() const
Definition: PixelChargeInterpolationParameters.h:87
PixelCalib::PixelClusterOnTrackErrorData::setParameters
void setParameters(const int ncsx, const int ncsy, const int neta, const int nalpha, int offset, const std::vector< float > &constants)
Definition: PixelClusterOnTrackErrorData.cxx:219
PixelCalib::PixelClusterOnTrackErrorData::setIBLcsybins
void setIBLcsybins(int icsy)
Definition: PixelClusterOnTrackErrorData.h:99
PixelCalib::PixelChargeInterpolationParameters::setIBLphibins
void setIBLphibins(int ialpha)
Definition: PixelChargeInterpolationParameters.h:105
PixelCalib::PixelClusterOnTrackErrorData::getEtaBins
const std::vector< float > & getEtaBins() const
Definition: PixelClusterOnTrackErrorData.h:49
PixelCalib::PixelClusterOnTrackErrorData::getPixelIBLPhiError
float getPixelIBLPhiError(int ibin) const
Definition: PixelClusterOnTrackErrorData.cxx:143
PixelCalib::PixelClusterOnTrackErrorData::setPixelBarrelEtaError
void setPixelBarrelEtaError(int ibin, double error)
Definition: PixelClusterOnTrackErrorData.h:70
PixelCalib::PixelClusterErrorData::getPixelEndcapRError
float getPixelEndcapRError(int ibin) const
Definition: PixelClusterErrorData.cxx:77
PixelCalib::PixelClusterOnTrackErrorData::setVersion
void setVersion(int version)
Definition: PixelClusterOnTrackErrorData.cxx:294
PixelCalib::PixelClusterErrorData::getPixelIBLPhiError
float getPixelIBLPhiError(int ibin) const
Definition: PixelClusterErrorData.cxx:96
PixelCalib::PixelChargeInterpolationParameters::setVersion
void setVersion(int version)
Definition: PixelChargeInterpolationParameters.cxx:66
PixelCalib::PixelClusterErrorData::setPixelIBLEtaError
int setPixelIBLEtaError(int ibin, float error)
Definition: PixelClusterErrorData.cxx:143
PixelCalib::PixelClusterErrorData::setVersion
void setVersion(int version)
Definition: PixelClusterErrorData.cxx:67
PixelChargeInterpolationParameters
PixelCalib::PixelChargeInterpolationParameters::getVersion
int getVersion() const
Definition: PixelChargeInterpolationParameters.cxx:68
PixelCalib::PixelClusterErrorData::getPixelIBLEtaError
float getPixelIBLEtaError(int ibin) const
Definition: PixelClusterErrorData.cxx:102
Rtt_histogram.n1
n1
Definition: Rtt_histogram.py:21
ReadCellNoiseFromCoolCompare.v2
v2
Definition: ReadCellNoiseFromCoolCompare.py:364
PixelCalib::PixelChargeInterpolationParameters::setIBLetabins
void setIBLetabins(int ieta)
Definition: PixelChargeInterpolationParameters.h:104
PixelCalib::PixelChargeInterpolationParameters::Print
void Print(const std::string &filename) const
Definition: PixelChargeInterpolationParameters.cxx:421
PixelCalib::PixelClusterOnTrackErrorData::getClusterSizeBinsX
const std::vector< float > & getClusterSizeBinsX() const
Definition: PixelClusterOnTrackErrorData.h:47
constants
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:1
PixelCalib::PixelChargeInterpolationParameters::getClusterSizeXBins
const std::vector< float > & getClusterSizeXBins() const
Definition: PixelChargeInterpolationParameters.h:86
PixelCalib::PixelClusterOnTrackErrorData::getPixelBarrelEtaError
float getPixelBarrelEtaError(int ibin) const
Definition: PixelClusterOnTrackErrorData.cxx:125
PixelCalib::PixelClusterOnTrackErrorData::getIBLcsybins
int getIBLcsybins() const
Definition: PixelClusterOnTrackErrorData.h:94
PixelCalib::PixelClusterOnTrackErrorData::getIBLetabins
int getIBLetabins() const
Definition: PixelClusterOnTrackErrorData.h:95
PixelCalib::PixelClusterOnTrackErrorData::setPixelIBLPhiError
void setPixelIBLPhiError(int ibin, double error)
Definition: PixelClusterOnTrackErrorData.h:73
PixelCalib::PixelClusterErrorData::getVersion
int getVersion() const
Methods to access the calibration data.
Definition: PixelClusterErrorData.cxx:69
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
PixelCalib::PixelChargeInterpolationParameters::setDeltaX
int setDeltaX(int iangle, int iclustersize, int ilayer, float value)
Definition: PixelChargeInterpolationParameters.cxx:249
PixelCalib::PixelOfflineCalibData::m_chargeinterpolationparameters
PixelChargeInterpolationParameters * m_chargeinterpolationparameters
Definition: PixelOfflineCalibData.h:67
PixelCalib::PixelChargeInterpolationParameters::setIBLcsxbins
void setIBLcsxbins(int icsx)
Definition: PixelChargeInterpolationParameters.h:102
PixelCalib::PixelClusterErrorData::Print
void Print(const std::string &file) const
Definition: PixelClusterErrorData.cxx:176
PixelCalib::PixelClusterErrorData::setPixelBarrelPhiError
int setPixelBarrelPhiError(int ibin, float error)
Definition: PixelClusterErrorData.cxx:122
PixelCalib::PixelChargeInterpolationParameters::getIBLcsybins
int getIBLcsybins() const
Definition: PixelChargeInterpolationParameters.h:99
PixelCalib::PixelClusterOnTrackErrorData::getIncidenceAngleIBLBins
const std::vector< float > & getIncidenceAngleIBLBins() const
Definition: PixelClusterOnTrackErrorData.h:53
PixelCalib::PixelChargeInterpolationParameters::getIBLEtaBins
const std::vector< float > & getIBLEtaBins() const
Definition: PixelChargeInterpolationParameters.h:96
PixelCalib::PixelClusterOnTrackErrorData::getPixelIBLEtaError
float getPixelIBLEtaError(int ibin) const
Definition: PixelClusterOnTrackErrorData.cxx:137
Generated on Sun Dec 22 2024 22:06:00 for ATLAS Offline Software by   doxygen 1.8.18