RAW/AliMDC.cxx

   1 // @(#)alimdc:$Name$:$Id$
   2 // Author: Fons Rademakers  26/11/99
   3 // Updated: Dario Favretto  15/04/2003
   4
   5 /**************************************************************************
   6  * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
   7  *                                                                        *
   8  * Author: The ALICE Off-line Project.                                    *
   9  * Contributors are mentioned in the code where appropriate.              *
  10  *                                                                        *
  11  * Permission to use, copy, modify and distribute this software and its   *
  12  * documentation strictly for non-commercial purposes is hereby granted   *
  13  * without fee, provided that the above copyright notice appears in all   *
  14  * copies and that both the copyright notice and this permission notice   *
  15  * appear in the supporting documentation. The authors make no claims     *
  16  * about the suitability of this software for any purpose. It is          *
  17  * provided "as is" without express or implied warranty.                  *
  18  **************************************************************************/
  19
  20 /* $Id$ */
  21
  22 //////////////////////////////////////////////////////////////////////////
  23 //                                                                      //
  24 // AliMDC                                                               //
  25 //                                                                      //
  26 // Set of classes defining the ALICE RAW event format. The AliRawEvent  //
  27 // class defines a RAW event. It consists of an AliEventHeader object   //
  28 // an AliEquipmentHeader object, an AliRawData object and an array of   //
  29 // sub-events, themselves also being AliRawEvents. The number of        //
  30 // sub-events depends on the number of DATE LDC's.                      //
  31 // The AliRawEvent objects are written to a ROOT file using different   //
  32 // technologies, i.e. to local disk via AliRawDB or via rfiod using     //
  33 // AliRawRFIODB or via rootd using AliRawRootdDB or to CASTOR via       //
  34 // rootd using AliRawCastorDB (and for performance testing there is     //
  35 // also AliRawNullDB).                                                  //
  36 // The AliRunDB class provides the interface to the run and file        //
  37 // catalogues (AliEn or plain MySQL).                                   //
  38 // The AliStats class provides statics information that is added as     //
  39 // a single keyed object to each raw file.                              //
  40 // The AliTagDB provides an interface to a TAG database.                //
  41 // The AliMDC class is usid by the "alimdc" stand-alone program         //
  42 // that reads data directly from DATE.                                  //
  43 //                                                                      //
  44 //////////////////////////////////////////////////////////////////////////
  45
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48
  49 #include <errno.h>
  50
  51 #include <TSystem.h>
  52 #include <TError.h>
  53 #include <TStopwatch.h>
  54
  55 #ifdef ALI_DATE
  56 #include "event.h"
  57 #endif
  58 #ifdef USE_EB
  59 #include "libDateEb.h"
  60 #endif
  61
  62 #include "AliRawEvent.h"
  63 #include "AliRawEventHeader.h"
  64 #include "AliRawEquipmentHeader.h"
  65 #include "AliRawData.h"
  66 #include "AliStats.h"
  67 #include "AliRawDB.h"
  68 #include "AliRawRFIODB.h"
  69 #include "AliRawCastorDB.h"
  70 #include "AliRawRootdDB.h"
  71 #include "AliRawNullDB.h"
  72 #include "AliTagDB.h"
  73
  74 #include "AliMDC.h"
  75
  76
  77 ClassImp(AliMDC)
  78
  79
  80 #define ALIDEBUG(level) \
  81    if (AliMDC::Instance() && (AliMDC::Instance()->GetDebugLevel() >= (level)))
  82
  83
  84 // Fixed file system locations for the different DB's
  85 #ifdef USE_RDM
  86 const char* const AliMDC::fgkFifo       = "/tmp/alimdc.fifo";
  87 const char* const AliMDC::fgkRawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
  88 const char* const AliMDC::fgkTagDBFS    = "/tmp/mdc1/tags";
  89 const char* const AliMDC::fgkRunDBFS    = "/tmp/mdc1/meta";
  90 const char* const AliMDC::fgkRFIOFS     = "rfio:/castor/cern.ch/user/r/rdm";
  91 const char* const AliMDC::fgkCastorFS   = "castor:/castor/cern.ch/user/r/rdm";
  92 const char* const AliMDC::fgkRootdFS    = "root://localhost//tmp/mdc1";
  93 const char* const AliMDC::fgkAlienHost  = "alien://aliens7.cern.ch:15000/?direct";
  94 const char* const AliMDC::fgkAlienDir   = "/alice_mdc/DC";
  95 #else
  96 const char* const AliMDC::fgkFifo       = "/tmp/alimdc.fifo";
  97 const char* const AliMDC::fgkRawDBFS[2] = { "/data1/mdc", "/data2/mdc" };
  98 const char* const AliMDC::fgkTagDBFS    = "/data1/mdc/tags";
  99 const char* const AliMDC::fgkRunDBFS    = "/data1/mdc/meta";
 100 const char* const AliMDC::fgkRFIOFS     = "rfio:/castor/cern.ch/lcg/dc5";
 101 const char* const AliMDC::fgkCastorFS   = "castor:/castor/cern.ch/lcg/dc5";
 102 const char* const AliMDC::fgkRootdFS    = "root://localhost//tmp/mdc1";
 103 const char* const AliMDC::fgkAlienHost  = "alien://aliens7.cern.ch:15000/?direct";
 104 const char* const AliMDC::fgkAlienDir   = "/alice_mdc/DC";
 105 #endif
 106
 107 // Maximum size of tag db files
 108 const Double_t AliMDC::fgkMaxTagFileSize = 2.5e8;    // 250MB
 109
 110 Bool_t AliMDC::fgDeleteFiles = kFALSE;
 111 AliMDC* AliMDC::fgInstance = NULL;
 112
 113
 114 //______________________________________________________________________________
 115 AliMDC::AliMDC(Int_t fd, Int_t compress, Double_t maxFileSize, Bool_t useFilter,
 116                EWriteMode mode, Bool_t useLoop, Bool_t delFiles)
 117 {
 118    // Create MDC processor object.
 119
 120    fFd           = fd;
 121    fCompress     = compress;
 122    fMaxFileSize  = maxFileSize;
 123    fUseFilter    = useFilter;
 124    fWriteMode    = mode;
 125    fUseLoop      = useLoop;
 126    fUseFifo      = kFALSE;
 127    fUseEb        = kFALSE;
 128    fStopLoop     = kFALSE;
 129    fNumEvents    = 0;
 130    fDebugLevel   = 0;
 131    fgDeleteFiles = delFiles;
 132
 133    if (fFd == -1) {
 134 #ifdef USE_EB
 135      if (!ebRegister()) {
 136         Error("AliMDC", "cannot register with the event builder (%s)",
 137               ebGetLastError());
 138         return;
 139      }
 140      fUseEb = kTRUE;
 141 #else
 142      if ((mkfifo(fgkFifo, 0644) < 0) && (errno != EEXIST)) {
 143          Error("AliMDC", "cannot create fifo %s", fgkFifo);
 144          return;
 145       }
 146       if ((chmod(fgkFifo, 0666) == -1) && (errno != EPERM)) {
 147          Error("AliMDC", "cannot change permission of fifo %s", fgkFifo);
 148          return;
 149       }
 150       if ((fFd = open(fgkFifo, O_RDONLY)) == -1) {
 151          Error("AliMDC", "cannot open input file %s", fgkFifo);
 152          return;
 153       }
 154       fUseFifo = kTRUE;
 155 #endif
 156       fUseLoop = kFALSE;
 157    }
 158
 159    printf("<AliMDC::AliMDC>: input = %s, rawdb size = %f, filter = %s, "
 160           "looping = %s, compression = %d, delete files = %s",
 161           fUseFifo ? "fifo" : (fUseEb ? "eb" : "file"), fMaxFileSize,
 162           fUseFilter ? "on" : "off", fUseLoop ? "yes" : "no", fCompress,
 163           fgDeleteFiles ? "yes" : "no");
 164    if (fWriteMode == kRFIO)
 165       printf(", use RFIO\n");
 166    else if (fWriteMode == kROOTD)
 167       printf(", use rootd\n");
 168    else if (fWriteMode == kCASTOR)
 169       printf(", use CASTOR/rootd\n");
 170    else if (fWriteMode == kDEVNULL)
 171       printf(", write raw data to /dev/null\n");
 172    else
 173       printf("\n");
 174
 175    // install SIGUSR1 handler to allow clean interrupts
 176    gSystem->AddSignalHandler(new AliMDCInterruptHandler(this));
 177
 178    fgInstance = this;
 179 }
 180
 181 //______________________________________________________________________________
 182 AliMDC::AliMDC(const AliMDC& mdc): TObject(mdc)
 183 {
 184 // copy constructor
 185
 186   Fatal("AliMDC", "copy constructor not implemented");
 187 }
 188
 189 //______________________________________________________________________________
 190 AliMDC& AliMDC::operator = (const AliMDC& /*mdc*/)
 191 {
 192 // assignment operator
 193
 194   Fatal("operator =", "assignment operator not implemented");
 195   return *this;
 196 }
 197
 198 //______________________________________________________________________________
 199 Int_t AliMDC::Run()
 200 {
 201    // Run the MDC processor. Read from the input stream and only return
 202    // when the input gave and EOF or a fatal error occured. On success 0
 203    // is returned, 1 in case of a fatality.
 204
 205    TStopwatch timer;
 206    Int_t status;
 207
 208    // Make sure needed directories exist
 209    const char *dirs[4];
 210    dirs[0] = fgkRawDBFS[0];
 211    dirs[1] = fgkRawDBFS[1];
 212    dirs[2] = fgkTagDBFS;
 213    dirs[3] = fgkRunDBFS;
 214    for (int idir = 0; idir < 4; idir++) {
 215       gSystem->ResetErrno();
 216       gSystem->MakeDirectory(dirs[idir]);
 217       if (gSystem->GetErrno() && gSystem->GetErrno() != EEXIST) {
 218          SysError("Run", "mkdir %s", dirs[idir]);
 219          return 1;
 220       }
 221    }
 222
 223    // Used for statistics
 224    timer.Start();
 225    Double_t told = 0, tnew = 0;
 226    Float_t  chunkSize = fMaxFileSize/100, nextChunk = chunkSize;
 227
 228    // Event object used to store event data.
 229    AliRawEvent *event = new AliRawEvent;
 230
 231    // Create new raw DB.
 232    AliRawDB *rawdb;
 233    if (fWriteMode == kRFIO)
 234       rawdb = new AliRawRFIODB(event, fMaxFileSize, fCompress);
 235    else if (fWriteMode == kROOTD)
 236       rawdb = new AliRawRootdDB(event, fMaxFileSize, fCompress);
 237    else if (fWriteMode == kCASTOR)
 238       rawdb = new AliRawCastorDB(event, fMaxFileSize, fCompress);
 239    else if (fWriteMode == kDEVNULL)
 240       rawdb = new AliRawNullDB(event, fMaxFileSize, fCompress);
 241    else
 242       rawdb = new AliRawDB(event, fMaxFileSize, fCompress);
 243
 244    if (rawdb->IsZombie()) return 1;
 245    printf("Filling raw DB %s\n", rawdb->GetDBName());
 246
 247    // Create new tag DB.
 248    AliTagDB *tagdb = 0;
 249 #if 0
 250    // no tagdb for the time being to get maximum speed
 251    if (fWriteMode == fgkDEVNULL)
 252       tagdb = new AliTagNullDB(event->GetHeader(), fgkMaxTagFileSize);
 253    else
 254       tagdb = new AliTagDB(event->GetHeader(), fgkMaxTagFileSize);
 255    if (tagdb->IsZombie())
 256       tagdb = 0;
 257    else
 258       printf("Filling tag DB %s\n", tagdb->GetDBName());
 259 #endif
 260
 261    // Create AliStats object
 262    AliStats *stats = new AliStats(rawdb->GetDBName(), fCompress, fUseFilter);
 263
 264    // Shortcut for easy header access
 265    AliRawEventHeader &header = *event->GetHeader();
 266
 267    // Process input stream
 268 #ifdef USE_EB
 269    Int_t eorFlag = 0;
 270    while (!(eorFlag = ebEor())) {
 271       struct iovec *ebvec;
 272       if ((ebvec = ebGetNextEvent()) == (void *)-1) {
 273          Error("Run", "error getting next event (%s)", ebGetLastError());
 274          break;
 275       }
 276       if (ebvec == 0) {
 277          // no event, sleep for 1 second and try again
 278          gSystem->Sleep(1000);
 279          continue;
 280       }
 281       char *ebdata = (char *) ebvec[0].iov_base;
 282 #else
 283    while (1) {
 284       char *ebdata = 0;
 285 #endif
 286
 287       // Read event header
 288       if ((status = ReadHeader(header, ebdata)) != header.HeaderSize()) {
 289          if (status == 0) {
 290             if (fUseLoop) {
 291 #ifndef USE_EB
 292                ::lseek(fFd, 0, SEEK_SET);
 293 #endif
 294                continue;
 295             }
 296             printf("<AliMDC::Run>: EOF, processed %d events\n", fNumEvents);
 297             break;
 298          }
 299          return 1;
 300       }
 301       ALIDEBUG(3)
 302          header.Dump();
 303
 304       // If we were in looping mode stop directly after a SIGUSR1 signal
 305       if (StopLoop()) {
 306          Info("Run", "Stopping loop, processed %d events", fNumEvents);
 307          break;
 308       }
 309
 310       // Check if event has any hard track flagged
 311       Bool_t callFilter = kFALSE;
 312       // This needs to be re-engineered for the next ADC...
 313       //if (fUseFilter && TEST_USER_ATTRIBUTE(header.GetTypeAttribute(), 0))
 314       //   callFilter = kTRUE;
 315
 316       // Check event type and skip "Start of Run", "End of Run",
 317       // "Start of Run Files" and "End of Run Files"
 318       switch (header.GetType()) {
 319          case AliRawEventHeader::kStartOfRun:
 320          case AliRawEventHeader::kEndOfRun:
 321          case AliRawEventHeader::kStartOfRunFiles:
 322          case AliRawEventHeader::kEndOfRunFiles:
 323             {
 324                Int_t skip = header.GetEventSize() - header.HeaderSize();
 325 #ifndef USE_EB
 326                ::lseek(fFd, skip, SEEK_CUR);
 327 #endif
 328                ALIDEBUG(1)
 329                   Info("Run", "Skipping %s (%d bytes)", header.GetTypeName(), skip);
 330                continue;
 331             }
 332          default:
 333             ALIDEBUG(1) {
 334                Int_t s = header.GetEventSize() - header.HeaderSize();
 335                Info("Run", "Processing %s (%d bytes)", header.GetTypeName(), s);
 336             }
 337       }
 338
 339       // Amount of data left to read for this event
 340       Int_t toRead = header.GetEventSize() - header.HeaderSize();
 341
 342       // If there is less data for this event than the next sub-event
 343       // header, something is wrong. Skip to next event...
 344       if (toRead < header.HeaderSize()) {
 345          ALIDEBUG(1) {
 346             Warning("Run",
 347                     "header size (%d) exceeds number of bytes to read (%d)\n",
 348                     header.HeaderSize(), toRead);
 349             header.Dump();
 350          }
 351          if ((status = DumpEvent(toRead)) != toRead) {
 352             if (status == 0)
 353                break;
 354             return 1;
 355          }
 356          Error("Run", "discarding event %d (too little data for header)", fNumEvents);
 357          continue;
 358       }
 359
 360       // Loop over all sub-events... (LDCs)
 361       Int_t nsub = 1;
 362       while (toRead > 0) {
 363 #ifdef USE_EB
 364          ebdata = (char *)ebvec[nsub].iov_base;
 365 #endif
 366
 367          ALIDEBUG(1)
 368             Info("Run", "reading LDC %d", nsub);
 369
 370          AliRawEvent *subEvent = event->NextSubEvent();
 371
 372          // Read sub-event header
 373          AliRawEventHeader &subHeader = *subEvent->GetHeader();
 374          if ((status = ReadHeader(subHeader, ebdata)) != subHeader.HeaderSize()) {
 375             if (status == 0) {
 376                Error("Run", "unexpected EOF reading sub-event header");
 377                break;
 378             }
 379             return 1;
 380          }
 381
 382          ALIDEBUG(3)
 383             subHeader.Dump();
 384
 385          toRead -= subHeader.HeaderSize();
 386
 387 #ifdef USE_EB
 388          ebdata = (char *)(ebvec[nsub].iov_base) + subHeader.HeaderSize();
 389 #endif
 390
 391          Int_t rawSize = subHeader.GetEventSize() - subHeader.HeaderSize();
 392
 393          // Read Equipment Header (in case of physics or calibration event)
 394          if (header.GetType() == AliRawEventHeader::kPhysicsEvent ||
 395              header.GetType() == AliRawEventHeader::kCalibrationEvent) {
 396             AliRawEquipmentHeader &equipment = *subEvent->GetEquipmentHeader();
 397             Int_t equipHeaderSize = equipment.HeaderSize();
 398             if ((status = ReadEquipmentHeader(equipment, header.DataIsSwapped(),
 399                                               ebdata)) != equipHeaderSize) {
 400                if (status == 0) {
 401                   Error("Run", "unexpected EOF reading equipment-header");
 402                   break;
 403                }
 404                return 1;
 405             }
 406             toRead  -= equipHeaderSize;
 407             rawSize -= equipHeaderSize;
 408 #ifdef USE_EB
 409             ebdata = (char *)(ebvec[nsub].iov_base) + subHeader.HeaderSize() +
 410                      equipHeaderSize;
 411 #endif
 412          }
 413
 414          // Make sure raw data less than left over bytes for current event
 415          if (rawSize > toRead) {
 416             ALIDEBUG(1) {
 417                Warning("Run", "raw data size (%d) exceeds number of bytes "
 418                        "to read (%d)\n", rawSize, toRead);
 419                subHeader.Dump();
 420             }
 421             if ((status = DumpEvent(toRead)) != toRead) {
 422                if (status == 0)
 423                   break;
 424                return 1;
 425             }
 426             Error("Run", "discarding event %d (too much data)", fNumEvents);
 427             continue;
 428          }
 429
 430          // Read sub-event raw data
 431          AliRawData &subRaw = *subEvent->GetRawData();
 432          if ((status = ReadRawData(subRaw, rawSize, ebdata)) != rawSize) {
 433             if (status == 0) {
 434                Error("Run", "unexpected EOF reading sub-event raw data");
 435                break;
 436             }
 437             return 1;
 438          }
 439
 440          if (callFilter) {
 441 #ifdef ALI_DATE
 442             if (TEST_USER_ATTRIBUTE(subHeader.GetTypeAttribute(), 0))
 443                Filter(subRaw);
 444             else {
 445                // set size of all sectors without hard track flag to 0
 446                subRaw.SetSize(0);
 447             }
 448 #endif
 449          }
 450
 451          toRead -= rawSize;
 452          nsub++;
 453       }
 454
 455       // Set stat info for first event of this file
 456       if (rawdb->GetEvents() == 0)
 457          stats->SetFirstId(header.GetRunNumber(), header.GetEventInRun());
 458
 459       // Store raw event in tree
 460       rawdb->Fill();
 461
 462       // Store header in tree
 463       if (tagdb) tagdb->Fill();
 464
 465       fNumEvents++;
 466
 467       if (!(fNumEvents%10))
 468          printf("Processed event %d (%d)\n", fNumEvents, rawdb->GetEvents());
 469
 470       // Filling time statistics
 471       if (rawdb->GetBytesWritten() > nextChunk) {
 472          tnew = timer.RealTime();
 473          stats->Fill(tnew-told);
 474          told = tnew;
 475          timer.Continue();
 476          nextChunk += chunkSize;
 477       }
 478
 479       // Check size of raw db. If bigger than maxFileSize, close file
 480       // and continue with new file.
 481       if (rawdb->FileFull()) {
 482
 483          printf("Written raw DB at a rate of %.1f MB/s\n",
 484                 rawdb->GetBytesWritten() / timer.RealTime() / 1000000.);
 485
 486          // Write stats object to raw db, run db, MySQL and AliEn
 487          stats->WriteToDB(rawdb);
 488          delete stats;
 489
 490          if (!rawdb->NextFile()) {
 491             Error("Run", "error opening next raw data file");
 492             return 1;
 493          }
 494
 495          printf("Filling raw DB %s\n", rawdb->GetDBName());
 496          stats = new AliStats(rawdb->GetDBName(), fCompress, fUseFilter);
 497
 498          timer.Start();
 499          told = 0, tnew = 0;
 500          nextChunk = chunkSize;
 501       }
 502
 503       // Check size of tag db
 504       if (tagdb && tagdb->FileFull()) {
 505          if (!tagdb->NextFile())
 506             tagdb = 0;
 507          else
 508             printf("Filling tag DB %s\n", tagdb->GetDBName());
 509       }
 510
 511       // Make top event object ready for next event data
 512       //printf("Event %d has %d sub-events\n", fNumEvents, event->GetNSubEvents());
 513       event->Reset();
 514
 515 #ifdef USE_EB
 516       if (!ebReleaseEvent(ebvec)) {
 517          Error("Run", "problem releasing event (%s)", ebGetLastError());
 518          break;
 519       }
 520 #endif
 521    }
 522
 523    printf("Written raw DB at a rate of %.1f MB/s\n",
 524           rawdb->GetBytesWritten() / timer.RealTime() / 1000000.);
 525
 526    // Write stats to raw db and run db and delete stats object
 527    stats->WriteToDB(rawdb);
 528    delete stats;
 529
 530    // Close the raw DB
 531    delete rawdb;
 532
 533    // Close the tag DB
 534    delete tagdb;
 535
 536    // Close input source
 537    close(fFd);
 538
 539 #if 0
 540    // Cleanup fifo
 541    if (fUseFifo && ::unlink(fgkFifo) == -1) {
 542       SysError("Run", "unlink");
 543       return 1;
 544    }
 545 #endif
 546
 547 #ifdef USE_EB
 548    // Print eor flag
 549    if (eorFlag) {
 550       Info("Run", "event builder reported end of run (%d)", eorFlag);
 551    }
 552 #endif
 553
 554    return 0;
 555 }
 556
 557 //______________________________________________________________________________
 558 Int_t AliMDC::Read(void *buffer, Int_t length)
 559 {
 560    // Read exactly length bytes into buffer. Returns number of bytes
 561    // received, returns -1 in case of error and 0 for EOF.
 562
 563    errno = 0;
 564
 565    if (fFd < 0) return -1;
 566
 567    Int_t n, nrecv = 0;
 568    char *buf = (char *)buffer;
 569
 570    for (n = 0; n < length; n += nrecv) {
 571       if ((nrecv = read(fFd, buf+n, length-n)) <= 0) {
 572          if (nrecv == 0)
 573             break;        // EOF
 574          if (errno != EINTR)
 575             SysError("Read", "read");
 576          return -1;
 577       }
 578    }
 579    return n;
 580 }
 581
 582 //______________________________________________________________________________
 583 Int_t AliMDC::ReadHeader(AliRawEventHeader &header, void *eb)
 584 {
 585    // Read header info from DATE data stream. Returns bytes read (i.e.
 586    // AliRawEventHeader::HeaderSize()), -1 in case of error and 0 for EOF.
 587
 588    Int_t nrecv;
 589
 590    if (eb) {
 591       // read from event builder memory area
 592       memcpy(header.HeaderBegin(), eb, header.HeaderSize());
 593       nrecv = header.HeaderSize();
 594    } else {
 595       // read from fifo or file
 596       if ((nrecv = Read(header.HeaderBegin(), header.HeaderSize())) !=
 597            header.HeaderSize()) {
 598          if (nrecv == 0)
 599             return 0;
 600          return -1;
 601       }
 602    }
 603
 604    // Swap header data if needed
 605    if (header.IsSwapped())
 606       header.Swap();
 607
 608    // Is header valid...
 609    if (!header.IsValid()) {
 610       Error("ReadHeader", "invalid header format");
 611       // try recovery... how?
 612       return -1;
 613    }
 614    if (header.GetEventSize() < (UInt_t)header.HeaderSize()) {
 615       Error("ReadHeader", "invalid header size");
 616       // try recovery... how?
 617       return -1;
 618    }
 619
 620    return nrecv;
 621 }
 622
 623 //______________________________________________________________________________
 624 Int_t AliMDC::ReadEquipmentHeader(AliRawEquipmentHeader &header,
 625                                   Bool_t isSwapped, void *eb)
 626 {
 627    // Read equipment header info from DATE data stream. Returns bytes read
 628    // (i.e. AliRawEquipmentHeader::HeaderSize()), -1 in case of error and
 629    // 0 for EOF. If isSwapped is kTRUE the event data is byte swapped
 630    // and we will swap the header to host format.
 631
 632    Int_t nrecv;
 633
 634    if (eb) {
 635       // read from event builder memory area
 636       memcpy(header.HeaderBegin(), eb, header.HeaderSize());
 637       nrecv = header.HeaderSize();
 638    } else {
 639       // read from fifo or file
 640       if ((nrecv = Read(header.HeaderBegin(), header.HeaderSize())) !=
 641            header.HeaderSize()) {
 642          if (nrecv == 0)
 643             return 0;
 644          return -1;
 645       }
 646    }
 647
 648    // Swap equipment header data if needed
 649    if (isSwapped)
 650       header.Swap();
 651
 652    if (header.GetEquipmentSize() < (UInt_t)header.HeaderSize()) {
 653       Error("ReadEquipmentHeader", "invalid equipment header size");
 654       // try recovery... how?
 655       return -1;
 656    }
 657
 658    return nrecv;
 659 }
 660
 661 //______________________________________________________________________________
 662 Int_t AliMDC::ReadRawData(AliRawData &raw, Int_t size, void *eb)
 663 {
 664    // Read raw data from DATE data stream. Returns bytes read (i.e.
 665    // AliRawEventHeader::HeaderSize()), -1 in case of error and 0 for EOF.
 666
 667    Int_t nrecv;
 668
 669    if (eb) {
 670       // read from event builder memory area
 671       raw.SetBuffer(eb, size);
 672       nrecv = size;
 673    } else {
 674       // read from fifo or file
 675       raw.SetSize(size);
 676       if ((nrecv = Read(raw.GetBuffer(), size)) != size) {
 677          if (nrecv == 0) {
 678             Error("ReadRawData", "unexpected EOF");
 679             return 0;
 680          }
 681          return -1;
 682       }
 683    }
 684
 685    return nrecv;
 686 }
 687
 688 //______________________________________________________________________________
 689 Int_t AliMDC::DumpEvent(Int_t toRead)
 690 {
 691    // This case should not happen, but if it does try to handle it
 692    // gracefully by reading the rest of the event and discarding it.
 693    // Returns bytes read, -1 in case of fatal error and 0 for EOF.
 694
 695    Error("DumpEvent", "dumping %d bytes of event %d", toRead, fNumEvents);
 696
 697    Int_t nrecv;
 698    char *tbuf = new char[toRead];
 699    if ((nrecv = Read(tbuf, toRead)) != toRead) {
 700       if (nrecv == 0) {
 701          Error("DumpEvent", "unexpected EOF");
 702          return 0;
 703       }
 704       return -1;
 705    }
 706    delete [] tbuf;
 707
 708    return nrecv;
 709 }
 710
 711 //______________________________________________________________________________
 712 Int_t AliMDC::Filter(AliRawData &raw)
 713 {
 714    // Call 3rd level filter for this raw data segment.
 715
 716 #ifdef USE_HLT
 717
 718    // Add HLT code here
 719
 720 #else
 721
 722    raw.GetSize();
 723    printf("Filter called for event %d\n", fNumEvents);
 724
 725 #endif
 726
 727    return 0;
 728 }
 729
 730 //______________________________________________________________________________
 731 AliMDC::AliMDCInterruptHandler::AliMDCInterruptHandler(const
 732                                                        AliMDCInterruptHandler&
 733                                                        handler):
 734   TSignalHandler(handler)
 735 {
 736 // copy constructor
 737
 738   Fatal("AliMDCInterruptHandler", "copy constructor not implemented");
 739 }
 740
 741 //______________________________________________________________________________
 742 AliMDC::AliMDCInterruptHandler&
 743   AliMDC::AliMDCInterruptHandler::operator = (const AliMDCInterruptHandler&
 744                                               /*handler*/)
 745 {
 746 // assignment operator
 747
 748   Fatal("operator =", "assignment operator not implemented");
 749   return *this;
 750 }