ATLAS Offline Software
Loading...
Searching...
No Matches
PixelChargeInterpolationValidation.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4
5#ifndef PixelChargeInterpolationValidation_C
6#define PixelChargeInterpolationValidation_C
7
8#include <string>
9#include <vector>
10#include <sstream>
11#include <fstream>
12
13#include <TDirectory.h>
14#include <TH1.h>
15#include <TH2.h>
16#include <TProfile.h>
17
18#include "PixelCalibAlgs/OfflineCalibUtils.icc"
19#include "PixelCalibAlgs/PixelChargeInterpolationValidation.h"
20#include "PixelCalibAlgs/PixelResidualHistograms.h"
21#include "PixelConditionsData/PixelChargeInterpolationParameters.h"
22#include "PixelConditionsData/PixelClusterOnTrackErrorData.h"
23
24static const int NLAYERS = 4;
25static const int NCLUSSIZES = 10;
26
27namespace PixelCalib{
28
29
30PixelChargeInterpolationValidation::PixelChargeInterpolationValidation(const std::string& tag,
31 const PixelChargeInterpolationParameters &model):
32 m_eta(0),
33 m_phi(0),
34 m_etaDig(0),
35 m_phiDig(0),
36 m_etaPull(0),
37 m_phiPull(0),
38 m_etaErr(0),
39 m_phiErr(0),
40 m_eta_phi(0),
41 m_phi_eta(0),
42 m_etaDig_phi(0),
43 m_phiDig_eta(0),
44 m_etaPull_phi(0),
45 m_phiPull_eta(0),
46 m_etaErr_phi(0),
47 m_phiErr_eta(0),
48 m_charge_eta(0),
49 m_charge_phi(0),
50 m_name(tag){
51
52 std::vector<float> *layers = getLayersBins();
53 std::vector<float> clustersizeEta = model.getClusterSizeYBins();
54 clustersizeEta.insert(clustersizeEta.begin(),0.5);
55 clustersizeEta.push_back(100);
56 std::vector<float> clustersizePhi = model.getClusterSizeXBins();
57 clustersizePhi.insert(clustersizePhi.begin(),0.5);
58 clustersizePhi.push_back(100);
59
60 std::vector<float> phibins_Layer;
61 for(int i = -60; i <= 60; i+=2) phibins_Layer.push_back(i);
62 std::vector<float> etabins_Layer;
63 for(float i = -2.5; i <= 2.5; i+=0.125) etabins_Layer.push_back(i);
64 std::vector<float> ptbins_Layer;
65 int ntot = 9;
66 double start = 0.1;
67 double end = 10E3;
68 ptbins_Layer.reserve(ntot+1);
69for(int i = 0; i < ntot+1; i++){
70 ptbins_Layer.push_back( start * pow( end/start, double(i)/double(ntot) ) );
71 }
72
73
74
75 std::vector<std::string> binsnames(3);
76 std::vector<std::vector <float> > binsvectors(3);
77
78 binsnames[LayerIndex] = "Layer";
79 binsnames[AngleIndex] = "#eta_{i}";
80 binsnames[ClustersizeIndex] = "ClusterSize";
81
82 binsvectors[LayerIndex] = *layers;
83 binsvectors[AngleIndex] = etabins_Layer;
84 binsvectors[ClustersizeIndex] = std::move(clustersizeEta);
85
86 m_eta = new PixelResidualHistograms(std::string("ResEta"),
87 std::string("Local y residuals - Analog position"),
88 500,100,binsvectors,binsnames);
89
90 m_etaDig = new PixelResidualHistograms(std::string("ResEtaDig"),
91 std::string("Local y residuals - Center position"),
92 500,100,binsvectors,binsnames);
93
94 m_etaPull = new PixelResidualHistograms(std::string("PullEta"),
95 std::string("Local y pulls - Analog position"),
96 10.,100,binsvectors,binsnames);
97
98 m_etaErr = new PixelResidualHistograms(std::string("ErrEta"),
99 std::string("Local y errors - Cluster uncertainty"),
100 1000,250,binsvectors,binsnames);
101
102 m_phi_eta = new PixelResidualHistograms(std::string("ResPhiEta"),
103 std::string("Local x residuals - Analog position"),
104 150, 100, binsvectors,binsnames);
105
106 m_phiDig_eta = new PixelResidualHistograms(std::string("ResPhiDigEta"),
107 std::string("Local x residuals - Center position"),
108 150, 100, binsvectors,binsnames);
109
110 m_phiPull_eta = new PixelResidualHistograms(std::string("PullPhiEta"),
111 std::string("Local x pulls - Analog position"),
112 10.,100,binsvectors,binsnames);
113
114 m_phiErr_eta = new PixelResidualHistograms(std::string("ErrPhiEta"),
115 std::string("Local x errors - Cluster uncertainty"),
116 100,100,binsvectors,binsnames);
117
118 m_charge_eta = new PixelResidualHistograms(std::string("ChargeEta"),
119 std::string("Charge"),
120 600000,600,binsvectors,binsnames);
121
122 binsnames[AngleIndex] = "#phi_{i} [#circ]";
123
124 binsvectors[AngleIndex] = phibins_Layer;
125 binsvectors[ClustersizeIndex] = std::move(clustersizePhi);
126
127 m_phi = new PixelResidualHistograms(std::string("ResPhi"),
128 std::string("Local x residuals - Analog position"),
129 150, 100, binsvectors,binsnames);
130
131 m_phiDig = new PixelResidualHistograms(std::string("ResPhiDig"),
132 std::string("Local x residuals - Center position"),
133 150, 100, binsvectors,binsnames);
134
135 m_phiPull = new PixelResidualHistograms(std::string("PullPhi"),
136 std::string("Local x pulls - Analog position"),
137 10.,100,binsvectors,binsnames);
138
139 m_phiErr = new PixelResidualHistograms(std::string("ErrPhi"),
140 std::string("Local x errors - Cluster uncertainty"),
141 100,100,binsvectors,binsnames);
142
143 m_eta_phi = new PixelResidualHistograms(std::string("ResEtaPhi"),
144 std::string("Local y residuals - Analog position"),
145 500,100,binsvectors,binsnames);
146
147 m_etaDig_phi = new PixelResidualHistograms(std::string("ResEtaDigPhi"),
148 std::string("Local y residuals - Center position"),
149 500,100,binsvectors,binsnames);
150
151 m_etaPull_phi = new PixelResidualHistograms(std::string("PullEtaPhi"),
152 std::string("Local y pulls - Analog position"),
153 10.,100,binsvectors,binsnames);
154
155 m_etaErr_phi = new PixelResidualHistograms(std::string("ErrEtaPhi"),
156 std::string("Local y errors - Cluster uncertainty"),
157 1000,250,binsvectors,binsnames);
158
159 m_charge_phi = new PixelResidualHistograms(std::string("ChargePhi"),
160 std::string("Charge"),
161 600000,600,binsvectors,binsnames);
162
163 std::vector<std::string> binsnames_Layer(2);
164 std::vector<std::vector <float> > binsvectors_Layer(2);
165
166 binsnames_Layer[0] = "p_{T} [GeV]";
167 binsnames_Layer[1] = "#eta_{i}";
168
169 binsvectors_Layer[0] = std::move(ptbins_Layer);
170 binsvectors_Layer[1] = etabins_Layer;
171
172 for(int i = 0 ; i < NLAYERS; i++){
173
174 std::cout << "layers " << NLAYERS << " " << i << std::endl;
175
176 std::ostringstream name;
177 std::ostringstream title;
178 name << "ResEta_Layer" << i;
179 title << "Local y resolution - Layer " << i ;
180 m_eta_Layer.push_back(
181 new PixelResidualHistograms(name.str(),
182 ( title.str() + " - Analog position").c_str(),
183 500, 100, binsvectors_Layer, binsnames_Layer)
184 );
185 m_etaDig_Layer.push_back(
186 new PixelResidualHistograms( (name.str() + "Dig").c_str(),
187 ( title.str() + " - Center position").c_str(),
188 500, 100, binsvectors_Layer, binsnames_Layer)
189 );
190 m_etaPull_Layer.push_back(
191 new PixelResidualHistograms( (name.str() + "Pull").c_str(),
192 ( title.str() + " - Pulls").c_str(),
193 10., 100, binsvectors_Layer, binsnames_Layer)
194 );
195 }
196
197
198 binsnames_Layer[1] = "#phi_{i} [#circ]";
199 binsvectors_Layer[1] = phibins_Layer;
200
201 for(int i = 0 ; i < NLAYERS; i++){
202 std::ostringstream name;
203 std::ostringstream title;
204 name << "ResPhi_Layer" << i;
205 title << "Local x resolution - Layer " << i ;
206 m_phi_Layer.push_back(
207 new PixelResidualHistograms(name.str(),
208 ( title.str() + " - Analog position").c_str(),
209 150, 100, binsvectors_Layer, binsnames_Layer)
210 );
211 m_phiDig_Layer.push_back(
212 new PixelResidualHistograms( (name.str() + "Dig").c_str(),
213 ( title.str() + " - Center position").c_str(),
214 150, 100, binsvectors_Layer, binsnames_Layer)
215 );
216 m_phiPull_Layer.push_back(
217 new PixelResidualHistograms( (name.str() + "Pull").c_str(),
218 ( title.str() + " - Pulls").c_str(),
219 10., 100, binsvectors_Layer, binsnames_Layer)
220 );
221 }
222
223 std::vector<std::string> binsnames_Clustersize(1);
224 std::vector<std::vector <float> > binsvectors_Clustersize(1);
225
226 binsnames_Clustersize[0] = "#eta_{i}";
227 binsvectors_Clustersize[0] = etabins_Layer;
228
229 for(int i = 0 ; i < NCLUSSIZES; i++){
230 std::ostringstream name;
231 std::ostringstream title;
232 name << "ResEta_Clustersize" << i+1;
233 title << "Local y resolution - Clustersize " << i+1;
234 m_eta_Clustersize.push_back(
235 new PixelResidualHistograms(name.str(),
236 ( title.str() + " - Analog position").c_str(),
237 400, 100, binsvectors_Clustersize, binsnames_Clustersize)
238 );
239 m_etaDig_Clustersize.push_back(
240 new PixelResidualHistograms( (name.str() + "Dig").c_str(),
241 ( title.str() + " - Center position").c_str(),
242 400, 100, binsvectors_Clustersize, binsnames_Clustersize)
243 );
244 m_etaErr_Clustersize.push_back(
245 new PixelResidualHistograms( (name.str() + "Err").c_str(),
246 ( title.str() + " - Cluster uncertainty").c_str(),
247 1000, 250, binsvectors_Clustersize, binsnames_Clustersize)
248 );
249 m_etaPull_Clustersize.push_back(
250 new PixelResidualHistograms( (name.str() + "Pull").c_str(),
251 ( title.str() + " - Pull").c_str(),
252 10., 100., binsvectors_Clustersize, binsnames_Clustersize)
253 );
254 std::ostringstream namecs;
255 std::ostringstream titlecs;
256 namecs << "Eta_Clustersize" << i+1;
257 titlecs << "#eta_{i} distribution - Clustersize " << i+1 ;
258 if (! etabins_Layer.empty()){
259 m_etaClustersize.push_back(
260 new TH1F(namecs.str().c_str(), titlecs.str().c_str(),
261 etabins_Layer.size(), etabins_Layer.front(),
262 etabins_Layer.back())
263 );
264 }
265 }
266
267
268 binsnames_Clustersize[0] = "#phi_{i} [#circ]";
269 binsvectors_Clustersize[0] = std::move(phibins_Layer);
270
271 for(int i = 0 ; i < NCLUSSIZES; i++){
272 std::ostringstream name;
273 std::ostringstream title;
274 name << "ResPhi_Clustersize" << i+1;
275 title << "Local x resolution - Clustersize " << i+1;
276 m_phi_Clustersize.push_back(
277 new PixelResidualHistograms(name.str(),
278 ( title.str() + " - Analog position").c_str(),
279 150, 100, binsvectors_Clustersize, binsnames_Clustersize)
280 );
281 m_phiDig_Clustersize.push_back(
282 new PixelResidualHistograms( (name.str() + "Dig").c_str(),
283 ( title.str() + " - Center position").c_str(),
284 150, 100, binsvectors_Clustersize, binsnames_Clustersize)
285 );
286 m_phiErr_Clustersize.push_back(
287 new PixelResidualHistograms( (name.str() + "Err").c_str(),
288 ( title.str() + " - Cluster uncertainty").c_str(),
289 100, 100, binsvectors_Clustersize, binsnames_Clustersize)
290 );
291 m_phiPull_Clustersize.push_back(
292 new PixelResidualHistograms( (name.str() + "Pull").c_str(),
293 ( title.str() + " - Pull").c_str(),
294 10., 100., binsvectors_Clustersize, binsnames_Clustersize)
295 );
296 std::ostringstream namecs;
297 std::ostringstream titlecs;
298 namecs << "Phi_Clustersize" << i+1;
299 titlecs << "#phi_{i} distribution - Clustersize " << i+1 ;
300 m_phiClustersize.push_back(
301 new TH1F(namecs.str().c_str(), titlecs.str().c_str(),
302 400, -100,100)
303 );
304 }
305
306 m_eta_phi_correlation = new TH2F("eta_phi_correlation",
307 "#phi_{i} #eta_{i} correlation", 100, -100,100, 100, -2.5, 2.5);
308
309 m_eta_phi_correlation->GetYaxis()->SetTitle("#eta_{i}");
310 m_eta_phi_correlation->GetXaxis()->SetTitle("#phi_{i}");
311
312 m_CSeta_CSphi_correlation = new TH2F("CSeta_CSphi_correlation",
313 "#Deltarow #Deltacolumn correlation", 10, 0,10, 10, 0, 10);
314
315 m_CSeta_CSphi_correlation->GetYaxis()->SetTitle("#eta_{i}");
316 m_CSeta_CSphi_correlation->GetXaxis()->SetTitle("#phi_{i}");
317
318
319 double ptbins_Layerpointer[101];
320 int ntot2 = 100;
321 double start2 = 0.1;
322 double end2 = 10E3;
323 for(int i = 0; i < ntot2+1; i++){
324 ptbins_Layerpointer[i] = start2 * pow( end2/start2, double(i)/double(ntot2) );
325 }
326 m_ResEtaDig_vs_p = new TH2F("ResEtaDig_vs_p",
327 "Local y residuals vs p_{T}",
328 100, ptbins_Layerpointer, 100, -1000, 1000);
329 m_ResPhiDig_vs_p = new TH2F("ResPhiDig_vs_p", "Local x residuals vs p_{T}",
330 100, ptbins_Layerpointer, 100, -400, 400);
331
332
333 delete layers;
334
335}
336
338
339PixelChargeInterpolationValidation::~PixelChargeInterpolationValidation(){
340
341 delete m_phi;
342 delete m_eta;
343 delete m_phiDig;
344 delete m_etaDig;
345 delete m_phiPull;
346 delete m_etaPull;
347 delete m_phiErr;
348 delete m_etaErr;
349 delete m_phi_eta;
350 delete m_eta_phi;
351 delete m_phiDig_eta;
352 delete m_etaDig_phi;
353 delete m_phiPull_eta;
354 delete m_etaPull_phi;
355 delete m_phiErr_eta;
356 delete m_etaErr_phi;
357 delete m_charge_eta;
358 delete m_charge_phi;
359
360 m_phi = 0;
361 m_eta = 0;
362 m_phiDig = 0;
363 m_etaDig = 0;
364 m_phiPull = 0;
365 m_etaPull = 0;
366 m_phiErr = 0;
367 m_etaErr = 0;
368 m_phi_eta = 0;
369 m_eta_phi = 0;
370 m_phiDig_eta = 0;
371 m_etaDig_phi = 0;
372 m_phiPull_eta = 0;
373 m_etaPull_phi = 0;
374 m_phiErr_eta = 0;
375 m_etaErr_phi = 0;
376 m_charge_eta = 0;
377 m_charge_phi = 0;
378
379 for(int i = 0 ; i < NLAYERS; i++){
380 delete m_eta_Layer[i];
381 delete m_etaDig_Layer[i];
382 delete m_etaPull_Layer[i];
383 delete m_phi_Layer[i];
384 delete m_phiDig_Layer[i];
385 delete m_phiPull_Layer[i];
386
387 m_eta_Layer[i] = 0;
388 m_etaDig_Layer[i] = 0;
389 m_etaPull_Layer[i] = 0;
390 m_phi_Layer[i] = 0;
391 m_phiDig_Layer[i] = 0;
392 m_phiPull_Layer[i] = 0;
393 }
394
395 for(int i = 0 ; i < NCLUSSIZES; i++){
396 delete m_eta_Clustersize[i];
397 delete m_etaDig_Clustersize[i];
398 delete m_etaPull_Clustersize[i];
399 delete m_etaErr_Clustersize[i];
400 delete m_phi_Clustersize[i];
401 delete m_phiDig_Clustersize[i];
402 delete m_phiPull_Clustersize[i];
403 delete m_phiErr_Clustersize[i];
404 m_eta_Clustersize[i] = 0;
405 m_etaDig_Clustersize[i] = 0;
406 m_etaPull_Clustersize[i] = 0;
407 m_etaErr_Clustersize[i] = 0;
408 m_phi_Clustersize[i] = 0;
409 m_phiDig_Clustersize[i] = 0;
410 m_phiPull_Clustersize[i] = 0;
411 m_phiErr_Clustersize[i] = 0;
412 delete m_phiClustersize[i]; m_phiClustersize[i] = 0;
413 delete m_etaClustersize[i]; m_etaClustersize[i] = 0;
414 }
415
416 delete m_eta_phi_correlation; m_eta_phi_correlation = 0;
417 delete m_CSeta_CSphi_correlation; m_CSeta_CSphi_correlation = 0;
418 delete m_ResEtaDig_vs_p; m_ResEtaDig_vs_p = 0;
419 delete m_ResPhiDig_vs_p; m_ResPhiDig_vs_p = 0;
420
421
422}
423
424
426
427int PixelChargeInterpolationValidation::Read(TDirectory *file){
428
429
430 TDirectory *current = gDirectory;
431 if(file !=0) file->cd();
432 TDirectory *globaldir = (TDirectory *)gDirectory->Get("Validation");
433 globaldir->cd();
434 int readhistos = 0;
435 readhistos += m_phi->Read();
436 readhistos += m_eta->Read();
437 readhistos += m_phiDig->Read();
438 readhistos += m_etaDig->Read();
439 readhistos += m_phiPull->Read();
440 readhistos += m_etaPull->Read();
441 readhistos += m_phiErr->Read();
442 readhistos += m_etaErr->Read();
443 readhistos += m_phi_eta->Read();
444 readhistos += m_eta_phi->Read();
445 readhistos += m_phiDig_eta->Read();
446 readhistos += m_etaDig_phi->Read();
447 readhistos += m_phiPull_eta->Read();
448 readhistos += m_etaPull_phi->Read();
449 readhistos += m_phiErr_eta->Read();
450 readhistos += m_etaErr_phi->Read();
451 readhistos += m_charge_eta->Read();
452 readhistos += m_charge_phi->Read();
453 for(int i = 0 ; i < NLAYERS; i++){
454 m_eta_Layer[i]->Read();
455 m_etaDig_Layer[i]->Read();
456 m_etaPull_Layer[i]->Read();
457 m_phi_Layer[i]->Read();
458 m_phiDig_Layer[i]->Read();
459 m_phiPull_Layer[i]->Read();
460 }
461 for(int i = 0 ; i < NCLUSSIZES; i++){
462 m_eta_Clustersize[i]->Read();
463 m_etaDig_Clustersize[i]->Read();
464 m_etaErr_Clustersize[i]->Read();
465 m_etaPull_Clustersize[i]->Read();
466 m_phi_Clustersize[i]->Read();
467 m_phiDig_Clustersize[i]->Read();
468 m_phiErr_Clustersize[i]->Read();
469 m_phiErr_Clustersize[i]->Read();
470 //m_phiClustersize[i]->Read();
471 //m_etaClustersize[i]->Read();
472 }
473 //m_eta_phi_correlation
474 //m_CSeta_CSphi_correlation
475
476 current->cd();
477 return readhistos;
478}
479
481
482int PixelChargeInterpolationValidation::Write(TDirectory *writedir){
483
484 TDirectory *current = gDirectory;
485 TDirectory *globaldir;
486 if(writedir != 0) writedir->cd();
487 globaldir = gDirectory->mkdir("Validation");
488 globaldir->cd();
489 int writtenhistos = 0;
490 writtenhistos += m_phi->Write(true);
491 writtenhistos += m_eta->Write(true);
492 writtenhistos += m_phiDig->Write(true);
493 writtenhistos += m_etaDig->Write(true);
494 writtenhistos += m_phiPull->Write(true);
495 writtenhistos += m_etaPull->Write(true);
496 writtenhistos += m_phiErr->Write(true);
497 writtenhistos += m_etaErr->Write(true);
498 writtenhistos += m_phi_eta->Write(true);
499 writtenhistos += m_eta_phi->Write(true);
500 writtenhistos += m_phiDig_eta->Write(true);
501 writtenhistos += m_etaDig_phi->Write(true);
502 writtenhistos += m_phiPull_eta->Write(true);
503 writtenhistos += m_etaPull_phi->Write(true);
504 writtenhistos += m_phiErr_eta->Write(true);
505 writtenhistos += m_etaErr_phi->Write(true);
506 writtenhistos += m_charge_eta->Write(true);
507 writtenhistos += m_charge_phi->Write(true);
508
509 for(int i = 0 ; i < NLAYERS; i++){
510 m_eta_Layer[i]->Write(true);
511 m_etaDig_Layer[i]->Write(true);
512 m_etaPull_Layer[i]->Write(true);
513 m_phi_Layer[i]->Write(true);
514 m_phiDig_Layer[i]->Write(true);
515 m_phiPull_Layer[i]->Write(true);
516 }
517 for(int i = 0 ; i < NCLUSSIZES; i++){
518 m_eta_Clustersize[i]->Write(true);
519 m_etaDig_Clustersize[i]->Write(true);
520 m_etaErr_Clustersize[i]->Write(true);
521 m_etaPull_Clustersize[i]->Write(true);
522 m_phi_Clustersize[i]->Write(true);
523 m_phiDig_Clustersize[i]->Write(true);
524 m_phiErr_Clustersize[i]->Write(true);
525 m_phiPull_Clustersize[i]->Write(true);
526 m_phiClustersize[i]->Write();
527 m_etaClustersize[i]->Write();
528 }
529
530 m_eta_phi_correlation->Write();
531 m_CSeta_CSphi_correlation->Write();
532 m_ResEtaDig_vs_p->Write();
533 m_ResPhiDig_vs_p->Write();
534
535 current->cd();
536 return writtenhistos;
537}
538
540
541void PixelChargeInterpolationValidation::WriteErrorsFile(const std::string& name){
542
543 // Let's write resolutions into text file (see:
544 // void PixelClusterOnTrackErrorData::Print(std::string file) const
545 PixelClusterOnTrackErrorData *parameters = new PixelClusterOnTrackErrorData();
546
547 TProfile *etaModel = m_eta_Clustersize[0]->GetRMSProfile("#eta_{i}");
548 TProfile *phiModel = m_phi_Clustersize[0]->GetRMSProfile("#phi_{i} [#circ]");
549 //int ncsx = m_phi_Clustersize.size();
550 //int ncsy = m_eta_Clustersize.size(); // number of cluster size (x-direction) bins
551 int ncsx = 4;
552 int ncsy = 4;
553 int neta = etaModel->GetNbinsX(); // number of eta values bins
554 int nalpha = phiModel->GetNbinsX(); // number of incidence angle bins
555 int ntotbins = ncsx + ncsy + neta + nalpha;
556
557 std::vector<float> values;
558 values.reserve(ntotbins);
559 int globalindex = 0;
560 for (int i=0; i<ncsx && globalindex<ntotbins; i++, globalindex++) {
561 values.push_back(i+0.5);
562 }
563 for (int i=0; i<ncsy && globalindex<ntotbins; i++, globalindex++) {
564 values.push_back(i+0.5);
565 }
566 values.push_back(-2.5);
567 for (int i=1; i<neta && globalindex<ntotbins; i++, globalindex++) {
568 values.push_back(etaModel->GetBinLowEdge(i+1));
569 }
570 values.push_back(-180);
571 for (int i=1; i<nalpha && globalindex<ntotbins; i++, globalindex++) {
572 values.push_back(phiModel->GetBinLowEdge(i+1));
573 }
574 parameters->setParameters(ncsx, ncsy, neta, nalpha,0,std::move(values));
575
576 int ntotyconstnx = ncsx * nalpha;
577 globalindex = 0;
578 for(int i = 0; i < nalpha && globalindex < ntotyconstnx; i++)
579 for(int j = 0; j < ncsx && globalindex < ntotyconstnx; j++, globalindex++){
580 double value = m_phi_Clustersize[j]->GetRMSProfile("#phi_{i} [#circ]")->GetBinContent(i+1)/1000;
581 if (value == 0) value = (j+1)*50/sqrt(12)/1000;
582 parameters->setPixelBarrelPhiError(globalindex,value);
583 }
584 int ntotyconstny = ncsx * ncsy * neta;
585 globalindex = 0;
586 for(int i = 0; i < neta && globalindex < ntotyconstny; i++)
587 for(int j = 0; j < ncsx && globalindex < ntotyconstny; j++)
588 for(int k = 0; k < ncsy && globalindex < ntotyconstny; k++, globalindex++){
589 double value = m_eta_Clustersize[k]->GetRMSProfile("#eta_{i}")->GetBinContent(i+1)/1000;
590 if (value == 0) value = (k+1)*400/sqrt(12)/1000;
591 parameters->setPixelBarrelEtaError(globalindex,value);
592 }
593 parameters->Print(name);
594
595 delete parameters;
596}
597
599
600void PixelChargeInterpolationValidation::Fill(int Layer, double GeVTrkPt,
601 double Phi, double CSphi, double digResPhi, double ResPhi, double ErrPhi, Double_t PullPhi,
602 double Eta, double CSeta, double digResEta, double ResEta, double ErrEta, Double_t PullEta, double Charge){
603
604 std::vector< float >parameters(3);
605 parameters[LayerIndex] = Layer;
606 parameters[AngleIndex] = Eta;
607 parameters[ClustersizeIndex] = CSeta;
608 m_eta->Fill(float(ResEta),parameters);
609 m_etaDig->Fill(float(digResEta),parameters);
610 m_etaPull->Fill(float(PullEta),parameters);
611 m_etaErr->Fill(float(ErrEta), parameters);
612 m_phi_eta->Fill(float(ResPhi),parameters);
613 m_phiDig_eta->Fill(float(digResPhi),parameters);
614 m_phiPull_eta->Fill(float(PullPhi),parameters);
615 m_phiErr_eta->Fill(float(ErrPhi), parameters);
616 m_charge_eta->Fill(float(Charge), parameters);
617
618 parameters[AngleIndex] = Phi;
619 parameters[ClustersizeIndex] = CSphi;
620 m_phi->Fill(float(ResPhi),parameters);
621 m_phiDig->Fill(float(digResPhi),parameters);
622 m_phiPull->Fill(float(PullPhi),parameters);
623 m_phiErr->Fill(float(ErrPhi), parameters);
624 m_eta_phi->Fill(float(ResEta),parameters);
625 m_etaDig_phi->Fill(float(digResEta),parameters);
626 m_etaPull_phi->Fill(float(PullEta),parameters);
627 m_etaErr_phi->Fill(float(ErrEta), parameters);
628 m_charge_phi->Fill(float(Charge), parameters);
629
630 if( Layer < NLAYERS){
631 std::vector< float >parameters_Layer(2);
632 if(GeVTrkPt < 10E10) parameters_Layer[0] = GeVTrkPt;
633 else parameters_Layer[0] = 1.;
634
635 parameters_Layer[1] = Eta;
636 m_eta_Layer[Layer]->Fill(float(ResEta),parameters_Layer);
637 m_etaDig_Layer[Layer]->Fill(float(digResEta),parameters_Layer);
638 m_etaPull_Layer[Layer]->Fill(float(PullEta), parameters_Layer);
639
640 parameters_Layer[1] = Phi;
641 m_phi_Layer[Layer]->Fill(float(ResPhi),parameters_Layer);
642 m_phiDig_Layer[Layer]->Fill(float(digResPhi),parameters_Layer);
643 m_phiPull_Layer[Layer]->Fill(float(PullPhi), parameters_Layer);
644 }
645
646 std::vector< float >parameters_Clustersize(1);
647
648 if( int(CSeta)-1 < NCLUSSIZES){
649 parameters_Clustersize[0] = Eta;
650 m_eta_Clustersize[int(CSeta)-1]->Fill(float(ResEta),parameters_Clustersize);
651 m_etaDig_Clustersize[int(CSeta)-1]->Fill(float(digResEta),parameters_Clustersize);
652 m_etaErr_Clustersize[int(CSeta)-1]->Fill(float(ErrEta),parameters_Clustersize);
653 m_etaPull_Clustersize[int(CSeta)-1]->Fill(float(PullEta),parameters_Clustersize);
654 m_etaClustersize[int(CSeta)-1]->Fill(Eta);
655 }
656 if( int(CSphi)-1 < NCLUSSIZES){
657 parameters_Clustersize[0] = Phi;
658 m_phi_Clustersize[int(CSphi)-1]->Fill(float(ResPhi),parameters_Clustersize);
659 m_phiDig_Clustersize[int(CSphi)-1]->Fill(float(digResPhi),parameters_Clustersize);
660 //std::cout << ErrPhi << " " << CSphi << " " << Phi << std::endl;
661 m_phiErr_Clustersize[int(CSphi)-1]->Fill(float(ErrPhi),parameters_Clustersize);
662 m_phiPull_Clustersize[int(CSphi)-1]->Fill(float(PullPhi),parameters_Clustersize);
663 m_phiClustersize[int(CSphi)-1]->Fill(Phi);
664 }
665
666 m_eta_phi_correlation->Fill(Phi,Eta);
667 m_CSeta_CSphi_correlation->Fill(Phi,Eta);
668 m_ResEtaDig_vs_p->Fill(GeVTrkPt,digResEta);
669 m_ResPhiDig_vs_p->Fill(GeVTrkPt,digResPhi);
670 return;
671
672}
673
675
676void PixelChargeInterpolationValidation::Analyze(TDirectory *ref_file){
677
678 if(ref_file == 0) return;
679
680 /*
681 PixelResidualHistograms *eta_reference = 0;
682 PixelResidualHistograms *phi_reference = 0;
683 PixelResidualHistograms *eta_referencePerLayer = 0;
684 PixelResidualHistograms *phi_referencePerLayer = 0;
685 PixelResidualHistograms *eta_referencePerAngle = 0;
686 PixelResidualHistograms *phi_referencePerAngle = 0;
687 PixelResidualProfiles* phi_referenceProfileLayer = 0;
688 PixelResidualProfiles* eta_referenceProfileLayer = 0;
689 PixelResidualProfiles* phiPt_referenceProfileLayer = 0;
690 PixelResidualProfiles* etaPt_referenceProfileLayer = 0;
691 PixelResidualHistograms* phi_referencePerPt = 0;
692 PixelResidualHistograms* eta_referencePerPt = 0;
693 PixelResidualHistograms* phi_referencePerCs = 0;
694 PixelResidualHistograms* eta_referencePerCs = 0;
695 std::string ref_name = std::string("Reference ");
696
697 if(ref_file != 0 ){
698 eta_reference = m_etaVector->Clone();
699 eta_reference->Read(ref_file);
700 phi_reference = m_phiVector->Clone();
701 phi_reference->Read(ref_file);
702 eta_referencePerLayer = m_etaPerLayer->Clone();
703 eta_referencePerLayer->Read(ref_file);
704 phi_referencePerLayer = m_phiPerLayer->Clone();
705 phi_referencePerLayer->Read(ref_file);
706 eta_referencePerAngle = m_etaPerAngle->Clone();
707 eta_referencePerAngle->Read(ref_file);
708 phi_referencePerAngle = m_phiPerAngle->Clone();
709 phi_referencePerAngle->Read(ref_file);
710 phi_referenceProfileLayer = m_phivsAnglePerLayer->Clone();
711 phi_referenceProfileLayer->Read(ref_file);
712 eta_referenceProfileLayer = m_etavsAnglePerLayer->Clone();
713 eta_referenceProfileLayer->Read(ref_file);
714 phiPt_referenceProfileLayer = m_phivsPtPerLayer->Clone();
715 phiPt_referenceProfileLayer->Read(ref_file);
716 etaPt_referenceProfileLayer = m_etavsPtPerLayer->Clone();
717 etaPt_referenceProfileLayer->Read(ref_file);
718 phi_referencePerPt = m_phiPerPt->Clone();
719 phi_referencePerPt->Read(ref_file);
720 eta_referencePerPt = m_etaPerPt->Clone();
721 eta_referencePerPt->Read(ref_file);
722 phi_referencePerCs = m_phiPerCs->Clone();
723 phi_referencePerCs->Read(ref_file);
724 eta_referencePerCs = m_etaPerCs->Clone();
725 eta_referencePerCs->Read(ref_file);
726 }else{
727 eta_reference = m_etaDigVector;
728 phi_reference = m_phiDigVector;
729 eta_referencePerLayer = m_etaDigPerLayer;
730 phi_referencePerLayer = m_phiDigPerLayer;
731 eta_referencePerAngle = m_etaDigPerAngle;
732 phi_referencePerAngle = m_phiDigPerAngle;
733 phi_referenceProfileLayer = m_phiDigvsAnglePerLayer;
734 eta_referenceProfileLayer = m_etaDigvsAnglePerLayer;
735 phiPt_referenceProfileLayer = m_phiDigvsPtPerLayer;
736 etaPt_referenceProfileLayer = m_etaDigvsPtPerLayer;
737 phi_referencePerPt = m_phiDigPerPt;
738 eta_referencePerPt = m_phiDigPerPt;
739 phi_referencePerCs = m_phiDigPerCs;
740 eta_referencePerCs = m_etaDigPerCs;
741 ref_name = std::string("Digital ");
742 }
743
744 m_etaVector->Analyze(eta_reference, ref_name);
745 m_phiVector->Analyze(phi_reference, ref_name);
746 m_etaPerLayer->Analyze(eta_referencePerLayer, ref_name);
747 m_phiPerLayer->Analyze(phi_referencePerLayer, ref_name);
748 m_etaPerAngle->Analyze(eta_referencePerAngle, ref_name);
749 m_phiPerAngle->Analyze(phi_referencePerAngle, ref_name);
750
751 //m_phivsAnglePerLayer->Analyze(phi_referenceProfileLayer, ref_name);
752 //m_etavsAnglePerLayer->Analyze(eta_referenceProfileLayer, ref_name);
753
754 //m_phivsPtPerLayer->Analyze(phiPt_referenceProfileLayer, ref_name,std::string("log"));
755 //m_etavsPtPerLayer->Analyze(etaPt_referenceProfileLayer, ref_name,std::string("log"));
756 m_phiPerPt->Analyze(phi_referencePerPt, ref_name);
757 m_etaPerPt->Analyze(eta_referencePerPt, ref_name);
758
759 m_phiPerCs->Analyze(phi_referencePerCs, ref_name);
760 m_etaPerCs->Analyze(eta_referencePerCs, ref_name);
761
762 if(ref_file != 0 ){
763 delete eta_reference;
764 delete phi_reference;
765 delete eta_referencePerLayer;
766 delete phi_referencePerLayer;
767 delete eta_referencePerAngle;
768 delete phi_referencePerAngle;
769 delete phi_referenceProfileLayer;
770 delete eta_referenceProfileLayer;
771 delete phiPt_referenceProfileLayer;
772 delete etaPt_referenceProfileLayer;
773 delete phi_referencePerPt;
774 delete eta_referencePerPt;
775 delete phi_referencePerCs;
776 delete eta_referencePerCs;
777 }
778
779 phi_reference = 0;
780 eta_reference = 0;
781 phi_referencePerLayer = 0;
782 eta_referencePerLayer = 0;
783 phi_referencePerAngle = 0;
784 eta_referencePerAngle = 0;
785 phi_referenceProfileLayer = 0;
786 eta_referenceProfileLayer = 0;
787 phiPt_referenceProfileLayer = 0;
788 etaPt_referenceProfileLayer = 0;
789 phi_referencePerPt = 0;
790 eta_referencePerPt = 0;
791 phi_referencePerCs = 0;
792 eta_referencePerCs = 0;
793 */
794
795}
796
797}
798
799#endif // #ifdef PixelChargeInterpolationValidation_C
NCLUSSIZES
static const int NCLUSSIZES
Definition PixelChargeInterpolationValidation.cxx:25
NLAYERS
static const int NLAYERS
Definition PixelChargeInterpolationValidation.cxx:24
PixelCalib::PixelChargeInterpolationValidation::m_phiDig_Clustersize
std::vector< PixelResidualHistograms * > m_phiDig_Clustersize
Definition PixelChargeInterpolationValidation.h:73
PixelCalib::PixelChargeInterpolationValidation::PixelChargeInterpolationValidation
PixelChargeInterpolationValidation(const std::string &tag, const PixelChargeInterpolationParameters &model)
Definition PixelChargeInterpolationValidation.cxx:30
PixelCalib::PixelChargeInterpolationValidation::Fill
void Fill(int Layer, double GeVTrkPt, double Phi, double CSphi, double MicronDigResPhi, double MicronResPhi, double MicronErrPhi, double PullPhi, double Eta, double CSeta, double MicronDigResEta, double MicronResEta, double MicronErrEta, double PullEta, double Charge)
Definition PixelChargeInterpolationValidation.cxx:600
PixelCalib::PixelChargeInterpolationValidation::m_phiPull_Clustersize
std::vector< PixelResidualHistograms * > m_phiPull_Clustersize
Definition PixelChargeInterpolationValidation.h:77
PixelCalib::PixelChargeInterpolationValidation::m_etaDig_Clustersize
std::vector< PixelResidualHistograms * > m_etaDig_Clustersize
Definition PixelChargeInterpolationValidation.h:74
PixelCalib::PixelChargeInterpolationValidation::m_etaErr_Clustersize
std::vector< PixelResidualHistograms * > m_etaErr_Clustersize
Definition PixelChargeInterpolationValidation.h:76
PixelCalib::PixelChargeInterpolationValidation::m_phiErr_Clustersize
std::vector< PixelResidualHistograms * > m_phiErr_Clustersize
Definition PixelChargeInterpolationValidation.h:75
PixelCalib::PixelChargeInterpolationValidation::m_etaPull_Clustersize
std::vector< PixelResidualHistograms * > m_etaPull_Clustersize
Definition PixelChargeInterpolationValidation.h:78
file
TFile * file
Definition tile_monitor.h:29
Generated on for ATLAS Offline Software by doxygen 1.16.1