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