Allow reading of calibration data from comma separarated value files.
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Aug 2009 10:18:54 +0000 (10:18 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Aug 2009 10:18:54 +0000 (10:18 +0000)
This is useful in an online environment and for testing purposes.

FMD/AliFMDCalibGain.cxx
FMD/AliFMDCalibGain.h
FMD/AliFMDCalibPedestal.cxx
FMD/AliFMDCalibPedestal.h
FMD/AliFMDParameters.cxx
FMD/AliFMDParameters.h

index 509c2f6..064e9a8 100644 (file)
 #include <iostream>
 #include <TString.h>
 #include <AliLog.h>
+#include "AliFMDDebug.h"
+
+#include "AliFMDBoolMap.h"
+
 
 //____________________________________________________________________
 ClassImp(AliFMDCalibGain)
@@ -86,6 +90,65 @@ AliFMDCalibGain::Value(UShort_t det, Char_t ring, UShort_t sec,
 }
 
 //____________________________________________________________________
+namespace {
+  struct MakeDead : public AliFMDMap::ForOne
+  {
+    MakeDead(AliFMDBoolMap* dead, Float_t min, Float_t max) 
+      : fDead(dead), fMin(min), fMax(max), fCount(0)
+    {}
+    MakeDead(const MakeDead& other) 
+      : fDead(other.fDead), fMin(other.fMin), fMax(other.fMax), 
+       fCount(other.fCount)
+    {}
+    MakeDead& operator=(const MakeDead& other) 
+    { 
+      fDead   = other.fDead;
+      fMin    = other.fMin;
+      fMax    = other.fMax;
+      fCount  = other.fCount;
+      return *this;
+    }
+    Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, Float_t v)
+    {
+      AliDebugGeneral("AliFMDCalibGain::MakeDeadMap", 100, 
+                     Form("Checking if gain of FMD%d%c[%2d,%3d]=%f "
+                          "is out of range [%f,%f]", 
+                          d, r, s, t, v, fMin, fMax));
+      if (v > fMax || v < fMin) {
+       fDead->operator()(d,r,s,t) = kTRUE;
+       fCount++;
+      }
+      return kTRUE;
+    }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Int_t) 
+    { return kFALSE; }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, UShort_t) 
+    { return kFALSE; }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Bool_t)
+    { return kFALSE; }
+    AliFMDBoolMap* fDead;
+    Float_t        fMin;
+    Float_t        fMax;
+    Int_t          fCount;
+  };
+}
+
+//____________________________________________________________________
+AliFMDBoolMap*
+AliFMDCalibGain::MakeDeadMap(Float_t min, Float_t max, 
+                            AliFMDBoolMap* dead) const
+{
+  if (!dead) { 
+    dead = new AliFMDBoolMap(0,0,0,0);
+    dead->Reset(kFALSE);
+  }
+  MakeDead dm(dead, min, max);
+  fValue.ForEach(dm);
+  AliFMDDebug(1, ("Found a total of %d dead channels", dm.fCount));
+  return dead;
+}
+
+//____________________________________________________________________
 Bool_t
 AliFMDCalibGain::ReadFromFile(std::istream& in)
 {
index 7dffcde..7cd7cf9 100644 (file)
@@ -18,6 +18,7 @@
 # include <AliFMDFloatMap.h>
 #endif
 #include <iosfwd>
+class AliFMDBoolMap;
 
 //____________________________________________________________________
 /** @brief Gain value and width for each strip in the FMD 
@@ -63,6 +64,28 @@ public:
   /** @return threshold */
   Float_t Threshold() const { return fThreshold; }
   const AliFMDFloatMap& Values() const { return fValue; }
+  /** 
+   * Make a dead map based on the gain of the channels.  If the gain 
+   * of a paraticular channel falls outside the range specified by @a
+   * min and @a max, then the channel is marked as dead. 
+   *
+   * If the argument @a dead is non-null, then the map passed is
+   * modified.  That is, channels marked as dead in the map will
+   * remain marked.   Channels that meat the criterion (gain outside
+   * the specified range) will in addition be marked as dead. 
+   *
+   * If the argument @a dead is null, then a new map is created and a
+   * pointer to this will be returned. 
+   * 
+   * @param min Minimum value of gain for a channel before it is
+   * @param max Maximum value of gain for a channel before it is
+   * marked as dead. 
+   * @param dead If non-null, then modify this map. 
+   * 
+   * @return A pointer to possibly newly allocated dead map. 
+   */
+  AliFMDBoolMap* MakeDeadMap(Float_t min, Float_t max, 
+                            AliFMDBoolMap* dead=0) const;
 private:
   AliFMDFloatMap fValue;       // Map
   Float_t        fThreshold;   // Global threshold
index 222aef8..8bcdccc 100644 (file)
@@ -31,6 +31,8 @@
 #include <iostream>
 #include <TString.h>
 #include <AliLog.h>
+#include "AliFMDDebug.h"
+#include "AliFMDBoolMap.h"
 
 //____________________________________________________________________
 ClassImp(AliFMDCalibPedestal)
@@ -97,6 +99,60 @@ AliFMDCalibPedestal::Width(UShort_t det, Char_t ring, UShort_t sec,
 }
 
 //____________________________________________________________________
+namespace {
+  struct MakeDead : public AliFMDMap::ForOne
+  {
+    MakeDead(AliFMDBoolMap* dead, Float_t max) 
+      : fDead(dead), fMax(max), fCount(0)
+    {}
+    MakeDead(const MakeDead& other) 
+      : fDead(other.fDead), fMax(other.fMax), fCount(other.fCount)
+    {}
+    MakeDead& operator=(const MakeDead& other) 
+    { 
+      fDead   = other.fDead;
+      fMax    = other.fMax;
+      fCount  = other.fCount;
+      return *this;
+    }
+    Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, Float_t v)
+    {
+      AliDebugGeneral("AliFMDCalibPedestal::MakeDeadMap", 100, 
+                     Form("Checking if noise of FMD%d%c[%2d,%3d]=%f "
+                             "is larger than %f", d, r, s, t, v, fMax));
+      if (v > fMax) {
+       fDead->operator()(d,r,s,t) = kTRUE;
+       fCount++;
+      }
+      return kTRUE;
+    }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Int_t) 
+    { return kFALSE; }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, UShort_t)
+    { return kFALSE; }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Bool_t)
+    { return kFALSE; }
+    AliFMDBoolMap* fDead;
+    Float_t        fMax;
+    Int_t          fCount;
+  };
+}
+
+//____________________________________________________________________
+AliFMDBoolMap*
+AliFMDCalibPedestal::MakeDeadMap(Float_t maxW, AliFMDBoolMap* dead) const
+{
+  if (!dead) { 
+    dead = new AliFMDBoolMap(0,0,0,0);
+    dead->Reset(kFALSE);
+  }
+  MakeDead dm(dead, maxW);
+  fWidth.ForEach(dm);
+  AliFMDDebug(1, ("Found a total of %d dead channels", dm.fCount));
+  return dead;
+}
+
+//____________________________________________________________________
 Bool_t
 AliFMDCalibPedestal::ReadFromFile(std::istream& in)
 {
index f6161b6..7014ce1 100644 (file)
@@ -22,6 +22,7 @@
 # include <AliFMDFloatMap.h>
 #endif
 #include <iosfwd>
+class AliFMDBoolMap;
 
 //____________________________________________________________________
 /** @brief Pedestal value and width for each strip in the FMD 
@@ -70,7 +71,26 @@ public:
      @param inFile inputFile
    */
   Bool_t ReadFromFile(std::istream & inFile);
-
+  /** 
+   * Make a dead map based on the noise of the channels.  If the noise
+   * of a paraticular channel is larger than @a maxW, then the channel
+   * is marked as dead. 
+   *
+   * If the argument @a dead is non-null, then the map passed is
+   * modified.  That is, channels marked as dead in the map will
+   * remain marked.   Channels that meat the criterion (noise larger
+   * than @a maxW) will in addition be marked as dead. 
+   *
+   * If the argument @a dead is null, then a new map is created and a
+   * pointer to this will be returned. 
+   * 
+   * @param maxW Maximum value of noise for a channel before it is
+   * marked as dead. 
+   * @param dead If non-null, then modify this map. 
+   * 
+   * @return A pointer to possibly newly allocated dead map. 
+   */
+  AliFMDBoolMap* MakeDeadMap(Float_t maxW, AliFMDBoolMap* dead=0) const;
 private:
   AliFMDFloatMap fValue; /** Pedestal */
   AliFMDFloatMap fWidth; /** Pedestal width */
index 6911a62..86a87d2 100644 (file)
@@ -157,6 +157,87 @@ AliFMDParameters::Init(AliFMDPreprocessor* pp, Bool_t forceReInit, UInt_t what)
 }
 
 //__________________________________________________________________
