Improved ALTRO mapping: Now does the full conversion from
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 30 Aug 2008 02:29:34 +0000 (02:29 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 30 Aug 2008 02:29:34 +0000 (02:29 +0000)
    <DDL>/<FEC>/<ALTRO>/<Channel>/<Timebin>
  ->
    FMD<detector><ring>[<sector>,<strip>]-<sample>

and the other way back. Changed all relevant code to use this conversion.
This ensures that the conversion is consistent over all the code. To do
this, I had to implement the AliFMDDigit::SetCount member function.
Not nice, but so be it.  Alternatively, AliFMDRawReader could be a friend
of AliFMDDigit - but that's not nice either.

Fixed up AliFMDPattern to display the modules correctly.

17 files changed:
FMD/AliFMDAltroMapping.cxx
FMD/AliFMDAltroMapping.h
FMD/AliFMDDetector.cxx
FMD/AliFMDDigit.h
FMD/AliFMDDisplay.cxx
FMD/AliFMDParameters.cxx
FMD/AliFMDParameters.h
FMD/AliFMDPattern.cxx
FMD/AliFMDPattern.h
FMD/AliFMDPedestalDA.cxx
FMD/AliFMDRawReader.cxx
FMD/AliFMDRawReader.h
FMD/AliFMDRawWriter.cxx
FMD/AliFMDReconstructor.h
FMD/Reconstruct.C
FMD/scripts/PatternRaw.C
FMD/scripts/TestAltroMapping.C

index e360e8f..bdd3ca0 100644 (file)
@@ -73,7 +73,7 @@ AliFMDAltroMapping::CreateInvMapping()
 Bool_t 
 AliFMDAltroMapping::Hardware2Detector(UInt_t    ddl, UInt_t    addr, 
                                      UShort_t& det, Char_t&   ring, 
-                                     UShort_t& sec, UShort_t& str) const
+                                     UShort_t& sec, Short_t&  str) const
 {
   // Translate a hardware address to detector coordinates. 
   // 
@@ -89,7 +89,7 @@ Bool_t
 AliFMDAltroMapping::Hardware2Detector(UInt_t    ddl,   UInt_t    board, 
                                      UInt_t    altro, UInt_t    chan,
                                      UShort_t& det,   Char_t&   ring, 
-                                     UShort_t& sec,   UShort_t& str) const
+                                     UShort_t& sec,   Short_t&  str) const
 {
   // Translate a hardware address to detector coordinates. 
   // The detector is simply 
@@ -110,7 +110,7 @@ AliFMDAltroMapping::Hardware2Detector(UInt_t    ddl,   UInt_t    board,
   // the outer rings. 
   // 
   // The board number and ALTRO number together identifies the sensor,
-  // and hence.  The lower board number (0 or 2) are the first N / 2
+  // and hence.  The lower board number (0 or 16) are the first N / 2
   // sensors (where N is the number of sensors in the ring).  
   // 
   // There are 3 ALTRO's per card, and each ALTRO serves up to 4
@@ -140,25 +140,26 @@ AliFMDAltroMapping::Hardware2Detector(UInt_t    ddl,   UInt_t    board,
   // number only.  For the inner rings, the map is 
   // 
   //    Channel 0                   -> Sector 0, strips   0-127
-  //    Channel 1                   -> Sector 1, strips   0-127
+  //    Channel 1                   -> Sector 1, strips 127-0
   //    Channel 3                   -> Sector 0, strips 128-255
-  //    Channel 4                   -> Sector 1, strips 128-255
+  //    Channel 4                   -> Sector 1, strips 255-128
   //    Channel 5                   -> Sector 0, strips 256-383
-  //    Channel 6                   -> Sector 1, strips 256-383
+  //    Channel 6                   -> Sector 1, strips 383-256
   //    Channel 7                   -> Sector 0, strips 384-511
-  //    Channel 8                   -> Sector 1, strips 384-511 
+  //    Channel 8                   -> Sector 1, strips 511-384
   // 
   // There are only half as many strips in the outer sensors, so there
   // only 4 channels are used for a full sensor.  The map is 
   // 
   //    Channel 0                   -> Sector 0, strips   0-127
-  //    Channel 1                   -> Sector 1, strips   0-127
+  //    Channel 1                   -> Sector 1, strips 127-0
   //    Channel 3                   -> Sector 0, strips 128-255
-  //    Channel 4                   -> Sector 1, strips 128-255
+  //    Channel 4                   -> Sector 1, strips 255-128
   // 
   // With this information, we can decode the hardware address to give
   // us detector coordinates, unique at least up a 128 strips.  We
-  // return the first strip in the given range. 
+  // return the first strip, as seen by the ALTRO channel, in the
+  // given range.  
   //
   det          =  ddl + 1;
   ring         =  (board % 2) == 0 ? 'I' : 'O';
@@ -176,11 +177,63 @@ AliFMDAltroMapping::Hardware2Detector(UInt_t    ddl,   UInt_t    board,
     str = ((chan % 4) / 2) * 128;
     break;
   }
+  if (sec % 2) str += 127;
   return kTRUE;
 }
 
 //____________________________________________________________________
 Bool_t 
+AliFMDAltroMapping::Hardware2Detector(UInt_t    ddl,       UInt_t   addr,
+                                     UShort_t  timebin,   UShort_t preSamples, 
+                                     UShort_t  sampleRate,
+                                     UShort_t& det,       Char_t&   ring, 
+                                     UShort_t& sec,       Short_t&  str,
+                                     UShort_t& sam) const
+{
+  // Translate a hardware address to detector coordinates. 
+  // 
+  // See also Hardware2Detector that accepts 4 inputs 
+  UInt_t board =  (addr >> 7) & 0x1F;
+  UInt_t altro =  (addr >> 4) & 0x7;
+  UInt_t chan  =  (addr & 0xf);
+  return Hardware2Detector(ddl, board, altro, chan, 
+                          timebin, preSamples, sampleRate, 
+                          det, ring, sec, str, sam);
+}
+
+//____________________________________________________________________
+Bool_t 
+AliFMDAltroMapping::Hardware2Detector(UInt_t    ddl,     UInt_t    board, 
+                                     UInt_t    altro,   UInt_t    chan,
+                                     UInt_t    timebin, UInt_t    preSamples,
+                                     UInt_t    sampleRate,
+                                     UShort_t& det,     Char_t&   ring, 
+                                     UShort_t& sec,     Short_t&  str,
+                                     UShort_t& sam) const
+{
+  // Full conversion from hardware address, including timebin number,
+  // to detector coordinates and sample number.  Note, that this
+  // conversion depends on the oversampling rate and the number of
+  // pre-samples 
+  if (!Hardware2Detector(ddl, board, altro, chan, det, ring, sec, str))
+    return kFALSE;
+  UShort_t t =  (timebin - preSamples);
+  sam        =  (t % sampleRate);
+  t          -= sam;
+  str        += (sec % 2 ? -1 : 1) * t / sampleRate;
+  // if (sec % 2) sam = sampleRate - 1 - sam;
+#if 0
+  AliFMDDebug(3, ("%d/0x%02x/0x%x/0x%x/%04d -> FMD%d%c[%02d,%03d]-%d"
+                 " (pre=%2d, rate=%d)", 
+                 ddl, board, altro, chan, timebin, 
+                 det, ring, sec, str, sam, preSamples, sampleRate));
+#endif
+  return kTRUE;
+}
+
+
+//____________________________________________________________________
+Bool_t 
 AliFMDAltroMapping::Detector2Hardware(UShort_t  det,   Char_t    ring, 
                                      UShort_t  sec,   UShort_t  str,
                                      UInt_t&   ddl,   UInt_t&   board,
@@ -229,37 +282,37 @@ AliFMDAltroMapping::Detector2Hardware(UShort_t  det,   Char_t    ring,
   //    Sector  0, strips 128-255  ->   Channel  2
   //    Sector  0, strips 256-383  ->   Channel  4
   //    Sector  0, strips 384-511  ->   Channel  6
-  //    Sector  1, strips   0-127  ->   Channel  1
-  //    Sector  1, strips 128-255  ->   Channel  3
-  //    Sector  1, strips 256-383  ->   Channel  5
-  //    Sector  1, strips 384-511  ->   Channel  7
+  //    Sector  1, strips 127-  0  ->   Channel  1
+  //    Sector  1, strips 255-128  ->   Channel  3
+  //    Sector  1, strips 383-256  ->   Channel  5
+  //    Sector  1, strips 511-384  ->   Channel  7
   //    Sector  2, strips   0-127  ->   Channel  8
   //    Sector  2, strips 128-255  ->   Channel 10
   //    Sector  2, strips 256-383  ->   Channel 12
   //    Sector  2, strips 384-511  ->   Channel 14
-  //    Sector  3, strips   0-127  ->   Channel  9
-  //    Sector  3, strips 128-255  ->   Channel 11
-  //    Sector  3, strips 256-383  ->   Channel 13
-  //    Sector  3, strips 384-511  ->   Channel 15
+  //    Sector  3, strips 127-  0  ->   Channel  9
+  //    Sector  3, strips 255-128  ->   Channel 11
+  //    Sector  3, strips 383-256  ->   Channel 13
+  //    Sector  3, strips 511-384  ->   Channel 15
   // 
   // and so on, up to sector 19.  For the outer, the map is 
   // 
   //    Sector  0, strips   0-127  ->   Channel  0
   //    Sector  0, strips 128-255  ->   Channel  2
-  //    Sector  1, strips   0-127  ->   Channel  1
-  //    Sector  1, strips 128-255  ->   Channel  3
+  //    Sector  1, strips 127-  0  ->   Channel  1
+  //    Sector  1, strips 255-128  ->   Channel  3
   //    Sector  2, strips   0-127  ->   Channel  4
   //    Sector  2, strips 128-255  ->   Channel  6
-  //    Sector  3, strips   0-127  ->   Channel  5
-  //    Sector  3, strips 128-255  ->   Channel  7
+  //    Sector  3, strips 127-  0  ->   Channel  5
+  //    Sector  3, strips 255-128  ->   Channel  7
   //    Sector  4, strips   0-127  ->   Channel  8
   //    Sector  4, strips 128-255  ->   Channel 10
-  //    Sector  5, strips   0-127  ->   Channel  9
-  //    Sector  5, strips 128-255  ->   Channel 11
+  //    Sector  5, strips 127-  0  ->   Channel  9
+  //    Sector  5, strips 255-128  ->   Channel 11
   //    Sector  6, strips   0-127  ->   Channel 12
   //    Sector  6, strips 128-255  ->   Channel 14
-  //    Sector  7, strips   0-127  ->   Channel 13
-  //    Sector  7, strips 128-255  ->   Channel 15
+  //    Sector  7, strips 127-  0  ->   Channel 13
+  //    Sector  7, strips 255-128  ->   Channel 15
   // 
   // and so on upto sector 40. 
   // 
@@ -305,6 +358,49 @@ AliFMDAltroMapping::Detector2Hardware(UShort_t  det, Char_t    ring,
 }
 
 //____________________________________________________________________
+Bool_t 
+AliFMDAltroMapping::Detector2Hardware(UShort_t  det,        Char_t    ring, 
+                                     UShort_t  sec,        UShort_t  str,
+                                     UShort_t  sam, 
+                                     UShort_t  preSamples, UShort_t sampleRate,
+                                     UInt_t&   ddl,        UInt_t&   board, 
+                                     UInt_t&   altro,      UInt_t&   channel, 
+                                     UShort_t& timebin) const
+{
+  if (!Detector2Hardware(det,ring,sec,str,ddl,board,altro,channel)) 
+    return kFALSE;
+  timebin = preSamples;
+  if (sec % 2) 
+    timebin += (127 - (str % 128)) * sampleRate;
+  else 
+    timebin += (str % 128) * sampleRate;
+  timebin += sam;
+  return kTRUE;
+}
+
+
+//____________________________________________________________________
+Bool_t 
+AliFMDAltroMapping::Detector2Hardware(UShort_t  det,        Char_t   ring, 
+                                     UShort_t  sec,        UShort_t str,
+                                     UShort_t  sam, 
+                                     UShort_t  preSamples, UShort_t sampleRate,
+                                     UInt_t&   ddl,        UInt_t&  hwaddr, 
+                                     UShort_t& timebin) const
+{
+  UInt_t board = 0;
+  UInt_t altro = 0;
+  UInt_t chan  = 0;
+  if (!Detector2Hardware(det, ring, sec, str, sam, 
+                        preSamples, sampleRate, 
+                        ddl, board, altro, chan, timebin)) return kFALSE;
+  hwaddr =  chan + (altro << 4) + (board << 7);
+  return kTRUE;
+}
+
+      
+
+//____________________________________________________________________
 Int_t
 AliFMDAltroMapping::GetHWAddress(Int_t sec, Int_t str, Int_t ring)
 {
@@ -340,7 +436,7 @@ AliFMDAltroMapping::GetPadRow(Int_t hwaddr) const
   UShort_t det;
   Char_t   ring;
   UShort_t sec;
-  UShort_t str;
+  Short_t  str;
   Int_t    ddl = 0;
   if (!Hardware2Detector(ddl, hwaddr, det, ring, sec, str)) return -1;
   return Int_t(sec);
@@ -362,7 +458,7 @@ AliFMDAltroMapping::GetPad(Int_t hwaddr) const
   UShort_t det;
   Char_t   ring;
   UShort_t sec;
-  UShort_t str;
+  Short_t  str;
   Int_t    ddl = 0;
   if (!Hardware2Detector(ddl, hwaddr, det, ring, sec, str)) return -1;
   return Int_t(str);
@@ -384,7 +480,7 @@ AliFMDAltroMapping::GetSector(Int_t hwaddr) const
   UShort_t det;
   Char_t   ring;
   UShort_t sec;
-  UShort_t str;
+  Short_t  str;
   Int_t    ddl = 0;
   if (!Hardware2Detector(ddl, hwaddr, det, ring, sec, str)) return -1;
   return Int_t(ring);
@@ -397,7 +493,8 @@ AliFMDAltroMapping::Print(Option_t* option) const
   TString opt(option);
   opt.ToLower();
   UInt_t ddl, board, chip, chan, addr;
-  UShort_t det, sec, str;
+  UShort_t det, sec;
+  Short_t str;
   Char_t   rng;
   
   if (opt.Contains("hw") || opt.Contains("hardware")) { 
index 138553f..c4d5783 100644 (file)
@@ -66,7 +66,25 @@ public:
       @return @c true on success, false otherwise */
   Bool_t Hardware2Detector(UInt_t    ddl, UInt_t    hwaddr, 
                           UShort_t& det, Char_t&   ring, 
-                          UShort_t& sec, UShort_t& str) const;
+                          UShort_t& sec, Short_t& str) const;
+  /** Map a hardware address into a detector index. 
+      @param ddl        Hardware DDL number 
+      @param hwaddr     Hardware address.  
+      @param timebin    Timebin 
+      @param preSamples # of pre samples 
+      @param sampleRate Over sampling rate 
+      @param det        On return, the detector #
+      @param ring       On return, the ring ID
+      @param sec        On return, the sector #
+      @param str        On return, the base of strip #
+      @param sam        On return, the sample number for this strip
+      @return @c true on success, false otherwise */
+  Bool_t Hardware2Detector(UInt_t    ddl,        UInt_t    hwaddr, 
+                          UShort_t  timebin,    UShort_t preSamples, 
+                          UShort_t  sampleRate,
+                          UShort_t& det,        Char_t&   ring, 
+                          UShort_t& sec,        Short_t&  str,
+                          UShort_t& sam) const;
   /** Map a hardware address into a detector index. 
       @param ddl     Hardware DDL number 
       @param board   FEC number
@@ -80,7 +98,28 @@ public:
   Bool_t Hardware2Detector(UInt_t    ddl,   UInt_t    board, 
                           UInt_t    altro, UInt_t    channel,
                           UShort_t& det,   Char_t&   ring, 
-                          UShort_t& sec,   UShort_t& str) const;
+                          UShort_t& sec,   Short_t&  str) const;
+  /** Map a hardware address into a detector index. 
+      @param ddl        Hardware DDL number 
+      @param board      FEC number
+      @param altro      ALTRO number 
+      @param channel    Channel number 
+      @param timebin    Timebin 
+      @param preSamples # of pre samples 
+      @param sampleRate Over sampling rate 
+      @param det        On return, the detector #
+      @param ring       On return, the ring ID
+      @param sec        On return, the sector #
+      @param str        On return, the base of strip #
+      @param sam        On return, the sample number for this strip
+      @return @c true on success, false otherwise */
+  Bool_t Hardware2Detector(UInt_t    ddl,        UInt_t    board, 
+                          UInt_t    altro,      UInt_t    chan,
+                          UInt_t    timebin,    UInt_t    preSamples,
+                          UInt_t    sampleRate,
+                          UShort_t& det,        Char_t&   ring, 
+                          UShort_t& sec,        Short_t&  str,
+                          UShort_t& sam) const;
   /** Map a detector index into a hardware address. 
       @param det     The detector #
       @param ring    The ring ID
@@ -96,6 +135,27 @@ public:
                           UInt_t&   ddl,   UInt_t&   board, 
                           UInt_t&   altro, UInt_t&   channel) const;
   /** Map a detector index into a hardware address. 
+      @param det         The detector #
+      @param ring        The ring ID
+      @param sec         The sector #
+      @param str         The strip #
+      @param sam         The sample number 
+      @param preSamples  Number of pre-samples
+      @param sampleRate  The oversampling rate 
+      @param ddl         On return, hardware DDL number 
+      @param board       On return, the FEC board address (local to DDL)
+      @param altro       On return, the ALTRO number (local to FEC)
+      @param channel     On return, the channel number (local to ALTRO)
+      @param timebin     On return, the timebin number (local to ALTRO)
+      @return @c true on success, false otherwise */
+  Bool_t Detector2Hardware(UShort_t  det,        Char_t    ring, 
+                          UShort_t  sec,        UShort_t  str,
+                          UShort_t  sam, 
+                          UShort_t  preSamples, UShort_t sampleRate,
+                          UInt_t&   ddl,        UInt_t&   board, 
+                          UInt_t&   altro,      UInt_t&   channel, 
+                          UShort_t& timebin) const;
+  /** Map a detector index into a hardware address. 
       @param det    The detector #
       @param ring   The ring ID
       @param sec    The sector #
@@ -106,6 +166,24 @@ public:
   Bool_t Detector2Hardware(UShort_t  det, Char_t    ring, 
                           UShort_t  sec, UShort_t  str,
                           UInt_t&   ddl, UInt_t&   hwaddr) const;
+  /** Map a detector index into a hardware address. 
+      @param det         The detector #
+      @param ring        The ring ID
+      @param sec         The sector #
+      @param str         The strip #
+      @param sam         The sample number 
+      @param preSamples  Number of pre-samples
+      @param sampleRate  The oversampling rate 
+      @param ddl         On return, hardware DDL number 
+      @param hwaddr      On return, hardware address.  
+      @param timebin     On return, the timebin number (local to ALTRO)
+      @return @c true on success, false otherwise */
+  Bool_t Detector2Hardware(UShort_t  det,        Char_t    ring, 
+                          UShort_t  sec,        UShort_t  str,
+                          UShort_t  sam, 
+                          UShort_t  preSamples, UShort_t sampleRate,
+                          UInt_t&   ddl,        UInt_t&   hwaddr, 
+                          UShort_t& timebin) const;
   /** convert a partial detector index into a hardware address
       @param sector Sector number
       @param str    Strip number
index 6baf3a3..4851e24 100644 (file)
@@ -521,9 +521,16 @@ AliFMDDetector::Detector2XYZ(Char_t   ring,
   // Translate detector coordinates (this,ring,sector,strip) into
   // (x,y,z) coordinates (in global reference frame)
   AliFMDRing* r = GetRing(ring);
-  if (!r) return;
+  if (!r) { 
+    AliWarning(Form("No such ring FMD%d%c ", fId, ring));
+    return;
+  }
   TGeoMatrix* m = FindTransform(ring, sector);
-  if (!m) return;
+  if (!m) { 
+    AliWarning(Form("No transfrmation found for FMD%d%c[%02d]", 
+                   fId, ring, sector));
+    return;
+  }
   Double_t rho      = r->GetStripRadius(strip);
   Double_t phi      = ((sector % 2) - .5) * r->GetTheta();
   Double_t siThick  = r->GetSiThickness();
index b865d59..da905fb 100644 (file)
@@ -62,6 +62,10 @@ public:
   void     Print(Option_t* opt="") const;
   /** @return Title */
   const char* GetTitle() const;
+  /** Set the count value 
+      @param s Sample number 
+      @param c Counts */
+  void SetCount(UShort_t s, Short_t c);
 protected:
   UShort_t fCount1;     // Digital signal 
   Short_t  fCount2;     // Digital signal (-1 if not used)
@@ -90,6 +94,16 @@ AliFMDDigit::Count(UShort_t i) const
   }
   return -1;
 }
+inline void
+AliFMDDigit::SetCount(UShort_t i, Short_t c)
+{
+  switch (i) {
+  case 0: fCount1 = c; break;
+  case 1: fCount2 = c; break;
+  case 2: fCount3 = c; break;
+  case 3: fCount4 = c; break;
+  }
+}
 
 #endif
 //____________________________________________________________________
index c7aee4b..52ec6ce 100644 (file)
@@ -165,7 +165,7 @@ AliFMDDisplay::MakeCanvas(const char** which)
   Int_t        n  = 0;
   Int_t        j  = 0;
   while (*(p++)) n++;
-  AliInfo(Form("Got %d buttons", n));
+  AliFMDDebug(1, ("Got %d buttons", n));
   if (n <= 0) return;
 
   Double_t yb = 0;
@@ -209,7 +209,7 @@ AliFMDDisplay::MakeCanvas(const char** which)
   p               = which;
   while ((m = *(p++))) {
     fCanvas->cd();
-    AliInfo(Form("Adding button %s", m));
+    AliFMDDebug(1, ("Adding button %s", m));
     TButton* b = new TButton(m, Form("AliFMDDisplay::Instance()->%s()", m),
                             x0, yb, TMath::Min(x0 + dx,.999F), y1);
     b->Draw();
@@ -239,17 +239,17 @@ AliFMDDisplay::ShowOnlyFMD()
   Bool_t hasFMD1 = kFALSE;
   Bool_t hasFMD2 = kFALSE;
   Bool_t hasFMD3 = kFALSE;
-  AliInfo("Getting material FMD_Si$");
+  AliFMDDebug(1, ("Getting material FMD_Si$"));
   TGeoMaterial* si   = gGeoManager->GetMaterial("FMD_Si$");      // kRed 
-  AliInfo("Getting material FMD_Carbon$");
+  AliFMDDebug(1, ("Getting material FMD_Carbon$"));
   TGeoMaterial* c    = gGeoManager->GetMaterial("FMD_Carbon$");  // kGray
-  AliInfo("Getting material FMD_Aluminum$");
+  AliFMDDebug(1, ("Getting material FMD_Aluminum$"));
   TGeoMaterial* al   = gGeoManager->GetMaterial("FMD_Aluminum$");// kGray-2
-  AliInfo("Getting material FMD_Copper$");
+  AliFMDDebug(1, ("Getting material FMD_Copper$"));
   TGeoMaterial* cu   = gGeoManager->GetMaterial("FMD_Copper$");        // kGreen-2
-  AliInfo("Getting material FMD_PCB$");
+  AliFMDDebug(1, ("Getting material FMD_PCB$"));
   TGeoMaterial* pcb  = gGeoManager->GetMaterial("FMD_PCB$");   // kGreen+2
-  AliInfo("Getting material FMD_PCB$");
+  AliFMDDebug(1, ("Getting material FMD_PCB$"));
   TGeoMaterial* chip = gGeoManager->GetMaterial("FMD_Si Chip$");// kGreen+2
   TObjArray     toshow;
   while ((node = static_cast<TGeoNode*>(next()))) {
@@ -463,11 +463,11 @@ AliFMDDisplay::Begin(Int_t event)
     Warning("End", "No geometry manager");
     return kFALSE;
   }
-  AliInfo("Drawing geometry");
+  AliFMDDebug(1, ("Drawing geometry"));
   fPad->cd();
   fGeoManager->GetTopVolume()->Draw();
   if (fOnlyFMD) ShowOnlyFMD();
-  AliInfo("Adjusting view");
+  AliFMDDebug(1, ("Adjusting view"));
   Int_t irep;
   if (fPad->GetView()) {
     fPad->GetView()->SetView(-200, -40, 80, irep);
@@ -506,10 +506,10 @@ AliFMDDisplay::Idle()
     gSystem->InnerLoop();
     gApplication->StopIdleing();
   }
-  AliInfo("After idle loop");
+  AliFMDDebug(1, ("After idle loop"));
   if (fMarkers) fMarkers->Delete();
   if (fHits)    fHits->Clear();
-  AliInfo("After clearing caches");
+  AliFMDDebug(1, ("After clearing caches"));
 }
 
 //____________________________________________________________________
index 81ce338..2cc4e8b 100644 (file)
@@ -728,12 +728,59 @@ AliFMDParameters::GetAltroMap() const
 }
 
 
+//____________________________________________________________________
+Bool_t 
+AliFMDParameters::Hardware2Detector(UInt_t    ddl,       UInt_t   addr,
+                                   UShort_t  timebin,   
+                                   UShort_t& det,       Char_t&   ring, 
+                                   UShort_t& sec,       Short_t& str,
+                                   UShort_t& sam) const
+{
+  // Translate a hardware address to detector coordinates. 
+  // 
+  // See also Hardware2Detector that accepts 4 inputs 
+  if (!Hardware2Detector(ddl, addr, det, ring, sec, str)) return kFALSE;
+  UShort_t preSamples = GetPreSamples(det, ring, sec, str);
+  UShort_t sampleRate = GetSampleRate(det, ring, sec, str);
+  if (!fAltroMap->Hardware2Detector(ddl, addr, timebin, 
+                                   preSamples, sampleRate,
+                                   det, ring, sec, str, sam)) return kFALSE;
+  AliFMDDebug(50, ("%d/0x%02x/0x%x/0x%x/%04d -> FMD%d%c[%02d,%03d]-%d"
+                 " (pre=%2d, rate=%d)", 
+                 ddl, ((addr >> 7) & 0x1F), ((addr >> 4) & 0x7), addr & 0xF,
+                 timebin, det, ring, sec, str, sam, preSamples, sampleRate));
+  // str += GetMinStrip(det,ring,sec,str);
+  return kTRUE;
+  
+}
+//____________________________________________________________________
+Bool_t 
+AliFMDParameters::Hardware2Detector(UInt_t    ddl,       UInt_t   board,
+                                   UInt_t    chip,      UInt_t   chan,
+                                   UShort_t  timebin,   
+                                   UShort_t& det,       Char_t&   ring, 
+                                   UShort_t& sec,       Short_t& str,
+                                   UShort_t& sam) const
+{
+  // Translate a hardware address to detector coordinates. 
+  // 
+  // See also Hardware2Detector that accepts 4 inputs 
+  if (!Hardware2Detector(ddl,board,chip,chan,det,ring,sec,str)) return kFALSE;
+  UShort_t preSamples = GetPreSamples(det, ring, sec, str);
+  UShort_t sampleRate = GetSampleRate(det, ring, sec, str);
+  if (!fAltroMap->Hardware2Detector(ddl, board, chip, chan, timebin,
+                                   preSamples, sampleRate,
+                                   det, ring, sec, str, sam)) return kFALSE;
+  // str += GetMinStrip(det,ring,sec,str);
+  return kTRUE;
+}
+
 //__________________________________________________________________
 Bool_t
 AliFMDParameters::Hardware2Detector(UInt_t    ddl,  UInt_t    board, 
                                    UInt_t    chip, UInt_t    chan,
                                    UShort_t& det,  Char_t&   ring, 
-                                   UShort_t& sec,  UShort_t& str) const
+                                   UShort_t& sec,  Short_t& str) const
 {
   // Map hardware address to detector index
   if (!fAltroMap) return kFALSE;
@@ -743,13 +790,33 @@ AliFMDParameters::Hardware2Detector(UInt_t    ddl,  UInt_t    board,
 Bool_t
 AliFMDParameters::Hardware2Detector(UInt_t    ddl,  UInt_t    addr, 
                                    UShort_t& det,  Char_t&   ring, 
-                                   UShort_t& sec,  UShort_t& str) const
+                                   UShort_t& sec,  Short_t& str) const
 {
   // Map hardware address to detector index
   if (!fAltroMap) return kFALSE;
   return fAltroMap->Hardware2Detector(ddl, addr, det, ring, sec, str);
 }
 
+//____________________________________________________________________
+Bool_t 
+AliFMDParameters::Detector2Hardware(UShort_t  det,        Char_t    ring, 
+                                   UShort_t  sec,        UShort_t  str,
+                                   UShort_t  sam, 
+                                   UInt_t&   ddl,        UInt_t&   board, 
+                                   UInt_t&   altro,      UInt_t&   channel, 
+                                   UShort_t& timebin) const
+{
+  if (!fAltroMap) return kFALSE;
+  UShort_t preSamples = GetPreSamples(det, ring, sec, str);
+  UShort_t sampleRate = GetSampleRate(det, ring, sec, str);
+  UShort_t strip      = str - GetMinStrip(det,ring,sec,str);
+  return fAltroMap->Detector2Hardware(det, ring, sec, strip, sam,
+                                     preSamples, sampleRate,
+                                     ddl, board, altro, channel, timebin);
+}
+
+  
+
 //__________________________________________________________________
 Bool_t
 AliFMDParameters::Detector2Hardware(UShort_t det,  Char_t   ring, 
@@ -762,6 +829,23 @@ AliFMDParameters::Detector2Hardware(UShort_t det,  Char_t   ring,
   return fAltroMap->Detector2Hardware(det,ring,sec,str, ddl,board,chip,chan);
 }
 
+//____________________________________________________________________
+Bool_t 
+AliFMDParameters::Detector2Hardware(UShort_t  det,        Char_t    ring, 
+                                   UShort_t  sec,        UShort_t  str,
+                                   UShort_t  sam, 
+                                   UInt_t&   ddl,        UInt_t&   addr,
+                                   UShort_t& timebin) const
+{
+  if (!fAltroMap) return kFALSE;
+  UShort_t preSamples = GetPreSamples(det, ring, sec, str);
+  UShort_t sampleRate = GetSampleRate(det, ring, sec, str);
+  UShort_t strip      = str - GetMinStrip(det,ring,sec,str);
+  return fAltroMap->Detector2Hardware(det, ring, sec, strip, sam,
+                                     preSamples, sampleRate,
+                                     ddl, addr, timebin);
+}
+
 //__________________________________________________________________
 Bool_t
 AliFMDParameters::Detector2Hardware(UShort_t det, Char_t   ring, 
index b934e91..9d0a26f 100644 (file)
@@ -187,7 +187,7 @@ public:
   /** @} */
 
   /** @{ */
-  /** @name Get variable parameters */
+  /** @name Various varible conditions */
   /** Whether the strip is considered dead
       @param detector Detector # (1-3)
       @param ring     Ring ID ('I' or 'O')
@@ -280,6 +280,28 @@ public:
                         Char_t, 
                         UShort_t, 
                         UShort_t) const { return 14+5; }
+  /** @} */
+  
+  /** @{ 
+      @name Hardware to detector translation (and inverse) */
+  /** Map a hardware address into a detector index. 
+      @param ddl        Hardware DDL number 
+      @param board      FEC number
+      @param altro      ALTRO number 
+      @param channel    Channel number 
+      @param timebin    Timebin 
+      @param det        On return, the detector #
+      @param ring       On return, the ring ID
+      @param sec        On return, the sector #
+      @param str        On return, the base of strip #
+      @param sam        On return, the sample number for this strip
+      @return @c true on success, false otherwise */
+  Bool_t Hardware2Detector(UInt_t    ddl,        UInt_t    board, 
+                          UInt_t    altro,      UInt_t    chan,
+                          UShort_t  timebin,   
+                          UShort_t& det,        Char_t&   ring, 
+                          UShort_t& sec,        Short_t& str,
+                          UShort_t& sam) const;
   /** Translate hardware address to detector coordinates 
       @param ddl      DDL number 
       @param board    Board address
@@ -293,7 +315,22 @@ public:
   Bool_t   Hardware2Detector(UInt_t ddl,    UInt_t    board, 
                             UInt_t chip,   UInt_t    channel, 
                             UShort_t& det, Char_t&   ring, 
-                            UShort_t& sec, UShort_t& str) const;
+                            UShort_t& sec, Short_t& str) const;
+  /** Map a hardware address into a detector index. 
+      @param ddl        Hardware DDL number 
+      @param hwaddr     Hardware address.  
+      @param timebin    Timebin 
+      @param det        On return, the detector #
+      @param ring       On return, the ring ID
+      @param sec        On return, the sector #
+      @param str        On return, the base of strip #
+      @param sam        On return, the sample number for this strip
+      @return @c true on success, false otherwise */
+  Bool_t Hardware2Detector(UInt_t    ddl,        UInt_t    hwaddr, 
+                          UShort_t  timebin,    
+                          UShort_t& det,        Char_t&   ring, 
+                          UShort_t& sec,        Short_t& str,
+                          UShort_t& sam) const;
   /** Translate hardware address to detector coordinates 
       @param ddl      DDL number 
       @param addr     Hardware address
@@ -303,8 +340,26 @@ public:
       @param str      On return, Strip number (0-511)
       @return @c true on success. */
   Bool_t   Hardware2Detector(UInt_t ddl, UInt_t addr, UShort_t& det,
-                            Char_t& ring, UShort_t& sec, UShort_t& str) const;
+                            Char_t& ring, UShort_t& sec, Short_t& str) const;
 
+  /** Map a detector index into a hardware address. 
+      @param det         The detector #
+      @param ring        The ring ID
+      @param sec         The sector #
+      @param str         The strip #
+      @param sam         The sample number 
+      @param ddl         On return, hardware DDL number 
+      @param board       On return, the FEC board address (local to DDL)
+      @param altro       On return, the ALTRO number (local to FEC)
+      @param channel     On return, the channel number (local to ALTRO)
+      @param timebin     On return, the timebin number (local to ALTRO)
+      @return @c true on success, false otherwise */
+  Bool_t Detector2Hardware(UShort_t  det,        Char_t    ring, 
+                          UShort_t  sec,        UShort_t  str,
+                          UShort_t  sam, 
+                          UInt_t&   ddl,        UInt_t&   board, 
+                          UInt_t&   altro,      UInt_t&   channel, 
+                          UShort_t& timebin) const;
   /** Translate detector coordinates to hardware address 
       @param det      Detector # (1-3)
       @param ring     Ring ID ('I' or 'O')
@@ -319,6 +374,21 @@ public:
                             UShort_t sec, UShort_t str, 
                             UInt_t& ddl,  UInt_t& board,
                             UInt_t& chip, UInt_t& channel) const;
+  /** Map a detector index into a hardware address. 
+      @param det         The detector #
+      @param ring        The ring ID
+      @param sec         The sector #
+      @param str         The strip #
+      @param sam         The sample number 
+      @param ddl         On return, hardware DDL number 
+      @param hwaddr      On return, hardware address.  
+      @param timebin     On return, the timebin number (local to ALTRO)
+      @return @c true on success, false otherwise */
+  Bool_t Detector2Hardware(UShort_t  det,        Char_t    ring, 
+                          UShort_t  sec,        UShort_t  str,
+                          UShort_t  sam, 
+                          UInt_t&   ddl,        UInt_t&   hwaddr, 
+                          UShort_t& timebin) const;
   /** Translate detector coordinates to hardware address 
       @param det      Detector # (1-3)
       @param ring     Ring ID ('I' or 'O')
index d575a5e..7cbc1ad 100644 (file)
@@ -65,7 +65,8 @@ AliFMDPattern::AliFMDPatternDetector::AliFMDPatternDetector(UShort_t id)
   : fId(id),
     fCounts(0), 
     fGraphs(0), 
-    fFrame(0)
+    fFrame(0), 
+    fInners(id == 1 ? 10 : 0)
 {
   // CTOR 
   // 
@@ -103,6 +104,44 @@ AliFMDPattern::AliFMDPatternDetector::DrawShape(TObjArray& a)
 
 //____________________________________________________________________
 void
+AliFMDPattern::AliFMDPatternDetector::CopyShapes(TObjArray& src, 
+                                                TObjArray& dest, 
+                                                Double_t ang, 
+                                                Double_t fx, 
+                                                Double_t fy)
+{
+  TIter     next(&src);
+  TGraph*   g = 0;
+  while ((g = static_cast<TGraph*>(next()))) { 
+    TGraph* gg = new TGraph(*g);
+    Double_t* x  = gg->GetX();
+    Double_t* y  = gg->GetY();
+    for (Int_t i = 0; i < gg->GetN(); i++) { 
+      Float_t xx = x[i] * TMath::Cos(ang) - y[i] * TMath::Sin(ang);
+      Float_t yy = x[i] * TMath::Sin(ang) + y[i] * TMath::Cos(ang);
+      gg->SetPoint(i, fx * xx, fy * yy);
+    }
+    gg->SetFillStyle(g->GetFillStyle());
+    gg->SetFillColor(g->GetFillColor());
+    gg->SetLineStyle(g->GetLineStyle());
+    gg->SetLineColor(g->GetLineColor());
+    gg->SetLineWidth(g->GetLineWidth());
+    gg->SetMarkerStyle(g->GetMarkerStyle());
+    gg->SetMarkerColor(g->GetMarkerColor());
+    gg->SetMarkerSize(g->GetMarkerSize());
+    TString name(g->GetName());
+    name.ReplaceAll("X", Form("%d",fId));
+    gg->SetName(name.Data());
+    TString title(g->GetTitle());
+    title.ReplaceAll("X", Form("%d",fId));
+    gg->SetTitle(title.Data());
+    dest.Add(gg);
+  }
+  dest.SetOwner();
+}
+
+//____________________________________________________________________
+void
 AliFMDPattern::AliFMDPatternDetector::Begin(Int_t      nlevel, 
                                            Double_t   r, 
                                            TObjArray& inners, 
@@ -130,8 +169,17 @@ AliFMDPattern::AliFMDPatternDetector::Begin(Int_t      nlevel,
     fFrame->SetStats(kFALSE);
     fFrame->Draw();
   }
-  DrawShape(inners);
-  if (fId != 1) DrawShape(outers);
+  Double_t ang = (fId == 1 ? -TMath::Pi() / 2 : 0);
+  Double_t fx  = (fId == 3 ? -1               : 1); // Flip around Y
+  Double_t fy  = (fId == 1 ?  1               : 1); // Flip around X
+  
+  CopyShapes(inners, fInners, ang, fx, fy);
+  DrawShape(fInners);
+  if (fId != 1) { 
+    CopyShapes(outers, fOuters, ang, fx, fy);
+    DrawShape(fOuters);
+  }
+
   for (Int_t i = 0; i < nlevel; i++) { 
     TGraph* g = new TGraph;
     Int_t idx = Int_t(Float_t(i) / nlevel * style->GetNumberOfColors());
@@ -268,7 +316,7 @@ AliFMDPattern::Init()
     TObjArray&       gs = (*r == 'I' ? fInners   : fOuters);
     Float_t&         mr = (*r == 'I' ? fInnerMax : fOuterMax);
     Int_t            nm = ring->GetNModules();
-    AliInfo(Form("Making %d modules for %c", nm, *r));
+    AliFMDDebug(1, ("Making %d modules for %c", nm, *r));
     for (Int_t m = 0; m < nm; m++) {
       Int_t          nv = vs.GetEntries();
       Double_t       a  = TMath::Pi() / 180 * (m * 2 + 1) * ring->GetTheta();
@@ -282,7 +330,8 @@ AliFMDPattern::Init()
        if (c == 0) { x0 = w.X(); y0 = w.Y(); }
        g->SetPoint(c, w.X(), w.Y());
       }
-      g->SetName(Form("FMDX%c_%02d", *r, m));
+      g->SetName(Form("FMDX%c_%02d%02d", *r, 2*m,2*m+1));
+      g->SetTitle(Form("FMDX%c, sectors %d and %d", *r, 2*m,2*m+1));
       g->SetPoint(nv, x0, y0);
       g->SetFillColor((*rs == 'I' ? 
                       (m % 2 == 0 ? 18 : 17) :
@@ -459,7 +508,7 @@ AliFMDPattern::AddMarker(UShort_t det, Char_t rng,
   geom->Detector2XYZ(det, rng, sec, str, x, y, z);
   // Make code-checker shut the f**k up 
   TRandom* rand = gRandom;
-  if (true) {
+  if (false) {
     AliFMDRing* r  = geom->GetRing(rng);
     Double_t    t  = .9 * r->GetTheta() / 2;
     Double_t    a  = rand->Uniform(-t,t) * TMath::Pi() / 180;
index 02974bc..d66e214 100644 (file)
@@ -83,7 +83,12 @@ public:
     /** Assignement operator 
        -- Not implemented */
     AliFMDPatternDetector& operator=(const AliFMDPatternDetector&);
-
+    void CopyShapes(TObjArray& input, TObjArray& own, 
+                   Double_t ang=0, Double_t fx=1, Double_t fy=1);
+    /** Our own cache of shapes */
+    TObjArray fInners;
+    /** Our own cache of shapes */
+    TObjArray fOuters;
   };
   
   
index 2ab013f..7edf312 100644 (file)
@@ -127,7 +127,8 @@ void AliFMDPedestalDA::FillChannels(AliFMDDigit* digit)
 void AliFMDPedestalDA::Analyse(UShort_t det, 
                               Char_t   ring, 
                               UShort_t sec, 
-                              UShort_t strip) {
+                              UShort_t strip) 
+{
 
   TH1S* hChannel       = GetChannel(det, ring, sec, strip);
   if(hChannel->GetEntries() == 0) {
index fba982b..bc4c142 100644 (file)
@@ -77,7 +77,8 @@ AliFMDRawReader::AliFMDRawReader(AliRawReader* reader, TTree* tree)
     fReader(reader), 
     fSampleRate(1),
     fData(0),
-    fNbytes(0)
+    fNbytes(0), 
+    fSeen()
 {
   // Default CTOR
 }
@@ -114,6 +115,9 @@ AliFMDRawReader::ReadAdcs(TClonesArray* array)
     AliError("No TClonesArray passed");
     return kFALSE;
   }
+  const UShort_t kUShortMax = (1 << 16) - 1;
+  fSeen.Reset(kUShortMax);
+  
   //  if (!fReader->ReadHeader()) {
   //    AliError("Couldn't read header");
   //    return kFALSE;
@@ -125,8 +129,8 @@ AliFMDRawReader::ReadAdcs(TClonesArray* array)
   input.SetShortDataHeader(!pars->HasCompleteHeader());
 
   UShort_t stripMin = 0;
-  UShort_t stripMax = 127;
-  UShort_t preSamp  = 14+5;
+  UShort_t stripMax = 0; // 127;
+  UShort_t preSamp  = 0; // 14+5;
   
   UInt_t ddl    = 0;
   UInt_t rate   = 0;
@@ -146,44 +150,56 @@ AliFMDRawReader::ReadAdcs(TClonesArray* array)
     }
 
     AliFMDDebug(5, ("Read channel 0x%x of size %d", hwaddr, last));
-    UShort_t det, sec, str;
-    Char_t   ring;
-    if (!pars->Hardware2Detector(ddl, hwaddr, det, ring, sec, str)) {
-      AliError(Form("Failed to get detector id from DDL %d "
-                   "and hardware address 0x%x", ddl, hwaddr));
-      continue;
-    }
+
     
-    rate     = pars->GetSampleRate(det, ring, sec, str);
-    stripMin = pars->GetMinStrip(det, ring, sec, str);
-    stripMax = pars->GetMaxStrip(det, ring, sec, str);
-    preSamp  = pars->GetPreSamples(det, ring, sec, str);
-    AliFMDDebug(5, ("DDL 0x%04x, address 0x%03x maps to FMD%d%c[%2d,%3d]", 
-                      ddl, hwaddr, det, ring, sec, str));
     
     // Loop over the `timebins', and make the digits
     for (size_t i = 0; i < last; i++) {
-      if (i < preSamp) continue;
-      Int_t    n      = array->GetEntriesFast();
-      Short_t  curStr = str + stripMin + (i-preSamp) / rate;
-      if ((curStr-str) > stripMax) {
-       // AliInfo(Form("timebin %4d -> (%3d+%3d+(%4d-%d)/%d) -> %d", 
-       //              i, str, stripMin, i, preSamp, rate, curStr));
-       // AliError(Form("Current strip is %3d (0x%04x,0x%03x,%4d) "
-       //               "but DB says max is %3d (rate=%d)", 
-       //               curStr, ddl, hwaddr, i, str+stripMax, rate));
-       // Garbage timebins - ignore 
+      // if (i < preSamp) continue;
+
+      UShort_t det, sec, samp;
+      Short_t str;
+      Char_t   ring;
+      if (!pars->Hardware2Detector(ddl, hwaddr, i, det, ring, sec, str, samp)) {
+       AliError(Form("Failed to get detector id from DDL %d, "
+                     "hardware address 0x%03x, timebin %d", ddl, hwaddr, i));
        continue;
       }
-      AliFMDDebug(5, ("making digit for FMD%d%c[%2d,%3d] from sample %4d", 
-                      det, ring, sec, curStr, i));
-      new ((*array)[n]) AliFMDDigit(det, ring, sec, curStr, data[i], 
-                                   (rate >= 2 ? data[i+1] : 0),
-                                   (rate >= 3 ? data[i+2] : 0),
-                                   (rate >= 4 ? data[i+3] : 0));
-      if (rate >= 2) i++;
-      if (rate >= 3) i++;
-      if (rate >= 4) i++;
+      AliFMDDebug(10, ("0x%04x/0x%03x/%04d maps to FMD%d%c[%2d,%3d]-%d", 
+                     ddl, hwaddr, i, det, ring, sec, str, samp));
+      if (str < 0) { 
+       AliFMDDebug(8, ("Got presamples at timebin %d", i));
+       continue;
+      }
+      
+      stripMin = pars->GetMinStrip(det, ring, sec, str);
+      stripMax = pars->GetMaxStrip(det, ring, sec, str);
+      preSamp  = pars->GetPreSamples(det, ring, sec, str);
+      rate     = pars->GetSampleRate(det, ring, sec, str);
+      Short_t lstrip = (i - preSamp) / rate + stripMin;
+      
+      AliFMDDebug(15, ("Checking if strip %d (%d) in range [%d,%d]", 
+                     lstrip, str, stripMin, stripMax));
+      if (lstrip < stripMin || lstrip > stripMax) {
+       AliFMDDebug(5, ("FMD%d%c[%02d,%03d]-%d out of range (%3d->%3d)", 
+                       det, ring, sec, samp, str, stripMin, stripMax));
+       continue;
+      }
+      
+      // Check the cache of indicies
+      Int_t idx = fSeen(det, ring, sec, str);
+      if (idx == kUShortMax) { 
+       // We haven't seen this strip yet. 
+       fSeen(det, ring, sec, str) = idx = array->GetEntriesFast();
+       AliFMDDebug(7,("making digit for FMD%d%c[%2d,%3d]-%d from timebin %4d", 
+                      det, ring, sec, str, samp, i));
+       new ((*array)[idx]) AliFMDDigit(det, ring, sec, str);
+      }
+      AliFMDDigit* digit = static_cast<AliFMDDigit*>(array->At(idx));
+      AliFMDDebug(10,
+                 ("Setting from FMD%d%c[%2d,%3d]-%d from timebin %4d = %4d", 
+                  det, ring, sec, str, samp, i, data[i]));
+      digit->SetCount(samp, data[i]);
     }
   }
   return kTRUE;
@@ -388,7 +404,8 @@ AliFMDRawReader::Exec(Option_t*)
 Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, 
                                     AliFMDCalibStripRange* stripRange, 
                                     TArrayS &pulseSize, 
-                                    TArrayS &pulseLength) {
+                                    TArrayS &pulseLength) 
+{
 
   AliFMDDebug(0, ("Start of SOD/EOD"));
   
@@ -398,6 +415,7 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate,
   UInt_t strip_high[18];
   UInt_t pulse_size[18];
   UInt_t pulse_length[18];  
+  AliFMDParameters* param = AliFMDParameters::Instance();
   
   while(fReader->ReadNextData(fData)) {
     
@@ -410,249 +428,251 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate,
     ULong_t nWords      = GetNwords();
     UInt_t  trailerLast = Get32bitWord(nWords);
     AliFMDDebug(20, (" # Bytes: %d, # Words: %d, Last word: 0x%08x", 
-                   fNbytes, nWords, trailerLast));
+                    fNbytes, nWords, trailerLast));
     if ((trailerLast & 0xFFFF0000) != 0xAAAA0000) {
       AliWarning(Form("Last word 0x%08x does not match RCU II trailer",
                      trailerLast));
       return kFALSE;
     }
     
-    ULong_t nTrailerWords = trailerLast & 0x7f; // 7 last bits is size of trailer
-    
+    // 7 last bits is size of trailer
+    ULong_t nTrailerWords = trailerLast & 0x7f; 
     ULong_t nPayloadWords = Get32bitWord(nWords - nTrailerWords+1);
+
     AliFMDDebug(20, (" # trailer words: %d, # payload words: %d", 
-                   nTrailerWords, nPayloadWords));
+                    nTrailerWords, nPayloadWords));
     
     
     for (ULong_t i = 1; i <= nPayloadWords ; i++) {
       UInt_t payloadWord = Get32bitWord(i);
       
-       // address is only 24 bit
-       UInt_t address       = (0xffffff & payloadWord);
-       UInt_t type          = ((address >> 21) & 0xf);
-       UInt_t error         = ((address >> 20) & 0x1);
-       UInt_t bcast         = ((address >> 18) & 0x1);
-       UInt_t bc_not_altro  = ((address >> 17) & 0x1);
-       UInt_t board         = ((address >> 12) & 0x1f);
-       UInt_t instruction   = 0;
-       UInt_t chip          = 0;
-       UInt_t channel       = 0;
-       if(bc_not_altro)
-         instruction        = address & 0xfff;
-       else {
-         chip               = ((address >> 9) & 0x7);
-         channel            = ((address >> 5) & 0x5);
-         instruction        = (address & 0x1f);
-       }
-       
-       Bool_t readDataWord = kFALSE;
-       switch(type) {
-       case 0x0: // Fec read
-         readDataWord = kTRUE;  
-       case 0x1: // Fec cmd
-       case 0x2: // Fec write
-         i++;  
-         break;
-       case 0x4: // Loop
-       case 0x5: // Wait
-         break;
-       case 0x6: // End sequence
-       case 0x7: // End Mem
-         i = nPayloadWords + 1;
-         break;
-       default:    
-         break;
-       }
-       
+      // address is only 24 bit
+      UInt_t address       = (0xffffff & payloadWord);
+      UInt_t type          = ((address >> 21) & 0xf);
+      UInt_t error         = ((address >> 20) & 0x1);
+      UInt_t bcast         = ((address >> 18) & 0x1);
+      UInt_t bc_not_altro  = ((address >> 17) & 0x1);
+      UInt_t board         = ((address >> 12) & 0x1f);
+      UInt_t instruction   = 0;
+      UInt_t chip          = 0;
+      UInt_t channel       = 0;
+      if(bc_not_altro)
+       instruction        = address & 0xfff;
+      else {
+       chip               = ((address >> 9) & 0x7);
+       channel            = ((address >> 5) & 0x5);
+       instruction        = (address & 0x1f);
+      }
        
+      Bool_t readDataWord = kFALSE;
+      switch(type) {
+      case 0x0: // Fec read
+       readDataWord = kTRUE;  
+      case 0x1: // Fec cmd
+      case 0x2: // Fec write
+       i++;  
+       break;
+      case 0x4: // Loop
+      case 0x5: // Wait
+       break;
+      case 0x6: // End sequence
+      case 0x7: // End Mem
+       i = nPayloadWords + 1;
+       break;
+      default:    
+       break;
+      }
        
-       if(!readDataWord)  //Don't read unless we have a FEC_RD
-         continue;
-       UInt_t dataWord      = Get32bitWord(i);
-       UInt_t data          = (0xFFFFF & dataWord) ;
-       //UInt_t data          = (0xFFFF & dataWord) ;
+      //Don't read unless we have a FEC_RD
+      if(!readDataWord)  continue;
+
+      UInt_t dataWord      = Get32bitWord(i);
+      UInt_t data          = (0xFFFFF & dataWord) ;
+      //UInt_t data          = (0xFFFF & dataWord) ;
        
-       if(error) {
-         AliWarning(Form("error bit detected at Word 0x%06x; "
-                         "error % d, type %d, bc_not_altro %d, "
-                         "bcast %d, board 0x%02x, chip 0x%x, "
-                         "channel 0x%02x, instruction 0x%03x",
-                         address, error, type, bc_not_altro, 
-                         bcast,board,chip,channel,instruction));
-         
-         
-         //process error
-         continue;
-       }
+      if(error) {
+       AliWarning(Form("error bit detected at Word 0x%06x; "
+                       "error % d, type %d, bc_not_altro %d, "
+                       "bcast %d, board 0x%02x, chip 0x%x, "
+                       "channel 0x%02x, instruction 0x%03x",
+                       address, error, type, bc_not_altro, 
+                       bcast,board,chip,channel,instruction));
+       //process error
+       continue;
+      }
        
        
-       switch(instruction) {
+      switch(instruction) {
          
-       case 0x01: break;  // First ADC T           
-       case 0x02: break; // I  3.3 V              
-       case 0x03: break; // I  2.5 V altro digital
-       case 0x04: break; // I  2.5 V altro analog 
-       case 0x05: break; // I  2.5 V VA           
-       case 0x06: break; // First ADC T           
-       case 0x07: break; // I  3.3 V              
-       case 0x08: break; // I  2.5 V altro digital
-       case 0x09: break; // I  2.5 V altro analog 
-       case 0x0A: break; // I  2.5 V VA           
-       case 0x2D: break; // Second ADC T           
-       case 0x2E: break; // I  1.5 V VA            
-       case 0x2F: break; // I -2.0 V               
-       case 0x30: break; // I -2.0 V VA            
-       case 0x31: break; //    2.5 V Digital driver
-       case 0x32: break; // Second ADC T           
-       case 0x33: break; // I  1.5 V VA            
-       case 0x34: break; // I -2.0 V               
-       case 0x35: break; // I -2.0 V VA            
-       case 0x36: break; //    2.5 V Digital driver
-       case 0x37: break; // Third ADC T             
-       case 0x38: break; // Temperature sens. 1     
-       case 0x39: break; // Temperature sens. 2     
-       case 0x3A: break; // U  2.5 altro digital (m)
-       case 0x3B: break; // U  2.5 altro analog (m) 
-       case 0x3C: break; // Third ADC T             
-       case 0x3D: break; // Temperature sens. 1     
-       case 0x3E: break; // Temperature sens. 2     
-       case 0x3F: break; // U  2.5 altro digital (m)
-       case 0x40: break; // U  2.5 altro analog (m) 
-       case 0x41: break; // Forth ADC T  
-       case 0x42: break; // U  2.5 VA (m)
-       case 0x43: break; // U  1.5 VA (m)
-       case 0x44: break; // U -2.0 VA (m)
-       case 0x45: break; // U -2.0 (m)   
-       case 0x46: break; // Forth ADC T  
-       case 0x47: break; // U  2.5 VA (m)
-       case 0x48: break; // U  1.5 VA (m)
-       case 0x49: break; // U -2.0 VA (m)
-       case 0x4A: break;  // U -2.0 (m)   
-         // Counters 
-       case 0x0B: break; // L1 trigger CouNTer
-       case 0x0C: break; // L2 trigger CouNTer
-       case 0x0D: break; // Sampling CLK CouNTer
-       case 0x0E: break; // DSTB CouNTer
-         // Test mode 
-       case 0x0F: break; // Test mode word
-       case 0x10: break; // Undersampling ratio.
-         // Configuration and status 
-       case 0x11: break; // Config/Status Register 0
-       case 0x12: break; // Config/Status Register 1
-       case 0x13: break; // Config/Status Register 2
-       case 0x14: break; // Config/Status Register 3
-       case 0x15: break; // Free
-     // Comands:
-       case 0x16: break; // Latch L1, L2, SCLK Counters
-       case 0x17: break; // Clear counters
-       case 0x18: break; // Clear CSR1
-       case 0x19: break; // rstb ALTROs
-       case 0x1A: break; // rstb BC
-       case 0x1B: break; // Start conversion
-       case 0x1C: break; // Scan event length
-       case 0x1D: break; // Read event length
-       case 0x1E: break; // Start test mode
-       case 0x1F: break; // Read acquisition memory
-         // FMD
-       case 0x20: break; // FMDD status
-       case 0x21: break; // L0 counters
-       case 0x22: break; // FMD: Wait to hold
-       case 0x23: break; // FMD: L1 timeout
-       case 0x24: break; // FMD: L2 timeout
-       case 0x25: // FMD: Shift clk 
-         shift_clk[board] = ((data >> 8 ) & 0xFF); 
-         break; 
-       case 0x26: // FMD: Strips 
-         strip_low[board]  = ((data >> 0 ) & 0xFF); 
-         strip_high[board] = ((data >> 8 ) & 0xFF);  
-         break; 
-       case 0x27: // FMD: Cal pulse 
-         pulse_size[board]  =  ((data >> 8 ) & 0xFF);
-         break; 
-       case 0x28: break; // FMD: Shape bias
-       case 0x29: break; // FMD: Shape ref
-       case 0x2A: break; // FMD: Preamp ref
-       case 0x2B: // FMD: Sample clk 
-         sample_clk[board] = ((data >> 8 ) & 0xFF); 
-         break; 
-       case 0x2C: break; // FMD: Commands
-       case 0x4B: // FMD: Cal events 
-         pulse_length[board] = ((data >> 0 ) & 0xFF);
-         break; 
-       default: break;
+      case 0x01: break;  // First ADC T           
+      case 0x02: break; // I  3.3 V              
+      case 0x03: break; // I  2.5 V altro digital
+      case 0x04: break; // I  2.5 V altro analog 
+      case 0x05: break; // I  2.5 V VA           
+      case 0x06: break; // First ADC T           
+      case 0x07: break; // I  3.3 V              
+      case 0x08: break; // I  2.5 V altro digital
+      case 0x09: break; // I  2.5 V altro analog 
+      case 0x0A: break; // I  2.5 V VA           
+      case 0x2D: break; // Second ADC T           
+      case 0x2E: break; // I  1.5 V VA            
+      case 0x2F: break; // I -2.0 V               
+      case 0x30: break; // I -2.0 V VA            
+      case 0x31: break; //    2.5 V Digital driver
+      case 0x32: break; // Second ADC T           
+      case 0x33: break; // I  1.5 V VA            
+      case 0x34: break; // I -2.0 V               
+      case 0x35: break; // I -2.0 V VA            
+      case 0x36: break; //    2.5 V Digital driver
+      case 0x37: break; // Third ADC T             
+      case 0x38: break; // Temperature sens. 1     
+      case 0x39: break; // Temperature sens. 2     
+      case 0x3A: break; // U  2.5 altro digital (m)
+      case 0x3B: break; // U  2.5 altro analog (m) 
+      case 0x3C: break; // Third ADC T             
+      case 0x3D: break; // Temperature sens. 1     
+      case 0x3E: break; // Temperature sens. 2     
+      case 0x3F: break; // U  2.5 altro digital (m)
+      case 0x40: break; // U  2.5 altro analog (m) 
+      case 0x41: break; // Forth ADC T  
+      case 0x42: break; // U  2.5 VA (m)
+      case 0x43: break; // U  1.5 VA (m)
+      case 0x44: break; // U -2.0 VA (m)
+      case 0x45: break; // U -2.0 (m)   
+      case 0x46: break; // Forth ADC T  
+      case 0x47: break; // U  2.5 VA (m)
+      case 0x48: break; // U  1.5 VA (m)
+      case 0x49: break; // U -2.0 VA (m)
+      case 0x4A: break;  // U -2.0 (m)   
+       // Counters 
+      case 0x0B: break; // L1 trigger CouNTer
+      case 0x0C: break; // L2 trigger CouNTer
+      case 0x0D: break; // Sampling CLK CouNTer
+      case 0x0E: break; // DSTB CouNTer
+       // Test mode 
+      case 0x0F: break; // Test mode word
+      case 0x10: break; // Undersampling ratio.
+       // Configuration and status 
+      case 0x11: break; // Config/Status Register 0
+      case 0x12: break; // Config/Status Register 1
+      case 0x13: break; // Config/Status Register 2
+      case 0x14: break; // Config/Status Register 3
+      case 0x15: break; // Free
+       // Comands:
+      case 0x16: break; // Latch L1, L2, SCLK Counters
+      case 0x17: break; // Clear counters
+      case 0x18: break; // Clear CSR1
+      case 0x19: break; // rstb ALTROs
+      case 0x1A: break; // rstb BC
+      case 0x1B: break; // Start conversion
+      case 0x1C: break; // Scan event length
+      case 0x1D: break; // Read event length
+      case 0x1E: break; // Start test mode
+      case 0x1F: break; // Read acquisition memory
+       // FMD
+      case 0x20: break; // FMDD status
+      case 0x21: break; // L0 counters
+      case 0x22: break; // FMD: Wait to hold
+      case 0x23: break; // FMD: L1 timeout
+      case 0x24: break; // FMD: L2 timeout
+      case 0x25: // FMD: Shift clk 
+       shift_clk[board] = ((data >> 8 ) & 0xFF); 
+       break; 
+      case 0x26: // FMD: Strips 
+       strip_low[board]  = ((data >> 0 ) & 0xFF); 
+       strip_high[board] = ((data >> 8 ) & 0xFF);  
+       break; 
+      case 0x27: // FMD: Cal pulse 
+       pulse_size[board]  =  ((data >> 8 ) & 0xFF);
+       break; 
+      case 0x28: break; // FMD: Shape bias
+      case 0x29: break; // FMD: Shape ref
+      case 0x2A: break; // FMD: Preamp ref
+      case 0x2B: // FMD: Sample clk 
+       sample_clk[board] = ((data >> 8 ) & 0xFF); 
+       break; 
+      case 0x2C: break; // FMD: Commands
+      case 0x4B: // FMD: Cal events 
+       pulse_length[board] = ((data >> 0 ) & 0xFF);
+       break; 
+      default: break;
        
-       }
-       AliFMDDebug(50, ("instruction 0x%x, dataword 0x%x",instruction,dataWord));
+      }
+      AliFMDDebug(50, ("instruction 0x%x, dataword 0x%x",
+                      instruction,dataWord));
     }
     
