Compatibility with the trunk of ROOT
[u/mrichter/AliRoot.git] / FMD / AliFMDDisplay.cxx
index 52ec6ce..572a381 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 /* $Id$ */
-/** @file    AliFMDDisplay.cxx
-    @author  Christian Holm Christensen <cholm@nbi.dk>
-    @date    Mon Mar 27 12:39:09 2006
-    @brief   FMD Event display 
-*/
+/** 
+ * @file    AliFMDDisplay.cxx
+ * @author  Christian Holm Christensen <cholm@nbi.dk>
+ * @date    Mon Mar 27 12:39:09 2006
+ * @brief   FMD Event display 
+ */
 //___________________________________________________________________
 //
 // The classes defined here, are utility classes for reading in data
@@ -54,6 +55,7 @@
 #include "AliFMDRecPoint.h"     // ALIFMDRECPOINT_H
 #include "AliFMDGeometry.h"    // ALIFMDGEOMETRY_H
 #include "AliFMDParameters.h"  // ALIFMDPARAMETERS_H
+#include "AliFMDRawReader.h"    // ALIFMDRAWREADER_H
 #include <AliESDFMD.h>          // ALIESDFMD_H
 // #include <AliLog.h>
 #include "AliFMDDebug.h" // Better debug macros
@@ -128,7 +130,12 @@ AliFMDDisplay::AliFMDDisplay(Bool_t onlyFMD, const char* gAliceFile)
     fSpec(0), 
     fSpecCut(0),
     fAux(0), 
-    fReturn(kFALSE)
+    fReturn(kFALSE), 
+    fContinous(kFALSE),
+    fTimeout("gApplication->StopIdleing()", 10), 
+    fInitialMin(0), 
+    fInitialMax(1), 
+    fInitialFactor(3/10.)
 {
   // Constructor of an FMD display object. 
   // Must be called 
@@ -172,13 +179,15 @@ AliFMDDisplay::MakeCanvas(const char** which)
   Double_t xb = 1;
   fCanvas->cd();
   if (TESTBIT(fTreeMask, kDigits) || 
+      TESTBIT(fTreeMask, kRawCalib) || 
       TESTBIT(fTreeMask, kRaw)) { 
     yb = .05;
     xb = .66;
     fFactor = new TSlider("pedFactor", "Pedestal Factor", xb+.01, 0, 1, yb);
     fFactor->SetMethod("AliFMDDisplay::Instance()->ChangeFactor()");
-    fFactor->SetRange(3./10, 1);
+    fFactor->SetRange(fInitialFactor, 1);
     fFactor->Draw();
+    fFactor->SetMinimum(fInitialFactor);
     TSliderBox *sbox = 
       static_cast<TSliderBox*>(fFactor->GetListOfPrimitives()->
                               FindObject("TSliderBox"));
@@ -191,11 +200,12 @@ AliFMDDisplay::MakeCanvas(const char** which)
       TESTBIT(fTreeMask, kESD)     || 
       TESTBIT(fTreeMask, kDigits)  || 
       TESTBIT(fTreeMask, kSDigits) || 
-      TESTBIT(fTreeMask, kRaw)) {
+      TESTBIT(fTreeMask, kRaw)     ||
+      TESTBIT(fTreeMask, kRawCalib)) {
     yb = .05;
     fSlider = new TSlider("genCut", "Multiplicity cut", 0, 0, xb, yb);
     fSlider->SetMethod("AliFMDDisplay::Instance()->ChangeCut()");
-    fSlider->SetRange(0,1);
+    fSlider->SetRange(fInitialMin,fInitialMax);
     fSlider->Draw();
     TSliderBox *sbox = 
       static_cast<TSliderBox*>(fSlider->GetListOfPrimitives()->
@@ -204,6 +214,9 @@ AliFMDDisplay::MakeCanvas(const char** which)
       sbox->SetToolTipText("Adjust lower and upper limit on data signal");
     }
   }
+  // fCanvas->Modified();
+  // fCanvas->Update();
+  // fCanvas->cd();
   Float_t      x0 = 0;
   Float_t      dx = 1. / n;
   p               = which;
@@ -236,9 +249,9 @@ AliFMDDisplay::ShowOnlyFMD()
   TGeoIterator next(top);
   TGeoNode* node;
   TGeoVolume* v = 0;
-  Bool_t hasFMD1 = kFALSE;
-  Bool_t hasFMD2 = kFALSE;
-  Bool_t hasFMD3 = kFALSE;
+  // Bool_t hasFMD1 = kFALSE;
+  // Bool_t hasFMD2 = kFALSE;
+  // Bool_t hasFMD3 = kFALSE;
   AliFMDDebug(1, ("Getting material FMD_Si$"));
   TGeoMaterial* si   = gGeoManager->GetMaterial("FMD_Si$");      // kRed 
   AliFMDDebug(1, ("Getting material FMD_Carbon$"));
@@ -272,13 +285,13 @@ AliFMDDisplay::ShowOnlyFMD()
       }
       if (name[2] == 'M' && (name[3] == 'T' || name[3] == 'B')) {
        // Virtual Master half-ring volume - top-level
-       Int_t det = node->GetNumber();
-       switch (det) {
-       case 1: hasFMD1 = true; break;
-       case 2: hasFMD2 = true; break;
-       case 3: hasFMD3 = true; break;
-       default: continue;
-       }
+       // Int_t det = node->GetNumber();
+       /* switch (det) {
+          case 1: hasFMD1 = true; break;
+          case 2: hasFMD2 = true; break;
+          case 3: hasFMD3 = true; break;
+          default: continue;
+          } */
        toshow.Add(v);
       }
       else if (name[3] == 'V' && (name[2] == 'T' || name[2] == 'B')) 