+Bool_t
+AliFMDParameters::CheckFile(const char* prefix, 
+                           const char* path, 
+                           int         number, 
+                           TString&    f) const
+{
+  f = (Form("%s%d.csv", prefix, number));
+  AliFMDDebug(5, ("Checking if %s exists in %s ...", f.Data(), path));
+  f = gSystem->Which(path, f.Data());
+  AliFMDDebug(5, ("Got back '%s'", f.Data()));
+  return !f.IsNull();
+}
+
+//__________________________________________________________________
+void
+AliFMDParameters::Init(const char* path, Bool_t forceReInit, UInt_t what)
+{
+  // Initialize the parameters manager.  Pedestals, gains, strip
+  // range, and sample rate is read from local comma separated value
+  // files if available.  Otherwise, the calibrations are obtained
+  // from OCDB.
+  if (forceReInit) fIsInit = kFALSE;
+  if (fIsInit) return;
+
+  AliFMDCalibStripRange*  range = 0;
+  AliFMDCalibSampleRate*  rate  = 0;
+  AliFMDCalibPedestal*    peds  = 0;
+  AliFMDCalibGain*        gains = 0;
+
+  for (Int_t i = 1; i <= 3; i++) { 
+    TString f;
+    if (((what & kSampleRate) || (what & kStripRange)) && 
+       CheckFile("conditions", path, i, f)) {
+      if (!rate  && (what & kSampleRate)) rate  = new AliFMDCalibSampleRate;
+      if (!range && (what & kStripRange)) range = new AliFMDCalibStripRange;
+      std::ifstream in(f.Data());
+      if (range) range->ReadFromFile(in);
+      if (rate)  rate->ReadFromFile(in);
+      in.close();
+    }
+    if ((what & kPedestal) && CheckFile("peds", path, i, f)) {
+      if (!peds) peds  = new AliFMDCalibPedestal;
+      std::ifstream in(f.Data());
+      peds->ReadFromFile(in);
+      in.close();
+    }
+    if ((what & kPulseGain) && CheckFile("gains", path, i, f)) { 
+      if (!gains) gains = new AliFMDCalibGain;
+      std::ifstream in(f.Data());
+      gains->ReadFromFile(in);
+      in.close();
+    }
+  }
+
+  if (range) what &= ~kStripRange;
+  if (rate)  what &= ~kSampleRate;
+  if (peds)  what &= ~kPedestal;
+  if (gains) what &= ~kPulseGain;
+
+  Init(kFALSE, what);
+  
+  if (range) SetStripRange(range);
+  if (rate)  SetSampleRate(rate);
+  if (peds)  SetPedestal(peds);
+  if (gains) SetGain(gains);
+
+  fIsInit = kTRUE;
+}
+
+//__________________________________________________________________
+void
+AliFMDParameters::MakeDeadMap(Float_t maxNoise, 
+                             Float_t minGain, 
+                             Float_t maxGain)
+{
+  if (fPedestal)  
+    fDeadMap = fPedestal->MakeDeadMap(maxNoise, fDeadMap);
+  if (fPulseGain) 
+    fDeadMap = fPulseGain->MakeDeadMap(minGain, maxGain, fDeadMap);
+}
+//__________________________________________________________________
 #define DET2IDX(det,ring,sec,str) \
   (det * 1000 + (ring == 'I' ? 0 : 512) + str)  
   
