Fixes to AliFMDDisplay and AliFMDPattern for use in DQM environment.
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 11 Jul 2009 16:50:40 +0000 (16:50 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 11 Jul 2009 16:50:40 +0000 (16:50 +0000)
Similar fixes for AliFMDInput.
Introduce ReadFromFile methods in AliFMDCalib{Pedestal,Gain}.
Allow setting AliFMDCalib{Pedestal,Gain} in AliFMDParameters.
Added DQM scripts to SVN for storage

15 files changed:
FMD/AliFMDCalibGain.cxx
FMD/AliFMDCalibGain.h
FMD/AliFMDCalibPedestal.cxx
FMD/AliFMDCalibPedestal.h
FMD/AliFMDDisplay.cxx
FMD/AliFMDDisplay.h
FMD/AliFMDInput.cxx
FMD/AliFMDInput.h
FMD/AliFMDParameters.h
FMD/AliFMDPattern.cxx
FMD/AliFMDPattern.h
FMD/scripts/dqm/PatternCalib.C [new file with mode: 0644]
FMD/scripts/dqm/PatternRaw.C [new file with mode: 0644]
FMD/scripts/dqm/SpectraRaw.C [new file with mode: 0644]
FMD/scripts/dqm/fmd_online.C [new file with mode: 0644]

index aee7030..509c2f6 100644 (file)
 // Gnus
 //
 #include "AliFMDCalibGain.h"   // ALIFMDCALIBGAIN_H
+#include <iostream>
+#include <TString.h>
+#include <AliLog.h>
+
 //____________________________________________________________________
 ClassImp(AliFMDCalibGain)
 #if 0
@@ -82,6 +86,47 @@ AliFMDCalibGain::Value(UShort_t det, Char_t ring, UShort_t sec,
 }
 
 //____________________________________________________________________
+Bool_t
+AliFMDCalibGain::ReadFromFile(std::istream& in)
+{
+  //Get header (how long is it ?)
+  TString header;
+  header.ReadLine(in);
+  header.ToLower();
+  if(!header.Contains("gains")) {
+    AliError("File does not contain gains!");
+    return kFALSE;;
+  }
+
+  // Read column headers
+  header.ReadLine(in);
+  
+  int lineno  = 2;
+  // Read until EOF 
+  while(in.peek()!=EOF) {
+    if(in.bad()) { 
+      AliError(Form("Bad read at line %d of input", lineno));
+      break;
+    }
+    UShort_t det, sec, strip;
+    Char_t ring;
+    
+    Float_t gain,error,  chi2ndf;
+    Char_t c[6];
+    
+    in >> det      >> c[0] 
+       >> ring     >> c[1]
+       >> sec      >> c[2]
+       >> strip    >> c[3]
+       >> gain     >> c[4]
+       >> error    >> c[5]
+       >> chi2ndf;
+    lineno++;
+    Set(det,ring,sec,strip,gain);
+  }
+  return kTRUE;
+}
+//____________________________________________________________________
 //
 // EOF
 //
index fb8209d..7dffcde 100644 (file)
@@ -17,6 +17,8 @@
 #ifndef ALIFMDFLOATMAP_H
 # include <AliFMDFloatMap.h>
 #endif
+#include <iosfwd>
+
 //____________________________________________________________________
 /** @brief Gain value and width for each strip in the FMD 
     @ingroup FMD_base
@@ -51,6 +53,13 @@ public:
       @param str  Strip
       @return Gain for strip */
   Float_t Value(UShort_t det, Char_t ring, UShort_t sec, UShort_t str);
+
+  /**
+     Read information from file and set values
+     @param inFile inputFile
+   */
+  Bool_t ReadFromFile(std::istream & inFile);
+
   /** @return threshold */
   Float_t Threshold() const { return fThreshold; }
   const AliFMDFloatMap& Values() const { return fValue; }
index cefeca5..222aef8 100644 (file)
 // Need to make algorithm that makes this data
 //
 #include "AliFMDCalibPedestal.h"       // ALIFMDCALIBPEDESTAL_H
+#include <iostream>
+#include <TString.h>
+#include <AliLog.h>
+
 //____________________________________________________________________
 ClassImp(AliFMDCalibPedestal)
 #if 0
@@ -93,6 +97,49 @@ AliFMDCalibPedestal::Width(UShort_t det, Char_t ring, UShort_t sec,
 }
 
 //____________________________________________________________________
+Bool_t
+AliFMDCalibPedestal::ReadFromFile(std::istream& in)
+{
+  // Get header (how long is it ?)
+  TString header;
+  header.ReadLine(in);
+  header.ToLower();
+  if(!header.Contains("pedestals")) {
+    AliError("File does not contain pedestals!");
+    return kFALSE;
+  }
+    
+  // Read columns line
+  int lineno = 2;
+  header.ReadLine(in);
+    
+  // Loop until EOF
+  while(in.peek()!=EOF) {
+    if(in.bad()) { 
+      AliError(Form("Bad read at line %d in input", lineno));
+      break;
+    }
+    UShort_t det, sec, strip;
+    Char_t ring;
+    Float_t ped, noise, mu, sigma, chi2ndf;
+    Char_t c[8];
+         
+    in >> det      >> c[0] 
+       >> ring     >> c[1]
+       >> sec      >> c[2]
+       >> strip    >> c[3]
+       >> ped      >> c[4]
+       >> noise    >> c[5]
+       >> mu       >> c[6]
+       >> sigma    >> c[7]
+       >> chi2ndf;
+    lineno++;
+      
+    Set(det,ring,sec,strip,ped,noise);
+  }
+  return kTRUE;
+}
+//____________________________________________________________________
 //
 // EOF
 //
index afb69f0..f6161b6 100644 (file)
@@ -21,6 +21,8 @@
 #ifndef ALIFMDFLOATMAP_H
 # include <AliFMDFloatMap.h>
 #endif
+#include <iosfwd>
+
 //____________________________________________________________________
 /** @brief Pedestal value and width for each strip in the FMD 
     @ingroup FMD_base
@@ -62,6 +64,13 @@ public:
       @param str  Strip
       @return Pedestal width for strip */  
   Float_t Width(UShort_t det, Char_t ring, UShort_t sec, UShort_t str);
+
+  /**
+     Read information from file and set values
+     @param inFile inputFile
+   */
+  Bool_t ReadFromFile(std::istream & inFile);
+
 private:
   AliFMDFloatMap fValue; /** Pedestal */
   AliFMDFloatMap fWidth; /** Pedestal width */
index 3832b9e..4aa9173 100644 (file)
@@ -175,6 +175,7 @@ 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;
@@ -194,7 +195,8 @@ 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()");
@@ -384,6 +386,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;
@@ -558,10 +561,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;
@@ -577,9 +581,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()-fFactor->GetMaximum())));
+  AliInfo(Form("Noise factor is now %4.1f", 10 * fFactor->GetMinimum()));
   Redisplay();
 }
 