-    UShort_t det,sector,strip;
+    UShort_t det,sector;
+    Short_t strip;
     Char_t ring;
    
     const UInt_t boards[4] = {0,1,16,17};
     for(Int_t i=0;i<4;i++) {
-      if(ddl==0 && (i==1 || i==3))
-       continue;
+      if(ddl==0 && (i==1 || i==3)) continue;
+
       UInt_t chip =0, channel=0;
-      
-      AliFMDParameters::Instance()->Hardware2Detector(ddl,boards[i],chip,channel,det,ring,sector,strip);
+      param->Hardware2Detector(ddl,boards[i],chip,channel,
+                              det,ring,sector,strip);
      
       UInt_t samplerate = 1;
-      
       if(sample_clk[boards[i]] == 0) {
-         if(ddl == 0) {
-           Int_t sample1 = sample_clk[boards[0]];
-           Int_t sample2 = sample_clk[boards[2]];          
-           if(sample1) sample_clk[boards[i]] = sample1;
-           else sample_clk[boards[i]] = sample2;
-         }
-         
-         if(ddl!=0) {
-           Int_t sample1 = sample_clk[boards[0]];
-           Int_t sample2 = sample_clk[boards[1]];
-           Int_t sample3 = sample_clk[boards[2]];
-           Int_t sample4 = sample_clk[boards[3]];
-           Int_t agreement = 0;
-           if(sample1 == sample2) agreement++;
-           if(sample1 == sample3) agreement++;
-           if(sample1 == sample4) agreement++;
-           if(sample2 == sample3) agreement++;
-           if(sample2 == sample4) agreement++;
-           if(sample3 == sample4) agreement++;
+       if(ddl == 0) {
+         Int_t sample1 = sample_clk[boards[0]];
+         Int_t sample2 = sample_clk[boards[2]];            
+         if(sample1) sample_clk[boards[i]] = sample1;
+         else sample_clk[boards[i]] = sample2;
+       }
+       else {
+         Int_t sample1 = sample_clk[boards[0]];
+         Int_t sample2 = sample_clk[boards[1]];
+         Int_t sample3 = sample_clk[boards[2]];
+         Int_t sample4 = sample_clk[boards[3]];
+         Int_t agreement = 0;
+         if(sample1 == sample2) agreement++;
+         if(sample1 == sample3) agreement++;
+         if(sample1 == sample4) agreement++;
+         if(sample2 == sample3) agreement++;
+         if(sample2 == sample4) agreement++;
+         if(sample3 == sample4) agreement++;
            
-           Int_t idx = 0;
-           if(i<3) idx = i+1;
-           else  idx = i-1;
-           if(agreement == 3) {
-             sample_clk[boards[i]] = sample_clk[boards[idx]];
-             shift_clk[boards[i]] = shift_clk[boards[idx]];
-             strip_low[boards[i]] = strip_low[boards[idx]];
-             strip_high[boards[i]] = strip_high[boards[idx]];
-             pulse_length[boards[i]] = pulse_length[boards[idx]];
-             pulse_size[boards[i]] = pulse_size[boards[idx]];
-             AliFMDDebug(0, ("Vote taken for ddl %d, board 0x%x",ddl,boards[i]));
-           }
+         Int_t idx = 0;
+         if(i<3) idx = i+1;
+         else  idx = i-1;
+         if(agreement == 3) {
+           sample_clk[boards[i]] = sample_clk[boards[idx]];
+           shift_clk[boards[i]] = shift_clk[boards[idx]];
+           strip_low[boards[i]] = strip_low[boards[idx]];
+           strip_high[boards[i]] = strip_high[boards[idx]];
+           pulse_length[boards[i]] = pulse_length[boards[idx]];
+           pulse_size[boards[i]] = pulse_size[boards[idx]];
+           AliFMDDebug(0, ("Vote taken for ddl %d, board 0x%x",
+                           ddl,boards[i]));
          }
+       }
       } 
       
       if(sample_clk[boards[i]])
-      samplerate = shift_clk[boards[i]]/sample_clk[boards[i]];
+       samplerate = shift_clk[boards[i]]/sample_clk[boards[i]];
       sampleRate->Set(det,ring,sector,0,samplerate);
-      stripRange->Set(det,ring,sector,0,strip_low[boards[i]],strip_high[boards[i]]);
+      stripRange->Set(det,ring,sector,0,
+                     strip_low[boards[i]],strip_high[boards[i]]);
       
       AliFMDDebug(20, ("det %d, ring %c, ",det,ring));
-      pulseLength.AddAt(pulse_length[boards[i]],GetHalfringIndex(det,ring,boards[i]/16));
-      pulseSize.AddAt(pulse_size[boards[i]],GetHalfringIndex(det,ring,boards[i]/16));
+      pulseLength.AddAt(pulse_length[boards[i]],
+                       GetHalfringIndex(det,ring,boards[i]/16));
+      pulseSize.AddAt(pulse_size[boards[i]],
+                     GetHalfringIndex(det,ring,boards[i]/16));
       
       
       
       AliFMDDebug(20, (": Board: 0x%02x\n"
-                     "\tstrip_low  %3d, strip_high   %3d\n"
-                     "\tshift_clk  %3d, sample_clk   %3d\n"
-                     "\tpulse_size %3d, pulse_length %3d",
-                     boards[i], 
-                     strip_low[boards[i]], strip_high[boards[i]],
-                     shift_clk[boards[i]], sample_clk[boards[i]],
-                     pulse_size[boards[i]],pulse_length[boards[i]]));
+                      "\tstrip_low  %3d, strip_high   %3d\n"
+                      "\tshift_clk  %3d, sample_clk   %3d\n"
+                      "\tpulse_size %3d, pulse_length %3d",
+                      boards[i], 
+                      strip_low[boards[i]], strip_high[boards[i]],
+                      shift_clk[boards[i]], sample_clk[boards[i]],
+                      pulse_size[boards[i]],pulse_length[boards[i]]));
     }
     
   }