index 0718ee3..47d6f48 100644 (file)
@@ -93,10 +93,13 @@ public:
     /** ALTRO data map */ 
     kAltroMap = 0x20, // Altro channel map
     /** Strip Range */
-    kStripRange = 0x40 //Strip range
-    
+    kStripRange = 0x40 //Strip range, 
   };
-  
+  enum { 
+    kAll = (kPulseGain|kPedestal|kDeadMap|kSampleRate|
+           kZeroSuppression|kAltroMap|kStripRange)
+  };
+    
   /** Singleton access
       @return  single to */
   static AliFMDParameters* Instance();
@@ -104,16 +107,57 @@ public:
   /** Initialize the manager.  This tries to read the parameters from
       CDB.  If that fails, the class uses the hard-coded parameters. 
    */
-  void Init(Bool_t forceReInit=kFALSE, 
-           UInt_t what = (kPulseGain|kPedestal|kDeadMap|kSampleRate|
-                          kZeroSuppression|kAltroMap|kStripRange));
+  void Init(Bool_t forceReInit=kFALSE, UInt_t what=kAll );
   /** Initialize the manager.  This tries to read the parameters from
       CDB.  If that fails, the class uses the hard-coded parameters. 
    */
   void Init(AliFMDPreprocessor* pp, 
-           Bool_t forceReInit=kFALSE, 
-           UInt_t what = (kPulseGain|kPedestal|kDeadMap|kSampleRate|
-                          kZeroSuppression|kAltroMap|kStripRange));
+           Bool_t              forceReInit=kFALSE, 
+           UInt_t              what=kAll);
+  /** 
+   * Initialize the manager.  This will try to read some calibrations
+   * (sample rate, strip range, gains, pedestals) from local comma
+   * separated value (CSV) files in the directory pointed at by @a
+   * path.  If they are not found, then they will be retrieved from
+   * OCDB as appropriately.   Other calibrations are always read from
+   * OCDB.  
+   * 
+   * The CSV files should be named as 
+   * 
+   * - Pedestals: <tt>peds</tt><i>det_number</i><tt>.csv</tt>
+   * - Gains: <tt>gains</tt><i>det_number</i><tt>.csv</tt>
+   * - Sample Rate: <tt>conditions</tt><i>det_number</i><tt>.csv</tt>
+   * - Strip Range: <tt>conditions</tt><i>det_number</i><tt>.csv</tt>
+   *
+   * where <i>det_number</i> is the detector number (1, 2, or 3). 
+   *
+   * @param path        Where to look for the CSV files
+   * @param forceReInit Always reinitialise 
+   * @param what        What calibrations to load. 
+   */  
+  void Init(const char* path, 
+           Bool_t      forceReInit=kFALSE, 
+           UInt_t      what=kAll);
+  
+  /** 
+   * Automatically generate a dead map from the pedestals and gains.
+   * A channel is marked as dead of the noise is too high (currently
+   * more than 10 ADC counts), or the gain is unreasonable (currently
+   * larger than 10, or smaller than 0.1). 
+   * 
+   * The procedure does not overwrite channels previously marked as
+   * dead - e.g., channels marked as dead in the calibration loaded
+   * from OCDB will continue to be marked as dead.  That is, this
+   * procedure will never make a channel un-dead. 
+   *
+   * @param maxNoise  Maximum noise value before a channel is marked
+   * as dead. 
+   * @param minGain   Minimum value of the calibrated gain before a
+   * channel is considered dead. 
+   * @param maxGain   Maximum value of the calibrated gain before a
+   * channel is considered dead. 
+   */
+  void MakeDeadMap(Float_t maxNoise=10, Float_t minGain=.1, Float_t maxGain=10);
   /** Print all parameters. 
       @param option Option string */
   void Print(Option_t* option="A") const;
@@ -488,6 +532,19 @@ protected:
   virtual ~AliFMDParameters() {}
   /** Singleton instance  */
   static AliFMDParameters* fgInstance;   // Static singleton instance
+  /** 
+   * Check if the file <i>prefix</i><i>number</i> exists in @a path, 
+   * and write the full path to @a f.  
+   * 
+   * @param prefix  File prefix (cond, peds, gains, ...)
+   * @param path    Path to files
+   * @param number  Detector number (1, 2, or 3)
+   * @param f       On return full path to file (if found)
+   * 
+   * @return @c true if file exists and is readable, @c false otherwise
+   */
+  Bool_t CheckFile(const char* prefix, const char* path, 
+                  int         number, TString&    f) const;
   /** Get an entry from either global AliCDBManager or passed
       AliFMDPreprocessor. 
       @param path  Path to CDB object.