@@ -676,7 +678,11 @@ AliFMDDisplay::InsideCut(Float_t val, const Float_t& 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(1, ("Value %f is outside cut %f - %f (range %f - %f)", 
+                   val, min+r*l, min+r*h, min, max));
+    return kFALSE;
+  }
   return kTRUE;
 }
 
@@ -716,21 +722,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     =  ((fFMDReader && fFMDReader->IsZeroSuppressed(det-1)
-                             ? 0 : (ped * (fFactor->GetMaximum()
-                                           -fFactor->GetMinimum())))
-                            + pedW * 10 * fFactor->GetMinimum());
-  if (threshold > fgkAdcRange.fHigh) threshold = fgkAdcRange.fHigh;
+  Double_t threshold     =  GetADCThreshold(det, ring, sec, str);
   Float_t  counts        =  digit->Counts();
-  if (fFMDReader && fFMDReader->IsZeroSuppressed(det-1) && counts > 0)
-    counts += fFMDReader->NoiseFactor(det-1) * pedW;
+  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)));
@@ -787,6 +785,50 @@ 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());
+  
+
+  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 
@@ -830,6 +872,25 @@ AliFMDDisplay::ProcessESD(UShort_t det, Char_t rng, UShort_t sec, UShort_t str,
   return kTRUE;
 }
 
