SSD ladder supports + endcaps systems (E. Cattaruzza)
[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>
35#include <TF1.h>
36#include <TGraph.h>
37#include <TH2F.h>
53ae21ce 38#include <TError.h>
6727e2db 39#include <iostream>
40#include <fstream>
f0aa5f6c 41
42Double_t itsSpdErrorf(Double_t *x, Double_t *par){
43 if (par[2]<0) par[2]=0;
44 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.)));
45 return val;
46}
47//Double_t itsSpdErrorfOrig(Double_t *x, Double_t *par){
48// return 0.5+0.5*TMath::Erf((x[0]-par[0])/par[1]/sqrt(2.));
49//}
50
51
6727e2db 52AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler *handler) :
53 fType(99),fDacId(99),fFileName(fileName),fScanObj(NULL),fHandler(handler),fTriggers(NULL),
f0aa5f6c 54 fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
6727e2db 55 fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(5),fMaxBaseLineLevel(10)
f0aa5f6c 56{
57 // constructor
f0aa5f6c 58 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
59 for (UInt_t hs=0; hs<6; hs++) {
60 fMeanMultiplicity[hs][chipNr]=NULL;
61 fHitEventEfficiency[hs][chipNr]=NULL;
62 }
63 }
6727e2db 64 for (UInt_t mod=0; mod<240; mod++) {
65 fbModuleScanned[mod]=kFALSE;
f0aa5f6c 66 }
67
68 Init();
69}
70
71AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle) :
6727e2db 72 fType(99),fDacId(99),fFileName("."),fScanObj(NULL),fHandler(NULL),fTriggers(NULL),
f0aa5f6c 73 fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
6727e2db 74 fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(5),fMaxBaseLineLevel(10)
f0aa5f6c 75{
6727e2db 76 // copy constructor, only copies the filename and params (not the processed data)
53ae21ce 77 fFileName=handle.fFileName;
6727e2db 78 fOverWrite=handle.fOverWrite;
79 fNoiseThreshold=handle.fNoiseThreshold;
80 fNoiseMinimumEvents=handle.fNoiseMinimumEvents;
81 fMinNrStepsBeforeIncrease=handle.fMinNrStepsBeforeIncrease;
82 fMinIncreaseFromBaseLine=handle.fMinIncreaseFromBaseLine;
83 fStepDownDacSafe=handle.fStepDownDacSafe;
84 fMaxBaseLineLevel=handle.fMaxBaseLineLevel;
f0aa5f6c 85
f0aa5f6c 86 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
87 for (UInt_t hs=0; hs<6; hs++) {
88 fMeanMultiplicity[hs][chipNr]=NULL;
89 fHitEventEfficiency[hs][chipNr]=NULL;
90 }
91 }
6727e2db 92 for (UInt_t mod=0; mod<240; mod++) {
93 fbModuleScanned[mod]=kFALSE;
f0aa5f6c 94 }
95
96 Init();
97}
98
99AliITSOnlineSPDscanAnalyzer::~AliITSOnlineSPDscanAnalyzer() {
100 // destructor
101 for (UInt_t hs=0; hs<6; hs++) {
102 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
103 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
104 delete fMeanMultiplicity[hs][chipNr];
105 }
106 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
107 delete fHitEventEfficiency[hs][chipNr];
108 }
109 }
110 }
111 if (fTriggers!=NULL) delete fTriggers;
112 if (fScanObj!=NULL) delete fScanObj;
f0aa5f6c 113}
114
115AliITSOnlineSPDscanAnalyzer& AliITSOnlineSPDscanAnalyzer::operator=(const AliITSOnlineSPDscanAnalyzer& handle) {
6727e2db 116 // assignment operator, only copies the filename and params (not the processed data)
f0aa5f6c 117 if (this!=&handle) {
118 for (UInt_t hs=0; hs<6; hs++) {
119 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
120 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
121 delete fMeanMultiplicity[hs][chipNr];
122 }
123 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
124 delete fHitEventEfficiency[hs][chipNr];
125 }
126 }
127 }
128 if (fTriggers!=NULL) delete fTriggers;
129 if (fScanObj!=NULL) delete fScanObj;
f0aa5f6c 130
53ae21ce 131 fFileName=handle.fFileName;
6727e2db 132 fOverWrite=handle.fOverWrite;
133 fNoiseThreshold=handle.fNoiseThreshold;
134 fNoiseMinimumEvents=handle.fNoiseMinimumEvents;
135 fMinNrStepsBeforeIncrease=handle.fMinNrStepsBeforeIncrease;
136 fMinIncreaseFromBaseLine=handle.fMinIncreaseFromBaseLine;
137 fStepDownDacSafe=handle.fStepDownDacSafe;
138 fMaxBaseLineLevel=handle.fMaxBaseLineLevel;
f0aa5f6c 139
f0aa5f6c 140 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
141 for (UInt_t hs=0; hs<6; hs++) {
142 fMeanMultiplicity[hs][chipNr]=NULL;
143 fHitEventEfficiency[hs][chipNr]=NULL;
144 }
145 }
6727e2db 146 for (UInt_t mod=0; mod<240; mod++) {
147 fbModuleScanned[mod]=kFALSE;
f0aa5f6c 148 }
6727e2db 149 fTriggers=NULL;
150 fHandler=NULL;
f0aa5f6c 151
6727e2db 152 fScanObj=NULL;
153 fType=99;
154 fDacId=99;
155
f0aa5f6c 156 Init();
157 }
158 return *this;
159}
160
161void AliITSOnlineSPDscanAnalyzer::Init() {
162 // first checks type of container and then initializes container obj
53ae21ce 163 FILE* fp0 = fopen(fFileName.Data(), "r");
f0aa5f6c 164 if (fp0 == NULL) {
165 return;
166 }
167 else {
168 fclose(fp0);
169 }
53ae21ce 170 fScanObj = new AliITSOnlineSPDscan(fFileName.Data());
f0aa5f6c 171 fType = fScanObj->GetType();
172 delete fScanObj;
173
174 // init container
175 switch(fType) {
176 case kUNIMA:
177 case kNOISE:
53ae21ce 178 fScanObj = new AliITSOnlineSPDscanSingle(fFileName.Data());
f0aa5f6c 179 break;
180 case kMINTH:
181 case kDAC:
182 case kDELAY:
53ae21ce 183 fScanObj = new AliITSOnlineSPDscanMultiple(fFileName.Data());
f0aa5f6c 184 fDacId = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacId();
185 break;
186 case kMEANTH:
53ae21ce 187 fScanObj = new AliITSOnlineSPDscanMeanTh(fFileName.Data());
f0aa5f6c 188 fDacId = ((AliITSOnlineSPDscanMeanTh*)fScanObj)->GetDacId();
189 break;
190 default:
53ae21ce 191 Error("AliITSOnlineSPDscanAnalyzer::Init","Type %d not defined!",fType);
f0aa5f6c 192 fScanObj=NULL;
193 return;
194 break;
195 }
196
f0aa5f6c 197}
198
53ae21ce 199void AliITSOnlineSPDscanAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
200 // set a parameter
201 TString name = pname;
202 TString val = pval;
203 if (name.CompareTo("fOverWrite")==0) {
6727e2db 204 if (val.CompareTo("YES")==0 || val.CompareTo("1")==0) {
53ae21ce 205 fOverWrite = kTRUE;
206 }
6727e2db 207 else fOverWrite = kFALSE;
53ae21ce 208 }
209 else if (name.CompareTo("fNoiseThreshold")==0) {
210 fNoiseThreshold = val.Atof();
211 }
212 else if (name.CompareTo("fNoiseMinimumEvents")==0) {
213 fNoiseMinimumEvents = val.Atoi();
214 }
215 else if (name.CompareTo("fMinNrStepsBeforeIncrease")==0) {
216 fMinNrStepsBeforeIncrease = val.Atoi();
217 }
218 else if (name.CompareTo("fMinIncreaseFromBaseLine")==0) {
219 fMinIncreaseFromBaseLine = val.Atof();
220 }
221 else if (name.CompareTo("fStepDownDacSafe")==0) {
222 fStepDownDacSafe = val.Atoi();
223 }
224 else if (name.CompareTo("fMaxBaseLineLevel")==0) {
225 fMaxBaseLineLevel = val.Atof();
226 }
227 else {
228 Error("AliITSOnlineSPDscanAnalyzer::SetParam","Parameter %s in configuration file unknown.",name.Data());
229 }
230}
f0aa5f6c 231
6727e2db 232void AliITSOnlineSPDscanAnalyzer::ReadParamsFromLocation(const Char_t *dirName) {
233 // opens file (default name) in dir dirName and reads parameters from it
234 TString paramsFileName = Form("%s/standal_params.txt",dirName);
235 ifstream paramsFile;
236 paramsFile.open(paramsFileName, ifstream::in);
237 if (paramsFile.fail()) {
238 printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName.Data());
239 }
240 else {
241 while(1) {
242 Char_t paramN[50];
243 Char_t paramV[50];
244 paramsFile >> paramN;
245 if (paramsFile.eof()) break;
246 paramsFile >> paramV;
247 SetParam(paramN,paramV);
248 if (paramsFile.eof()) break;
249 }
250 paramsFile.close();
251 }
252}
253
254Bool_t AliITSOnlineSPDscanAnalyzer::IsModuleScanned(UInt_t module) const {
255 // is this module scanned?
256 if (module<240) {
257 return fbModuleScanned[module];
258 }
259 return kFALSE;
260}
261
262Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(/*Char_t *oldcalibDir*/) {
53ae21ce 263 // process dead pixel data, for uniformity scan,
264 // NB: This will not be the general way of finding dead pixels.
f0aa5f6c 265 if (fScanObj==NULL) {
53ae21ce 266 Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","No data!");
f0aa5f6c 267 return kFALSE;
268 }
269 // should be type kUNIMA
270 if (fType!=kUNIMA) {
53ae21ce 271 Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Dead pixels only for scan type %d.",kUNIMA);
f0aa5f6c 272 return kFALSE;
273 }
6727e2db 274 // handler should be initialized
275 if (fHandler==NULL) {
276 Error("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Calibration handler is not initialized!");
277 return kFALSE;
278 }
f0aa5f6c 279
f0aa5f6c 280 UInt_t routerNr = fScanObj->GetRouterNr();
281 UInt_t rowStart = fScanObj->GetRowStart();
282 UInt_t rowEnd = fScanObj->GetRowEnd();
283 for (UInt_t hs=0; hs<6; hs++) {
284 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
285 if (fScanObj->GetChipPresent(hs,chipNr) && fScanObj->GetAverageMultiplicity(0,hs,chipNr)>0) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
53ae21ce 286 UInt_t module = AliITSRawStreamSPD::GetModuleNumber(routerNr,hs,chipNr);
6727e2db 287 if (!fbModuleScanned[module]) {
288 fbModuleScanned[module]=kTRUE;
289 // fHandler[module]->SetFileLocation(oldcalibDir);
290 // fHandler[module]->ReadFromFile(module);
291 if (fOverWrite) {fHandler->ResetDeadForChip(routerNr,hs,chipNr);}
292 }
f0aa5f6c 293 for (UInt_t col=0; col<32; col++) {
294 for (UInt_t row=rowStart; row<=rowEnd; row++) {
295 if (col!=1 && col!=9 && col!=17 && col!=25) { //exclude test columns!!!
296 if (fScanObj->GetHits(0,hs,chipNr,col,row)==0) {
6727e2db 297 fHandler->SetDeadPixel(routerNr,hs,chipNr,col,row);
f0aa5f6c 298 }
299 }
300 }
301 }
302 }
303 }
304 }
305 return kTRUE;
306}
307
308
309
6727e2db 310Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(/*Char_t *oldcalibDir*/) {
f0aa5f6c 311 // process noisy pixel data
312 if (fScanObj==NULL) {
53ae21ce 313 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","No data!");
f0aa5f6c 314 return kFALSE;
315 }
316 // should be type kNOISE
317 if (fType != kNOISE) {
53ae21ce 318 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Noisy pixels only for scan type %d.",kNOISE);
f0aa5f6c 319 return kFALSE;
320 }
6727e2db 321 // handler should be initialized
322 if (fHandler==NULL) {
323 Error("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
324 return kFALSE;
325 }
326 // check if enough statistics
f0aa5f6c 327 if (fScanObj->GetTriggers(0)<fNoiseMinimumEvents) {
53ae21ce 328 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Process noisy: Too few events.");
f0aa5f6c 329 return kFALSE;
330 }
6727e2db 331
f0aa5f6c 332 UInt_t routerNr = fScanObj->GetRouterNr();
333 for (UInt_t hs=0; hs<6; hs++) {
334 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
335 if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
53ae21ce 336 UInt_t module = AliITSRawStreamSPD::GetModuleNumber(routerNr,hs,chipNr);
6727e2db 337 if (!fbModuleScanned[module]) {
338 fbModuleScanned[module]=kTRUE;
339 if (fOverWrite) {fHandler->ResetNoisyForChip(routerNr,hs,chipNr);}
340 }
f0aa5f6c 341 for (UInt_t col=0; col<32; col++) {
342 for (UInt_t row=0; row<256; row++) {
343 if (fScanObj->GetHitsEfficiency(0,hs,chipNr,col,row)>fNoiseThreshold) {
6727e2db 344 fHandler->SetNoisyPixel(routerNr,hs,chipNr,col,row);
f0aa5f6c 345 }
346 }
347 }
348 }
349 }
350 }
351 return kTRUE;
352}
353
f0aa5f6c 354Int_t AliITSOnlineSPDscanAnalyzer::GetDelay(UInt_t hs, UInt_t chipNr) {
355 // get delay
356 if (hs>=6 || chipNr>10) return -1;
357 if (fScanObj==NULL) {
53ae21ce 358 Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","No data!");
f0aa5f6c 359 return -1;
360 }
361 // should be type kDELAY or kDAC with id 42 (delay_ctrl)
362 if (fType!=kDELAY && (fType!=kDAC || fDacId!=42)) {
53ae21ce 363 Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","Delay only for scan type %d or %d and dac_id 42.",kDELAY,kDAC);
f0aa5f6c 364 return -1;
365 }
366 if (fMeanMultiplicity[hs][chipNr]==NULL) {
367 if (!ProcessMeanMultiplicity()) {
368 return -1;
369 }
370 }
371
1fd93b67 372 UInt_t maxStep=0;
373 Float_t maxVal=0;
374 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
375 Double_t thisDac;
376 Double_t thisMult;
377 fMeanMultiplicity[hs][chipNr]->GetPoint(step,thisDac,thisMult);
378 if (thisMult > maxVal) {
379 maxVal = thisMult;
380 maxStep = step;
381 }
382 }
383
384 if (maxVal>0) {
385 return ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(maxStep);
f0aa5f6c 386 }
387 else {
388 return -1;
389 }
1fd93b67 390
f0aa5f6c 391}
392
1fd93b67 393
f0aa5f6c 394Int_t AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima(UInt_t hs, UInt_t chipNr) {
395 // in case of a uniformity scan, returns the nr of noisy pixels, (here > 200 hits)
396 if (hs>=6 || chipNr>10) return -1;
397 if (fScanObj==NULL) {
53ae21ce 398 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","No data!");
f0aa5f6c 399 return kFALSE;
400 }
401 // should be type kUNIMA
402 if (fType != kUNIMA) {
53ae21ce 403 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Noisy pixels Unima only for scan type %d.",kUNIMA);
f0aa5f6c 404 return kFALSE;
405 }
406 if (fScanObj->GetTriggers(0)!=25600) {
53ae21ce 407 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Process noisy unima: Incorrect number of events (!=25600.");
f0aa5f6c 408 return kFALSE;
409 }
410
411 Int_t nrNoisy=0;
412 if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
413 for (UInt_t col=0; col<32; col++) {
414 for (UInt_t row=0; row<256; row++) {
415 if (fScanObj->GetHits(0,hs,chipNr,col,row)>200) {
416 nrNoisy++;
417 }
418 }
419 }
420 }
421 else {
422 return -1;
423 }
424 return nrNoisy;
425}
426
427Int_t AliITSOnlineSPDscanAnalyzer::FindLastMinThDac(UInt_t hs, UInt_t chipNr) {
428 // returns dac value where fMinIncreaseFromBaseLine reached
429 if (hs>=6 || chipNr>10) return -1;
430 if (fMeanMultiplicity[hs][chipNr]==NULL) {
431 if (!ProcessMeanMultiplicity()) {
432 return -1;
433 }
434 }
435 Double_t firstVal, dummy1;
436 fMeanMultiplicity[hs][chipNr]->GetPoint(0,dummy1,firstVal);
437 UInt_t step=0;
438 while (step<fScanObj->GetNSteps()-1) {
439 Double_t graphVal, dummy2;
440 fMeanMultiplicity[hs][chipNr]->GetPoint(step+1,dummy2,graphVal);
441 if (graphVal>firstVal+fMinIncreaseFromBaseLine) break;
442 step++;
443 }
444 if (step==fScanObj->GetNSteps()-1) return -1;
445 return ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step);
446}
447
448Int_t AliITSOnlineSPDscanAnalyzer::FindClosestLowerStep(Float_t dacValueInput) {
449 // returns step closest (lower) to a dacvalue
450 UInt_t step=0;
451 while (step<fScanObj->GetNSteps()-1) {
452 Int_t dacVal = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step+1);
453 if (dacVal>=dacValueInput) break;
454 step++;
455 }
456 return step;
457}
458
459Float_t AliITSOnlineSPDscanAnalyzer::GetCompareLine(UInt_t step, UInt_t hs, UInt_t chipNr, Float_t basePar2) {
460 // returns value to compare mean mult with (when finding min th)
461 if (hs>=6 || chipNr>10) return -1;
462 if (step<fMinNrStepsBeforeIncrease) return -1;
463 Float_t baseLine = basePar2;
464 if (baseLine<0) baseLine=0;
465 Float_t baseAdd;
466 Double_t baseM=0;
467 Double_t baseS=0;
468 Double_t d,m;
469 for (UInt_t st=1;st<2*step/3;st++) { // skip first point...
470 fMeanMultiplicity[hs][chipNr]->GetPoint(st,d,m);
471 baseM+=m-baseLine;
472 baseS+=(m-baseLine)*(m-baseLine);
473 }
474 baseAdd=2*sqrt( baseS/(2*step/3-1) - (baseM/(2*step/3-1))*(baseM/(2*step/3-1)) );
475 baseAdd+=0.03; // magic number
476 if (baseAdd>fMinIncreaseFromBaseLine) baseAdd=fMinIncreaseFromBaseLine;
477 return baseLine + baseAdd;
478}
479
480Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
481 // calculates and returns the minimum threshold
482 if (hs>=6 || chipNr>10) return -1;
483 if (fScanObj==NULL) {
53ae21ce 484 Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","No data!");
f0aa5f6c 485 return -1;
486 }
487 // should be type kMINTH or kDAC with id 39 (pre_vth)
488 if (fType!=kMINTH && (fType!=kDAC || fDacId!=39)) {
53ae21ce 489 Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","MinTh only for scan type %d OR %d with dac_id 39.",kMINTH,kDAC);
f0aa5f6c 490 return -1;
491 }
492 if (fMeanMultiplicity[hs][chipNr]==NULL) {
493 if (!ProcessMeanMultiplicity()) {
494 return -1;
495 }
496 }
497
498 Int_t lastDac = FindLastMinThDac(hs,chipNr);
499 if (lastDac==-1) {
53ae21ce 500 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Increase of Mean Multiplicity by %1.2f never reached.",hs,chipNr,fMinIncreaseFromBaseLine);
f0aa5f6c 501 return -1;
502 }
503
504 Int_t minDac = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(0);
53ae21ce 505 TString funcName = Form("Fit minth func HS%d CHIP%d",hs,chipNr);
506 TF1 *minThFunc = new TF1(funcName.Data(),itsSpdErrorf,100,500,3);
f0aa5f6c 507 minThFunc->SetParameter(0,lastDac+10);
508 minThFunc->SetParameter(1,2);
509 minThFunc->SetParameter(2,0);
510 minThFunc->SetParName(0,"Mean");
511 minThFunc->SetParName(1,"Sigma");
512 minThFunc->SetParName(2,"BaseLine");
513 minThFunc->SetLineWidth(1);
514 if (fMeanMultiplicity[hs][chipNr]==NULL) {
515 if (!ProcessMeanMultiplicity()) {
516 return -1;
517 }
518 }
519 fMeanMultiplicity[hs][chipNr]->Fit(funcName,"Q0","",minDac,lastDac);
520
521 // Double_t mean = fMinThFunc[hs][chipNr]->GetParameter(0);
522 // Double_t sigma = fMinThFunc[hs][chipNr]->GetParameter(1);
523 Double_t baseLine = minThFunc->GetParameter(2);
524 delete minThFunc;
525
526 if (baseLine>fMaxBaseLineLevel) {
53ae21ce 527 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: BaseLine too large (%1.2f>%1.2f).",hs,chipNr,baseLine,fMaxBaseLineLevel);
f0aa5f6c 528 return -1;
529 }
530 UInt_t step=FindClosestLowerStep(lastDac);
531 Float_t compareLine = GetCompareLine(step,hs,chipNr,baseLine);
532 if (compareLine==-1) {
53ae21ce 533 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Not enough steps (%d<%d) before increase to get a compare line.",hs,chipNr,step,fMinNrStepsBeforeIncrease);
f0aa5f6c 534 return -1;
535 }
536
537 Double_t mult, dummy;
538 mult=1000;
539 while (mult > compareLine && step>0) {
540 fMeanMultiplicity[hs][chipNr]->GetPoint(step,dummy,mult);
541 step--;
542 }
543 Int_t minth = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step+1)-fStepDownDacSafe;
544
545 if (step>0) {
546 return minth;
547 }
548 else {
53ae21ce 549 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Did not find a point below the compare line (%f).",hs,chipNr,compareLine);
f0aa5f6c 550 return -1;
551 }
552}
553
554
555
556Bool_t AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity() {
557 // process mean multiplicity data
558 if (fScanObj==NULL) {
53ae21ce 559 Error("AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity","No data!");
f0aa5f6c 560 return kFALSE;
561 }
562 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
563 for (UInt_t hs=0; hs<6; hs++) {
564 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
565 // if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
566 if (step==0) {
567 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
568 delete fMeanMultiplicity[hs][chipNr];
569 }
570 fMeanMultiplicity[hs][chipNr] = new TGraph();
571 }
572 Float_t multiplMean=fScanObj->GetAverageMultiplicity(step,hs,chipNr);
573 if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
574 fMeanMultiplicity[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),multiplMean);
575 }
576 else {
577 fMeanMultiplicity[hs][chipNr]->SetPoint(step,0,multiplMean);
578 }
579 }
580 // }
581 }
582 }
583 return kTRUE;
584}
585
586TGraph* AliITSOnlineSPDscanAnalyzer::GetMeanMultiplicityG(UInt_t hs, UInt_t chipNr) {
587 // returns mean multiplicity graph
588 if (hs>=6 || chipNr>10) return NULL;
589 if (fMeanMultiplicity[hs][chipNr]==NULL) {
590 if (!ProcessMeanMultiplicity()) {
591 return NULL;
592 }
593 }
594 return fMeanMultiplicity[hs][chipNr];
595}
596
597Bool_t AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency() {
598 // process hit event efficiency
599 if (fScanObj==NULL) {
53ae21ce 600 Error("AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency","No data!");
f0aa5f6c 601 return kFALSE;
602 }
603 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
604 for (UInt_t hs=0; hs<6; hs++) {
605 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
606 // if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
607 if (step==0) {
608 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
609 delete fHitEventEfficiency[hs][chipNr];
610 }
611 fHitEventEfficiency[hs][chipNr] = new TGraph();
612 }
613 Float_t efficiency=fScanObj->GetHitEventsEfficiency(step,hs,chipNr);
614 if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
615 fHitEventEfficiency[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),efficiency);
616 }
617 else {
618 fHitEventEfficiency[hs][chipNr]->SetPoint(step,0,efficiency);
619 }
620 }
621 // }
622 }
623 }
624 return kTRUE;
625}
626
627TGraph* AliITSOnlineSPDscanAnalyzer::GetHitEventEfficiencyG(UInt_t hs, UInt_t chipNr) {
628 // returns hit event efficiency graph
629 if (hs>=6 || chipNr>10) return NULL;
630 if (fHitEventEfficiency[hs][chipNr]==NULL) {
631 if (!ProcessHitEventEfficiency()) {
632 return NULL;
633 }
634 }
635 return fHitEventEfficiency[hs][chipNr];
636}
637
638
639Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers() {
640 // process nr of triggers data
641 if (fScanObj==NULL) {
53ae21ce 642 Error("AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers","No data!");
f0aa5f6c 643 return kFALSE;
644 }
645 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
646 if (step==0) {
647 if (fTriggers!=NULL) {
648 delete fTriggers;
649 }
650 fTriggers = new TGraph();
651 }
652 if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
653 fTriggers->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),fScanObj->GetTriggers(step));
654 }
655 else {
656 fTriggers->SetPoint(step,0,fScanObj->GetTriggers(step));
657 }
658 }
659 return kTRUE;
660}
661
662TGraph* AliITSOnlineSPDscanAnalyzer::GetNrTriggersG() {
663 // returns nr of triggers graph
664 if (fTriggers==NULL) {
665 if (!ProcessNrTriggers()) {
666 return NULL;
667 }
668 }
669 return fTriggers;
670}
671
672Bool_t AliITSOnlineSPDscanAnalyzer::GetHalfStavePresent(UInt_t hs) {
673 // returns half stave present info
674 if (hs<6 && fScanObj!=NULL) {
675 Int_t chipstatus=0;
676 for (Int_t chip=0; chip<10; chip++) {
677 chipstatus+=fScanObj->GetChipPresent(hs,chip);
678 }
679 if (chipstatus>0) return kTRUE;
680 }
681 return kFALSE;
682}
683
f0aa5f6c 684UInt_t AliITSOnlineSPDscanAnalyzer::GetRouterNr() {
685 // returns the router nr of scan obj
686 if (fScanObj!=NULL) return fScanObj->GetRouterNr();
687 else return 99;
688}
689
690TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapTot(UInt_t step) {
691 // creates and returns a pointer to a hitmap histo (half sector style a la spdmood)
692 if (fScanObj==NULL) {
53ae21ce 693 Error("AliITSOnlineSPDscanAnalyzer::GetHitMapTot","No data!");
f0aa5f6c 694 return NULL;
695 }
53ae21ce 696 TString histoname;
f0aa5f6c 697 if (fType==kMINTH || fType==kMEANTH || fType==kDAC) {
53ae21ce 698 histoname = Form("Router %d , DAC %d",GetRouterNr(),((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step));
f0aa5f6c 699 }
700 else {
53ae21ce 701 histoname = Form("Router %d ",GetRouterNr());
f0aa5f6c 702 }
53ae21ce 703 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 704 fHitMapTot->SetNdivisions(-10,"X");
705 fHitMapTot->SetNdivisions(-006,"Y");
706 fHitMapTot->SetTickLength(0,"X");
707 fHitMapTot->SetTickLength(0,"Y");
708 fHitMapTot->GetXaxis()->SetLabelColor(gStyle->GetCanvasColor());
709 fHitMapTot->GetYaxis()->SetLabelColor(gStyle->GetCanvasColor());
710 for (UInt_t hs=0; hs<6; hs++) {
711 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
712 for (UInt_t col=0; col<32; col++) {
713 for (UInt_t row=0; row<256; row++) {
714 fHitMapTot->Fill(chipNr*32+col,(5-hs)*256+row,fScanObj->GetHits(step,hs,chipNr,col,row));
715 }
716 }
717 }
718 }
719 return fHitMapTot;
720}
6727e2db 721
722TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapChip(UInt_t step, UInt_t hs, UInt_t chip) {
723 // creates and returns a pointer to a hitmap histo (chip style a la spdmood)
724 if (fScanObj==NULL) {
725 Error("AliITSOnlineSPDscanAnalyzer::GetHitMapChip","No data!");
726 return NULL;
727 }
728
729 TString histoName;
730 TString histoTitle;
731 histoName = Form("fChipHisto_%d_%d_%d", GetRouterNr(), hs, chip);
732 histoTitle = Form("Eq ID %d, Half Stave %d, Chip %d", GetRouterNr(), hs, chip);
733
734 TH2F *returnHisto = new TH2F(histoName.Data(), histoTitle.Data(), 32, -0.5, 31.5, 256, -0.5, 255.5);
735 returnHisto->SetMinimum(0);
736 for (UInt_t col=0; col<32; col++) {
737 for (UInt_t row=0; row<256; row++) {
738 returnHisto->Fill(col,row,fScanObj->GetHits(step,hs,chip,col,row));
739 }
740 }
741
742 return returnHisto;
743}