@@ -695,7 +715,8 @@ UInt_t AliFMDRawReader::Get32bitWord(Int_t idx)
   return word;
 }
 //_____________________________________________________________________ 
-Int_t AliFMDRawReader::GetHalfringIndex(UShort_t det, Char_t ring, UShort_t board) {
+Int_t AliFMDRawReader::GetHalfringIndex(UShort_t det, Char_t ring, 
+                                       UShort_t board) {
 
   UShort_t iring  =  (ring == 'I' ? 1 : 0);
   
index af94f8b..1595bae 100644 (file)
@@ -23,6 +23,7 @@
 #ifndef ROOT_TTask
 # include <TTask.h>
 #endif
+#include "AliFMDUShortMap.h"
 
 //____________________________________________________________________
 class AliRawReader;
@@ -73,17 +74,19 @@ protected:
       fReader(0), 
       fSampleRate(0),
       fData(0),
-      fNbytes(0)
+      fNbytes(0), 
+      fSeen()
   {}
   AliFMDRawReader& operator=(const AliFMDRawReader&) { return *this; }
   ULong_t GetNwords() const {return fNbytes / 4;}
   UInt_t Get32bitWord(Int_t idx);
   Int_t GetHalfringIndex(UShort_t det, Char_t ring, UShort_t board);
-  TTree*        fTree;       //! Pointer to tree to read into 
-  AliRawReader* fReader;     //! Pointer to raw reader 
-  UShort_t      fSampleRate; // The sample rate (if 0, inferred from data)
-  UChar_t* fData; 
-  ULong_t  fNbytes; 
+  TTree*          fTree;       //! Pointer to tree to read into 
+  AliRawReader*   fReader;     //! Pointer to raw reader 
+  UShort_t        fSampleRate; // The sample rate (if 0, inferred from data)
+  UChar_t*        fData; 
+  ULong_t        fNbytes; 
+  AliFMDUShortMap fSeen;
   
   ClassDef(AliFMDRawReader, 0) // Read FMD raw data into a cache 
 };
index e91daab..af05dd4 100644 (file)
@@ -178,9 +178,7 @@ AliFMDRawWriter::WriteDigits(TClonesArray* digits)
   // Which channel number in the ALTRO channel we're at 
   UShort_t nWords       = 0;
   UShort_t preSamples   = 0;
-  
-  // How many times the ALTRO Samples one VA1_ALICE channel 
-  Int_t sampleRate      = 1;
+  UShort_t sampleRate   = 0;
   
   // A buffer to hold 1 ALTRO channel - Normally, one ALTRO channel
   // holds 128 VA1_ALICE channels, sampled at a rate of `sampleRate' 
@@ -188,7 +186,10 @@ AliFMDRawWriter::WriteDigits(TClonesArray* digits)
 
   // The Altro buffer 
   AliAltroBuffer* altro = 0;
-    
+  
+  Int_t totalWords = 0;
+  Int_t nCounts    = 0;
+  
   // Loop over the digits in the event.  Note, that we assume the
   // the digits are in order in the branch.   If they were not, we'd
   // have to cache all channels before we could write the data to
@@ -203,67 +204,81 @@ AliFMDRawWriter::WriteDigits(TClonesArray* digits)
     UShort_t strip  = digit->Strip();
     UInt_t   ddl;
     UInt_t   addr;  
+    UShort_t time;
+
+    AliFMDDebug(10, ("Processing digit # %5d FMD%d%c[%2d,%3d]", 
+                   i, det, ring, sector, strip));
+    threshold  = pars->GetZeroSuppression(det, ring, sector, strip);
+    sampleRate = pars->GetSampleRate(det, ring, sector, strip);
+    preSamples = pars->GetPreSamples(det, ring, sector, strip);
+
     if (det != oldDet) {
       AliFMDDebug(5, ("Got new detector: %d (was %d)", det, oldDet));
       oldDet = det;
     }
-    AliFMDDebug(10, ("Processing digit # %5d FMD%d%c[%2d,%3d]", 
-                   i, det, ring, sector, strip));
-    threshold       = pars->GetZeroSuppression(det, ring, sector, strip);
-    if (!pars->Detector2Hardware(det, ring, sector, strip, ddl, addr)) {
-      AliError(Form("Failed to get hardware address for FMD%d%c[%2d,%3d]", 
-                   det, ring, sector, strip));
-      continue;
-    }
-    preSamples = pars->GetPreSamples(det, ring, sector, strip);
+    AliFMDDebug(10, ("Sample rate is %d", sampleRate));
     
-    AliFMDDebug(10, ("FMD%d%c[%2d,%3d]-> ddl: 0x%x addr: 0x%x", 
-                   det, ring, sector, strip, ddl, addr));
-    if (addr != prevaddr) {
-      // Flush a channel to output 
-      AliFMDDebug(15, ("Now hardware address 0x%x from FMD%d%c[%2d,%3d] "
-                      "(board 0x%x, chip 0x%x, channel 0x%x), flushing old "
-                      "channel at 0x%x with %d words", 
-                      addr, det, ring, sector, strip, 
-                      (addr >> 7), (addr >> 4) & 0x7, addr & 0xf, 
-                      prevaddr, nWords));
-      if (altro) altro->WriteChannel(prevaddr,nWords,data.fArray,threshold);
-      nWords   = preSamples;
-      prevaddr = addr;
-      for (size_t j = 0; j < nWords; j++) data[j] = digit->Count(0);
-    }
-    if (ddl != prevddl) {
-      AliFMDDebug(5, ("FMD: New DDL, was %d, now %d", prevddl, ddl));
-      // If an altro exists, delete the object, flushing the data to
-      // disk, and closing the file. 
-      if (altro) { 
-       // When the first argument is false, we write the real
-       // header. 
-       AliFMDDebug(15, ("Closing output"));
-       altro->Flush();
-       altro->WriteDataHeader(kFALSE, kFALSE);
-       delete altro;
-       altro = 0;
+    for (UShort_t j = 0; j < sampleRate; j++) { 
+      if (!pars->Detector2Hardware(det,ring,sector,strip,j,ddl,addr,time)){
+       AliError(Form("Failed to get hardware address for FMD%d%c[%2d,%3d]-%d", 
+                     det, ring, sector, strip, j));
+       continue;
       }
-      prevddl = ddl;
-      // Need to open a new DDL! 
-      TString filename(AliDAQ::DdlFileName(fFMD->GetName(),  ddl));
-      AliFMDDebug(5, ("New altro buffer with DDL file %s", filename.Data()));
-      // Create a new altro buffer - a `1' as the second argument
-      // means `write mode' 
-      altro = new AliAltroBuffer(filename.Data());
-      altro->SetMapping(pars->GetAltroMap());      
-      // Write a dummy (first argument is true) header to the DDL
-      // file - later on, when we close the file, we write the real
-      // header
-      altro->WriteDataHeader(kTRUE, kFALSE);
-    }
     
-    // Store the counts of the ADC in the channel buffer 
-    sampleRate = pars->GetSampleRate(det, ring, sector, strip);
-    for (int s = 0; s < sampleRate; s++) {
-      data[nWords] = digit->Count(s);
+      AliFMDDebug(10, ("FMD%d%c[%2d,%3d]-%d-> 0x%x/0x%x/%04d", 
+                      det, ring, sector, strip, j, ddl, addr, time));
+      if (addr != prevaddr) {
+       // Flush a channel to output 
+       AliFMDDebug(5, ("Now hardware address 0x%x from FMD%d%c[%2d,%3d]-%d"
+                        "(b: 0x%02x, a: 0x%01x, c: 0x%02x, t: %04d), "
+                        "flushing old channel at 0x%x with %d words", 
+                        addr, det, ring, sector, strip, j,
+                        (addr >> 7), (addr >> 4) & 0x7, addr & 0xf, 
+                        time, prevaddr, nWords));
+       totalWords += nWords;
+       if (altro) altro->WriteChannel(prevaddr,nWords,data.fArray,threshold);
+       nWords   = 0;
+       prevaddr = addr;
+      }
+      if (ddl != prevddl) {
+       AliFMDDebug(10, ("FMD: New DDL, was %d, now %d", prevddl, ddl));
+       // If an altro exists, delete the object, flushing the data to
+       // disk, and closing the file. 
+       if (altro) { 
+         // When the first argument is false, we write the real
+         // header. 
+         AliFMDDebug(15, ("Closing output"));
+         altro->Flush();
+         altro->WriteDataHeader(kFALSE, kFALSE);
+         delete altro;
+         altro = 0;
+       }
+       prevddl = ddl;
+       // Need to open a new DDL! 
+       TString filename(AliDAQ::DdlFileName(fFMD->GetName(),  ddl));
+       AliFMDDebug(5, ("New altro buffer with DDL file %s", filename.Data()));
+       // Create a new altro buffer - a `1' as the second argument
+       // means `write mode' 
+       altro = new AliAltroBuffer(filename.Data());
+       altro->SetMapping(pars->GetAltroMap());      
+       // Write a dummy (first argument is true) header to the DDL
+       // file - later on, when we close the file, we write the real
+       // header
+       altro->WriteDataHeader(kTRUE, kFALSE);
+      }
+    
+      // Store the counts of the ADC in the channel buffer 
+      AliFMDDebug(6, ("Storing FMD%d%c[%02d,%03d]-%d in timebin %d (%d)",
+                     det, ring, sector, strip, j, time, preSamples));
+      UShort_t count = digit->Count(j);
+      data[time] = count;
       nWords++;
+      nCounts++;
+      if (time == preSamples) {
+       AliFMDDebug(5, ("Filling in %4d for %d presamples", count, preSamples));
+       for (int k = 0; k < preSamples; k++) data[k] = count;
+       nWords += preSamples;
+      }
     }
   }
   // Finally, we need to close the final ALTRO buffer if it wasn't
@@ -274,6 +289,8 @@ AliFMDRawWriter::WriteDigits(TClonesArray* digits)
     altro->WriteDataHeader(kFALSE, kFALSE);
     delete altro;
   }
+  AliFMDDebug(5, ("Wrote a total of %d words for %d counts", 
+                 nWords, nCounts));
 }
 #else
 //____________________________________________________________________
