Added possibility to reconstruct directly from raw data (rather than
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 6 Nov 2008 15:22:49 +0000 (15:22 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 6 Nov 2008 15:22:49 +0000 (15:22 +0000)
going via an intermedant TClonesArray of AliFMDDigits).   Also,
changed prototypes of various member functions in the AliFMDReconstructor
to be independent of having AliFMDDigit objects.   This could speed
up the reconstruction considerably.

FMD/AliFMDRawReader.cxx
FMD/AliFMDRawReader.h
FMD/scripts/TestRawReader.C [new file with mode: 0644]

index bb7bd9e..332c319 100644 (file)
@@ -105,6 +105,160 @@ AliFMDRawReader::Exec(Option_t*)
 }
 
 
+//____________________________________________________________________
+Bool_t
+AliFMDRawReader::NextSignal(UShort_t& det, Char_t&   rng, 
+                           UShort_t& sec, UShort_t& str, 
+                           Short_t&  adc, Bool_t&   zs, 
+                           UShort_t& fac)
+{
+  // Scan current event for next signal.   It returns kFALSE when
+  // there's no more data in the event. 
+  static AliAltroRawStream   stream(fReader); //    = 0;
+  static AliFMDParameters*   pars     = 0;
+  static AliFMDAltroMapping* map      = 0;
+  static Int_t               ddl      = -1;
+  static UInt_t              rate     = 0;
+  static UShort_t            tdet     = 0;
+  static Char_t              trng     = '\0';
+  static UShort_t            tsec     = 0;
+  static Short_t             tstr     = 0;   
+  static Short_t             bstr     = -1;
+  static Int_t               hwaddr   = -1;
+  static UShort_t            stripMin = 0;
+  static UShort_t            stripMax = 0; // 127;
+  static UShort_t            preSamp  = 0; // 14+5;
+  if (stream.GetDDLNumber() < 0) { 
+    fReader->Select("FMD");
+
+    // Reset "seen" array
+    // const UShort_t kUShortMax = (1 << 16) - 1;
+    // fSeen.Reset(kUShortMax);
+
+    pars   = AliFMDParameters::Instance();
+    map    = pars->GetAltroMap();
+    // stream = new AliAltroRawStream(fReader);
+
+    AliFMDDebug(5, ("Setting %d word headers", 
+                   pars->HasCompleteHeader() ? 8 : 7));
+    stream.SetShortDataHeader(!pars->HasCompleteHeader());
+    stream.SetNoAltroMapping(kFALSE);
+
+    // Reset variables
+    ddl    = -1;  
+    rate   = 0;   
+    tdet   = 0;   
+    trng   = '\0';
+    tsec   = 0;   
+    tstr   = 0;  
+    hwaddr = -1;
+  }
+  do { 
+    Bool_t next = stream.Next();
+    if (!next) { 
+      // if (stream) delete stream;
+      // stream = 0;
+      return kFALSE;
+    }
+    Int_t thisDDL = stream.GetDDLNumber();
+    AliFMDDebug(10, ("RCU @ DDL %d", thisDDL));
+    if (thisDDL != ddl) { 
+      ddl  = thisDDL;
+      zs   = stream.GetZeroSupp();
+      fac  = stream.GetNPostsamples();
+      tdet = map->DDL2Detector(ddl);
+      rate = 0; // stream.GetNPresamples();
+      AliFMDDebug(10, ("RCU @ DDL %d zero suppression: %s",ddl, zs?"yes":"no"));
+      AliFMDDebug(10, ("RCU @ DDL %d noise factor: %d", ddl,fac));
+      AliFMDDebug(10, ("RCU @ DDL %d sample rate: %d", ddl, rate));
+    }
+    Int_t thisAddr = stream.GetHWAddress();
+    AliFMDDebug(10, ("RCU @ DDL %d, Address 0x%03x", ddl, thisAddr));    
+    if (thisAddr != hwaddr) { 
+      hwaddr = thisAddr;
+      UShort_t  board, chip, channel;
+      map->ChannelAddress(hwaddr, board, chip, channel);
+      map->Channel2StripBase(board, chip, channel, trng, tsec, bstr);
+      AliFMDDebug(10, ("0x%04x/0x%03x maps to FMD%d%c[%2d]-%3d", 
+                     ddl, hwaddr, tdet, trng, tsec, bstr));
+      
+      stripMin = pars->GetMinStrip(tdet, trng, tsec, bstr);
+      stripMax = pars->GetMaxStrip(tdet, trng, tsec, bstr);
+      preSamp  = pars->GetPreSamples(tdet, trng, tsec, bstr);
+      if (rate == 0) rate = pars->GetSampleRate(tdet, trng, tsec, bstr);
+      AliFMDDebug(10, ("RCU @ DDL %d, Address 0x%03x sample rate: %d", 
+                     ddl, hwaddr, rate));
+      
+      Int_t nChAddrMismatch = stream.GetNChAddrMismatch();
+      Int_t nChLenMismatch  = stream.GetNChLengthMismatch();
+      if (nChAddrMismatch != 0) 
+       AliWarning(Form("Got %d channels with address mis-matches for 0x%03x",
+                       nChAddrMismatch, hwaddr));
+      if (nChLenMismatch != 0) 
+       AliWarning(Form("Got %d channels with length mis-matches for 0x%03x",
+                       nChLenMismatch, hwaddr));
+    }
+    // Get the signal
+    adc = stream.GetSignal();
+
+    // Sanity check - if the total bunch length is less than 1, then
+    // read until we get the next bunch. 
+    Int_t b  = stream.GetTimeLength();
+    if (b < 1) { 
+      AliWarning(Form("Bunch length %0d is less than 0 for "
+                     "DDL %4d address 0x%03x", b, ddl, hwaddr));
+      continue;
+    }
+    // Sanity check - if the current time is less than 0, then read
+    // until we get a new bunch. 
+    Int_t t  = stream.GetTime();
+    if (t < 0) {
+      AliWarning(Form("Time %0d is less than 0 for DDL %4d address 0x%03x", 
+                     t, ddl, hwaddr));
+      continue;
+    }
+
+    Short_t  strOff = 0;
+    UShort_t samp   = 0;
+    map->Timebin2Strip(tsec, t, preSamp, rate, strOff, samp);
+    tstr = bstr + strOff;
+    AliFMDDebug(20, ("0x%04x/0x%03x/%04d maps to FMD%d%c[%2d,%3d]-%d", 
+                    ddl, hwaddr, t, tdet, trng, tsec, tstr, samp));
+    
+    Bool_t take = kFALSE;
+    switch (rate) { 
+    case 1:                      take = kTRUE; break;
+    case 2:  if (samp == 1)      take = kTRUE; break;
+    case 3:  if (samp == 1)      take = kTRUE; break; 
+    case 4:  if (samp == 2)      take = kTRUE; break;
+    default: if (samp == rate-2) take = kTRUE; break;
+    }
+    if (!take) continue;
+
+
+    // Local strip number to channel
+    Short_t l = (tstr > bstr ? tstr - bstr : bstr - tstr);
+    AliFMDDebug(10, ("Checking if strip %d in range [%d,%d]", 
+                    l, stripMin, stripMax));
+    if (l < stripMin || l > stripMax) { 
+      AliFMDDebug(5, ("VA channel %3d (t: %4d) of DDL %4d address 0x%03x "
+                     "is out of range (%3d->%3d)", 
+                     l, t, ddl, hwaddr, stripMin, stripMax));
+      continue;
+    }
+
+
+    det = tdet;
+    rng = trng;
+    sec = tsec;
+    str = tstr;
+    // adc = stream.GetSignal();
+    
+    break;
+  } while (true);
+  return kTRUE;
+}
+
 #if 1
 //____________________________________________________________________
 Bool_t