@@ -352,21 +365,6 @@ AliFMDDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 }
 
 //____________________________________________________________________
-Int_t          
-AliFMDDisplay::DistancetoPrimitive(Int_t px, Int_t) 
-{
-  // Calculate the distance from point to 
-  // something in the canvas. 
-  // Depends on the zoom mode. 
-  fPad->SetCursor(kCross);
-  Float_t xmin = fPad->GetX1();
-  Float_t xmax = fPad->GetX2();
-  Float_t dx   = .02 * (xmax - xmin);
-  Float_t x    = fPad->AbsPixeltoX(px);
-  if (x < xmin + dx || x > xmax - dx) return 9999;
-  return (fZoomMode ? 0 : 7);
-}
-//____________________________________________________________________
 Bool_t 
 AliFMDDisplay::Init()
 {
@@ -396,6 +394,7 @@ AliFMDDisplay::MakeAux()
   // etc, 
   const Range_t* range = 0;
   if      (TESTBIT(fTreeMask, kESD))      range = &fgkMultRange;
+  else if (TESTBIT(fTreeMask, kRawCalib)) range = &fgkMultRange;
   else if (TESTBIT(fTreeMask, kDigits))   range = &fgkAdcRange;
   else if (TESTBIT(fTreeMask, kSDigits))  range = &fgkAdcRange;
   else if (TESTBIT(fTreeMask, kRaw))      range = &fgkAdcRange;
@@ -403,14 +402,28 @@ AliFMDDisplay::MakeAux()
   if (!range) return;
   
   if (!fAux) {
-    fAux = new TCanvas("aux", "Aux");
+    fAux = new TCanvas(Form("aux_%s", GetName()), 
+                      Form("Aux - %s", GetTitle()));
     fAux->SetLogy();
+    fAux->SetFillColor(kWhite);
+    fAux->SetBorderMode(0);
+    fAux->SetBorderSize(0);
     Float_t dBin = (range->fHigh - range->fLow) / range->fNbins;
     fSpec = new TH1D("spec", "Spectra", range->fNbins, 
-                    range->fLow-dBin/2, range->fHigh-dBin/2);
+                    range->fLow-dBin/2, range->fHigh+dBin/2);
     fSpecCut = static_cast<TH1*>(fSpec->Clone("specCut"));
+    TString xTitle((TESTBIT(fTreeMask, kRawCalib) || 
+                   TESTBIT(fTreeMask, kESD)) ? "#Delta E/#Delta E_{mip}" :
+                  (TESTBIT(fTreeMask, kDigits) ||
+                   TESTBIT(fTreeMask, kSDigits) || 
+                   TESTBIT(fTreeMask, kRaw)) ? "ADC [counts]" :
+                  TESTBIT(fTreeMask, kHits) ? "Hits" : "signal");
+    fSpec->SetXTitle(xTitle.Data());
+    fSpec->SetYTitle("events");
     fSpec->SetFillColor(2);
     fSpec->SetFillStyle(3001);
+    fSpecCut->SetXTitle(xTitle.Data());
+    fSpecCut->SetYTitle("events");
     fSpecCut->SetFillColor(4);
     fSpecCut->SetFillStyle(3001);
   }
@@ -430,6 +443,7 @@ AliFMDDisplay::DrawAux()
   if (!fAux) return;
   fAux->cd();
   fAux->Clear();
+  fAux->SetLogy(fSpec->GetMaximum() > 10);
   fSpec->Draw();
   fSpecCut->Draw("same");
   fAux->Modified();
@@ -501,15 +515,17 @@ AliFMDDisplay::Idle()
   // Sends the ROOT loop into the idle loop,
   // so that we can go on. 
   fWait = kTRUE;
+  if (fContinous) fTimeout.Start(10, kTRUE);
   while (fWait) {
     gApplication->StartIdleing();
     gSystem->InnerLoop();
     gApplication->StopIdleing();
+    if (fContinous) break;
   }