index f0f2fc5..27e5fea 100644 (file)
@@ -24,7 +24,6 @@
 #ifndef ALIRECONSTRUCTOR_H
 # include <AliReconstructor.h>
 #endif
-
 #include "AliLog.h"
 
 //____________________________________________________________________
index c6e0a34..a1a051b 100644 (file)
@@ -36,6 +36,8 @@ Reconstruct()
   AliMagF* mag = static_cast<AliMagF*>(magF->Get("mag"));
   if (!mag) return;
   AliTracker::SetFieldMap(mag, true);
+  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+  AliCDBManager::Instance()->SetRun(0);
 
   AliReconstruction rec;   
   rec.SetRunLocalReconstruction("FMD");
@@ -43,7 +45,8 @@ Reconstruct()
   rec.SetRunReconstruction("FMD");
   rec.SetRunTracking(""); 
   rec.SetFillESD("FMD"); 
-  rec.SetInput("./");
+  rec.SetRunQA("");
+  rec.SetInput(".");
   // rec.SetRecoParam("TOF", new AliTOFRecoParam());
   
   rec.Run(); 
index 67a2060..885bd35 100644 (file)
@@ -10,7 +10,7 @@
 void
 PatternRaw(const char* file="raw.root")
 {
-  AliLog::SetModuleDebugLevel("FMD", 3);
+  AliLog::SetModuleDebugLevel("FMD", 0);
   AliCDBManager* cdb = AliCDBManager::Instance();
   cdb->SetDefaultStorage("local://$ALICE_ROOT");
   cdb->SetRun(0);
index 85e7b3c..23722e7 100644 (file)
@@ -7,19 +7,29 @@
 /** @defgroup ALTRO_test ALTRO test
     @ingroup FMD_script 
 */
+#ifndef __CINT__
+# include <TString.h>
+// # include <FMD/AliFMDParameters.h>
+# include <FMD/AliFMDAltroMapping.h>
+// # include <FMD/AliFMDUShortMap.h>
+// # include <FMD/AliFMDBoolMap.h>
+# include <TError.h>
+# include <iostream>
+#endif
+#define SHOW_ALL 1
 //____________________________________________________________________
 /** @ingroup ALTRO_test
     @param ddl 
     @param hwaddr 
     @return  */
-Char_t* 
-Addr2Str(UInt_t ddl, UInt_t hwaddr)
+const Char_t* 
+Addr2Str(UInt_t ddl, UInt_t hwaddr, UShort_t timebin)
 {
   static TString s;
   UInt_t board = (hwaddr >> 7) & 0x1F;
   UInt_t chip  = (hwaddr >> 4) & 0x7;
   UInt_t chan  = hwaddr & 0xF;
-  s = Form("(0x%05X,0x%02X,0x%1X,0x%1X)", ddl, board, chip, chan);
+  s = Form("(0x%05X,0x%02X,0x%1X,0x%1X,%04d)", ddl, board, chip, chan, timebin);
   return s.Data();
 }
 
@@ -30,11 +40,11 @@ Addr2Str(UInt_t ddl, UInt_t hwaddr)
     @param sec 
     @param str 
     @return  */
-Char_t* 
-Det2Str(UShort_t det, Char_t ring, UShort_t sec, UShort_t str)
+const Char_t* 
+Det2Str(UShort_t det, Char_t ring, UShort_t sec, UShort_t str, UShort_t sam)
 {
   static TString s;
-  s = Form("FMD%d%c[%2d,%3d]", det, ring, sec, str);
+  s = Form("FMD%d%c[%2d,%3d]-%d", det, ring, sec, str, sam);
   return s.Data();
 }
 
@@ -52,14 +62,15 @@ Det2Str(UShort_t det, Char_t ring, UShort_t sec, UShort_t str)
     @param ostr 
 */
 void 
-PrintTrans(UShort_t det, Char_t ring, UShort_t sec, UShort_t str, 
-          UInt_t ddl, UInt_t hwaddr,
-          UShort_t odet, Char_t oring, UShort_t osec, UShort_t ostr)
+PrintTrans(UShort_t det, Char_t ring, UShort_t sec, Short_t str, UShort_t sam,
+          UInt_t ddl, UInt_t hwaddr, UShort_t timebin,
+          UShort_t odet, Char_t oring, UShort_t osec, Short_t ostr, 
+          UShort_t osam)
 {
   static TString s1, s2, s3;
-  s1 = Det2Str(det, ring, sec, str);
-  s2 = Addr2Str(ddl,hwaddr);
-  s3 = Det2Str(odet, oring, osec, ostr);
+  s1 = Det2Str(det, ring, sec, str, sam);
+  s2 = Addr2Str(ddl,hwaddr,timebin);
+  s3 = Det2Str(odet, oring, osec, ostr, osam);
   Info("TestHWMap","%s -> %s -> %s", s1.Data(), s2.Data(), s3.Data());
 }
 
@@ -75,17 +86,38 @@ PrintTrans(UShort_t det, Char_t ring, UShort_t sec, UShort_t str,
     @param ostr 
 */
 void
-CheckTrans(UShort_t det, Char_t ring, UShort_t sec, UShort_t str, 
-          UShort_t odet, Char_t oring, UShort_t osec, UShort_t ostr)
+CheckTrans(UShort_t det, Char_t ring, UShort_t sec, UShort_t str, UShort_t sam,
+          UInt_t ddl, UInt_t hwaddr, UShort_t timebin,
+          UShort_t odet, Char_t oring, UShort_t osec, UShort_t ostr,
+          UShort_t osam)
 {
-  if (det != odet) 
+  bool ok = true;
+  if (det != odet) {
     Warning("TestHWMap", "Detector # differ %d != %d", det, odet);
-  if (ring != oring) 
+    ok = false;
+  }
+  if (ring != oring) {
     Warning("TestHWMap", "Ring Id differ %c != %c", ring, oring);  
-  if (sec != osec) 
+    ok = false;
+  }
+  if (sec != osec) {
     Warning("TestHWMap", "Sector # differ %d != %d", sec, osec);
-  if (str != ostr) 
+    ok = false;
+  }
+  if (str != ostr) { 
+    ok = false;
     Warning("TestHWMap", "Strip # differ %d != %d", str, ostr);
+  }
+  if (sam != osam) { 
+    ok = false;
+    Warning("TestHWMap", "Sample # differ %d != %d", sam, osam);
+  }
+#ifndef SHOW_ALL
+  if (!ok) 
+    PrintTrans(det,ring,sec,str,sam,
+              ddl,hwaddr,timebin,
+              odet,oring,osec,ostr,osam);
+#endif
 }
 
 //____________________________________________________________________
@@ -96,31 +128,47 @@ TestAltroMapping(Int_t min=2, Int_t max=0)
 {
   // if (min < 1 || min > 3) min = 1;
   if (max < min)          max = min;
-  AliFMDParameters* param = AliFMDParameters::Instance();
+  // AliFMDParameters* param = AliFMDParameters::Instance();
   AliFMDAltroMapping m;
-  
+  UShort_t presamp  = 0;
+  UShort_t oversamp = 4;
+
   for (UShort_t det = min; det <= max; det++) {
     for (UShort_t rng = 0; rng < 2; rng++) {
       Char_t ring = (rng == 0 ? 'I' : 'O');
       Int_t  nsec = (ring == 'I' ?  20 :  40);
       Int_t  nstr = (ring == 'I' ? 512 : 256);
       for (UShort_t sec = 0; sec < nsec; sec++) {
-       for (UShort_t str = 0; str < nstr; str += 128) {
-         UInt_t ddl, hwaddr;
-         if (!m.Detector2Hardware(det, ring, sec, str, ddl, hwaddr)) {
-           Warning("TestHWMap", "detector to hardware failed on %s", 
-                   Det2Str(det, ring, sec, str));
-           continue;
-         }
-         UShort_t odet, osec, ostr;
-         Char_t   oring;
-         if (!m.Hardware2Detector(ddl, hwaddr, odet, oring, osec, ostr)){
-           Warning("TestHWMap", "hardware to detector failed on %s", 
-                   Addr2Str(ddl, hwaddr));
-           continue;
+       for (Short_t str = 0; str < nstr; str ++ /*= 128*/) {
+         for(UShort_t sam = 0; sam < oversamp; sam++) {
+           UInt_t ddl, hwaddr;
+           UShort_t timebin;
+           if (!m.Detector2Hardware(det, ring, sec, str, sam, 
+                                    presamp, oversamp, 
+                                    ddl, hwaddr, timebin)) {
+             Warning("TestHWMap", "detector to hardware failed on %s", 
+                     Det2Str(det, ring, sec, str, sam));
+             continue;
+           }
+           UShort_t odet, osec, osam;
+           Short_t ostr;
+           Char_t   oring;
+           if (!m.Hardware2Detector(ddl, hwaddr, timebin, 
+                                    presamp, oversamp, 
+                                    odet, oring, osec, ostr, osam)){
+             Warning("TestHWMap", "hardware to detector failed on %s", 
+                     Addr2Str(ddl, hwaddr, timebin));
+             continue;
+           }
+#ifdef SHOW_ALL
+           PrintTrans(det,ring,sec,str,sam,
+                      ddl,hwaddr,timebin,
+                      odet,oring,osec,ostr,osam);
+#endif
+           CheckTrans(det,ring,sec,str,sam,
+                      ddl,hwaddr,timebin,
+                      odet,oring,osec,ostr,osam);
          }
-         PrintTrans(det,ring,sec,str,ddl,hwaddr,odet,oring,osec,ostr);
-         CheckTrans(det,ring,sec,str,odet,oring,osec,ostr);
        }// Loop over strips
       } // Loop over sectors
     } // Loop over rings