Update for Ds
[u/mrichter/AliRoot.git] / ITS / AliITSOnlineSPDscanAnalyzer.cxx
CommitLineData
4ee23d3d 1/**************************************************************************
2 * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
f0aa5f6c 18////////////////////////////////////////////////////////////
19// Author: Henrik Tydesjo //
20// This class is used in the detector algorithm framework //
21// to process the data stored in special container files //
22// (see AliITSOnlineSPDscan). For instance, minimum //
6727e2db 23// threshold values can be extracted. //
f0aa5f6c 24////////////////////////////////////////////////////////////
25
26#include "AliITSOnlineSPDscanAnalyzer.h"
27#include "AliITSOnlineSPDscan.h"
28#include "AliITSOnlineSPDscanSingle.h"
29#include "AliITSOnlineSPDscanMultiple.h"
30#include "AliITSOnlineSPDscanMeanTh.h"
31#include "AliITSOnlineCalibrationSPDhandler.h"
32#include "AliITSRawStreamSPD.h"
33#include <TStyle.h>
34#include <TMath.h>
f652c3be 35#include <TLine.h>
f0aa5f6c 36#include <TF1.h>
37#include <TGraph.h>
38#include <TH2F.h>
53ae21ce 39#include <TError.h>
6727e2db 40#include <iostream>
41#include <fstream>
f0aa5f6c 42
43Double_t itsSpdErrorf(Double_t *x, Double_t *par){
44 if (par[2]<0) par[2]=0;
45 Double_t val = par[2]+(0.12*256*32-par[2])*(0.5+0.5*TMath::Erf((x[0]-par[0])/par[1]/sqrt(2.)));
46 return val;
47}
48//Double_t itsSpdErrorfOrig(Double_t *x, Double_t *par){
49// return 0.5+0.5*TMath::Erf((x[0]-par[0])/par[1]/sqrt(2.));
50//}
f652c3be 51//_________________________________________________________________________
52Double_t itsSpdScurveForMeanTh(Double_t *x, Double_t *par){
53 if (par[2]<0) par[2]=0;
54 Double_t val = 1.- par[2]*(1.-TMath::Erf((x[0]-par[0])/par[1]/sqrt(2.)));
55// Double_t val = par[2]+(0.12*256*32-par[2])*(0.5+0.5*TMath::Erf((x[0]-par[0])/par[1]/sqrt(2.)));
56 return val;
57}
f0aa5f6c 58
de12e454 59//_________________________________________________________________________
6ddf3d66 60AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler *handler, Bool_t readFromGridFile) :
de12e454 61 fType(99),fDacId(99),fFileName(fileName),fScanObj(NULL),fHandler(handler),fTriggers(NULL),fTPeff(0),fTPeffHS(NULL),fDeadPixel(0),fDeadPixelHS(NULL),fNoisyPixel(0),fNoisyPixelHS(NULL),
f0aa5f6c 62 fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
6727e2db 63 fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(5),fMaxBaseLineLevel(10)
f0aa5f6c 64{
65 // constructor
f0aa5f6c 66 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
67 for (UInt_t hs=0; hs<6; hs++) {
68 fMeanMultiplicity[hs][chipNr]=NULL;
69 fHitEventEfficiency[hs][chipNr]=NULL;
70 }
71 }
de12e454 72 for (UInt_t hs=0; hs<6; hs++) {
73 fTPeffChip[hs]=NULL;
74 fDeadPixelChip[hs]=NULL;
75 fNoisyPixelChip[hs]=NULL;
76 }
77
6727e2db 78 for (UInt_t mod=0; mod<240; mod++) {
79 fbModuleScanned[mod]=kFALSE;
f0aa5f6c 80 }
81
6ddf3d66 82 Init(readFromGridFile);
f0aa5f6c 83}
de12e454 84//_________________________________________________________________________
f0aa5f6c 85AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle) :
de12e454 86 fType(99),fDacId(99),fFileName("."),fScanObj(NULL),fHandler(NULL),fTriggers(NULL),fTPeff(0),fTPeffHS(NULL),fDeadPixel(0),fDeadPixelHS(NULL),fNoisyPixel(0),fNoisyPixelHS(NULL),
f0aa5f6c 87 fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
6727e2db 88 fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(5),fMaxBaseLineLevel(10)
f0aa5f6c 89{
6727e2db 90 // copy constructor, only copies the filename and params (not the processed data)
53ae21ce 91 fFileName=handle.fFileName;
6727e2db 92 fOverWrite=handle.fOverWrite;
93 fNoiseThreshold=handle.fNoiseThreshold;
94 fNoiseMinimumEvents=handle.fNoiseMinimumEvents;
95 fMinNrStepsBeforeIncrease=handle.fMinNrStepsBeforeIncrease;
96 fMinIncreaseFromBaseLine=handle.fMinIncreaseFromBaseLine;
97 fStepDownDacSafe=handle.fStepDownDacSafe;
98 fMaxBaseLineLevel=handle.fMaxBaseLineLevel;
f0aa5f6c 99
f0aa5f6c 100 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
101 for (UInt_t hs=0; hs<6; hs++) {
102 fMeanMultiplicity[hs][chipNr]=NULL;
103 fHitEventEfficiency[hs][chipNr]=NULL;
104 }
105 }
de12e454 106 for (UInt_t hs=0; hs<6; hs++) {
107 fTPeffChip[hs]=NULL;
108 fDeadPixelChip[hs]=NULL;
109 fNoisyPixelChip[hs]=NULL;
110 }
111
6727e2db 112 for (UInt_t mod=0; mod<240; mod++) {
113 fbModuleScanned[mod]=kFALSE;
f0aa5f6c 114 }
115
116 Init();
117}
de12e454 118//_________________________________________________________________________
f0aa5f6c 119AliITSOnlineSPDscanAnalyzer::~AliITSOnlineSPDscanAnalyzer() {
120 // destructor
121 for (UInt_t hs=0; hs<6; hs++) {
122 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
123 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
124 delete fMeanMultiplicity[hs][chipNr];
de12e454 125 fMeanMultiplicity[hs][chipNr]=NULL;
f0aa5f6c 126 }
127 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
128 delete fHitEventEfficiency[hs][chipNr];
de12e454 129 fHitEventEfficiency[hs][chipNr]=NULL;
f0aa5f6c 130 }
131 }
132 }
f0aa5f6c 133
de12e454 134 if (fTriggers!=NULL) {
135 delete fTriggers;
136 fTriggers=NULL;
137 }
138
139 DeleteUniformityHistograms();
140
141 if (fScanObj!=NULL) {
142 delete fScanObj;
143 fScanObj=NULL;
144 }
145}
146//_________________________________________________________________________
f0aa5f6c 147AliITSOnlineSPDscanAnalyzer& AliITSOnlineSPDscanAnalyzer::operator=(const AliITSOnlineSPDscanAnalyzer& handle) {
6727e2db 148 // assignment operator, only copies the filename and params (not the processed data)
f0aa5f6c 149 if (this!=&handle) {
150 for (UInt_t hs=0; hs<6; hs++) {
151 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
152 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
153 delete fMeanMultiplicity[hs][chipNr];
154 }
155 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
156 delete fHitEventEfficiency[hs][chipNr];
157 }
158 }
159 }
de12e454 160 if (fTriggers!=NULL) {
161 delete fTriggers;
162 fTriggers=NULL;
163 }
164
165 DeleteUniformityHistograms();
166
167 if (fScanObj!=NULL) {
168 delete fScanObj;
169 fScanObj=NULL;
170 }
f0aa5f6c 171
53ae21ce 172 fFileName=handle.fFileName;
6727e2db 173 fOverWrite=handle.fOverWrite;
174 fNoiseThreshold=handle.fNoiseThreshold;
175 fNoiseMinimumEvents=handle.fNoiseMinimumEvents;
176 fMinNrStepsBeforeIncrease=handle.fMinNrStepsBeforeIncrease;
177 fMinIncreaseFromBaseLine=handle.fMinIncreaseFromBaseLine;
178 fStepDownDacSafe=handle.fStepDownDacSafe;
179 fMaxBaseLineLevel=handle.fMaxBaseLineLevel;
f0aa5f6c 180
f0aa5f6c 181 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
182 for (UInt_t hs=0; hs<6; hs++) {
183 fMeanMultiplicity[hs][chipNr]=NULL;
184 fHitEventEfficiency[hs][chipNr]=NULL;
185 }
186 }
6727e2db 187 for (UInt_t mod=0; mod<240; mod++) {
188 fbModuleScanned[mod]=kFALSE;
f0aa5f6c 189 }
de12e454 190
6727e2db 191 fHandler=NULL;
f0aa5f6c 192
6727e2db 193 fType=99;
194 fDacId=99;
195
f0aa5f6c 196 Init();
197 }
198 return *this;
199}
de12e454 200//_________________________________________________________________________
6ddf3d66 201void AliITSOnlineSPDscanAnalyzer::Init(Bool_t readFromGridFile) {
f0aa5f6c 202 // first checks type of container and then initializes container obj
6ddf3d66 203 if (!readFromGridFile) {
204 FILE* fp0 = fopen(fFileName.Data(), "r");
205 if (fp0 == NULL) {
206 return;
207 }
208 else {
209 fclose(fp0);
210 }
f0aa5f6c 211 }
6ddf3d66 212
213 fScanObj = new AliITSOnlineSPDscan(fFileName.Data(),readFromGridFile);
f0aa5f6c 214 fType = fScanObj->GetType();
215 delete fScanObj;
216
217 // init container
218 switch(fType) {
219 case kUNIMA:
220 case kNOISE:
6ddf3d66 221 fScanObj = new AliITSOnlineSPDscanSingle(fFileName.Data(),readFromGridFile);
f0aa5f6c 222 break;
223 case kMINTH:
224 case kDAC:
225 case kDELAY:
6ddf3d66 226 fScanObj = new AliITSOnlineSPDscanMultiple(fFileName.Data(),readFromGridFile);
f0aa5f6c 227 fDacId = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacId();
228 break;
229 case kMEANTH:
6ddf3d66 230 fScanObj = new AliITSOnlineSPDscanMeanTh(fFileName.Data(),readFromGridFile);
f0aa5f6c 231 fDacId = ((AliITSOnlineSPDscanMeanTh*)fScanObj)->GetDacId();
232 break;
233 default:
53ae21ce 234 Error("AliITSOnlineSPDscanAnalyzer::Init","Type %d not defined!",fType);
f0aa5f6c 235 fScanObj=NULL;
236 return;
237 break;
238 }
239
f0aa5f6c 240}
de12e454 241//_________________________________________________________________________
53ae21ce 242void AliITSOnlineSPDscanAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
243 // set a parameter
244 TString name = pname;
245 TString val = pval;
246 if (name.CompareTo("fOverWrite")==0) {
6727e2db 247 if (val.CompareTo("YES")==0 || val.CompareTo("1")==0) {
53ae21ce 248 fOverWrite = kTRUE;
249 }
6727e2db 250 else fOverWrite = kFALSE;
53ae21ce 251 }
252 else if (name.CompareTo("fNoiseThreshold")==0) {
253 fNoiseThreshold = val.Atof();
254 }
255 else if (name.CompareTo("fNoiseMinimumEvents")==0) {
256 fNoiseMinimumEvents = val.Atoi();
257 }
258 else if (name.CompareTo("fMinNrStepsBeforeIncrease")==0) {
259 fMinNrStepsBeforeIncrease = val.Atoi();
260 }
261 else if (name.CompareTo("fMinIncreaseFromBaseLine")==0) {
262 fMinIncreaseFromBaseLine = val.Atof();
263 }
264 else if (name.CompareTo("fStepDownDacSafe")==0) {
265 fStepDownDacSafe = val.Atoi();
266 }
267 else if (name.CompareTo("fMaxBaseLineLevel")==0) {
268 fMaxBaseLineLevel = val.Atof();
269 }
270 else {
271 Error("AliITSOnlineSPDscanAnalyzer::SetParam","Parameter %s in configuration file unknown.",name.Data());
272 }
273}
de12e454 274//_________________________________________________________________________
6727e2db 275void AliITSOnlineSPDscanAnalyzer::ReadParamsFromLocation(const Char_t *dirName) {
276 // opens file (default name) in dir dirName and reads parameters from it
277 TString paramsFileName = Form("%s/standal_params.txt",dirName);
278 ifstream paramsFile;
279 paramsFile.open(paramsFileName, ifstream::in);
280 if (paramsFile.fail()) {
281 printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName.Data());
282 }
283 else {
284 while(1) {
285 Char_t paramN[50];
286 Char_t paramV[50];
287 paramsFile >> paramN;
288 if (paramsFile.eof()) break;
289 paramsFile >> paramV;
290 SetParam(paramN,paramV);
291 if (paramsFile.eof()) break;
292 }
293 paramsFile.close();
294 }
295}
de12e454 296//_________________________________________________________________________
4f88491f 297Bool_t AliITSOnlineSPDscanAnalyzer::IsChipPresent(UInt_t hs, UInt_t chipNr) {
298 // is the chip present?
299 if (fScanObj==NULL) {
300 Warning("AliITSOnlineSPDscanAnalyzer::IsChipPresent","No data!");
301 return kFALSE;
6727e2db 302 }
4f88491f 303 return fScanObj->GetChipPresent(hs,chipNr);
6727e2db 304}
de12e454 305//_________________________________________________________________________
6727e2db 306Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(/*Char_t *oldcalibDir*/) {
53ae21ce 307 // process dead pixel data, for uniformity scan,
308 // NB: This will not be the general way of finding dead pixels.
f0aa5f6c 309 if (fScanObj==NULL) {
53ae21ce 310 Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","No data!");
f0aa5f6c 311 return kFALSE;
312 }
313 // should be type kUNIMA
314 if (fType!=kUNIMA) {
53ae21ce 315 Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Dead pixels only for scan type %d.",kUNIMA);
f0aa5f6c 316 return kFALSE;
317 }
6727e2db 318 // handler should be initialized
319 if (fHandler==NULL) {
320 Error("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Calibration handler is not initialized!");
321 return kFALSE;
322 }
f0aa5f6c 323
f0aa5f6c 324 UInt_t routerNr = fScanObj->GetRouterNr();
325 UInt_t rowStart = fScanObj->GetRowStart();
326 UInt_t rowEnd = fScanObj->GetRowEnd();
327 for (UInt_t hs=0; hs<6; hs++) {
328 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
329 if (fScanObj->GetChipPresent(hs,chipNr) && fScanObj->GetAverageMultiplicity(0,hs,chipNr)>0) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
4f88491f 330 if (fOverWrite) {fHandler->ResetDeadForChip(routerNr,hs,chipNr);}
f0aa5f6c 331 for (UInt_t col=0; col<32; col++) {
332 for (UInt_t row=rowStart; row<=rowEnd; row++) {
333 if (col!=1 && col!=9 && col!=17 && col!=25) { //exclude test columns!!!
334 if (fScanObj->GetHits(0,hs,chipNr,col,row)==0) {
6727e2db 335 fHandler->SetDeadPixel(routerNr,hs,chipNr,col,row);
f0aa5f6c 336 }
337 }
338 }
339 }
340 }
341 }
342 }
343 return kTRUE;
344}
de12e454 345//_________________________________________________________________________
346Bool_t AliITSOnlineSPDscanAnalyzer::ProcessUniformity() {
347 // process uniformity scan data (thanks to Roberta Ferretti for providing this method)
348 if (fScanObj==NULL) {
349 Warning("AliITSOnlineSPDscanAnalyzer::ProcessUniformity","No data!");
350 return kFALSE;
351 }
352 // should be type kUNIMA
353 if (fType!=kUNIMA) {
354 Warning("AliITSOnlineSPDscanAnalyzer::ProcessUniformity","Only for scan type %d.",kUNIMA);
355 return kFALSE;
356 }
f0aa5f6c 357
de12e454 358 CreateUniformityHistograms(); // create all histograms that will be filled here
f0aa5f6c 359
de12e454 360 // UInt_t routerNr = fScanObj->GetRouterNr();
361 UInt_t rowStart = fScanObj->GetRowStart();
362 UInt_t rowEnd = fScanObj->GetRowEnd();
f652c3be 363 UInt_t nrTriggers = fScanObj->GetTriggers(0)/(rowEnd-rowStart+1);
de12e454 364
365 Float_t pixel100=0;
366 Float_t zeri=0;
367 Float_t pixelN=0;
368 UInt_t numChipsActive=0;
369
370 for (UInt_t hs=0; hs<6; hs++) {
371 Float_t pixel100hs=0;
372 Float_t zerihs=0;
373 Float_t pixelNhs=0;
374 UInt_t numChipsActiveHS=0;
375
376 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
377 Float_t pixel100chip=0;
378 Float_t zerichip=0;
379 Float_t pixelNchip=0;
380
381 if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
382 numChipsActive++;
383 numChipsActiveHS++;
f0aa5f6c 384
de12e454 385 for (UInt_t col=0; col<32; col++) {
386 for (UInt_t row=rowStart; row<=rowEnd; row++) {
387 if (col!=1 && col!=9 && col!=17 && col!=25) { //exclude test columns!!!
388
f652c3be 389 if (fScanObj->GetHits(0,hs,chipNr,col,row)==nrTriggers) {
de12e454 390 pixel100++;
391 pixel100hs++;
392 pixel100chip++;
393 }
394 if (fScanObj->GetHits(0,hs,chipNr,col,row)==0) {
395 zeri++;
396 zerihs++;
397 zerichip++;
398 }
f652c3be 399 if (fScanObj->GetHits(0,hs,chipNr,col,row)>nrTriggers) {
de12e454 400 pixelN++;
401 pixelNhs++;
402 pixelNchip++;
403 }
404 }
405 }
406 }
407
f652c3be 408 Float_t tPeffChip=(pixel100chip/(28*(rowEnd-rowStart+1)))*100;
409 fTPeffChip[hs]->Fill(chipNr,tPeffChip);
de12e454 410
f652c3be 411 Float_t deadPixelChip=(zerichip/(28*(rowEnd-rowStart+1)))*100;
412 fDeadPixelChip[hs]->Fill(chipNr,deadPixelChip);
de12e454 413
f652c3be 414 Float_t noisyPixelChip=(pixelNchip/(28*(rowEnd-rowStart+1)))*100;
415 fNoisyPixelChip[hs]->Fill(chipNr,noisyPixelChip);
de12e454 416 }
417 }
418
f652c3be 419 Float_t tPeffHS=(pixel100hs/(28*numChipsActiveHS*(rowEnd-rowStart+1)))*100;
420 fTPeffHS->Fill(hs,tPeffHS);
de12e454 421
f652c3be 422 Float_t deadPixelHS=(zerihs/(28*numChipsActiveHS*(rowEnd-rowStart+1)))*100;
423 fDeadPixelHS->Fill(hs,deadPixelHS);
de12e454 424
f652c3be 425 Float_t noisyPixelHS=(pixelNhs/(28*numChipsActiveHS*(rowEnd-rowStart+1)))*100;
426 fNoisyPixelHS->Fill(hs,noisyPixelHS);
de12e454 427 }
428
429 fTPeff=(pixel100/(28*numChipsActive*(rowEnd-rowStart+1)))*100;
430 fDeadPixel=(zeri/(28*numChipsActive*(rowEnd-rowStart+1)))*100;
431 fNoisyPixel=(pixelN/(28*numChipsActive*(rowEnd-rowStart+1)))*100;
432
433 return kTRUE;
434}
435//_________________________________________________________________________
436void AliITSOnlineSPDscanAnalyzer::CreateUniformityHistograms() {
437 // create uniformity histograms to be filled by "ProcessUniformity" method
438 DeleteUniformityHistograms(); // make sure no old histograms are lying around...
439 UInt_t eq = GetRouterNr();
440 TString label;
441
442 label = Form("Ratio of 'Good' Pixels Per HS (eq %d)",eq);
443 fTPeffHS = new TH1F(label.Data(),label.Data(),6,-0.5,5.5);
444 fTPeffHS->SetXTitle("hs");
445 fTPeffHS->SetYTitle("ratio [%]");
446 fTPeffHS->SetFillColor(kBlue);
447 fTPeffHS->SetStats(0);
448
449 label = Form("Ratio of 'Dead' Pixels Per HS (eq %d)",eq);
450 fDeadPixelHS = new TH1F(label.Data(),label.Data(),6,-0.5,5.5);
451 fDeadPixelHS->SetXTitle("hs");
452 fDeadPixelHS->SetYTitle("ratio [%]");
453 fDeadPixelHS->SetFillColor(kBlue);
454 fDeadPixelHS->SetStats(0);
455
456 label = Form("Ratio of 'Noisy' Pixels Per HS (eq %d)",eq);
457 fNoisyPixelHS = new TH1F(label.Data(),label.Data(),6,-0.5,5.5);
458 fNoisyPixelHS->SetXTitle("hs");
459 fNoisyPixelHS->SetYTitle("ratio [%]");
460 fNoisyPixelHS->SetFillColor(kBlue);
461 fNoisyPixelHS->SetStats(0);
462
463 for (UInt_t hs=0; hs<6; hs++) {
464 label = Form("Ratio of 'Good' Pixels Per Chip (eq %d, hs %d)",eq,hs);
465 fTPeffChip[hs] = new TH1F(label.Data(),label.Data(),10,-0.5,9.5);
466 fTPeffChip[hs]->SetXTitle("chip");
467 fTPeffChip[hs]->SetYTitle("ratio [%]");
468 fTPeffChip[hs]->SetFillColor(kBlue);
469 fTPeffChip[hs]->SetStats(0);
470
471 label = Form("Ratio of 'Dead' Pixels Per Chip (eq %d, hs %d)",eq,hs);
472 fDeadPixelChip[hs] = new TH1F(label.Data(),label.Data(),10,-0.5,9.5);
473 fDeadPixelChip[hs]->SetXTitle("chip");
474 fDeadPixelChip[hs]->SetYTitle("ratio [%]");
475 fDeadPixelChip[hs]->SetFillColor(kBlue);
476 fDeadPixelChip[hs]->SetStats(0);
477
478 label = Form("Ratio of 'Noisy' Pixels Per Chip (eq %d, hs %d)",eq,hs);
479 fNoisyPixelChip[hs] = new TH1F(label.Data(),label.Data(),10,-0.5,9.5);
480 fNoisyPixelChip[hs]->SetXTitle("chip");
481 fNoisyPixelChip[hs]->SetYTitle("ratio [%]");
482 fNoisyPixelChip[hs]->SetFillColor(kBlue);
483 fNoisyPixelChip[hs]->SetStats(0);
484 }
485
486}
487//_________________________________________________________________________
488void AliITSOnlineSPDscanAnalyzer::DeleteUniformityHistograms() {
489 // remove uniformity histograms if they are created
490 if (fTPeffHS!=NULL) {
491 delete fTPeffHS;
492 fTPeffHS=NULL;
493 }
494 if (fDeadPixelHS!=NULL) {
495 delete fDeadPixelHS;
496 fDeadPixelHS=NULL;
497 }
498 if (fNoisyPixelHS!=NULL) {
499 delete fNoisyPixelHS;
500 fNoisyPixelHS=NULL;
501 }
502 for (UInt_t hs=0; hs<6; hs++) {
503 if (fTPeffChip[hs]!=NULL) {
504 delete fTPeffChip[hs];
505 fTPeffChip[hs]=NULL;
506 }
507 if (fDeadPixelChip[hs]!=NULL) {
508 delete fDeadPixelChip[hs];
509 fDeadPixelChip[hs]=NULL;
510 }
511 if (fNoisyPixelChip[hs]!=NULL) {
512 delete fNoisyPixelChip[hs];
513 fNoisyPixelChip[hs]=NULL;
514 }
515 }
516}
517//_________________________________________________________________________
6727e2db 518Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(/*Char_t *oldcalibDir*/) {
f0aa5f6c 519 // process noisy pixel data
520 if (fScanObj==NULL) {
53ae21ce 521 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","No data!");
f0aa5f6c 522 return kFALSE;
523 }
524 // should be type kNOISE
525 if (fType != kNOISE) {
53ae21ce 526 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Noisy pixels only for scan type %d.",kNOISE);
f0aa5f6c 527 return kFALSE;
528 }
6727e2db 529 // handler should be initialized
530 if (fHandler==NULL) {
531 Error("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
532 return kFALSE;
533 }
534 // check if enough statistics
f0aa5f6c 535 if (fScanObj->GetTriggers(0)<fNoiseMinimumEvents) {
53ae21ce 536 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Process noisy: Too few events.");
f0aa5f6c 537 return kFALSE;
538 }
6727e2db 539
f0aa5f6c 540 UInt_t routerNr = fScanObj->GetRouterNr();
541 for (UInt_t hs=0; hs<6; hs++) {
542 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
543 if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
4f88491f 544 if (fOverWrite) {fHandler->ResetNoisyForChip(routerNr,hs,chipNr);}
f0aa5f6c 545 for (UInt_t col=0; col<32; col++) {
546 for (UInt_t row=0; row<256; row++) {
547 if (fScanObj->GetHitsEfficiency(0,hs,chipNr,col,row)>fNoiseThreshold) {
6727e2db 548 fHandler->SetNoisyPixel(routerNr,hs,chipNr,col,row);
f0aa5f6c 549 }
550 }
551 }
552 }
553 }
554 }
555 return kTRUE;
556}
de12e454 557//_________________________________________________________________________
f0aa5f6c 558Int_t AliITSOnlineSPDscanAnalyzer::GetDelay(UInt_t hs, UInt_t chipNr) {
559 // get delay
560 if (hs>=6 || chipNr>10) return -1;
561 if (fScanObj==NULL) {
53ae21ce 562 Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","No data!");
f0aa5f6c 563 return -1;
564 }
565 // should be type kDELAY or kDAC with id 42 (delay_ctrl)
566 if (fType!=kDELAY && (fType!=kDAC || fDacId!=42)) {
53ae21ce 567 Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","Delay only for scan type %d or %d and dac_id 42.",kDELAY,kDAC);
f0aa5f6c 568 return -1;
569 }
570 if (fMeanMultiplicity[hs][chipNr]==NULL) {
571 if (!ProcessMeanMultiplicity()) {
572 return -1;
573 }
574 }
575
1fd93b67 576 UInt_t maxStep=0;
577 Float_t maxVal=0;
578 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
579 Double_t thisDac;
580 Double_t thisMult;
581 fMeanMultiplicity[hs][chipNr]->GetPoint(step,thisDac,thisMult);
582 if (thisMult > maxVal) {
583 maxVal = thisMult;
584 maxStep = step;
585 }
586 }
587
588 if (maxVal>0) {
589 return ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(maxStep);
f0aa5f6c 590 }
591 else {
592 return -1;
593 }
1fd93b67 594
f0aa5f6c 595}
de12e454 596//_________________________________________________________________________
f0aa5f6c 597Int_t AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima(UInt_t hs, UInt_t chipNr) {
598 // in case of a uniformity scan, returns the nr of noisy pixels, (here > 200 hits)
599 if (hs>=6 || chipNr>10) return -1;
600 if (fScanObj==NULL) {
53ae21ce 601 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","No data!");
f0aa5f6c 602 return kFALSE;
603 }
604 // should be type kUNIMA
605 if (fType != kUNIMA) {
53ae21ce 606 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Noisy pixels Unima only for scan type %d.",kUNIMA);
f0aa5f6c 607 return kFALSE;
608 }
609 if (fScanObj->GetTriggers(0)!=25600) {
53ae21ce 610 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Process noisy unima: Incorrect number of events (!=25600.");
f0aa5f6c 611 return kFALSE;
612 }
613
614 Int_t nrNoisy=0;
615 if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
616 for (UInt_t col=0; col<32; col++) {
617 for (UInt_t row=0; row<256; row++) {
618 if (fScanObj->GetHits(0,hs,chipNr,col,row)>200) {
619 nrNoisy++;
620 }
621 }
622 }
623 }
624 else {
625 return -1;
626 }
627 return nrNoisy;
628}
de12e454 629//_________________________________________________________________________
f0aa5f6c 630Int_t AliITSOnlineSPDscanAnalyzer::FindLastMinThDac(UInt_t hs, UInt_t chipNr) {
631 // returns dac value where fMinIncreaseFromBaseLine reached
632 if (hs>=6 || chipNr>10) return -1;
633 if (fMeanMultiplicity[hs][chipNr]==NULL) {
634 if (!ProcessMeanMultiplicity()) {
635 return -1;
636 }
637 }
638 Double_t firstVal, dummy1;
639 fMeanMultiplicity[hs][chipNr]->GetPoint(0,dummy1,firstVal);
640 UInt_t step=0;
641 while (step<fScanObj->GetNSteps()-1) {
642 Double_t graphVal, dummy2;
643 fMeanMultiplicity[hs][chipNr]->GetPoint(step+1,dummy2,graphVal);
644 if (graphVal>firstVal+fMinIncreaseFromBaseLine) break;
645 step++;
646 }
647 if (step==fScanObj->GetNSteps()-1) return -1;
648 return ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step);
649}
650
651Int_t AliITSOnlineSPDscanAnalyzer::FindClosestLowerStep(Float_t dacValueInput) {
652 // returns step closest (lower) to a dacvalue
653 UInt_t step=0;
654 while (step<fScanObj->GetNSteps()-1) {
655 Int_t dacVal = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step+1);
656 if (dacVal>=dacValueInput) break;
657 step++;
658 }
659 return step;
660}
de12e454 661//_________________________________________________________________________
f0aa5f6c 662Float_t AliITSOnlineSPDscanAnalyzer::GetCompareLine(UInt_t step, UInt_t hs, UInt_t chipNr, Float_t basePar2) {
663 // returns value to compare mean mult with (when finding min th)
664 if (hs>=6 || chipNr>10) return -1;
665 if (step<fMinNrStepsBeforeIncrease) return -1;
666 Float_t baseLine = basePar2;
667 if (baseLine<0) baseLine=0;
668 Float_t baseAdd;
669 Double_t baseM=0;
670 Double_t baseS=0;
671 Double_t d,m;
672 for (UInt_t st=1;st<2*step/3;st++) { // skip first point...
673 fMeanMultiplicity[hs][chipNr]->GetPoint(st,d,m);
674 baseM+=m-baseLine;
675 baseS+=(m-baseLine)*(m-baseLine);
676 }
677 baseAdd=2*sqrt( baseS/(2*step/3-1) - (baseM/(2*step/3-1))*(baseM/(2*step/3-1)) );
678 baseAdd+=0.03; // magic number
679 if (baseAdd>fMinIncreaseFromBaseLine) baseAdd=fMinIncreaseFromBaseLine;
680 return baseLine + baseAdd;
681}
682
683Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
684 // calculates and returns the minimum threshold
685 if (hs>=6 || chipNr>10) return -1;
686 if (fScanObj==NULL) {
53ae21ce 687 Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","No data!");
f0aa5f6c 688 return -1;
689 }
690 // should be type kMINTH or kDAC with id 39 (pre_vth)
691 if (fType!=kMINTH && (fType!=kDAC || fDacId!=39)) {
53ae21ce 692 Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","MinTh only for scan type %d OR %d with dac_id 39.",kMINTH,kDAC);
f0aa5f6c 693 return -1;
694 }
695 if (fMeanMultiplicity[hs][chipNr]==NULL) {
696 if (!ProcessMeanMultiplicity()) {
697 return -1;
698 }
699 }
700
701 Int_t lastDac = FindLastMinThDac(hs,chipNr);
702 if (lastDac==-1) {
53ae21ce 703 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Increase of Mean Multiplicity by %1.2f never reached.",hs,chipNr,fMinIncreaseFromBaseLine);
f0aa5f6c 704 return -1;
705 }
706
707 Int_t minDac = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(0);
53ae21ce 708 TString funcName = Form("Fit minth func HS%d CHIP%d",hs,chipNr);
709 TF1 *minThFunc = new TF1(funcName.Data(),itsSpdErrorf,100,500,3);
f0aa5f6c 710 minThFunc->SetParameter(0,lastDac+10);
711 minThFunc->SetParameter(1,2);
712 minThFunc->SetParameter(2,0);
713 minThFunc->SetParName(0,"Mean");
714 minThFunc->SetParName(1,"Sigma");
715 minThFunc->SetParName(2,"BaseLine");
716 minThFunc->SetLineWidth(1);
717 if (fMeanMultiplicity[hs][chipNr]==NULL) {
718 if (!ProcessMeanMultiplicity()) {
719 return -1;
720 }
721 }
722 fMeanMultiplicity[hs][chipNr]->Fit(funcName,"Q0","",minDac,lastDac);
723
724 // Double_t mean = fMinThFunc[hs][chipNr]->GetParameter(0);
725 // Double_t sigma = fMinThFunc[hs][chipNr]->GetParameter(1);
726 Double_t baseLine = minThFunc->GetParameter(2);
727 delete minThFunc;
728
729 if (baseLine>fMaxBaseLineLevel) {
53ae21ce 730 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: BaseLine too large (%1.2f>%1.2f).",hs,chipNr,baseLine,fMaxBaseLineLevel);
f0aa5f6c 731 return -1;
732 }
733 UInt_t step=FindClosestLowerStep(lastDac);
734 Float_t compareLine = GetCompareLine(step,hs,chipNr,baseLine);
735 if (compareLine==-1) {
53ae21ce 736 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Not enough steps (%d<%d) before increase to get a compare line.",hs,chipNr,step,fMinNrStepsBeforeIncrease);
f0aa5f6c 737 return -1;
738 }
739
740 Double_t mult, dummy;
741 mult=1000;
742 while (mult > compareLine && step>0) {
743 fMeanMultiplicity[hs][chipNr]->GetPoint(step,dummy,mult);
744 step--;
745 }
746 Int_t minth = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step+1)-fStepDownDacSafe;
747
748 if (step>0) {
749 return minth;
750 }
751 else {
53ae21ce 752 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Did not find a point below the compare line (%f).",hs,chipNr,compareLine);
f0aa5f6c 753 return -1;
754 }
755}
de12e454 756//_________________________________________________________________________
1e954f66 757TArrayI AliITSOnlineSPDscanAnalyzer::GetMeanTh(UInt_t hs, UInt_t chipNr) {
f652c3be 758 // calculates and returns the mean threshold
1e954f66 759 TArrayI fitresults(4);
760 if (hs>=6 || chipNr>10) return fitresults;
f652c3be 761 if (fScanObj==NULL) {
762 Error("AliITSOnlineSPDscanAnalyzer::GetMeanTh","No data!");
1e954f66 763 return fitresults;
f652c3be 764 }
765 // should be type kMEANTH or kDAC with id 39
766 if (fType!=kMEANTH && (fType!=kDAC || fDacId!=105)) {
767 Error("AliITSOnlineSPDscanAnalyzer::GetMeanTh","MeanTh only for scan type %d OR %d with dac_id 105.",kMEANTH,kDAC);
1e954f66 768 return fitresults;
f652c3be 769 }
770 if (fHitEventEfficiency[hs][chipNr]==NULL) {
771 printf("processing hit efficiency \n");
772 if (!ProcessHitEventEfficiency()) {
773 printf("...not processed!!\n");
1e954f66 774 return fitresults;
f652c3be 775 }
776 }
777 Double_t x,y;
778 fHitEventEfficiency[hs][chipNr]->GetPoint(fHitEventEfficiency[hs][chipNr]->GetN()-1,x,y);
1e954f66 779 Double_t min = x;
f652c3be 780 fHitEventEfficiency[hs][chipNr]->GetPoint(0,x,y);
1e954f66 781 Double_t max = x;
f652c3be 782
1e954f66 783 Double_t mean = 0.5*(min+max);
f652c3be 784 TString funcName = Form("Fit meanth func HS%d CHIP%d",hs,chipNr);
785 TF1 *minThFunc = new TF1(funcName.Data(),itsSpdScurveForMeanTh,min,max,3);
1e954f66 786 minThFunc->SetParameter(0,mean);
787 minThFunc->SetParameter(1,264); // 4 (mV) * 66 (el)
788 minThFunc->SetParLimits(1,100,1000); // minimum value is 1 mV (-> 100 in TPAmplitude)
f652c3be 789 minThFunc->SetParameter(2,0.4);
790 minThFunc->SetParName(0,"Mean");
791 minThFunc->SetParName(1,"Sigma");
792 minThFunc->SetParName(2,"Half");
793 minThFunc->SetLineWidth(1);
f652c3be 794
1e954f66 795 fHitEventEfficiency[hs][chipNr]->Fit(funcName,"Q","",min,max);
796
797 fitresults.AddAt((Int_t)minThFunc->GetParameter(0),0);
798 fitresults.AddAt((Int_t)minThFunc->GetParError(0),1);
799 fitresults.AddAt((Int_t)minThFunc->GetParameter(1),2);
800 fitresults.AddAt((Int_t)minThFunc->GetParError(1),3);
801 TLine *ly = new TLine((Double_t)min,0.5,(Double_t)fitresults.At(0),0.5); ly->SetLineStyle(6);
f652c3be 802 ly->Draw("same");
1e954f66 803 TLine *lx = new TLine((Double_t)fitresults.At(0),0.,(Double_t)fitresults.At(0),0.5);
f652c3be 804 lx->SetLineStyle(6);
805 lx->Draw("same");
806 delete minThFunc;
1e954f66 807
808 return fitresults;
f652c3be 809}
810
811//_________________________________________________________________________
f0aa5f6c 812Bool_t AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity() {
813 // process mean multiplicity data
814 if (fScanObj==NULL) {
53ae21ce 815 Error("AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity","No data!");
f0aa5f6c 816 return kFALSE;
817 }
818 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
819 for (UInt_t hs=0; hs<6; hs++) {
820 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
821 // if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
822 if (step==0) {
823 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
824 delete fMeanMultiplicity[hs][chipNr];
825 }
826 fMeanMultiplicity[hs][chipNr] = new TGraph();
827 }
828 Float_t multiplMean=fScanObj->GetAverageMultiplicity(step,hs,chipNr);
829 if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
830 fMeanMultiplicity[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),multiplMean);
831 }
832 else {
833 fMeanMultiplicity[hs][chipNr]->SetPoint(step,0,multiplMean);
834 }
835 }
836 // }
837 }
838 }
839 return kTRUE;
840}
de12e454 841//_________________________________________________________________________
f0aa5f6c 842TGraph* AliITSOnlineSPDscanAnalyzer::GetMeanMultiplicityG(UInt_t hs, UInt_t chipNr) {
843 // returns mean multiplicity graph
844 if (hs>=6 || chipNr>10) return NULL;
845 if (fMeanMultiplicity[hs][chipNr]==NULL) {
846 if (!ProcessMeanMultiplicity()) {
847 return NULL;
848 }
849 }
850 return fMeanMultiplicity[hs][chipNr];
851}
de12e454 852//_________________________________________________________________________
f0aa5f6c 853Bool_t AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency() {
854 // process hit event efficiency
855 if (fScanObj==NULL) {
53ae21ce 856 Error("AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency","No data!");
f0aa5f6c 857 return kFALSE;
858 }
859 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
860 for (UInt_t hs=0; hs<6; hs++) {
861 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
862 // if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
863 if (step==0) {
864 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
865 delete fHitEventEfficiency[hs][chipNr];
866 }
867 fHitEventEfficiency[hs][chipNr] = new TGraph();
868 }
869 Float_t efficiency=fScanObj->GetHitEventsEfficiency(step,hs,chipNr);
1e954f66 870 if (fType==kMINTH || fType==kDAC || fType==kDELAY) {
f0aa5f6c 871 fHitEventEfficiency[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),efficiency);
1e954f66 872 } else if(fType==kMEANTH){
873 fHitEventEfficiency[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMeanTh*)fScanObj)->GetTPAmp(step,hs),efficiency);
874 } else {
f0aa5f6c 875 fHitEventEfficiency[hs][chipNr]->SetPoint(step,0,efficiency);
876 }
877 }
878 // }
879 }
880 }
881 return kTRUE;
882}
de12e454 883//_________________________________________________________________________
f0aa5f6c 884TGraph* AliITSOnlineSPDscanAnalyzer::GetHitEventEfficiencyG(UInt_t hs, UInt_t chipNr) {
885 // returns hit event efficiency graph
886 if (hs>=6 || chipNr>10) return NULL;
887 if (fHitEventEfficiency[hs][chipNr]==NULL) {
888 if (!ProcessHitEventEfficiency()) {
889 return NULL;
890 }
891 }
892 return fHitEventEfficiency[hs][chipNr];
893}
de12e454 894//_________________________________________________________________________
f0aa5f6c 895Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers() {
896 // process nr of triggers data
897 if (fScanObj==NULL) {
53ae21ce 898 Error("AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers","No data!");
f0aa5f6c 899 return kFALSE;
900 }
901 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
902 if (step==0) {
903 if (fTriggers!=NULL) {
904 delete fTriggers;
905 }
906 fTriggers = new TGraph();
907 }
908 if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
909 fTriggers->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),fScanObj->GetTriggers(step));
910 }
911 else {
912 fTriggers->SetPoint(step,0,fScanObj->GetTriggers(step));
913 }
914 }
915 return kTRUE;
916}
de12e454 917//_________________________________________________________________________
f0aa5f6c 918TGraph* AliITSOnlineSPDscanAnalyzer::GetNrTriggersG() {
919 // returns nr of triggers graph
920 if (fTriggers==NULL) {
921 if (!ProcessNrTriggers()) {
922 return NULL;
923 }
924 }
925 return fTriggers;
926}
de12e454 927//_________________________________________________________________________
f0aa5f6c 928Bool_t AliITSOnlineSPDscanAnalyzer::GetHalfStavePresent(UInt_t hs) {
929 // returns half stave present info
930 if (hs<6 && fScanObj!=NULL) {
931 Int_t chipstatus=0;
932 for (Int_t chip=0; chip<10; chip++) {
933 chipstatus+=fScanObj->GetChipPresent(hs,chip);
934 }
935 if (chipstatus>0) return kTRUE;
936 }
937 return kFALSE;
938}
de12e454 939//_________________________________________________________________________
f0aa5f6c 940UInt_t AliITSOnlineSPDscanAnalyzer::GetRouterNr() {
941 // returns the router nr of scan obj
942 if (fScanObj!=NULL) return fScanObj->GetRouterNr();
943 else return 99;
944}
de12e454 945//_________________________________________________________________________
f0aa5f6c 946TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapTot(UInt_t step) {
947 // creates and returns a pointer to a hitmap histo (half sector style a la spdmood)
948 if (fScanObj==NULL) {
53ae21ce 949 Error("AliITSOnlineSPDscanAnalyzer::GetHitMapTot","No data!");
f0aa5f6c 950 return NULL;
951 }
53ae21ce 952 TString histoname;
f0aa5f6c 953 if (fType==kMINTH || fType==kMEANTH || fType==kDAC) {
53ae21ce 954 histoname = Form("Router %d , DAC %d",GetRouterNr(),((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step));
f0aa5f6c 955 }
956 else {
53ae21ce 957 histoname = Form("Router %d ",GetRouterNr());
f0aa5f6c 958 }
53ae21ce 959 TH2F* fHitMapTot = new TH2F(histoname.Data(),histoname.Data(),32*10,-0.5,32*10-0.5,256*6,-0.5,256*6-0.5);
f0aa5f6c 960 fHitMapTot->SetNdivisions(-10,"X");
961 fHitMapTot->SetNdivisions(-006,"Y");
962 fHitMapTot->SetTickLength(0,"X");
963 fHitMapTot->SetTickLength(0,"Y");
964 fHitMapTot->GetXaxis()->SetLabelColor(gStyle->GetCanvasColor());
965 fHitMapTot->GetYaxis()->SetLabelColor(gStyle->GetCanvasColor());
966 for (UInt_t hs=0; hs<6; hs++) {
967 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
968 for (UInt_t col=0; col<32; col++) {
969 for (UInt_t row=0; row<256; row++) {
1e954f66 970 fHitMapTot->Fill(chipNr*32+col,(5-hs)*256+row,fScanObj->GetHits(step,hs,chipNr,col,row));
f0aa5f6c 971 }
972 }
973 }
974 }
975 return fHitMapTot;
976}
de12e454 977//_________________________________________________________________________
1e954f66 978TH2F* AliITSOnlineSPDscanAnalyzer::GetPhysicalHitMapTot(UInt_t step) {
979 // creates and returns a pointer to a hitmap histo (-> 1 equpment opened up)
980
981 if (fScanObj==NULL) {
982 Error("AliITSOnlineSPDscanAnalyzer::GetHitMapTot","No data!");
983 return NULL;
984 }
985 TString histoname;
986 if (fType==kMINTH || fType==kMEANTH || fType==kDAC) {
987 histoname = Form("Router %d , DAC %d",GetRouterNr(),((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step));
988 }
989 else {
990 histoname = Form("Router %d ",GetRouterNr());
991 }
992 TH2F* hPhysicalHitMapTot = new TH2F(histoname.Data(),histoname.Data(),32*10,-0.5,32*10-0.5,256*6,-0.5,256*6-0.5);
993 hPhysicalHitMapTot->SetNdivisions(-10,"X");
994 hPhysicalHitMapTot->SetNdivisions(-006,"Y");
995 hPhysicalHitMapTot->SetTickLength(0,"X");
996 hPhysicalHitMapTot->SetTickLength(0,"Y");
997 hPhysicalHitMapTot->GetXaxis()->SetLabelColor(gStyle->GetCanvasColor());
998 hPhysicalHitMapTot->GetYaxis()->SetLabelColor(gStyle->GetCanvasColor());
999 Int_t correctChip = -1;
1000 for (UInt_t hs=0; hs<6; hs++) {
1001 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
1002 if(GetRouterNr()<10) correctChip = 9-chipNr;
1003 else correctChip=chipNr;
1004 for (UInt_t col=0; col<32; col++) {
1005 for (UInt_t row=0; row<256; row++) {
1006 if(hs<2) hPhysicalHitMapTot->Fill(correctChip*32+col,(5-hs)*256+row,fScanObj->GetHits(step,hs,chipNr,col,row));
1007 else hPhysicalHitMapTot->Fill(correctChip*32+(31-col),(5-hs)*256+row,fScanObj->GetHits(step,hs,chipNr,col,row));
1008 }
1009 }
1010 }
1011 }
1012 return hPhysicalHitMapTot;
1013}
1014
1015//_________________________________________________________________________
6727e2db 1016TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapChip(UInt_t step, UInt_t hs, UInt_t chip) {
1017 // creates and returns a pointer to a hitmap histo (chip style a la spdmood)
1018 if (fScanObj==NULL) {
1019 Error("AliITSOnlineSPDscanAnalyzer::GetHitMapChip","No data!");
1020 return NULL;
1021 }
1022
1023 TString histoName;
1024 TString histoTitle;
1025 histoName = Form("fChipHisto_%d_%d_%d", GetRouterNr(), hs, chip);
1e954f66 1026 histoTitle = Form("Eq ID %d, Half Stave %d, Chip %d ", GetRouterNr(), hs, chip);
6727e2db 1027
1028 TH2F *returnHisto = new TH2F(histoName.Data(), histoTitle.Data(), 32, -0.5, 31.5, 256, -0.5, 255.5);
1029 returnHisto->SetMinimum(0);
1030 for (UInt_t col=0; col<32; col++) {
1031 for (UInt_t row=0; row<256; row++) {
8897dce2 1032 if(hs<2) returnHisto->Fill(31-col,row,fScanObj->GetHits(step,hs,chip,col,row));
1033 else returnHisto->Fill(col,row,fScanObj->GetHits(step,hs,chip,col,row));
6727e2db 1034 }
1035 }
1036
1037 return returnHisto;
1038}
de12e454 1039