+Double_t
+AliFMDDisplay::GetADCThreshold(UShort_t d, Char_t r, 
+                              UShort_t s, UShort_t t) const
+{
+  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
index a39a3d6..b8bd0e7 100644 (file)
@@ -102,6 +102,10 @@ public:
       @param digit Raw digit.
       @return @c false on error  */
   virtual Bool_t ProcessRawDigit(AliFMDDigit* digit);
+  /** Visualize a raw digit
+      @param digit Raw digit.
+      @return @c false on error  */
+  virtual Bool_t ProcessRawCalibDigit(AliFMDDigit* digit);
   /** Visualize a reconstructed point.
       @param recpoint Reconstructed point
       @return @c false on error  */
@@ -190,6 +194,8 @@ protected:
   virtual void AtEnd();
   virtual Bool_t InsideCut(Float_t v, const Float_t& min, 
                         const Float_t& max) const;
+  virtual Double_t GetADCThreshold(UShort_t d, Char_t r, 
+                                  UShort_t s, UShort_t t) const;
   
   static AliFMDDisplay* fgInstance; // Static instance 
   Bool_t                fWait;      // Wait until user presses `Continue'
index a805682..dcbcd48 100644 (file)
@@ -161,7 +161,8 @@ Int_t
 AliFMDInput::NEvents() const 
 {
   // Get number of events
-  if (TESTBIT(fTreeMask, kRaw)) return fReader->GetNumberOfEvents();
+  if (TESTBIT(fTreeMask, kRaw) || 
+      TESTBIT(fTreeMask, kRawCalib)) return fReader->GetNumberOfEvents();
   if (fChainE) return fChainE->GetEntriesFast();
   if (fTreeE) return fTreeE->GetEntries();
   return -1;
@@ -187,6 +188,7 @@ AliFMDInput::Init()
        "\tRecPoints:     %d\n"
        "\tESD:           %d\n"
        "\tRaw:           %d\n"
+       "\tRawCalib:      %d\n"
        "\tGeometry:      %d\n"
        "\tTracks:        %d\n"
        "\tTracksRefs:    %d",
@@ -199,6 +201,7 @@ AliFMDInput::Init()
        TESTBIT(fTreeMask, kRecPoints),
        TESTBIT(fTreeMask, kESD),
        TESTBIT(fTreeMask, kRaw),
+       TESTBIT(fTreeMask, kRawCalib),
        TESTBIT(fTreeMask, kGeometry),
        TESTBIT(fTreeMask, kTracks),
        TESTBIT(fTreeMask, kTrackRefs));
@@ -267,7 +270,8 @@ AliFMDInput::Init()
     
   }
     
