remoe duplicate QA initialisation and do ESD QA for same detectors as RecPoint QA
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerEfficiencyCells.cxx
CommitLineData
70b4a8d6 1/**************************************************************************
2 * Copyright(c) 1998-1999, 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
313c3f0c 16#include "AliMUONTriggerEfficiencyCells.h"
17#include "AliMpConstants.h"
313c3f0c 18
96079e17 19// Classes for display
20#include "AliMUONGeometryTransformer.h"
21#include "AliMpCDB.h"
683cb6c5 22#include "AliCDBManager.h"
96079e17 23#include "AliMpDDLStore.h"
24#include "AliMpDDL.h"
25#include "AliMpTriggerCrate.h"
26#include "AliMpLocalBoard.h"
27#include "AliMpPad.h"
28#include "AliMpVSegmentation.h"
29#include "AliMpSegmentation.h"
30
313c3f0c 31#include "AliLog.h"
32
33#include "TRandom.h"
70b4a8d6 34#include "Riostream.h"
081d3361 35#include "TSystem.h"
8c0b5e70 36#include "TFile.h"
37#include "TH1F.h"
311d0691 38#include "TMath.h"
39
40#include "TH2F.h"
96079e17 41#include "TH3F.h"
42#include "TF1.h"
311d0691 43#include "TStyle.h"
44#include "TPaveLabel.h"
45#include "TCanvas.h"
70b4a8d6 46
313c3f0c 47#include <fstream>
48#include <cassert>
70b4a8d6 49
3d1463c8 50//-----------------------------------------------------------------------------
5398f946 51/// \class AliMUONTriggerEfficiencyCells
52/// A class to store and give access to the trigger chamber efficiency.
53///
683cb6c5 54/// Efficiency is stored per cathode on local boards
5398f946 55///
56/// The main method of this class is IsTriggered().
57///
683cb6c5 58/// $ALICE_ROOT/MUON/data/efficiencyCells.dat contains efficiency
5398f946 59/// for each chamber (i.e. DetElement).
081d3361 60///
61/// In the case of local boards, efficiency is stored from left to right
62/// per increasing board number (from 1 to 234)
63///
683cb6c5 64/// The file can be edited in order to change efficiency
65/// in a chosen local board/region of the chamber.
081d3361 66///
5398f946 67///
68/// But please note that this object is also available from the CDB
5398f946 69///
70/// \author Diego Stocco; INFN Torino
3d1463c8 71//-----------------------------------------------------------------------------
70b4a8d6 72
5398f946 73/// \cond CLASSIMP
70b4a8d6 74ClassImp(AliMUONTriggerEfficiencyCells)
5398f946 75/// \endcond
70b4a8d6 76
77//__________________________________________________________________________
78AliMUONTriggerEfficiencyCells::AliMUONTriggerEfficiencyCells()
79:
311d0691 80TObject(),
81fCountHistoList(0x0),
96079e17 82fNoCountHistoList(0x0),
83fFiredStrips(0x0),
84fDisplayHistoList(0x0),
85fBoardLabelList(0x0),
86fFiredFitHistoList(0x0),
87fFiredDisplayHistoList(0x0)
70b4a8d6 88{
5398f946 89/// Default constructor.
313c3f0c 90 CheckConstants();
70b4a8d6 91 Reset();
311d0691 92 InitHistos();
70b4a8d6 93}
94
95//__________________________________________________________________________
96079e17 96AliMUONTriggerEfficiencyCells::AliMUONTriggerEfficiencyCells(const Char_t* filename)
70b4a8d6 97:
311d0691 98TObject(),
99fCountHistoList(0x0),
96079e17 100fNoCountHistoList(0x0),
101fFiredStrips(0x0),
102fDisplayHistoList(0x0),
103fBoardLabelList(0x0),
104fFiredFitHistoList(0x0),
105fFiredDisplayHistoList(0x0)
70b4a8d6 106{
5398f946 107/// Constructor using an ASCII file.
313c3f0c 108 CheckConstants();
70b4a8d6 109 Reset();
110 ReadFile(filename);
111}
112
311d0691 113AliMUONTriggerEfficiencyCells::AliMUONTriggerEfficiencyCells(TList *countHistoList,
114 TList *noCountHistoList)
115:
116TObject(),
117fCountHistoList(countHistoList),
96079e17 118fNoCountHistoList(noCountHistoList),
119fFiredStrips(0x0),
120fDisplayHistoList(0x0),
121fBoardLabelList(0x0),
122fFiredFitHistoList(0x0),
123fFiredDisplayHistoList(0x0)
311d0691 124{
125/// Constructor using an ASCII file.
126 CheckConstants();
127 Reset();
128 InitHistos();
129 FillHistosFromList();
130}
131
132//_____________________________________________________________________________
133AliMUONTriggerEfficiencyCells::AliMUONTriggerEfficiencyCells(const AliMUONTriggerEfficiencyCells& other)
134:
135TObject(other),
136fCountHistoList(other.fCountHistoList),
96079e17 137fNoCountHistoList(other.fNoCountHistoList),
138fFiredStrips(other.fFiredStrips),
139fDisplayHistoList(other.fDisplayHistoList),
140fBoardLabelList(other.fBoardLabelList),
141fFiredFitHistoList(other.fFiredFitHistoList),
142fFiredDisplayHistoList(other.fFiredDisplayHistoList)
311d0691 143{
144/// Copy constructor
145
146 for(Int_t chCath=0; chCath<fgkNplanes; chCath++){
311d0691 147 fBoardEfficiency[chCath] = other.fBoardEfficiency[chCath];
148 fSlatEfficiency[chCath] = other.fSlatEfficiency[chCath];
149 }
150}
151
152//_____________________________________________________________________________
153AliMUONTriggerEfficiencyCells& AliMUONTriggerEfficiencyCells::operator=(const AliMUONTriggerEfficiencyCells& other)
154{
155 /// Asignment operator
156 // check assignement to self
157 if (this == &other)
158 return *this;
159
160 for(Int_t chCath=0; chCath<fgkNplanes; chCath++){
311d0691 161 fBoardEfficiency[chCath] = other.fBoardEfficiency[chCath];
162 fSlatEfficiency[chCath] = other.fSlatEfficiency[chCath];
163 }
164
165 fCountHistoList = other.fCountHistoList;
166 fNoCountHistoList = other.fNoCountHistoList;
96079e17 167 fFiredStrips = other.fFiredStrips;
311d0691 168
96079e17 169 fDisplayHistoList = other.fDisplayHistoList;
170 fBoardLabelList = other.fBoardLabelList;
171 fFiredFitHistoList = other.fFiredFitHistoList;
172 fFiredDisplayHistoList = other.fFiredDisplayHistoList;
173
311d0691 174 return *this;
175}
70b4a8d6 176
177//__________________________________________________________________________
178AliMUONTriggerEfficiencyCells::~AliMUONTriggerEfficiencyCells()
179{
311d0691 180/// Destructor.
70b4a8d6 181}
70b4a8d6 182
183
184//__________________________________________________________________________
313c3f0c 185void AliMUONTriggerEfficiencyCells::GetCellEfficiency(Int_t detElemId, Int_t localBoard, Float_t &eff1, Float_t &eff2) const
70b4a8d6 186{
081d3361 187/// Get the efficiencies of the 2 cathodes at a given local board
5398f946 188
081d3361 189 Int_t chamber = FindChamberIndex(detElemId);
311d0691 190 Int_t bin = fBoardEfficiency[chamber]->FindBin(localBoard);
191 eff1 = fBoardEfficiency[chamber]->GetBinContent(bin);
192 eff2 = fBoardEfficiency[fgkNchambers+chamber]->GetBinContent(bin);
70b4a8d6 193}
194
195
196//__________________________________________________________________________
197void
313c3f0c 198AliMUONTriggerEfficiencyCells::IsTriggered(Int_t detElemId, Int_t localBoard, Bool_t &trig1, Bool_t &trig2) const
081d3361 199{
200/// Whether or not a given local board has a chance to trig, on each cathode.
201
202 Float_t eff1 = 0.0;
203 Float_t eff2 = 0.0;
204 GetCellEfficiency(detElemId, localBoard, eff1, eff2);
205 trig1 = kTRUE;
206 trig2 = kTRUE;
207 if(gRandom->Rndm()>eff1)trig1 = kFALSE;
208 if(gRandom->Rndm()>eff2)trig2 = kFALSE;
209}
210
70b4a8d6 211
212//__________________________________________________________________________
96079e17 213void AliMUONTriggerEfficiencyCells::ReadFile(const Char_t* filename)
70b4a8d6 214{
5398f946 215/// Reads a file containing the efficiency map.
216
70b4a8d6 217 TString fileName = gSystem->ExpandPathName(filename);
8c0b5e70 218 if(fileName.EndsWith(".root")){
219 ReadHistoBoards(fileName.Data());
220 return;
221 }
222
311d0691 223 InitHistos();
70b4a8d6 224 ifstream file(fileName.Data());
96079e17 225 Char_t dat[50];
70b4a8d6 226 if (file.good()){
081d3361 227 file >> dat;
228 if(!strcmp(dat,"localBoards"))ReadFileBoards(file);
683cb6c5 229 else AliWarning("File .dat in wrong format");
8c0b5e70 230 file.close();
081d3361 231 } else {
8c0b5e70 232 AliWarning(Form("Can't read file %s",fileName.Data()));
081d3361 233 }
234}
235
236
237//__________________________________________________________________________
081d3361 238void AliMUONTriggerEfficiencyCells::ReadFileBoards(ifstream &file)
239{
313c3f0c 240/// Structure of file (.dat) containing local board efficency
311d0691 241 Int_t datInt=0, detEl=0, chamber=0, chCath=0, bin=0;
081d3361 242 Float_t datFloat=0.0;
96079e17 243 Char_t dat[50];
081d3361 244
245 while (file >> dat) {
246 file >> detEl;
247 chamber = FindChamberIndex(detEl);
313c3f0c 248 for(Int_t cath=0; cath<fgkNcathodes; cath++){
249 chCath = fgkNchambers*cath + chamber;
081d3361 250 file >> dat;
251 file >> datInt;
311d0691 252 for(Int_t board=1; board<=AliMpConstants::NofLocalBoards(); board++){
081d3361 253 file >> datFloat;
311d0691 254 bin = fBoardEfficiency[chCath]->FindBin(board);
255 fBoardEfficiency[chCath]->SetBinContent(bin, datFloat);
081d3361 256 }
257 }
258 }
259}
70b4a8d6 260
8c0b5e70 261
262//__________________________________________________________________________
96079e17 263void AliMUONTriggerEfficiencyCells::ReadHistoBoards(const Char_t *filename)
8c0b5e70 264{
313c3f0c 265/// Structure of file (.root) containing local board efficency
8c0b5e70 266 TFile *file = new TFile(filename, "read");
267 if(!file) {
268 AliWarning(Form("Can't read file %s",filename));
269 return;
270 }
683cb6c5 271 Char_t histoName[40];
96079e17 272 Char_t *cathCode[fgkNcathodes] = {"bendPlane", "nonBendPlane"};
683cb6c5 273 enum {kAllChEff, kChNonEff, kNumOfHistoTypes};
274 Char_t *histoTypeName[2] = {"CountInCh", "NonCountInCh"};
311d0691 275
683cb6c5 276 if(!fCountHistoList) fCountHistoList = new TList();
277 else fCountHistoList->Delete();
278 if(!fNoCountHistoList) fNoCountHistoList = new TList();
279 else fNoCountHistoList->Delete();
280
281 TList *currList[2] = {fCountHistoList, fNoCountHistoList};
282
283 TH1F *histo = 0x0;
284
285 for(Int_t cath=0; cath<fgkNcathodes; cath++){
286 for(Int_t hType=0; hType<kNumOfHistoTypes; hType++){
287 sprintf(histoName, "%sChamber%s", cathCode[cath], histoTypeName[hType]);
288 histo = (TH1F*)file->Get(histoName);
289 currList[hType]->Add(histo);
290 }
291 }
292
293 for(Int_t cath=0; cath<fgkNcathodes; cath++){
294 for(Int_t ch=0; ch<fgkNchambers; ch++){
295 for(Int_t hType=0; hType<kNumOfHistoTypes; hType++){
296 sprintf(histoName, "%sSlat%s%i", cathCode[cath], histoTypeName[hType], 11+ch);
297 histo = (TH1F*)file->Get(histoName);
298 currList[hType]->Add(histo);
8c0b5e70 299 }
683cb6c5 300 }
8c0b5e70 301 }
683cb6c5 302
303 for(Int_t cath=0; cath<fgkNcathodes; cath++){
304 for(Int_t ch=0; ch<fgkNchambers; ch++){
305 for(Int_t hType=0; hType<kNumOfHistoTypes; hType++){
306 sprintf(histoName, "%sBoard%s%i", cathCode[cath], histoTypeName[hType], 11+ch);
307 histo = (TH1F*)file->Get(histoName);
308 currList[hType]->Add(histo);
309 }
310 }
311 }
312
313 InitHistos();
314 FillHistosFromList();
8c0b5e70 315}
316
317
313c3f0c 318//_____________________________________________________________________________
319void AliMUONTriggerEfficiencyCells::CheckConstants() const
320{
321/// Check consistence of redefined constants
322
323 assert(fgkNcathodes == AliMpConstants::NofCathodes());
324 assert(fgkNchambers == AliMpConstants::NofTriggerChambers());
325 assert(fgkNplanes == AliMpConstants::NofTriggerChambers() * fgkNcathodes);
326}
327
328
70b4a8d6 329//__________________________________________________________________________
313c3f0c 330Int_t AliMUONTriggerEfficiencyCells::FindChamberIndex(Int_t detElemId) const
70b4a8d6 331{
5398f946 332/// From detElemId to chamber number
42814105 333
334 // Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
335 Int_t iChamber = detElemId/100 - 1;
313c3f0c 336 Int_t chamber = iChamber-AliMpConstants::NofTrackingChambers();
70b4a8d6 337 return chamber;
338}
339
340
341//__________________________________________________________________________
70b4a8d6 342void
343AliMUONTriggerEfficiencyCells::Reset()
344{
5398f946 345/// Sets our internal array contents to zero.
346
683cb6c5 347 for(Int_t chCath=0; chCath<fgkNplanes; chCath++){
348 fBoardEfficiency[chCath] = 0x0;
349 fSlatEfficiency[chCath] = 0x0;
350 }
311d0691 351}
352
353
354//__________________________________________________________________________
355void
356AliMUONTriggerEfficiencyCells::InitHistos()
357{
358/// Sets our internal array contents to zero.
359
360 const Int_t kNumOfBoards = AliMpConstants::NofLocalBoards();
683cb6c5 361 const Int_t kNslats = 18;
311d0691 362 Int_t chCath=0;
363 Char_t histoName[40];
364
365 Char_t *cathCode[fgkNcathodes] = {"bendPlane", "nonBendPlane"};
366
367 for(Int_t ch=0; ch<fgkNchambers; ch++){
368 for(Int_t cath=0; cath<fgkNcathodes; cath++){
369 chCath = fgkNchambers*cath + ch;
370 sprintf(histoName, "%sBoardEffChamber%i", cathCode[cath], 11+ch);
371 fBoardEfficiency[chCath] = new TH1F(histoName, histoName, kNumOfBoards, 1-0.5, kNumOfBoards+1.-0.5);
372 sprintf(histoName, "%sSlatEffChamber%i", cathCode[cath], 11+ch);
683cb6c5 373 fSlatEfficiency[chCath] = new TH1F(histoName, histoName, kNslats, 0-0.5, kNslats-0.5);
311d0691 374 }
375 }
376}
377
378
379//__________________________________________________________________________
380void
381AliMUONTriggerEfficiencyCells::FillHistosFromList()
382{
96079e17 383/// Fills internal histos from list.
311d0691 384
385 Int_t nHistoBins=0;
386 TH1F *histoNum = 0x0, *histoDen=0x0, *currHisto = 0x0;
387 TString slatName = "Slat", boardName = "Board", histoName;
388 Int_t iHistoBoard = -1, iHistoSlat = -1;
389 Float_t efficiency, efficiencyError;
390
391 Int_t nentries = fCountHistoList->GetEntries();
392
393 for(Int_t iEntry=0; iEntry<nentries; iEntry++){
394 histoNum = (TH1F*)fCountHistoList->At(iEntry);
395 histoDen = (TH1F*)fNoCountHistoList->At(iEntry);
396
397 if(!histoNum) {
398 AliWarning("Histogram not found in fCountHistoList. Skip to next");
399 continue;
400 }
401 if(!histoDen) {
402 AliWarning("Histogram not found in fNoCountHistoList. Skip to next");
403 continue;
404 }
405
406 histoName = histoNum->GetName();
407 nHistoBins = histoNum->GetNbinsX();
408
409 if(histoName.Contains(boardName)){
410 iHistoBoard++;
411 currHisto = fBoardEfficiency[iHistoBoard];
412 }
413 else if(histoName.Contains(slatName)){
414 iHistoSlat++;
415 currHisto = fSlatEfficiency[iHistoSlat];
416 }
417 else continue;
418
419 for(Int_t iBin=1; iBin<=nHistoBins; iBin++){
420 CalculateEfficiency((Int_t)histoNum->GetBinContent(iBin), (Int_t)histoNum->GetBinContent(iBin) + (Int_t)histoDen->GetBinContent(iBin), efficiency, efficiencyError, kFALSE);
421
422 currHisto->SetBinContent(iBin, efficiency);
423 currHisto->SetBinError(iBin, efficiencyError);
424 }
425 }
426}
427
428
311d0691 429//_____________________________________________________________________________
430void AliMUONTriggerEfficiencyCells::CalculateEfficiency(Int_t trigger44, Int_t trigger34,
431 Float_t &efficiency, Float_t &error,
432 Bool_t failuresAsInput)
433{
434 //
435 /// Returns the efficiency.
436 //
437
438 efficiency=-9.;
439 error=0.;
440 if(trigger34>0){
441 efficiency=(Double_t)trigger44/((Double_t)trigger34);
442 if(failuresAsInput)efficiency=1.-(Double_t)trigger44/((Double_t)trigger34);
443 }
444 Double_t q = TMath::Abs(1-efficiency);
445 if(efficiency<0)error=0.0;
446 else error = TMath::Sqrt(efficiency*q/((Double_t)trigger34));
447}
448
96079e17 449
311d0691 450//_____________________________________________________________________________
683cb6c5 451void AliMUONTriggerEfficiencyCells::CheckFiredStrips(const Char_t* geoFilename,
452 const Char_t* cdbStorage,
453 Int_t runNumber)
311d0691 454{
455 //
96079e17 456 /// Check for fired strips participating to efficiency
457 /// calculation (when available).
458 /// Strips inside a local board should be quite homogeneously hit
459 /// If not, this could be a problem of electronics (i.e. ADULT board off).
311d0691 460 //
461
96079e17 462 if(!fFiredStrips) {
463 AliWarning("List of fired pads not present. Check not performable.");
464 return;
465 }
466
683cb6c5 467 GetListsForCheck(geoFilename, cdbStorage, runNumber);
96079e17 468
469 Char_t histoName[40], histoTitle[90];
470
471 // Check fired pads (when available)
472 if(fFiredFitHistoList){
473 TH1F *histo1D = 0x0;
474 TF1 *fitFunc = 0x0;
475 TCanvas *histoFiredCan[20];
476 Int_t nEntries = fFiredFitHistoList->GetEntries();
477 for(Int_t iEntry=0; iEntry<nEntries; iEntry++){
478 histo1D = (TH1F*)fFiredFitHistoList->At(iEntry);
479 printf("Problems found in %s\n", histo1D->GetTitle());
480 }
481 Int_t nPrintCan = nEntries;
482 if(nPrintCan>20) {
483 AliWarning("Too many boards with problems: only 20 will be shown");
484 nPrintCan = 20;
485 }
486 for(Int_t iCan=0; iCan<nPrintCan; iCan++){
487 histo1D = (TH1F*)fFiredFitHistoList->At(iCan);
488 histoFiredCan[iCan] = new TCanvas(histoName, histoTitle, 100+10*iCan, 10*iCan, 700, 700);
489 histoFiredCan[iCan]->SetRightMargin(0.14);
490 histoFiredCan[iCan]->SetLeftMargin(0.12);
491 histo1D->Draw("E");
492 fitFunc = histo1D->GetFunction("pol0");
493 fitFunc->SetLineColor(2);
494 fitFunc->Draw("same");
495 }
496 if(nEntries==0){
497 printf("\nAll local boards seem ok!!\n\n");
498 }
499 }
500}
501
502
503//_____________________________________________________________________________
683cb6c5 504void AliMUONTriggerEfficiencyCells::DisplayEfficiency(Bool_t perSlat,
505 const Char_t* geoFilename,
506 const Char_t* cdbStorage,
507 Int_t runNumber)
96079e17 508{
509 //
510 /// Display calculated efficiency.
511 //
311d0691 512
513 Bool_t isInitSlat = kFALSE, isInitBoard = kFALSE;
514 for(Int_t chCath=0; chCath<fgkNplanes; chCath++){
515 if(fBoardEfficiency[chCath]->GetEntries()>0) isInitBoard = kTRUE;
516 if(fSlatEfficiency[chCath]->GetEntries()>0) isInitSlat = kTRUE;
517 }
518
519 if(!isInitBoard){
520 printf("Trigger efficiency not initialized per board.\nDisplay not yet implemented.\n");
521 return;
522 }
523 if(!isInitSlat && perSlat){
524 printf("Trigger efficiency not initialized for slat.\nPlease try option kFALSE.\n");
525 return;
526 }
96079e17 527
683cb6c5 528 GetListsForCheck(geoFilename, cdbStorage, runNumber);
96079e17 529
530 const Int_t kNumOfBoards = AliMpConstants::NofLocalBoards();
531
532 TH2F *histo = 0x0;
533 Char_t histoName[40], histoTitle[90];
534 TPaveLabel *boardLabel = 0x0;
535
536 // Plot fired strips (when available)
537 if(fFiredDisplayHistoList){
538 TCanvas *displayFiredCan[fgkNplanes];
539 for(Int_t chCath=0; chCath<fgkNplanes; chCath++){
540 histo = (TH2F*)fFiredDisplayHistoList->At(chCath);
541 sprintf(histoName, "%sCan", histo->GetName());
542 sprintf(histoTitle, "%s", histo->GetTitle());
543 displayFiredCan[chCath] = new TCanvas(histoName, histoTitle, 100+10*chCath, 10*chCath, 700, 700);
544 displayFiredCan[chCath]->SetRightMargin(0.14);
545 displayFiredCan[chCath]->SetLeftMargin(0.12);
546 histo->GetYaxis()->SetTitleOffset(1.4);
547 histo->SetStats(kFALSE);
548 histo->Draw("COLZ");
549 for (Int_t board = 0; board < kNumOfBoards; board++) {
550 Int_t currLabel = chCath * kNumOfBoards + board;
551 boardLabel = (TPaveLabel*)fBoardLabelList->At(currLabel);
552 boardLabel->Draw("same");
553 }
554 }
555 }
556
557 // Plot efficiency
558 if(fDisplayHistoList){
559 TCanvas *can[fgkNplanes];
560 for(Int_t chCath=0; chCath<fgkNplanes; chCath++){
561 Int_t currChCath = chCath;
562 if(perSlat==kTRUE) currChCath += fgkNplanes;
563 histo = (TH2F*)fDisplayHistoList->At(currChCath);
564 sprintf(histoName, "%sCan", histo->GetName());
565 sprintf(histoTitle, "%s", histo->GetTitle());
566 can[chCath] = new TCanvas(histoName, histoTitle, 100+10*chCath, 10*chCath, 700, 700);
567 can[chCath]->SetRightMargin(0.14);
568 can[chCath]->SetLeftMargin(0.12);
569 histo->GetZaxis()->SetRangeUser(0.,1.);
570 histo->GetYaxis()->SetTitleOffset(1.4);
571 histo->SetStats(kFALSE);
572 histo->Draw("COLZ");
573 for (Int_t board = 0; board < kNumOfBoards; board++) {
574 Int_t currLabel = chCath * kNumOfBoards + board;
575 if(perSlat==kTRUE) currLabel += kNumOfBoards * fgkNplanes;
576 boardLabel = (TPaveLabel*)fBoardLabelList->At(currLabel);
577 boardLabel->Draw("same");
578 }
579 }
580 }
581}
582
583
584//__________________________________________________________________________
683cb6c5 585Bool_t AliMUONTriggerEfficiencyCells::GetListsForCheck(const Char_t* geoFilename,
586 const Char_t* cdbStorage,
587 Int_t runNumber)
96079e17 588{
3e0aa963 589 //
590 /// Getting histograms for efficiency,
591 /// map of fired strips entering efficiency calculations,
592 /// fits for checking switched-off elements in chambers.
593 //
594
96079e17 595 const Int_t kNumOfBoards = AliMpConstants::NofLocalBoards();
596 const Float_t kChi2RedMax = 1.5;
597 const Float_t kDummyFired = 1e-5;
598
599 if(fDisplayHistoList || fBoardLabelList || fFiredFitHistoList || fFiredDisplayHistoList) return kTRUE;
600
601 if(!fDisplayHistoList) fDisplayHistoList = new TList();
602 if(!fBoardLabelList) fBoardLabelList = new TList();
603 if(!fFiredFitHistoList && fFiredStrips) fFiredFitHistoList = new TList();
604 if(!fFiredDisplayHistoList && fFiredStrips) fFiredDisplayHistoList = new TList();
605
683cb6c5 606 AliCDBManager::Instance()->SetDefaultStorage(cdbStorage);
607 AliCDBManager::Instance()->SetRun(runNumber);
608
96079e17 609 AliMUONGeometryTransformer *transform = new AliMUONGeometryTransformer();
610 transform->LoadGeometryData(geoFilename);
311d0691 611
96079e17 612 if(!AliMpCDB::LoadDDLStore()) // Load DDL store from OCDB
613 AliFatal("Could not access mapping OCDB");
614
615 AliMpDDLStore *ddlStore = AliMpDDLStore::Instance();
616 Int_t line, slat;
617 Float_t xLocal1=0., yLocal1=0., xLocal2=0., yLocal2=0.;
618 Float_t xg1, yg1, zg1, xg2, yg2, zg2;
619 Float_t xWidth=0., yWidth=0.;
620 Float_t x1Label=0., x2Label=0., y1Label=0., y2Label=0.;
621 Float_t x1LabelSlat=0., x2LabelSlat=0., y1LabelSlat=0., y2LabelSlat=0.;
622 Int_t x1=0, y1=0, x2=0, y2=0, localId;
311d0691 623
624 gStyle->SetPalette(1);
625
626 Char_t *cathCode[fgkNcathodes] = {"bendPlane", "nonBendPlane"};
627
96079e17 628 Float_t boardsX = 280.00; // cm
629 Float_t boardsY = 335.00; // cm
630
631 // Check fired pads (when available)
632 Int_t maxY[fgkNcathodes] = {64,1};
633 TH3F *padFired[fgkNplanes];
634 TH1F *histoFired[fgkNplanes][234];
635 TH2F *histoFiredDisplay[fgkNplanes];
636 TF1 *fitFunc = 0x0;
637 Bool_t isStripOffInBoard[fgkNplanes][234];
311d0691 638
639 TH2F *histo[fgkNplanes];
96079e17 640 TH2F *histoSlat[fgkNplanes];
311d0691 641 TPaveLabel *boardLabel[fgkNplanes][234];
96079e17 642 TPaveLabel *boardLabelSlat[fgkNplanes][234];
643 assert(kNumOfBoards==234);
311d0691 644
96079e17 645 Char_t histoName[40], histoTitle[90], labelTxt[5], labelSlatTxt[5];
311d0691 646
96079e17 647 Float_t efficiency, efficiencyError, efficiencySlat, efficiencySlatError;
311d0691 648
96079e17 649 // Book histos
311d0691 650 for(Int_t cath=0; cath<fgkNcathodes; cath++){
96079e17 651 padFired[cath] = 0x0;
652 if(fFiredStrips) padFired[cath] = (TH3F*)fFiredStrips->At(cath);
311d0691 653 for(Int_t ch=0; ch<fgkNchambers; ch++){
654 Int_t chCath = fgkNchambers*cath + ch;
655 sprintf(histoName, "%sChamber%i", cathCode[cath], 11+ch);
656 sprintf(histoTitle, "Chamber %i: efficiency %s", 11+ch, cathCode[cath]);
657 histo[chCath] = new TH2F(histoName, histoTitle, (Int_t)boardsX, -boardsX, boardsX, (Int_t)boardsY, -boardsY, boardsY);
658 histo[chCath]->SetXTitle("X (cm)");
659 histo[chCath]->SetYTitle("Y (cm)");
96079e17 660 fDisplayHistoList->Add(histo[chCath]);
661
662 if(!fFiredStrips) continue;
663 sprintf(histoName, "firedPads%sChamber%i", cathCode[cath], 11+ch);
664 sprintf(histoTitle, "Chamber %i: Fired pads %s", 11+ch, cathCode[cath]);
665 histoFiredDisplay[chCath] = new TH2F(histoName, histoTitle, (Int_t)boardsX, -boardsX, boardsX, (Int_t)boardsY, -boardsY, boardsY);
666 histoFiredDisplay[chCath]->SetXTitle("X (cm)");
667 histoFiredDisplay[chCath]->SetYTitle("Y (cm)");
668 fFiredDisplayHistoList->Add(histoFiredDisplay[chCath]);
669
670 for(Int_t ib=0; ib<kNumOfBoards; ib++){
671 sprintf(histoName, "%sChamber%iBoard%i", cathCode[cath], 11+ch, ib+1);
672 sprintf(histoTitle, "Chamber %i: fired pads %s board = %i", 11+ch, cathCode[cath], ib+1);
673 histoFired[chCath][ib] = new TH1F(histoName, histoTitle, 16, -0.5, 15.5);
674 histoFired[chCath][ib]->SetXTitle("board");
675 isStripOffInBoard[chCath][ib] = kFALSE;
676 } // loop on board
677 } // loop on chamber
678 } // loop on cathode
311d0691 679
96079e17 680 for(Int_t cath=0; cath<fgkNcathodes; cath++){
681 for(Int_t ch=0; ch<fgkNchambers; ch++){
682 Int_t chCath = fgkNchambers*cath + ch;
683 sprintf(histoName, "%sChamber%iSlatEff", cathCode[cath], 11+ch);
684 sprintf(histoTitle, "Chamber %i: efficiency %s per slat", 11+ch, cathCode[cath]);
685 histoSlat[chCath] = new TH2F(histoName, histoTitle, (Int_t)boardsX, -boardsX, boardsX, (Int_t)boardsY, -boardsY, boardsY);
686 histoSlat[chCath]->SetXTitle("X (cm)");
687 histoSlat[chCath]->SetYTitle("Y (cm)");
688 fDisplayHistoList->Add(histoSlat[chCath]);
689 }
311d0691 690 }
691
96079e17 692 // loop over the trigger DDL (Right: 20, Left: 21)
693 for (Int_t iDDL = 20; iDDL <= 21; ++iDDL) {
694 AliMpDDL* ddl = ddlStore->GetDDL(iDDL);
695 Int_t nCrate = ddl->GetNofTriggerCrates();
696 // loop over the number of crates in DDL
697 for (Int_t index = 0; index < nCrate; ++index) {
698 // get crate object
699 AliMpTriggerCrate* crate = ddlStore->GetTriggerCrate(iDDL, index);
700 Int_t nLocal = crate->GetNofLocalBoards();
701 for (Int_t iLocal = 0; iLocal < nLocal; ++iLocal) {
702 // get local board Id from crate object
703 localId = crate->GetLocalBoardId(iLocal);
704 // get local board object
705 AliMpLocalBoard* localBoard = ddlStore->GetLocalBoard(localId);
706
707 if (!localBoard->IsNotified()) continue;
708
709 // get detection element connected to this board
710 for (Int_t ch = 0; ch < fgkNchambers; ++ch) {
711 Int_t iCh = ch + AliMpConstants::NofTrackingChambers();
712 Int_t detElemId = ddlStore->GetDEfromLocalBoard(localId, iCh);
713
714 if (!detElemId) continue;
715
716 // get segmentation
717 for (Int_t cath = 0; cath < fgkNcathodes; ++cath) {
718 const AliMpVSegmentation* seg = AliMpSegmentation::Instance()
719 ->GetMpSegmentation(detElemId,
720 AliMp::GetCathodType(cath));
311d0691 721
96079e17 722 Int_t chCath = fgkNchambers*cath + ch;
723 slat = detElemId%100;
724 Int_t nStrips=0;
725
726 // loop over strips
727 for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {
728 // get pad from electronics
729 AliMpPad pad = seg->PadByLocation(AliMpIntPair(localId,
730 ibitxy),kFALSE);
731
732 if (!pad.IsValid()) continue;
733 if(cath==0){ // Geometry info from bending plane only
734 if(ibitxy==0) {
735 xLocal1 = pad.Position().X();
736 yLocal1 = pad.Position().Y();
737 xWidth = pad.Dimensions().X();
738 yWidth = pad.Dimensions().Y();
739 }
740 xLocal2 = pad.Position().X();
741 yLocal2 = pad.Position().Y();
742 }
743
744 // Check fired pads (when available)
745 if(padFired[cath]) {
746 Int_t padX = pad.GetIndices().GetFirst();
747 Int_t padY = pad.GetIndices().GetSecond();
748 Int_t currPair = padX*maxY[cath] + padY;
749 nStrips++;
750 //printf("cath %i board = %i (%2i, %2i) -> %i\n",
751 //cath, localId, padX, padY, currPair);
752 Int_t chBin = padFired[cath]->GetXaxis()->FindBin(ch);
753 Int_t slatBin = padFired[cath]->GetYaxis()->FindBin(slat);
754 Int_t pairBin = padFired[cath]->GetZaxis()->FindBin(currPair);
755 Float_t nFired = padFired[cath]->GetBinContent(chBin, slatBin, pairBin);;
756
757 Float_t dimX = pad.Dimensions().X();
758 Float_t dimY = pad.Dimensions().Y();
759
760 Float_t stripX1 = pad.Position().X();
761 Float_t stripY1 = pad.Position().Y();
762 Float_t stripX2 = pad.Position().X();
763 Float_t stripY2 = pad.Position().Y();
764
765 transform->Local2Global(detElemId, stripX1, stripY1, 0, xg1, yg1, zg1);
766 transform->Local2Global(detElemId, stripX2, stripY2, 0, xg2, yg2, zg2);
767
768 Float_t x1Float = TMath::Min(xg1,xg2) - dimX;
769 Float_t y1Float = TMath::Min(yg1,yg2) - dimY;
770 Float_t x2Float = TMath::Max(xg1,xg2) + dimX;
771 Float_t y2Float = TMath::Max(yg1,yg2) + dimY;
772
773 Int_t x1Int = histoFiredDisplay[chCath]->GetXaxis()->FindBin(x1Float)+1;
774 Int_t y1Int = histoFiredDisplay[chCath]->GetYaxis()->FindBin(y1Float)+1;
775 Int_t x2Int = histoFiredDisplay[chCath]->GetXaxis()->FindBin(x2Float)-1;
776 Int_t y2Int = histoFiredDisplay[chCath]->GetYaxis()->FindBin(y2Float)-1;
777
778 for(Int_t binX=x1Int; binX<=x2Int; binX++){
779 for(Int_t binY=y1Int; binY<=y2Int; binY++){
780 histoFiredDisplay[chCath]->SetBinContent(binX, binY, nFired);
781 }
782 }
311d0691 783
96079e17 784 if(nFired==0.) nFired = kDummyFired;
785 histoFired[chCath][localId-1]->Fill(ibitxy, nFired);
786 }
787 } // loop on strips
788
789 if(cath==0){ // Geometry info from bending plane only
790 transform->Local2Global(detElemId, xLocal1, yLocal1, 0, xg1, yg1, zg1);
791 transform->Local2Global(detElemId, xLocal2, yLocal2, 0, xg2, yg2, zg2);
792
793 // Per board
794 x1Label = TMath::Min(xg1,xg2) - xWidth;
795 y1Label = TMath::Min(yg1,yg2) - yWidth;
796 x2Label = TMath::Max(xg1,xg2) + xWidth;
797 y2Label = TMath::Max(yg1,yg2) + yWidth;
798
799 x1 = histo[ch]->GetXaxis()->FindBin(x1Label)+1;
800 y1 = histo[ch]->GetYaxis()->FindBin(y1Label)+1;
801 x2 = histo[ch]->GetXaxis()->FindBin(x2Label)-1;
802 y2 = histo[ch]->GetYaxis()->FindBin(y2Label)-1;
803
804 sprintf(labelTxt,"%3d", localId);
805
806 // Per slat
807 line = localBoard->GetPosition().GetFirst();
808 x1LabelSlat = 140.;
809 x2LabelSlat = x1LabelSlat + 40.;
810 y1LabelSlat = -285. + ((Float_t)(line - 1)) * 68;
811 y2LabelSlat = y1LabelSlat + 34.;
812 if(localId>kNumOfBoards/2){
813 x1LabelSlat = -x2LabelSlat;
814 x2LabelSlat = x1LabelSlat + 40.;
815 }
816 sprintf(labelSlatTxt,"%2d", slat);
817 }
311d0691 818
96079e17 819 boardLabel[chCath][localId-1] = new TPaveLabel(x1Label, y1Label, x2Label, y2Label, labelTxt);
820 boardLabel[chCath][localId-1]->SetFillStyle(0);
821 boardLabel[chCath][localId-1]->SetBorderSize(0);
822
823 boardLabelSlat[chCath][localId-1] = new TPaveLabel(x1LabelSlat, y1LabelSlat, x2LabelSlat, y2LabelSlat, labelSlatTxt);
824 boardLabelSlat[chCath][localId-1]->SetFillStyle(0);
825 boardLabelSlat[chCath][localId-1]->SetBorderSize(0);
826
827 Int_t histoBin = localId;
828 efficiency = fBoardEfficiency[chCath]->GetBinContent(histoBin);
829 efficiencyError = fBoardEfficiency[chCath]->GetBinError(histoBin);
683cb6c5 830 if(efficiency==0.) efficiency = kDummyFired; // It allows to graphically distinguish
831 // efficiency = 0 from no hit on board
96079e17 832
833 histoBin = slat+1;
834 efficiencySlat = fSlatEfficiency[chCath]->GetBinContent(histoBin);
835 efficiencySlatError = fSlatEfficiency[chCath]->GetBinError(histoBin);
683cb6c5 836 if(efficiencySlat==0.) efficiencySlat = kDummyFired; // It allows to graphically distinguish
837 // efficiency = 0 from no hit on slat
96079e17 838
839 for(Int_t binX=x1; binX<=x2; binX++){
840 for(Int_t binY=y1; binY<=y2; binY++){
841 histo[chCath]->SetBinContent(binX, binY, efficiency);
842 histo[chCath]->SetBinError(binX, binY, efficiencyError);
843 histoSlat[chCath]->SetBinContent(binX, binY, efficiencySlat);
844 histoSlat[chCath]->SetBinError(binX, binY, efficiencySlatError);
845 }
846 }
311d0691 847
96079e17 848 // Check fired pads (when available)
849 if(padFired[cath]) {
850 histoFired[chCath][localId-1]->Fit("pol0","Q0R","",0., (Float_t)nStrips-1.);
851 fitFunc = histoFired[chCath][localId-1]->GetFunction("pol0");
852 Float_t chi2 = fitFunc->GetChisquare();
853 Float_t ndf = (Float_t)fitFunc->GetNDF();
854 Float_t reducedChi2 = chi2/ndf;
855 if(reducedChi2>kChi2RedMax) {
856 isStripOffInBoard[chCath][localId-1] = kTRUE;
857 //printf("Chamber = %i Cath = %i Board %i: chi2/NDF = %f\tparam = %f\n", ch, cath, localId, reducedChi2, fitFunc->GetParameter(0));
858 fFiredFitHistoList->Add(histoFired[chCath][localId-1]);
859 }
860 }
861 } // loop on cathodes
862 } // loop on chambers
863 } // loop on boards
864 } // loop on crates
865 } // loop on DDL
311d0691 866
96079e17 867 for(Int_t chCath=0; chCath<fgkNplanes; chCath++){
868 for(Int_t ib=0; ib<kNumOfBoards; ib++){
869 fBoardLabelList->Add(boardLabel[chCath][ib]);
311d0691 870 }
871 }
311d0691 872 for(Int_t chCath=0; chCath<fgkNplanes; chCath++){
96079e17 873 for(Int_t ib=0; ib<kNumOfBoards; ib++){
874 fBoardLabelList->Add(boardLabelSlat[chCath][ib]);
311d0691 875 }
876 }
96079e17 877
878 return kTRUE;
70b4a8d6 879}
880
313c3f0c 881
311d0691 882//__________________________________________________________________________
883Bool_t AliMUONTriggerEfficiencyCells::SumRunEfficiency(const AliMUONTriggerEfficiencyCells &other)
884{
885/// Sums results from different runs and gives the efficiency
886 if(!fCountHistoList || !fNoCountHistoList) {
887 AliWarning("Histograms for efficiency calculations not implemented in object");
888 return kFALSE;
889 }
890 if(!other.fCountHistoList || !other.fNoCountHistoList) {
891 AliWarning("Histograms for efficiency calculations not implemented in object passed as argument");
892 return kFALSE;
893 }
894
895 Int_t nentries = fCountHistoList->GetEntries();
896 TH1F *currNum = 0x0, *currDen = 0x0, *otherNum = 0x0, *otherDen = 0x0;
897
898 for(Int_t iEntry=0; iEntry<nentries; iEntry++){
899 currNum = (TH1F*)fCountHistoList->At(iEntry);
900 currDen = (TH1F*)fNoCountHistoList->At(iEntry);
901 otherNum = (TH1F*)other.fCountHistoList->At(iEntry);
902 otherDen = (TH1F*)other.fNoCountHistoList->At(iEntry);
903 currNum->Add(otherNum);
904 currDen->Add(otherDen);
905 }
906
907 FillHistosFromList();
96079e17 908
909 if(!fFiredStrips) {
910 AliWarning("Histograms for fired region check not implemented in object");
911 return kFALSE;
912 }
913 if(!other.fFiredStrips) {
914 AliWarning("Histograms for fired region check not implemented in object passed as argument");
915 return kFALSE;
916 }
917
918 TH3F *currFired = 0x0, *otherFired = 0x0;
919 nentries = fFiredStrips->GetEntries();
920 for(Int_t iEntry=0; iEntry<nentries; iEntry++){
921 currFired = (TH3F*)fFiredStrips->At(iEntry);
922 otherFired = (TH3F*)fFiredStrips->At(iEntry);
923 currFired->Add(otherFired);
924 }
925
311d0691 926 return kTRUE;
927}