index d2159ea..b1e2a53 100644 (file)
@@ -92,6 +92,10 @@ public:
    */
   UShort_t NoiseFactor(UShort_t ddl) const { return fNoiseFactor[ddl]; }
 
+  Bool_t NextSignal(UShort_t& det, Char_t&   rng, 
+                   UShort_t& sec, UShort_t& str, 
+                   Short_t&  adc, Bool_t&   zs, 
+                   UShort_t& fac);
 protected:
   AliFMDRawReader(const AliFMDRawReader& o) 
     : TTask(o), 
diff --git a/FMD/scripts/TestRawReader.C b/FMD/scripts/TestRawReader.C
new file mode 100644 (file)
index 0000000..7d9a5be
--- /dev/null
@@ -0,0 +1,71 @@
+//
+// Test of the "NextSignal" interface of the AliFMDRawReader
+//
+// w/ZS:       08000059807016.10.root
+// w/o ZS:     08000053726000.10.root
+
+Int_t ReadEvent(AliRawReader* reader)
+{
+  if (!reader)              return -1;
+  if (!reader->NextEvent()) return -1;
+  Int_t evno = reader->GetEventIndex();
+  // if (evno % 10 == 0) std::cout << "." << std::flush;
+  std::cout << "In event # " << evno << "/" 
+           << reader->GetNumberOfEvents() << std::endl;  
+  return evno;
+}
+
+void
+TestRawReader(const char* file=
+             //"/media/cholm_data/alice/data/08000053726000.10.root" // w/o ZS
+             "/media/cholm_data/alice/data/08000059807016.10.root" // w/ZS
+             )
+{
+  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+  AliCDBManager::Instance()->SetRun(59807);
+  AliFMDParameters::Instance()->Init();
+  AliLog::SetModuleDebugLevel("FMD", 2);
+
+  AliRawReader* rawReader = AliRawReader::Create(file);
+  if (!rawReader) return;
+  
+  AliFMDRawReader* fmdReader = new AliFMDRawReader(rawReader, 0);
+  
+  AliFMDBoolMap seen;
+  
+  Int_t evno = -1;
+  while ((evno = ReadEvent(rawReader)) >= 0) { 
+    if (evno <  25) continue;
+    if (evno > 120) break;
+    
+    UShort_t det, sec, str, fac;
+    Short_t adc;
+    Bool_t zs;
+    Char_t rng;
+    seen.Reset(kFALSE);
+    
+    while (fmdReader->NextSignal(det, rng, sec, str, adc, zs, fac)) { 
+      Printf("FMD%d%c[%02d,%03d]: %4d", det,rng,sec,str,adc);
+      seen(det,rng,sec,str) = kTRUE;
+    }
+#if 0
+    for (det = 1; det <= 3; det++) { 
+      UShort_t nrng = (det == 1 ? 1 : 2);
+      for (UShort_t ir = 0; ir < nrng; ir++) { 
+       Char_t   rng  = (ir == 0 ? 'I' : 'O');
+       UShort_t nsec = (ir == 0 ?  20 :  40);
+       UShort_t nstr = (ir == 0 ? 512 : 256);
+       for (sec = 0; sec < nsec; sec++) { 
+         for (str = 0; str < nstr; str++) {
+           if (!seen(det,rng,sec,str)) 
+             Printf("FMD%d%c[%02d,%03d] not seen", det,rng,sec,str);
+         }
+       }
+      }
+    }
+#endif
+  }
+}
+
+    
+