-  AliFMDDebug(1, ("After idle loop"));
+  AliFMDDebug(3, ("After idle loop"));
   if (fMarkers) fMarkers->Delete();
   if (fHits)    fHits->Clear();
-  AliFMDDebug(1, ("After clearing caches"));
+  AliFMDDebug(3, ("After clearing caches"));
 }
 
 //____________________________________________________________________
@@ -546,13 +562,27 @@ void
 AliFMDDisplay::SetCut(Float_t l, Float_t h) 
 {
   // Change the cut on the slider. 
-  fSlider->SetMinimum(l);
-  fSlider->SetMaximum(h);
+  fInitialMin = l;
+  fInitialMax = h;
+  if (!fSlider) return;
+  fSlider->SetMinimum(fInitialMin);
+  fSlider->SetMaximum(fInitialMax);
   ChangeCut();
 }
 
 //____________________________________________________________________
 void
+AliFMDDisplay::SetFactor(Float_t f) 
+{
+  // Change the cut on the slider. 
+  fInitialFactor = f / 10;
+  if (!fFactor) return;
+  fFactor->SetMinimum(fInitialFactor);
+  ChangeFactor();
+}
+
+//____________________________________________________________________
+void
 AliFMDDisplay::ChangeCut() 
 {
   // Change the cut on the slider. 
@@ -560,10 +590,11 @@ AliFMDDisplay::ChangeCut()
   // drawn in the AUX canvas
   AliInfo(Form("Range is now %7.5f - %7.5f", fSlider->GetMinimum(), 
               fSlider->GetMaximum()));
-  if ((TESTBIT(fTreeMask, kESD) || 
-       TESTBIT(fTreeMask, kDigits) || 
+  if ((TESTBIT(fTreeMask, kESD)     || 
+       TESTBIT(fTreeMask, kDigits)  || 
        TESTBIT(fTreeMask, kSDigits) || 
-       TESTBIT(fTreeMask, kRaw))) {
+       TESTBIT(fTreeMask, kRaw)     ||
+       TESTBIT(fTreeMask, kRawCalib))) {
     Float_t l = fSlider->GetMinimum();
     Float_t h = fSlider->GetMaximum();
     l         = 1024 * l + 0;
@@ -579,8 +610,7 @@ AliFMDDisplay::ChangeFactor()
   // Change the cut on the slider. 
   // The factor depends on what is 
   // drawn in the AUX canvas
-  AliInfo(Form("Noise factor is now %4.1f, pedestal factor %3.1f", 
-              10*fFactor->GetMinimum(),fFactor->GetMaximum()));
+  AliInfo(Form("Noise factor is now %4.1f", 10 * fFactor->GetMinimum()));
   Redisplay();
 }
 
@@ -673,11 +703,26 @@ Bool_t
 AliFMDDisplay::InsideCut(Float_t val, const Float_t& min, 
                         const Float_t& max) const
 {
+  // 
+  // Whether a point is inside 
+  // 
+  // Parameters:
+  //    v   Point
+  //    min Minimum
+  //    max Maximum
+  // 
+  // Return:
+  //    true if @a v is inside cut 
+  //
   Float_t r = max - min;
   Float_t l = fSlider->GetMinimum();
   Float_t h = fSlider->GetMaximum();
   if (l == h) { l = 0; h = 1; }
-  if (val < r * l + min || val > r * h + min) return kFALSE;
+  if (val < r * l + min || val > r * h + min) { 
+    AliFMDDebug(2, ("Value %f is outside cut %f - %f (range %f - %f)", 
+                   val, min+r*l, min+r*h, min, max));
+    return kFALSE;
+  }
   return kTRUE;
 }
 
@@ -717,17 +762,13 @@ AliFMDDisplay::ProcessDigit(AliFMDDigit* digit)
 
   if (!digit) { AliError("No digit");   return kFALSE; }
 
-  AliFMDParameters* parm = AliFMDParameters::Instance();
   UShort_t det           =  digit->Detector();
   Char_t   ring          =  digit->Ring();
   UShort_t sec           =  digit->Sector();
   UShort_t str           =  digit->Strip();
-  Double_t ped           =  parm->GetPedestal(det,ring, sec, str);
-  Double_t pedW          =  parm->GetPedestalWidth(det,ring, sec, str);
-  Double_t threshold     =  (ped * fFactor->GetMaximum()
-                            + pedW * fFactor->GetMinimum());
-  if (threshold > fgkAdcRange.fHigh) threshold = fgkAdcRange.fHigh;
+  Double_t threshold     =  GetADCThreshold(det, ring, sec, str);
   Float_t  counts        =  digit->Counts();
+  if (threshold < 0) { counts += -threshold; threshold = 0; }
 
   AliFMDDebug(10, ("FMD%d%c[%02d,%03d] counts %4d threshold %4d", 
                   det, ring, sec, str, Int_t(counts), Int_t(threshold)));
@@ -776,7 +817,7 @@ AliFMDDisplay::ProcessRawDigit(AliFMDDigit* digit)
   // Parameters: 
   //   digit Digit information 
   AliFMDDebug(50, ("Forwarding call of ProcessRaw to ProcessDigit "
-                 "for FMD%d&c[%02d,%03d] %d", 
+                 "for FMD%d%c[%02d,%03d] %d", 
                  digit->Detector(), digit->Ring(), digit->Sector(), 
                  digit->Strip(), digit->Counts()));
   return ProcessDigit(digit);
@@ -784,6 +825,51 @@ AliFMDDisplay::ProcessRawDigit(AliFMDDigit* digit)
 
 //____________________________________________________________________
 Bool_t 
+AliFMDDisplay::ProcessRawCalibDigit(AliFMDDigit* digit)
+{
+  // Process a digit 
+  // Parameters: 
+  //   digit Digit information 
+  static const Float_t rMin  = fgkMultRange.fLow;
+  static const Float_t rMax  = fgkMultRange.fHigh;
+  static const Float_t aMin  = fgkAdcRange.fLow;
+  static const Float_t aMax  = fgkAdcRange.fHigh;
+
+  if (!digit) { AliError("No digit");   return kFALSE; }
+
+  AliFMDParameters* parm = AliFMDParameters::Instance();
+  UShort_t det           =  digit->Detector();
+  Char_t   ring          =  digit->Ring();
+  UShort_t sec           =  digit->Sector();
+  UShort_t str           =  digit->Strip();
+  Double_t gain          =  parm->GetPulseGain(det, ring, sec, str);
+  Double_t ped           =  parm->GetPedestal(det, ring, sec, str);
+  Double_t threshold     =  GetADCThreshold(det, ring, sec, str);
+  Float_t  counts        =  digit->Counts();
+  if (threshold < 0) { counts += -threshold; threshold = 0; ped = 0; }
+
+  //   Double_t edep = ((counts * parm->GetEdepMip() / 
+  //               (gain * parm->GetDACPerMIP()));
+  Double_t mult = (counts-ped) / (gain * parm->GetDACPerMIP());
+  if (gain < 0.1 || gain > 10) mult = 0;
+  
+
+  AliFMDDebug(10, ("FMD%d%c[%02d,%03d] adc %4d "
+                  "(threshold %4d, gain %6.3f) -> mult %7.4f", 
+                  det, ring, sec, str, int(counts), int(threshold), 
+                  gain, mult));
+  if (fHits)                                    fHits->Add(digit);
+  if (fSpec)                                    fSpec->Fill(mult);
+  if (!InsideCut(counts-threshold, aMin, aMax)) return kTRUE;
+  if (fSpecCut)                                 fSpecCut->Fill(mult);
+  
+  if (mult >= 0) 
+    AddMarker(det, ring, sec, str, digit, mult, rMin, rMax);
+  return kTRUE;
+}
+
+//____________________________________________________________________
+Bool_t 
 AliFMDDisplay::ProcessRecPoint(AliFMDRecPoint* recpoint)
 {
   // Process reconstructed point 
@@ -828,6 +914,39 @@ AliFMDDisplay::ProcessESD(UShort_t det, Char_t rng, UShort_t sec, UShort_t str,
 }
 
 //____________________________________________________________________
+Double_t
+AliFMDDisplay::GetADCThreshold(UShort_t d, Char_t r, 
+                              UShort_t s, UShort_t t) const
+{
+  // 
+  // Get the ADC threshold
+  // 
+  // Parameters:
+  //    d Detector
+  //    r Ring 
+  //    s Sector 
+  //    t Strip 
+  // 
+  // Return:
+  //    The threshold 
+  //
+  AliFMDParameters* parm = AliFMDParameters::Instance();
+  Double_t ped           =  parm->GetPedestal(d,r, s, t);
+  Double_t pedW          =  parm->GetPedestalWidth(d,r, s, t);
+  Double_t threshold     = 0;
+  if (fFMDReader && fFMDReader->IsZeroSuppressed(d-1))
+    threshold = - fFMDReader->NoiseFactor(d-1) * pedW;
+  else 
+    threshold = ped + pedW * 10 * fFactor->GetMinimum();
+  AliFMDDebug(10, ("FMD%d%c[%2d,%3d] ped: %f +/- %f [factor: %f-%f]", 
+                  d, r, s, t, ped, pedW, 
+                  fFactor->GetMinimum(), fFactor->GetMaximum()));
+  if (threshold > fgkAdcRange.fHigh) threshold = fgkAdcRange.fHigh;
+  return threshold;
+}
+
+//____________________________________________________________________
 //
 // EOF
 //
+