FMD/AliFMDRawWriter.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15 /* $Id$ */
  16 /** @file    AliFMDRawWriter.cxx
  17     @author  Christian Holm Christensen <cholm@nbi.dk>
  18     @date    Mon Mar 27 12:45:56 2006
  19     @brief   Class to write raw data
  20 */
  21 //____________________________________________________________________
  22 //
  23 // Class to write ADC values to a raw data file
  24 //
  25 // This class writes FMD Raw data to a file.   The sample rate (number
  26 // of times the ALTRO ADC samples each pre-amp. channel - that is,
  27 // data from a single strip), can be set via SetSampleRate.
  28 //
  29 // Zero-suppression can be enabled by calling SetThreshold with a
  30 // non-zero argument.   ADC values less than the value set will not be
  31 // written to output.   Note, that if you use zero-suppression, you
  32 // need to explicitly set the sample rate when reading back the data
  33 // with AliFMDRawReader.
  34 //
  35 // This class uses the AliAltroBuffer class to write the data in the
  36 // ALTRO format.  See the Exec member function for more information on
  37 // that format.
  38 //
  39 #include <AliLog.h>             // ALILOG_H
  40 #include <AliLoader.h>          // ALILOADER_H
  41 #include <AliAltroBuffer.h>     // ALIALTROBUFFER_H
  42 #include "AliFMD.h"             // ALIFMD_H
  43 #include "AliFMDParameters.h"   // ALIFMDPARAMETERS_H
  44 #include "AliFMDDigit.h"        // ALIFMDDIGIT_H
  45 #include "AliFMDRawWriter.h"    // ALIFMDRAWREADER_H
  46 #include "AliFMDAltroMapping.h" // ALIFMDALTROMAPPING_H
  47 // #include "AliFMDAltroIO.h"   // ALIFMDALTROWRITER_H
  48 #include <TArrayI.h>            // ROOT_TArrayI
  49 #include <TClonesArray.h>       // ROOT_TClonesArray
  50 // #include <fstream>
  51
  52 //____________________________________________________________________
  53 ClassImp(AliFMDRawWriter)
  54 #if 0
  55   ; // This is here to keep Emacs for indenting the next line
  56 #endif
  57
  58 //____________________________________________________________________
  59 AliFMDRawWriter::AliFMDRawWriter(AliFMD* fmd)
  60   : TTask("FMDRawWriter", "Writer of Raw ADC values from the FMD"),
  61     fFMD(fmd)
  62 {
  63   // CTOR
  64 }
  65
  66
  67
  68 //____________________________________________________________________
  69 void
  70 AliFMDRawWriter::Exec(Option_t*)
  71 {
  72   // Turn digits into raw data.
  73   //
  74   // Digits are read from the Digit branch, and processed to make
  75   // three DDL files, one for each of the sub-detectors FMD1, FMD2,
  76   // and FMD3.
  77   //
  78   // The raw data files consists of a header, followed by ALTRO
  79   // formatted blocks.
  80   //
  81   //          +-------------+
  82   //          | Header      |
  83   //          +-------------+
  84   //          | ALTRO Block |
  85   //          | ...         |
  86   //          +-------------+
  87   //          DDL file
  88   //
  89   // An ALTRO formatted block, in the FMD context, consists of a
  90   // number of counts followed by a trailer.
  91   //
  92   //          +------------------+
  93   //          | Count            |
  94   //          | ...              |
  95   //          | possible fillers |
  96   //          +------------------+
  97   //          | Trailer          |
  98   //          +------------------+
  99   //          ALTRO block
 100   //
 101   // The counts are listed backwards, that is, starting with the
 102   // latest count, and ending in the first.
 103   //
 104   // Each count consist of 1 or more ADC samples of the VA1_ALICE
 105   // pre-amp. signal.  Just how many samples are used depends on
 106   // whether the ALTRO over samples the pre-amp.  Each sample is a
 107   // 10-bit word, and the samples are grouped into 40-bit blocks
 108   //
 109   //          +------------------------------------+
 110   //          |  S(1)   | S(2)   | S(3)   | S(4)   |
 111   //          |  ...    | ...    | ...    | ...    |
 112   //          |  S(n)   | T(n)   | n+2    | 2AA    |
 113   //          +------------------------------------+
 114   //          Counts + possible filler
 115   //
 116   // The trailer of the number of words of signales, the starting
 117   // strip number, the sector number, and the ring ID; each 10-bit
 118   // words,  packed into 40-bits.
 119   //
 120   //          +------------------------------------+
 121   //          |   2AAA   |  Len   |  A |  Address  |
 122   //          +------------------------------------+
 123   //          Trailer
 124   //
 125   // Note, that this method assumes that the digits are ordered.
 126   //
 127   AliLoader* loader = fFMD->GetLoader();
 128   loader->LoadDigits();
 129   TTree* digitTree = loader->TreeD();
 130   if (!digitTree) {
 131     Error("Digits2Raw", "no digit tree");
 132     return;
 133   }
 134
 135   TClonesArray* digits = new TClonesArray("AliFMDDigit", 1000);
 136   fFMD->SetTreeAddress();
 137   TBranch* digitBranch = digitTree->GetBranch(fFMD->GetName());
 138   if (!digitBranch) {
 139     Error("Digits2Raw", "no branch for %s", fFMD->GetName());
 140     return;
 141   }
 142   digitBranch->SetAddress(&digits);
 143
 144   Int_t nEvents = Int_t(digitTree->GetEntries());
 145   for (Int_t event = 0; event < nEvents; event++) {
 146     fFMD->ResetDigits();
 147     digitTree->GetEvent(event);
 148
 149     // Write out the digits
 150     WriteDigits(digits);
 151   }
 152   loader->UnloadDigits();
 153 }
 154
 155 #if 1
 156 //____________________________________________________________________
 157 void
 158 AliFMDRawWriter::WriteDigits(TClonesArray* digits)
 159 {
 160   // WRite an array of digits to disk file
 161   Int_t nDigits = digits->GetEntries();
 162   if (nDigits < 1) return;
 163
 164   AliFMDParameters* pars = AliFMDParameters::Instance();
 165   UShort_t threshold    = 0;
 166   UInt_t   prevddl      = 0;
 167   UInt_t   prevaddr     = 0xFFF;
 168   // UShort_t prevStrip    = 0;
 169
 170   // Which channel number in the ALTRO channel we're at
 171   UShort_t nWords       = 0;
 172   UShort_t preSamples   = 0;
 173
 174   // How many times the ALTRO Samples one VA1_ALICE channel
 175   Int_t sampleRate      = 1;
 176
 177   // A buffer to hold 1 ALTRO channel - Normally, one ALTRO channel
 178   // holds 128 VA1_ALICE channels, sampled at a rate of `sampleRate'
 179   TArrayI data(pars->GetChannelsPerAltro() * 8);
 180
 181   // The Altro buffer
 182   AliAltroBuffer* altro = 0;
 183
 184   // Loop over the digits in the event.  Note, that we assume the
 185   // the digits are in order in the branch.   If they were not, we'd
 186   // have to cache all channels before we could write the data to
 187   // the ALTRO buffer, or we'd have to set up a map of the digits.
 188   for (Int_t i = 0; i < nDigits; i++) {
 189     // Get the digit
 190     AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
 191
 192     UShort_t det    = digit->Detector();
 193     Char_t   ring   = digit->Ring();
 194     UShort_t sector = digit->Sector();
 195     UShort_t strip  = digit->Strip();
 196     UInt_t   ddl;
 197     UInt_t   addr;
 198     threshold       = pars->GetZeroSuppression(det, ring, sector, strip);
 199     if (!pars->Detector2Hardware(det, ring, sector, strip, ddl, addr)) {
 200       AliError(Form("Failed to get hardware address for FMD%d%c[%2d,%3d]",
 201                     det, ring, sector, strip));
 202       continue;
 203     }
 204     if (addr != prevaddr) {
 205       // Flush a channel to output
 206       AliDebug(15, Form("Now hardware address 0x%x from FMD%d%c[%2d,%3d] "
 207                         "(board 0x%x, chip 0x%x, channel 0x%x), flushing old "
 208                         "channel at 0x%x with %d words",
 209                         addr, det, ring, sector, strip,
 210                         (addr >> 7), (addr >> 4) & 0x7, addr & 0xf,
 211                         prevaddr, nWords));
 212       if (altro) altro->WriteChannel(prevaddr,nWords,data.fArray,threshold);
 213       nWords   = preSamples;
 214       prevaddr = addr;
 215       for (size_t i = 0; i < nWords; i++) data[i] = digit->Count(0);
 216     }
 217     if (ddl != prevddl) {
 218       AliDebug(15, Form("FMD: New DDL, was %d, now %d", prevddl, ddl));
 219       // If an altro exists, delete the object, flushing the data to
 220       // disk, and closing the file.
 221       if (altro) {
 222         // When the first argument is false, we write the real
 223         // header.
 224         AliDebug(15, Form("Closing output"));
 225         altro->Flush();
 226         altro->WriteDataHeader(kFALSE, kFALSE);
 227         delete altro;
 228         altro = 0;
 229       }
 230       prevddl = ddl;
 231       // Need to open a new DDL!
 232       TString filename(Form("%s_%d.ddl", fFMD->GetName(),  ddl));
 233       AliDebug(15, Form("New altro buffer with DDL file %s", filename.Data()));
 234       // Create a new altro buffer - a `1' as the second argument
 235       // means `write mode'
 236       altro = new AliAltroBuffer(filename.Data());
 237       altro->SetMapping(pars->GetAltroMap());
 238       // Write a dummy (first argument is true) header to the DDL
 239       // file - later on, when we close the file, we write the real
 240       // header
 241       altro->WriteDataHeader(kTRUE, kFALSE);
 242     }
 243
 244     // Store the counts of the ADC in the channel buffer
 245     sampleRate = pars->GetSampleRate(det, ring, sector, strip);
 246     for (int s = 0; s < sampleRate; s++) {
 247       data[nWords] = digit->Count(s);
 248       nWords++;
 249     }
 250   }
 251   // Finally, we need to close the final ALTRO buffer if it wasn't
 252   // already
 253   if (altro) {
 254     if (nWords > 0) altro->WriteChannel(prevaddr,nWords,data.fArray,threshold);
 255     altro->Flush();
 256     altro->WriteDataHeader(kFALSE, kFALSE);
 257     delete altro;
 258   }
 259 }
 260 #else
 261 //____________________________________________________________________
 262 void
 263 AliFMDRawWriter::WriteDigits(TClonesArray* digits)
 264 {
 265   Int_t nDigits = digits->GetEntries();
 266   if (nDigits < 1) return;
 267
 268   AliFMDParameters*  pars    = AliFMDParameters::Instance();
 269   AliFMDAltroWriter* writer  = 0;
 270   Int_t          sampleRate  = -1;
 271   UShort_t       hwaddr      = 0;
 272   UShort_t       ddl         = 0;
 273   std::ofstream* file        = 0;
 274   Int_t          ret         = 0;
 275   for (Int_t i = 0; i < nDigits; i++) {
 276     // Get the digit
 277     AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
 278     UInt_t   thisDDL, thisHwaddr;
 279     UShort_t det    = digit->Detector();
 280     Char_t   ring   = digit->Ring();
 281     UShort_t sector = digit->Sector();
 282     UShort_t strip  = digit->Strip();
 283     if (!pars->Detector2Hardware(det,ring,sector,strip,thisDDL,thisHwaddr)) {
 284       AliError(Form("Failed to get hardware address for FMD%d%c[%2d,%3d]",
 285                     det, ring, sector, strip));
 286       continue;
 287     }
 288     AliDebug(40, Form("Got DDL=%d and address=%d from FMD%d%c[%2d,%3d]",
 289                      thisDDL, thisHwaddr, det, ring, sector, strip));
 290     // Check if we're still in the same channel
 291     if (thisHwaddr != hwaddr) {
 292       AliDebug(30, Form("Now hardware address 0x%x from FMD%d%c[%2d,%3d] "
 293                        "(board 0x%x, chip 0x%x, channel 0x%x)",
 294                        thisHwaddr, det, ring, sector, strip,
 295                        (thisHwaddr >> 7), (thisHwaddr >> 4) & 0x7,
 296                        thisHwaddr & 0xf));
 297       if (writer) writer->AddChannelTrailer(hwaddr);
 298       hwaddr = thisHwaddr;
 299     }
 300     // Check if we're still in the same detector (DDL)
 301     if (ddl != thisDDL) {
 302       if (writer) {
 303         AliDebug(1, Form("Closing altro writer %p", writer));
 304         if ((ret = writer->Close()) < 0) {
 305           AliError(Form("Error: %s", writer->ErrorString(ret)));
 306           return;
 307         }
 308         delete writer;
 309         writer = 0;
 310         file->close();
 311         delete file;
 312         file = 0;
 313       }
 314       ddl = thisDDL;
 315     }
 316     // If we haven't got a writer (either because none were made so
 317     // far, or because we've switch DDL), make one.
 318     if (!writer) {
 319       AliDebug(1, Form("Opening new ALTRO writer w/file FMD_%d.ddl", ddl));
 320       file   = new std::ofstream(Form("FMD_%d.ddl", ddl));
 321       if (!file || !*file) {
 322         AliFatal(Form("Failed to open file FMD_%d.ddl", ddl));
 323         return;
 324       }
 325       writer  = new AliFMDAltroWriter(*file);
 326       writer->SetThreshold(pars->GetZeroSuppression(det, ring, sector, strip));
 327     }
 328     // Write out our signal
 329     sampleRate =  pars->GetSampleRate(det,ring,sector,strip);
 330     writer->AddSignal(digit->Count1());
 331     if (sampleRate >= 2) writer->AddSignal(digit->Count2());
 332     if (sampleRate >= 3) writer->AddSignal(digit->Count3());
 333   }
 334   if (writer) {
 335     writer->AddChannelTrailer(hwaddr);
 336     writer->Close();
 337     delete writer;
 338     file->close();
 339     delete file;
 340   }
 341 }
 342 #endif
 343
 344
 345
 346
 347 //____________________________________________________________________
 348 //
 349 // EOF
 350 //