Make the Scan method public
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerDisplay.cxx
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
16 // $Id$
17
18 // --- MUON header files ---
19 #include "AliMUONTriggerDisplay.h"
20
21 #include "AliMpDDLStore.h"
22 #include "AliMpVSegmentation.h"
23 #include "AliMpSegmentation.h"
24 #include "AliMpConstants.h"
25 #include "AliMpPad.h"
26 #include "AliMpLocalBoard.h"
27 #include "AliMpCDB.h"
28
29 // --- AliRoot header files ---
30 #include "AliLog.h"
31
32 // --- ROOT system ---
33 #include <TH1.h> 
34 #include <TH2.h>
35 #include <TGraph.h>
36
37 //-----------------------------------------------------------------------------
38 /// \class AliMUONTriggerDisplay
39 ///
40 /// MUON base class for converting histos as a function of strip/board/slat number
41 /// into display histos showing the detection element position in the 
42 /// trigger chamber.
43 ///
44 /// Input histos can be given as:
45 ///  - TH2 with x -> board # [1-234]  and   y -> strip # in board [0-15].  Option: kDisplayStrips
46 ///  - TH1 with x -> board # [1-234]                                       Option: kDisplayBoards
47 ///  - TH1 with x -> slat #  [0-17]                                        Option: kDisplaySlats
48 ///
49 /// \author D. Stocco
50
51 /// \cond CLASSIMP
52 ClassImp(AliMUONTriggerDisplay)
53 /// \endcond
54            
55 //____________________________________________________________________________ 
56 AliMUONTriggerDisplay::AliMUONTriggerDisplay() : 
57 TObject()
58 {
59   /// ctor
60 }
61
62 //__________________________________________________________________
63 AliMUONTriggerDisplay::~AliMUONTriggerDisplay()
64 {
65   /// dtor
66 }
67
68
69 //____________________________________________________________________________ 
70 TH2* AliMUONTriggerDisplay::GetEmptyDisplayHisto(TString displayHistoName, EDisplayType displayType,
71                                                  Int_t cathode, Int_t chamber,
72                                                  TString displayHistoTitle)
73 {
74   //
75   /// Return the display histogram with optimized binning
76   /// but do not fill it.
77   //
78   TH2F* displayHisto = new TH2F();
79   
80   InitOrDisplayTriggerInfo(0x0, displayHisto, displayType,
81                            cathode, chamber, displayHistoName, displayHistoTitle);
82   
83   return displayHisto;
84 }
85
86
87 //____________________________________________________________________________ 
88 TH2* AliMUONTriggerDisplay::GetBoardNumberHisto(TString displayHistoName,
89                                                 Int_t chamber,
90                                                 TString displayHistoTitle)
91 {
92   //
93   /// Return the display histogram with optimized binning
94   /// and fill it with the board number
95   //
96
97   const Int_t kNboards = AliMpConstants::NofLocalBoards();
98   TH1F* inputHisto = new TH1F("boardNumbers","Board Numbers",kNboards,0.5,(Float_t)kNboards + 0.5);
99   for(Int_t ibin=1; ibin<=kNboards; ibin++){
100     inputHisto->Fill(ibin,ibin);
101   }
102
103   TH2F* displayHisto = (TH2F*)GetEmptyDisplayHisto(displayHistoName, kDisplayBoards, 0, chamber, displayHistoTitle);
104   FillDisplayHistogram(inputHisto,displayHisto,kDisplayBoards,0,chamber,kNumbered);
105   
106   delete inputHisto;
107
108   displayHisto->SetStats(kFALSE);
109   return displayHisto;
110 }
111
112
113 //____________________________________________________________________________ 
114 TH2* AliMUONTriggerDisplay::GetDisplayHistogram(TH1* inputHisto, TString displayHistoName,
115                                                 EDisplayType displayType, Int_t cathode,
116                                                 Int_t chamber, TString displayHistoTitle,
117                                                 EDisplayOption displayOpt)
118 {
119   //
120   /// Get histogram displaying the information contained in the input histogram
121   //
122   TH2* displayHisto = GetEmptyDisplayHisto(displayHistoName, displayType,
123                                            cathode, chamber, displayHistoTitle);
124
125   FillDisplayHistogram(inputHisto, displayHisto, displayType, cathode, chamber, displayOpt);
126
127   return displayHisto;
128 }
129
130 //____________________________________________________________________________ 
131 TH2* AliMUONTriggerDisplay::GetDisplayHistogram(TGraph* inputGraph, TString displayHistoName,
132                                                 EDisplayType displayType, Int_t cathode,
133                                                 Int_t chamber, TString displayHistoTitle,
134                                                 EDisplayOption displayOpt)
135 {
136   //
137   /// Get histogram displaying the information contained in the input graph
138   //
139   TH2* displayHisto = GetEmptyDisplayHisto(displayHistoName, displayType,
140                                            cathode, chamber, displayHistoTitle);
141
142   FillDisplayHistogram(inputGraph, displayHisto, displayType, cathode, chamber, displayOpt);
143
144   return displayHisto;
145 }
146
147 //____________________________________________________________________________ 
148 Bool_t AliMUONTriggerDisplay::FillDisplayHistogram(TH1* inputHisto, TH2* displayHisto,
149                                                    EDisplayType displayType, Int_t cathode,
150                                                    Int_t chamber, EDisplayOption displayOpt)
151 {
152   //
153   /// Fill a previously initialized display histogram 
154   /// with the information contained in inputHisto.
155   /// To get initialized display, please use GetEmptyDisplayHisto method
156   //
157   return InitOrDisplayTriggerInfo(inputHisto, displayHisto, displayType,
158                                   cathode, chamber, "", "",displayOpt);
159 }
160
161 //____________________________________________________________________________ 
162 Bool_t AliMUONTriggerDisplay::FillDisplayHistogram(TGraph* inputGraph, TH2* displayHisto,
163                                                    EDisplayType displayType, Int_t cathode,
164                                                    Int_t chamber, EDisplayOption displayOpt)
165 {
166   //
167   /// Fill a previously initialized display histogram 
168   /// with the information contained in inputGraph.
169   /// To get initialized display, please use GetEmptyDisplayHisto method
170   //
171   return InitOrDisplayTriggerInfo(inputGraph, displayHisto, displayType,
172                                   cathode, chamber, "", "",displayOpt);
173 }
174
175 //____________________________________________________________________________ 
176 Bool_t AliMUONTriggerDisplay::InitOrDisplayTriggerInfo(TObject* inputObject, TH2* displayHisto,
177                                                        EDisplayType displayType,
178                                                        Int_t cathode, Int_t chamber,
179                                                        TString displayHistoName, TString displayHistoTitle,
180                                                        EDisplayOption displayOpt)
181 {
182   //
183   /// Initialize trigger information display histograms using mapping
184   /// Trigger information is displayed in a user-friendly way:
185   /// from local board and strip numbers to their position on chambers.
186   //
187
188   // Load mapping
189   if ( ! AliMpSegmentation::Instance(kFALSE) ) {
190     /// Load mapping
191     if ( ! AliMpCDB::LoadDDLStore() ) {
192       AliError("Could not access mapping from OCDB !");
193       AliError("Histograms are not initialized !");
194       return kFALSE;
195     }
196   }
197
198   Int_t iCh = (chamber > AliMpConstants::NofTrackingChambers()) ? chamber - 11 : chamber;
199   Int_t iCath = cathode;
200
201   TArrayD xAxisStrip;
202   TArrayD yAxisStrip;
203   TArrayD xAxisBoard;
204   TArrayD yAxisBoard;
205
206   Float_t yOffsetLine, xOffsetLine = 0.;
207
208   const Float_t kResetValue=1234567.;
209
210   if(!inputObject){
211     xAxisBoard.Set(55);
212     xAxisBoard.Reset(kResetValue);
213     yAxisBoard.Set(50);
214     yAxisBoard.Reset(kResetValue);
215
216     xAxisStrip.Set(420);
217     xAxisStrip.Reset(kResetValue);
218     yAxisStrip.Set(710);
219     yAxisStrip.Reset(kResetValue);
220   }
221   else if(!displayHisto){
222       AliWarning("Display histogram not initialized. Please initialize it first!");
223       return kFALSE;
224   }
225   else {
226     TH1* inputHisto = dynamic_cast<TH1*>(inputObject);    
227     if ( inputHisto ) {
228       if ( inputHisto->GetEntries() == 0 ) {
229         return kTRUE;
230       }
231     }
232     else {
233       TGraph* inputGraph = dynamic_cast<TGraph*>(inputObject);
234       if ( inputGraph ) {
235         if ( inputGraph->GetN() == 0 ){
236           return kTRUE;
237         }
238       }  
239       else {
240         AliWarning("The object should inherit from TH1 or TGraph!");
241         return kFALSE;
242       }
243     }
244   }
245
246   Float_t xWidth, yWidth, yWidthSlat=0., xWidthCol=0.;
247   Float_t x1,x2,y1,y2;
248   Float_t x1b=0., x2b=0., y1b=0., y2b=0.;
249   Float_t xcPad, ycPad;
250   Int_t line=0, slat;
251   Float_t sign = 1.;
252
253   const Float_t kShiftB = 0.5;
254   const Float_t kShiftS = 0.1;
255
256   const Float_t kShiftX = (iCath==0) ? kShiftB : kShiftS;
257   const Float_t kShiftY = (iCath==0) ? kShiftS : kShiftB;
258   const Float_t kShiftEl = (displayType==kDisplaySlats) ? 0.01 : kShiftB;
259
260   Int_t iChamber = iCh + AliMpConstants::NofTrackingChambers();
261   for(Int_t iLoc = 0; iLoc < AliMpConstants::NofLocalBoards(); iLoc++) {  
262     Int_t iBoard = iLoc+1;
263     Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromLocalBoard(iBoard, iChamber);
264
265     if (!detElemId) continue;
266
267     AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(iBoard, kFALSE);
268
269     // skip copy cards
270     if( !localBoard->IsNotified()) 
271       continue;
272
273     // get segmentation
274     const AliMpVSegmentation* seg[2] = {
275       AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(0)),
276       AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(1))};
277
278     if(iLoc==0){
279       AliMpPad pad1 = seg[1]->PadByLocation(iBoard,0,kFALSE);
280       yWidthSlat = pad1.GetDimensionY();
281       AliMpPad pad0 = seg[0]->PadByLocation(iBoard,0,kFALSE);
282       xOffsetLine = TMath::Abs(pad0.GetPositionX()) + pad0.GetDimensionX();
283       xWidthCol = 2.* pad0.GetDimensionX();
284     }
285
286     // Get ideal global position of DetElemId center
287     slat = detElemId%100;
288     line = (4 + slat)%18;
289     sign = 1.;
290     if(line>8) {
291       line = 17 - line;
292       sign = -1.;
293     }
294     yOffsetLine = (Float_t)(line - 4) * 2. * yWidthSlat;
295           
296     Int_t nLocations = 1;
297
298     for(Int_t cath=0; cath<AliMpConstants::NofCathodes(); cath++){
299       // Loop on cathodes: 
300       // necessary because strip info is read for each cathode
301       // board info is read only from cathode 0
302
303       // loop over strips
304       for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {
305         // get pad from electronics
306
307         Int_t offset = 0;
308         if (cath && localBoard->GetSwitch(AliMpLocalBoard::kZeroAllYLSB)) offset = -8;
309
310         AliMpPad pad = seg[cath]->PadByLocation(iBoard,ibitxy+offset,kFALSE);
311
312         if (!pad.IsValid()) continue;
313         
314   // For non-bending plane fill only the first board covered by the strip
315   // i.e. avoide filling many times the same information
316   if ( cath == 1 && pad.GetLocalBoardId(0) != iBoard ) continue;
317
318         xWidth = pad.GetDimensionX();
319         yWidth = pad.GetDimensionY();
320         xcPad = sign * (pad.GetPositionX() + xOffsetLine);
321         if(line==4) xcPad += 0.75 * sign * xWidthCol;
322         ycPad = pad.GetPositionY() + yOffsetLine;
323         nLocations = pad.GetNofLocations();
324         Int_t iStrip = pad.GetLocalBoardChannel(0);
325
326         if(cath==iCath){
327           x1 = xcPad - xWidth + kShiftX;
328           y1 = ycPad - yWidth + kShiftY;
329           x2 = xcPad + xWidth - kShiftX;
330           y2 = ycPad + yWidth - kShiftY;
331
332           if(!inputObject){
333             AddSortedPoint(x1, xAxisStrip, kResetValue);
334             AddSortedPoint(x2, xAxisStrip, kResetValue);
335
336             AddSortedPoint(y1, yAxisStrip, kResetValue);
337             AddSortedPoint(y2, yAxisStrip, kResetValue);
338           }
339           else if(displayType==kDisplayStrips) 
340             FillBins(inputObject, displayHisto, iBoard, iStrip, x1, x2, y1, y2, kShiftX, kShiftY, displayOpt);
341         }
342
343         if(cath==0){
344           if(iStrip==0) {
345             x1b = xcPad - xWidth + kShiftEl;
346             y1b = ycPad - yWidth + kShiftEl;
347           }
348           x2b = xcPad + xWidth - kShiftEl;
349           y2b = ycPad + yWidth - kShiftEl;
350         }
351
352       } // loop on strips
353
354       // if iCath==0 strip info and board info are both filled -> break!
355       // if iCath==1 board info is filled at cath==0. Strip info to be filled at cath==1
356       if(iCath==0) break;
357     } // loop on cathodes
358
359     if(!inputObject){
360       // Per board
361       AddSortedPoint(x1b, xAxisBoard, kResetValue);
362       AddSortedPoint(x2b, xAxisBoard, kResetValue);
363
364       AddSortedPoint(y1b, yAxisBoard, kResetValue);
365       AddSortedPoint(y2b, yAxisBoard, kResetValue);
366     }
367     else if(displayType==kDisplayBoards) 
368       FillBins(inputObject, displayHisto, iBoard, -nLocations, x1b, x2b, y1b, y2b, kShiftEl, kShiftEl, displayOpt);
369     else if(displayType==kDisplaySlats) 
370       FillBins(inputObject, displayHisto, slat, -1, x1b, x2b, y1b, y2b, kShiftEl, kShiftEl, displayOpt);
371   } // loop on local boards
372
373   if ( inputObject ) return kTRUE;
374
375   displayHisto->Reset();
376
377   // Book histos
378   const Float_t kMinDiff = 0.1;
379
380   TArrayD* currArray[4] = {&xAxisStrip, &yAxisStrip, 
381                            &xAxisBoard, &yAxisBoard};
382   for(Int_t iaxis=0; iaxis<4; iaxis++){
383     Int_t ipoint=0;
384     while(TMath::Abs((*currArray[iaxis])[ipoint]-kResetValue)>kMinDiff) { 
385       ipoint++;
386     }
387     if(ipoint>currArray[iaxis]->GetSize()-2) 
388       AliWarning(Form("Array size (%i) lower than the number of points!", currArray[iaxis]->GetSize()));
389     currArray[iaxis]->Set(ipoint);
390   }
391
392   switch(displayType){
393   case kDisplayStrips:
394     displayHisto->SetBins(xAxisStrip.GetSize()-1, xAxisStrip.GetArray(),
395                           yAxisStrip.GetSize()-1, yAxisStrip.GetArray());
396     break;
397   case kDisplayBoards:
398   case kDisplaySlats:
399     displayHisto->SetBins(xAxisBoard.GetSize()-1, xAxisBoard.GetArray(),
400                           yAxisBoard.GetSize()-1, yAxisBoard.GetArray());
401     break;
402   }
403
404   displayHisto->SetName(displayHistoName.Data());
405   displayHisto->SetTitle(displayHistoTitle.Data());
406   displayHisto->SetXTitle("X (cm)");
407   displayHisto->SetYTitle("Y (cm)");
408   //displayHisto->SetStats(kFALSE);
409
410   return kTRUE;
411 }
412
413
414 //____________________________________________________________________________ 
415 Bool_t AliMUONTriggerDisplay::AddSortedPoint(Float_t currVal, TArrayD& position, const Float_t kResetValue)
416 {
417   //
418   /// Add sorted point in array according to an increasing order.
419   /// Used to build display histograms axis.
420   //
421   Int_t nEntries = position.GetSize()-1;
422   Float_t tmp1, tmp2;
423   const Float_t kMinDiff = 0.1;
424   for(Int_t i=0; i<nEntries; i++){
425     if(TMath::Abs(position[i]-currVal)<kMinDiff) return kFALSE;
426     if(TMath::Abs(position[i]-kResetValue)<kMinDiff) {
427       position[i] = currVal;
428       return kTRUE;
429     }
430     if(currVal>position[i]) continue;
431     tmp1 = position[i];
432     position[i] = currVal;
433     for(Int_t j=i+1; j<nEntries; j++){
434       tmp2 = position[j];
435       position[j] = tmp1;
436       tmp1 = tmp2;
437       if(tmp1==kResetValue) break;
438     }
439     return kTRUE;
440   }
441   return kFALSE;
442 }
443
444
445 //____________________________________________________________________________ 
446 void AliMUONTriggerDisplay::FillBins(TObject* inputObject, TH2* displayHisto,
447                                      Int_t iElement1, Int_t iElement2,
448                                      Float_t x1, Float_t x2, Float_t y1, Float_t y2,
449                                      const Float_t kShiftX, const Float_t kShiftY,
450                                      EDisplayOption displayOpt)
451 {
452   //
453   /// Given the bin in inputHisto, search the corresponding bins
454   /// in display histo and fill it.
455   //
456   Int_t binY=0;
457   Float_t binContent=0;
458   TH1* inputHisto = dynamic_cast<TH1*>(inputObject);
459   if ( inputHisto ) {
460     Int_t binX = inputHisto->GetXaxis()->FindBin(iElement1);
461     if ( inputObject->IsA()->InheritsFrom("TH2") ) {
462       binY = inputHisto->GetYaxis()->FindBin(iElement2);
463       binContent = inputHisto->GetBinContent(binX, binY);
464     }
465     else binContent = inputHisto->GetBinContent(binX);
466   }
467   else {
468     TGraph* inputGraph = dynamic_cast<TGraph*>(inputObject);
469     if ( inputGraph ) {
470       Double_t xpt, ypt;
471       for ( Int_t ipt=0; ipt<inputGraph->GetN(); ipt++){
472         inputGraph->GetPoint(ipt, xpt, ypt);
473         if ( TMath::Abs(xpt - iElement1) < 0.1 ) {
474           binContent = ypt;
475           break;
476         }
477       }
478     }
479     else return;
480   }  
481
482   if(binContent==0) {
483     if(displayOpt==kShowZeroes) binContent = 1e-5;
484     else return;
485   }
486
487   Int_t binX1 = displayHisto->GetXaxis()->FindBin(x1 + 0.01*kShiftX);
488   Int_t binX2 = displayHisto->GetXaxis()->FindBin(x2 - 0.01*kShiftX);
489   Int_t binY1 = displayHisto->GetYaxis()->FindBin(y1 + 0.01*kShiftY);
490   Int_t binY2 = displayHisto->GetYaxis()->FindBin(y2 - 0.01*kShiftY);
491
492   if(displayOpt==kNumbered) {
493     Int_t meanBin = (binX1+binX2)/2;
494     binX1 = meanBin;
495     binX2 = meanBin;
496     
497     meanBin = (binY1+binY2)/2;
498     binY1 = meanBin;
499     binY2 = meanBin;
500   }
501
502   Float_t elementArea = 1.;
503   if(displayOpt == kNormalizeToArea) {
504     elementArea = (x2 - x1 + 2*kShiftX) * 
505       (y2 - y1 + 2*kShiftY); // In InitOrDisplayTriggerInfo: 
506                              // x2 = x_c + xHalfWidth - kShiftX
507                              // x1 = x_c - xHalfWidth + kShiftX
508                              // so x2 - x1 + 2*kShiftX returns the element width.
509           
510           // If iElement2 is less than 0, then its meaning is the 
511           // number of boards covered by one strip
512           // the area has therefore to be multiplied accordingly
513           // This fixes the problem when filling the trigger rate per boards in non-bending plane
514           // which is overestimated since the segmentation is always given by the bending-plane
515           if ( iElement2 < 0 ) elementArea *= -(Double_t)iElement2;
516
517   }
518
519   for(Int_t ibinx=binX1; ibinx<=binX2; ibinx++){
520     for(Int_t ibiny=binY1; ibiny<=binY2; ibiny++){
521       displayHisto->SetBinContent(ibinx,ibiny,binContent/elementArea);
522     }
523   }
524 }
525