-  if (TESTBIT(fTreeMask, kRaw)) {
+  if (TESTBIT(fTreeMask, kRaw) || 
+      TESTBIT(fTreeMask, kRawCalib)) {
     AliInfo("Getting FMD raw data digits");
     fArrayA = new TClonesArray("AliFMDDigit");
 #if 0
@@ -436,8 +440,9 @@ AliFMDInput::Begin(Int_t event)
   }
 
   // Possibly load FMD Digit information 
-  if (TESTBIT(fTreeMask, kRaw)) {
+  if (TESTBIT(fTreeMask, kRaw) || TESTBIT(fTreeMask, kRawCalib)) {
     // AliInfo("Getting FMD raw data digits");
+    std::cout << "Waiting for event ..." << std::endl;
     if (!fReader->NextEvent()) return kFALSE;
     // AliFMDRawReader r(fReader, 0);
     fArrayA->Clear();
@@ -473,6 +478,8 @@ AliFMDInput::Event()
     if (!ProcessDigits()) return kFALSE;
   if (TESTBIT(fTreeMask, kRaw)) 
     if (!ProcessRawDigits()) return kFALSE;
+  if (TESTBIT(fTreeMask, kRawCalib)) 
+    if (!ProcessRawCalibDigits()) return kFALSE;
   if (TESTBIT(fTreeMask, kRecPoints)) 
     if (!ProcessRecPoints()) return kFALSE;
   if (TESTBIT(fTreeMask, kESD))
@@ -687,6 +694,29 @@ AliFMDInput::ProcessRawDigits()
 
 //____________________________________________________________________
 Bool_t 
+AliFMDInput::ProcessRawCalibDigits()
+{
+  // Read the digit tree, and pass each digit to the member function
+  // ProcessDigit.
+  if (!fArrayA) {
+    AliError("No raw digit array defined");
+    return kFALSE;
+  }
+
+  Int_t nDigit = fArrayA->GetEntries();
+  if (nDigit <= 0) return kTRUE;
+  for (Int_t j = 0; j < nDigit; j++) {
+    AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayA->At(j));
+    if (!digit) continue;
+    if (AliLog::GetDebugLevel("FMD","") >= 40 && j < 30) 
+      digit->Print();
+    if (!ProcessRawCalibDigit(digit)) return kFALSE;
+  }    
+  return kTRUE;
+}
+
+//____________________________________________________________________
+Bool_t 
 AliFMDInput::ProcessRecPoints()
 {
   // Read the reconstrcted points tree, and pass each reconstruction
index 9fbe3dc..2a99a14 100644 (file)
@@ -115,7 +115,8 @@ public:
     kRaw,             // Read raw data 
     kGeometry,        // Not really a tree 
     kTracks,         // Hits and tracs - for BG study  
-    kTrackRefs        // Track references - also for BG study
+    kTrackRefs,       // Track references - also for BG study
+    kRawCalib         // Read raws and calibrate them
   };
   /** CTOR  */
   AliFMDInput();
@@ -182,6 +183,10 @@ public:
       ProcessRawDigit for each digit. 
       @return @c false on error  */
   virtual Bool_t ProcessRawDigits();
+  /** Loop over all digits read from raw data files, and call
+      ProcessRawDigit for each digit. 
+      @return @c false on error  */
+  virtual Bool_t ProcessRawCalibDigits();
   /** Loop over all reconstructed points, and call ProcessRecPoint for
       each reconstructed point. 
       @return @c false on error  */
@@ -224,6 +229,11 @@ public:
       @param digit Raw digit
       @return  @c false on error   */
   virtual Bool_t ProcessRawDigit(AliFMDDigit* digit);
+  /** Process one digit from raw data files.  Users should over this
+      to process each raw digit.  
+      @param digit Raw digit
+      @return  @c false on error   */
+  virtual Bool_t ProcessRawCalibDigit(AliFMDDigit* digit);
   /** Process one reconstructed point.  Users should over this to
       process each reconstructed point.  
       @param point Reconstructed point 
@@ -334,6 +344,7 @@ inline Bool_t AliFMDInput::ProcessTrack(Int_t,TParticle*,
 inline Bool_t AliFMDInput::ProcessDigit(AliFMDDigit*) { return kTRUE; }
 inline Bool_t AliFMDInput::ProcessSDigit(AliFMDSDigit*) { return kTRUE; }
 inline Bool_t AliFMDInput::ProcessRawDigit(AliFMDDigit*) { return kTRUE; }
+inline Bool_t AliFMDInput::ProcessRawCalibDigit(AliFMDDigit*) { return kTRUE; }
 inline Bool_t AliFMDInput::ProcessRecPoint(AliFMDRecPoint*) { return kTRUE; }
 inline Bool_t AliFMDInput::ProcessESD(UShort_t,Char_t,UShort_t,UShort_t,
                                      Float_t,Float_t) { return kTRUE; }
index 0a48809..0718ee3 100644 (file)
@@ -166,6 +166,8 @@ public:
   void SetSampleRate(AliFMDCalibSampleRate* r) { fSampleRate = r; }
   /** @param p Pedestal value in ADC counts */
   void SetPedestal(Float_t p=10)              { fFixedPedestal = p; }
+  /** @param p Pedestal map */
+  void SetPedestal(AliFMDCalibPedestal* p) { fPedestal = p; }
   /** @param w Pedestal width in ADC counts */
   void SetPedestalWidth(Float_t w=1)          { fFixedPedestalWidth = w; }
   /** @param t Threshold used for 1 MIP acceptance. */
@@ -179,6 +181,8 @@ public:
       the older invalid format (7 32bit words with bogus entries)
       @param yes if true the raw data has complete data header */ 
   void UseCompleteHeader(Bool_t yes=kTRUE) { fHasCompleteHeader = yes; } 
+  /** @param g Gain map */
+  void SetGain(AliFMDCalibGain* g) { fPulseGain = g; }
   /** @} */
 
   /** @{ */
index a359e64..ab4569f 100644 (file)
@@ -29,7 +29,7 @@
 // Latest changes by Christian Holm Christensen
 //
 
-// #include <iostream>
+#include <iostream>
 
 // #include <TApplication.h>
 // #include <TButton.h>
@@ -252,6 +252,12 @@ AliFMDPattern::AliFMDPatternDetector::AddMarker(Double_t x,
       this a usage of the TMath namespace declaration! Idiot */
   Int_t i = TMath::Min(Int_t(fCounts.fN * s / max),  
                       Int_t(fGraphs.GetEntries()-1));
+  if (i < 0 || i >= fCounts.fN) { 
+    std::cerr << "Graph index " << i << " out of bounds [0," 
+             << fCounts.fN << ") - " 
+             << fCounts.fN << " * " << s << " / " << max << std::endl;
+    return;
+  }
   TGraph* g = static_cast<TGraph*>(fGraphs.At(i));
   if (!g) return;
   g->SetPoint(fCounts[i]++, x, y);
@@ -277,7 +283,10 @@ AliFMDPattern::AliFMDPattern(const char* gAliceFile)
     fFMD2Sum(.2, .6, "# in FMD2: "),
     fFMD3Sum(.2, .5, "# in FMD3: "),
     fLine(.15, .47, .85, .47),
-    fTotal(.2, .35, "Total:   ")
+    fTotal(.2, .35, "Total:   "), 
+    fFMD1Area(0),
+    fFMD2Area(0),
+    fFMD3Area(0)
 {
   // Constructor. 
   // 
@@ -321,11 +330,26 @@ AliFMDPattern::Init()
   geom->Init();
   geom->InitTransformations();
   
+  fFMD1Area = 0;
+  fFMD2Area = 0;
+  fFMD3Area = 0;
+
+  Double_t innerArea = 0;
+  Double_t outerArea = 0;
+
   Char_t rs[] = { 'I' , 'O', '\0' };
   Char_t *r   = rs;
   do {
     AliFMDRing* ring = geom->GetRing(*r);
     if (!ring) continue;
+
+    Double_t rl   = ring->GetMinR();
+    Double_t rh   = ring->GetMaxR();
+    Double_t area = rh * rh * TMath::Pi() - rl * rl * TMath::Pi();
+    if (*r == 'I') innerArea = area;
+    else           outerArea = area;
+      
+
     const TObjArray& vs = ring->GetVerticies();
     TObjArray&       gs = (*r == 'I' ? fInners   : fOuters);
     Float_t&         mr = (*r == 'I' ? fInnerMax : fOuterMax);
@@ -363,7 +387,11 @@ AliFMDPattern::Init()
       g->SetLineStyle(2);
     }
   } while (*(++r));
-    
+
+  fFMD1Area = innerArea;
+  fFMD2Area = innerArea + outerArea;
+  fFMD3Area = innerArea + outerArea;
+  
   return kTRUE;
 }
 
@@ -449,17 +477,20 @@ AliFMDPattern::AtEnd()
   
   fFMD1.End();
   fFMD1Pad->Modified();
-  fFMD1Sum.SetTitle(Form("# hits in FMD1: %5d", fFMD1.Total()));
+  fFMD1Sum.SetTitle(Form("# hits in FMD1: %5d (%7.5f /cm^{2})", 
+                        fFMD1.Total(), fFMD1.Total()/fFMD1Area));
   total += fFMD1.Total();
 
   fFMD2.End();
   fFMD2Pad->Modified();
-  fFMD2Sum.SetTitle(Form("# hits in FMD2: %5d", fFMD2.Total()));
+  fFMD2Sum.SetTitle(Form("# hits in FMD2: %5d (%7.5f /cm^{2})", 
+                        fFMD2.Total(), fFMD2.Total()/fFMD2Area));
   total += fFMD2.Total();
 
   fFMD3.End();
   fFMD3Pad->Modified();
-  fFMD3Sum.SetTitle(Form("# hits in FMD3: %5d", fFMD3.Total()));
+  fFMD3Sum.SetTitle(Form("# hits in FMD3: %5d (%7.5f /cm^{2})", 
+                        fFMD3.Total(), fFMD3.Total()/fFMD3Area));
   total += fFMD3.Total();
 
   fTotal.SetTitle(Form("Total:    %5d/51200 (%3d%%)", 
index d66e214..1cb7c95 100644 (file)
@@ -164,6 +164,10 @@ public:
   TLine  fLine;                // Just a line 
   TLatex fTotal;       // Total in FMD
 
+  Double_t fFMD1Area;   // 
+  Double_t fFMD2Area;   // 
+  Double_t fFMD3Area;   // 
+
   ClassDef(AliFMDPattern,0) // Display FMD data as hit-patterns. 
 };
 
diff --git a/FMD/scripts/dqm/PatternCalib.C b/FMD/scripts/dqm/PatternCalib.C
new file mode 100644 (file)
index 0000000..7840a9c
--- /dev/null
@@ -0,0 +1,91 @@
+//____________________________________________________________________
+//
+// $Id: PatternDigits.C 28055 2008-08-18 00:33:20Z cholm $
+//
+// Draw hits in the specialised FMD event display 
+//
+/** Display hits 
+    @ingroup FMD_script
+ */
+Bool_t
+CheckFile(const char* prefix, int number, TString& f)
+{
+  f = (Form("%s%d.csv", prefix, number));
+  std::cout << "Checking if " << f << " exists ... " << std::flush;
+  f = gSystem->Which("$(HOME)/calib/", f.Data());
+  std::cout << '"' << f << '"' << std::endl;
+  return !f.IsNull();
+}
+void
+PatternCalib(const char* file="raw.root", Int_t runno=0)
+{
+  // AliLog::SetModuleDebugLevel("FMD", 1);
+  gSystem->Load("libFMDutil.so");
+
+  AliCDBManager* cdb = AliCDBManager::Instance();
+  const char* cdbUri = gSystem->Getenv("AMORE_CDB_URI");
+  cdb->SetDefaultStorage(cdbUri);
+  cdb->SetRun(runno);
+
+  AliFMDCalibStripRange* range = new AliFMDCalibStripRange;
+  AliFMDCalibSampleRate* rate  = new AliFMDCalibSampleRate;
+  AliFMDCalibPedestal*   peds  = new AliFMDCalibPedestal;
+  AliFMDCalibGain*       gains = new AliFMDCalibGain;
+  Bool_t gotConds = kFALSE;
+  Bool_t gotPeds  = kFALSE;
+  Bool_t gotGains = kFALSE;
+  for (Int_t i = 1; i <= 3; i++) { 
+    TString f;
+    if (CheckFile("conditions", i, f)) {
+      gotConds = kTRUE;
+      std::cout << "Reading conditions for FMD" <<i<< " from " <<f<< std::endl;
+      std::ifstream in(f.Data());
+      range->ReadFromFile(in);
+      rate->ReadFromFile(in);
+    }
+    if (CheckFile("peds", i, f)) {
+      gotPeds = kTRUE;
+      std::cout << "Reading pedestals for FMD" <<i<< " from " <<f<< std::endl;
+      std::ifstream in(f.Data());
+      peds->ReadFromFile(in);
+    }
+    if (CheckFile("gains", i, f)) {
+      gotGains = kTRUE;
+      std::cout << "Reading gains for FMD" <<i<< " from " <<f<< std::endl;
+      std::ifstream in(f.Data());
+      gains->ReadFromFile(in);
+    }
+  }
+
+  Int_t mask = (AliFMDParameters::kDeadMap|
+               AliFMDParameters::kZeroSuppression|
+               AliFMDParameters::kAltroMap);
+
+
+  if (!gotConds) mask |= AliFMDParameters::kStripRange;
+  if (!gotConds) mask |= AliFMDParameters::kSampleRate;
+  if (!gotPeds)  mask |= AliFMDParameters::kPedestal;
+  if (!gotGains) mask |= AliFMDParameters::kPulseGain;
+
+  AliFMDParameters* pars = AliFMDParameters::Instance();
+  pars->Init(kFALSE, mask);
+
+  if (gotConds) pars->SetStripRange(range);
+  if (gotConds) pars->SetSampleRate(rate);
+  if (gotPeds)  pars->SetPedestal(peds);
+  if (gotGains) pars->SetGain(gains);
+  
+  // pars->Print("pedestal");
+
+  AliFMDPattern* d = new AliFMDPattern;
+  d->AddLoad(AliFMDInput::kRawCalib);
+  d->SetRawFile(file);
+  d->SetName("rawCalib");
+  d->SetTitle("Calibrated Raw");
+  d->Run();
+}
+
+//____________________________________________________________________
+//
+// EOF
+//
diff --git a/FMD/scripts/dqm/PatternRaw.C b/FMD/scripts/dqm/PatternRaw.C
new file mode 100644 (file)
index 0000000..7d9c719
--- /dev/null
@@ -0,0 +1,88 @@
+//____________________________________________________________________
+//
+// $Id: PatternDigits.C 28055 2008-08-18 00:33:20Z cholm $
+//
+// Draw hits in the specialised FMD event display 
+//
+/** Display hits 
+    @ingroup FMD_script
+ */
+Bool_t
+CheckFile(const char* prefix, int number, TString& f)
+{
+  f = (Form("%s%d.csv", prefix, number));
+  std::cout << "Checking if " << f << " exists ... " << std::flush;
+  f = gSystem->Which("$(HOME)/calib/", f.Data());
+  std::cout << '"' << f << '"' << std::endl;
+  return !f.IsNull();
+}
+void
+PatternRaw(const char* file="raw.root", Int_t runno=0)
+{
+  gSystem->Load("libFMDutil.so");
+
+  AliCDBManager* cdb = AliCDBManager::Instance();
+  const char* cdbUri = gSystem->Getenv("AMORE_CDB_URI");
+  cdb->SetDefaultStorage(cdbUri);
+  cdb->SetRun(runno);
+
+  AliFMDCalibStripRange* range = new AliFMDCalibStripRange;
+  AliFMDCalibSampleRate* rate  = new AliFMDCalibSampleRate;
+  AliFMDCalibPedestal*   peds  = new AliFMDCalibPedestal;
+  AliFMDCalibGain*       gains = new AliFMDCalibGain;
+  Bool_t gotConds = kFALSE;
+  Bool_t gotPeds  = kFALSE;
+  Bool_t gotGains = kFALSE;
+  for (Int_t i = 1; i <= 3; i++) { 
+    TString f;
+    if (CheckFile("conditions", i, f)) {
+      gotConds = kTRUE;
+      std::cout << "Reading conditions for FMD" <<i<< " from " <<f<< std::endl;
+      std::ifstream in(f.Data());
+      range->ReadFromFile(in);
+      rate->ReadFromFile(in);
+    }
+    if (CheckFile("peds", i, f)) {
+      gotPeds = kTRUE;
+      std::cout << "Reading pedestals for FMD" <<i<< " from " <<f<< std::endl;
+      std::ifstream in(f.Data());
+      peds->ReadFromFile(in);
+    }
+    if (CheckFile("gains", i, f)) {
+      gotGains = kTRUE;
+      std::cout << "Reading gains for FMD" <<i<< " from " <<f<< std::endl;
+      std::ifstream in(f.Data());
+      gains->ReadFromFile(in);
+    }
+  }
+
+  Int_t mask = (AliFMDParameters::kDeadMap|
+               AliFMDParameters::kZeroSuppression|
+               AliFMDParameters::kAltroMap);
+
+
+  if (!gotConds) mask |= AliFMDParameters::kStripRange;
+  if (!gotConds) mask |= AliFMDParameters::kSampleRate;
+  if (!gotPeds)  mask |= AliFMDParameters::kPedestal;
+  if (!gotGains) mask |= AliFMDParameters::kPulseGain;
+
+  AliFMDParameters* pars = AliFMDParameters::Instance();
+  pars->Init(kFALSE, mask);
+
+  if (gotConds) pars->SetStripRange(range);
+  if (gotConds) pars->SetSampleRate(rate);
+  if (gotPeds)  pars->SetPedestal(peds);
+  if (gotGains) pars->SetGain(gains);
+  
+  AliFMDPattern* d = new AliFMDPattern;
+  d->AddLoad(AliFMDInput::kRaw);
+  d->SetRawFile(file);
+  d->SetName("raw");
+  d->SetTitle("Raw");
+  d->Run();
+}
+
+//____________________________________________________________________
+//
+// EOF
+//
diff --git a/FMD/scripts/dqm/SpectraRaw.C b/FMD/scripts/dqm/SpectraRaw.C
new file mode 100644 (file)
index 0000000..bce7376
--- /dev/null
@@ -0,0 +1,44 @@
+//____________________________________________________________________
+//
+// $Id: PatternDigits.C 28055 2008-08-18 00:33:20Z cholm $
+//
+// Draw hits in the specialised FMD event display 
+//
+/** Display hits 
+    @ingroup FMD_script
+ */
+void
+SpectraRaw(const char* file="raw.root", Int_t runno=0)
+{
+  gSystem->Load("libANALYSIS.so");
+  gSystem->Load("libANALYSISalice.so");
+  // gSystem->Load("libFMDanalysis.so");
+  gSystem->Load("$(HOME)/scripts/foo.so");
+  gSystem->Load("libFMDutil.so");
+
+  AliCDBManager* cdb = AliCDBManager::Instance();
+  const char* cdbUri = gSystem->Getenv("AMORE_CDB_URI");
+  cdb->SetDefaultStorage(cdbUri);
+  cdb->SetRun(runno);
+
+  AliFMDParameters::Instance()->Init(kFALSE,
+                                    AliFMDParameters::kPulseGain|
+                                    AliFMDParameters::kPedestal|
+                                    AliFMDParameters::kDeadMap|
+                                    AliFMDParameters::kZeroSuppression|
+                                    AliFMDParameters::kAltroMap|
+                                    AliFMDParameters::kStripRange);
+  AliFMDParameters::Instance()->SetSampleRate(2);
+  
+  AliFMDSpectraDisplay* d = new AliFMDSpectraDisplay;
+  d->AddLoad(AliFMDInput::kRaw);
+  d->SetRawFile(file);
+  d->SetName("raw");
+  d->SetTitle("Raw");
+  d->Run();
+}
+
+//____________________________________________________________________
+//
+// EOF
+//
diff --git a/FMD/scripts/dqm/fmd_online.C b/FMD/scripts/dqm/fmd_online.C
new file mode 100644 (file)
index 0000000..a72ff80
--- /dev/null
@@ -0,0 +1,18 @@
+void fmd_online(const char *input = "^FMD")
+{
+  gROOT->LoadMacro("alieve_init.C");
+  gROOT->LoadMacro("fmd_raw.C");
+  //          path, event, esdFile, aodFile, rawFile, cdbUri,  
+  alieve_init("",   0,     0,       0,       input,   0, 
+             //rl,   esd,    aod,    raw
+             kFALSE, kFALSE, kFALSE, kTRUE);
+
+  gAliEveEvent->SetAutoLoad(kTRUE);
+  // gAliEveEvent->SetAutoLoad(kFALSE);
+  gAliEveEvent->AddNewEventCommand("fmd_raw()");
+
+  //  while(true) 
+  //gSystem->Sleep(100);
+
+
+}