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 #ifdef USE_HLT
  63 #include <AliL3StandardIncludes.h>
  64 #include "AliL3Logging.h"
  65 #include <AliL3Transform.h>
  66 #include "AliRawReaderRoot.h"
  67 #include <AliL3Hough.h>
  68 #include <AliESD.h>
  69 #endif
  70
  71 #include "AliRawEvent.h"
  72 #include "AliRawEventHeader.h"
  73 #include "AliRawEquipment.h"
  74 #include "AliRawEquipmentHeader.h"
  75 #include "AliRawData.h"
  76 #include "AliStats.h"
  77 #include "AliRawDB.h"
  78 #include "AliRawRFIODB.h"
  79 #include "AliRawCastorDB.h"
  80 #include "AliRawRootdDB.h"
  81 #include "AliRawNullDB.h"
  82 #include "AliTagDB.h"
  83
  84 #include "AliMDC.h"
  85
  86
  87 ClassImp(AliMDC)
  88
  89
  90 #define ALIDEBUG(level) \
  91    if (AliMDC::Instance() && (AliMDC::Instance()->GetDebugLevel() >= (level)))
  92
  93
  94 // Fixed file system locations for the different DB's
  95 #ifdef USE_RDM
  96 const char* const AliMDC::fgkFifo       = "/tmp/alimdc.fifo";
  97 const char* const AliMDC::fgkRawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
  98 const char* const AliMDC::fgkTagDBFS    = "/tmp/mdc1/tags";
  99 const char* const AliMDC::fgkRunDBFS    = "/tmp/mdc1/meta";
 100 const char* const AliMDC::fgkRFIOFS     = "rfio:/castor/cern.ch/user/r/rdm";
 101 const char* const AliMDC::fgkCastorFS   = "castor:/castor/cern.ch/user/r/rdm";
 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 #else
 106 const char* const AliMDC::fgkFifo       = "/tmp/alimdc.fifo";
 107 const char* const AliMDC::fgkRawDBFS[2] = { "/data1/mdc", "/data2/mdc" };
 108 const char* const AliMDC::fgkTagDBFS    = "/data1/mdc/tags";
 109 const char* const AliMDC::fgkRunDBFS    = "/data1/mdc/meta";
 110 const char* const AliMDC::fgkRFIOFS     = "rfio:/castor/cern.ch/lcg/dc5";
 111 const char* const AliMDC::fgkCastorFS   = "castor:/castor/cern.ch/lcg/dc5";
 112 const char* const AliMDC::fgkRootdFS    = "root://localhost//tmp/mdc1";
 113 const char* const AliMDC::fgkAlienHost  = "alien://aliens7.cern.ch:15000/?direct";
 114 const char* const AliMDC::fgkAlienDir   = "/alice_mdc/DC";
 115 #endif
 116
 117 // Maximum size of tag db files
 118 const Double_t AliMDC::fgkMaxTagFileSize = 2.5e8;    // 250MB
 119
 120 Bool_t AliMDC::fgDeleteFiles = kFALSE;
 121 AliMDC* AliMDC::fgInstance = NULL;
 122
 123
 124 //______________________________________________________________________________
 125 AliMDC::AliMDC(Int_t fd, Int_t compress, Double_t maxFileSize, Bool_t useFilter,
 126                EWriteMode mode, Bool_t useLoop, Bool_t delFiles)
 127 {
 128    // Create MDC processor object.
 129
 130    fFd           = fd;
 131    fCompress     = compress;
 132    fMaxFileSize  = maxFileSize;
 133    fUseFilter    = useFilter;
 134    fWriteMode    = mode;
 135    fUseLoop      = useLoop;
 136    fUseFifo      = kFALSE;
 137    fUseEb        = kFALSE;
 138    fStopLoop     = kFALSE;
 139    fNumEvents    = 0;
 140    fDebugLevel   = 0;
 141    fgDeleteFiles = delFiles;
 142
 143    if (fFd == -1) {
 144 #ifdef USE_EB
 145      if (!ebRegister()) {
 146         Error("AliMDC", "cannot register with the event builder (%s)",
 147               ebGetLastError());
 148         return;
 149      }
 150      fUseEb = kTRUE;
 151 #else
 152      if ((mkfifo(fgkFifo, 0644) < 0) && (errno != EEXIST)) {
 153          Error("AliMDC", "cannot create fifo %s", fgkFifo);
 154          return;
 155       }
 156       if ((chmod(fgkFifo, 0666) == -1) && (errno != EPERM)) {
 157          Error("AliMDC", "cannot change permission of fifo %s", fgkFifo);
 158          return;
 159       }
 160       if ((fFd = open(fgkFifo, O_RDONLY)) == -1) {
 161          Error("AliMDC", "cannot open input file %s", fgkFifo);
 162          return;
 163       }
 164       fUseFifo = kTRUE;
 165 #endif
 166       fUseLoop = kFALSE;
 167    }
 168
 169    printf("<AliMDC::AliMDC>: input = %s, rawdb size = %f, filter = %s, "
 170           "looping = %s, compression = %d, delete files = %s",
 171           fUseFifo ? "fifo" : (fUseEb ? "eb" : "file"), fMaxFileSize,
 172           fUseFilter ? "on" : "off", fUseLoop ? "yes" : "no", fCompress,
 173           fgDeleteFiles ? "yes" : "no");
 174    if (fWriteMode == kRFIO)
 175       printf(", use RFIO\n");
 176    else if (fWriteMode == kROOTD)
 177       printf(", use rootd\n");
 178    else if (fWriteMode == kCASTOR)
 179       printf(", use CASTOR/rootd\n");
 180    else if (fWriteMode == kDEVNULL)
 181       printf(", write raw data to /dev/null\n");
 182    else
 183       printf("\n");
 184
 185    // install SIGUSR1 handler to allow clean interrupts
 186    gSystem->AddSignalHandler(new AliMDCInterruptHandler(this));
 187
 188    fgInstance = this;
 189 }
 190
 191 //______________________________________________________________________________
 192 AliMDC::AliMDC(const AliMDC& mdc): TObject(mdc)
 193 {
 194 // copy constructor
 195
 196   Fatal("AliMDC", "copy constructor not implemented");
 197 }
 198
 199 //______________________________________________________________________________
 200 AliMDC& AliMDC::operator = (const AliMDC& /*mdc*/)
 201 {
 202 // assignment operator
 203
 204   Fatal("operator =", "assignment operator not implemented");
 205   return *this;
 206 }
 207
 208 //______________________________________________________________________________
 209 Int_t AliMDC::Run()
 210 {
 211    // Run the MDC processor. Read from the input stream and only return
 212    // when the input gave and EOF or a fatal error occured. On success 0
 213    // is returned, 1 in case of a fatality.
 214
 215    TStopwatch timer;
 216    Int_t status;
 217
 218    // Make sure needed directories exist
 219    const char *dirs[4];
 220    dirs[0] = fgkRawDBFS[0];
 221    dirs[1] = fgkRawDBFS[1];
 222    dirs[2] = fgkTagDBFS;
 223    dirs[3] = fgkRunDBFS;
 224    for (int idir = 0; idir < 4; idir++) {
 225       gSystem->ResetErrno();
 226       gSystem->MakeDirectory(dirs[idir]);
 227       if (gSystem->GetErrno() && gSystem->GetErrno() != EEXIST) {
 228          SysError("Run", "mkdir %s", dirs[idir]);
 229          return 1;
 230       }
 231    }
 232
 233    // Used for statistics
 234    timer.Start();
 235    Double_t told = 0, tnew = 0;
 236    Float_t  chunkSize = fMaxFileSize/100, nextChunk = chunkSize;
 237
 238    // Event object used to store event data.
 239    AliRawEvent *event = new AliRawEvent;
 240 #ifdef USE_HLT
 241    //Init HLT
 242    AliL3Log::fgLevel=AliL3Log::kError;
 243    ALIDEBUG(1)
 244      AliL3Log::fgLevel=AliL3Log::kWarning;
 245    ALIDEBUG(2)
 246      AliL3Log::fgLevel=AliL3Log::kWarning;
 247    ALIDEBUG(3)
 248      AliL3Log::fgLevel=AliL3Log::kNone;
 249
 250    if (!AliL3Transform::Init("./", kFALSE)) {
 251      Error("Run","HLT initialization failed!");
 252      return 1;
 253    }
 254
 255    AliESD *esd = new AliESD;
 256 #endif
 257
 258    // Create new raw DB.
 259    AliRawDB *rawdb;
 260    if (fWriteMode == kRFIO)
 261       rawdb = new AliRawRFIODB(event, esd, fMaxFileSize, fCompress);
 262    else if (fWriteMode == kROOTD)
 263       rawdb = new AliRawRootdDB(event, esd, fMaxFileSize, fCompress);
 264    else if (fWriteMode == kCASTOR)
 265       rawdb = new AliRawCastorDB(event, esd, fMaxFileSize, fCompress);
 266    else if (fWriteMode == kDEVNULL)
 267       rawdb = new AliRawNullDB(event, esd, fMaxFileSize, fCompress);
 268    else
 269       rawdb = new AliRawDB(event, esd, fMaxFileSize, fCompress);
 270
 271    if (rawdb->IsZombie()) return 1;
 272    printf("Filling raw DB %s\n", rawdb->GetDBName());
 273
 274    // Create new tag DB.
 275    AliTagDB *tagdb = 0;
 276 #if 0
 277    // no tagdb for the time being to get maximum speed
 278    if (fWriteMode == fgkDEVNULL)
 279       tagdb = new AliTagNullDB(event->GetHeader(), fgkMaxTagFileSize);
 280    else
 281       tagdb = new AliTagDB(event->GetHeader(), fgkMaxTagFileSize);
 282    if (tagdb->IsZombie())
 283       tagdb = 0;
 284    else
 285       printf("Filling tag DB %s\n", tagdb->GetDBName());
 286 #endif
 287
 288    // Create AliStats object
 289    AliStats *stats = new AliStats(rawdb->GetDBName(), fCompress, fUseFilter);
 290
 291    // Shortcut for easy header access
 292    AliRawEventHeader &header = *event->GetHeader();
 293
 294    // Process input stream
 295 #ifdef USE_EB
 296    Int_t eorFlag = 0;
 297    while (!(eorFlag = ebEor())) {
 298       struct iovec *ebvec;
 299       if ((ebvec = ebGetNextEvent()) == (void *)-1) {
 300          Error("Run", "error getting next event (%s)", ebGetLastError());
 301          break;
 302       }
 303       if (ebvec == 0) {
 304          // no event, sleep for 1 second and try again
 305          gSystem->Sleep(1000);
 306          continue;
 307       }
 308       char *ebdata = (char *) ebvec[0].iov_base;
 309 #else
 310    while (1) {
 311       char *ebdata = 0;
 312 #endif
 313
 314       // Read event header
 315       if ((status = ReadHeader(header, ebdata)) != header.HeaderSize()) {
 316          if (status == 0) {
 317             if (fUseLoop) {
 318 #ifndef USE_EB
 319                ::lseek(fFd, 0, SEEK_SET);
 320 #endif
 321                continue;
 322             }
 323             printf("<AliMDC::Run>: EOF, processed %d events\n", fNumEvents);
 324             break;
 325          }
 326          return 1;
 327       }
 328       ALIDEBUG(3)
 329          header.Dump();
 330
 331       // If we were in looping mode stop directly after a SIGUSR1 signal
 332       if (StopLoop()) {
 333          Info("Run", "Stopping loop, processed %d events", fNumEvents);
 334          break;
 335       }
 336
 337       // Check if event has any hard track flagged
 338       Bool_t callFilter = kFALSE;
 339       if (fUseFilter)
 340         callFilter = kTRUE;
 341
 342       // Check event type and skip "Start of Run", "End of Run",
 343       // "Start of Run Files" and "End of Run Files"
 344       switch (header.GetType()) {
 345          case AliRawEventHeader::kStartOfRun:
 346          case AliRawEventHeader::kEndOfRun:
 347          case AliRawEventHeader::kStartOfRunFiles:
 348          case AliRawEventHeader::kEndOfRunFiles:
 349             {
 350                Int_t skip = header.GetEventSize() - header.HeaderSize();
 351 #ifndef USE_EB
 352                ::lseek(fFd, skip, SEEK_CUR);
 353 #endif
 354                ALIDEBUG(1)
 355                   Info("Run", "Skipping %s (%d bytes)", header.GetTypeName(), skip);
 356                continue;
 357             }
 358          default:
 359             ALIDEBUG(1) {
 360                Int_t s = header.GetEventSize() - header.HeaderSize();
 361                Info("Run", "Processing %s (%d bytes)", header.GetTypeName(), s);
 362             }
 363       }
 364
 365       // Amount of data left to read for this event
 366       Int_t toRead = header.GetEventSize() - header.HeaderSize();
 367
 368       // If there is less data for this event than the next sub-event
 369       // header, something is wrong. Skip to next event...
 370       if (toRead < header.HeaderSize()) {
 371          ALIDEBUG(1) {
 372             Warning("Run",
 373                     "header size (%d) exceeds number of bytes to read (%d)\n",
 374                     header.HeaderSize(), toRead);
 375             header.Dump();
 376          }
 377          if ((status = DumpEvent(toRead)) != toRead) {
 378             if (status == 0)
 379                break;
 380             return 1;
 381          }
 382          Error("Run", "discarding event %d (too little data for header)", fNumEvents);
 383          continue;
 384       }
 385
 386       // Loop over all sub-events... (LDCs)
 387       Int_t nsub = 1;
 388       while (toRead > 0) {
 389 #ifdef USE_EB
 390          ebdata = (char *)ebvec[nsub].iov_base;
 391 #endif
 392
 393          ALIDEBUG(1)
 394             Info("Run", "reading LDC %d", nsub);
 395
 396          AliRawEvent *subEvent = event->NextSubEvent();
 397
 398          // Read sub-event header
 399          AliRawEventHeader &subHeader = *subEvent->GetHeader();
 400          if ((status = ReadHeader(subHeader, ebdata)) != subHeader.HeaderSize()) {
 401             if (status == 0) {
 402                Error("Run", "unexpected EOF reading sub-event header");
 403                break;
 404             }
 405             return 1;
 406          }
 407
 408          ALIDEBUG(3)
 409             subHeader.Dump();
 410
 411          toRead -= subHeader.HeaderSize();
 412
 413 #ifdef USE_EB
 414          ebdata = (char *)(ebvec[nsub].iov_base) + subHeader.HeaderSize();
 415 #endif
 416
 417          Int_t rawSize = subHeader.GetEventSize() - subHeader.HeaderSize();
 418
 419          // Make sure raw data less than left over bytes for current event
 420          if (rawSize > toRead) {
 421             ALIDEBUG(1) {
 422                Warning("Run", "raw data size (%d) exceeds number of "
 423                        "bytes to read (%d)\n", rawSize, toRead);
 424                subHeader.Dump();
 425             }
 426             if ((status = DumpEvent(toRead)) != toRead) {
 427                if (status == 0)
 428                   break;
 429                return 1;
 430             }
 431             Error("Run", "discarding event %d (too much data)", fNumEvents);
 432             continue;
 433          }
 434
 435          // Read Equipment Headers (in case of physics or calibration event)
 436          if (header.GetType() == AliRawEventHeader::kPhysicsEvent ||
 437              header.GetType() == AliRawEventHeader::kCalibrationEvent) {
 438             while (rawSize > 0) {
 439                AliRawEquipment &equipment = *subEvent->NextEquipment();
 440                AliRawEquipmentHeader &equipmentHeader =
 441                   *equipment.GetEquipmentHeader();
 442                Int_t equipHeaderSize = equipmentHeader.HeaderSize();
 443                if ((status = ReadEquipmentHeader(equipmentHeader, header.DataIsSwapped(),
 444                                                  ebdata)) != equipHeaderSize) {
 445                   if (status == 0) {
 446                      Error("Run", "unexpected EOF reading equipment-header");
 447                      break;
 448                   }
 449                   return 1;
 450                }
 451                toRead  -= equipHeaderSize;
 452                rawSize -= equipHeaderSize;
 453 #ifdef USE_EB
 454                ebdata = (char *)(ebvec[nsub].iov_base) +
 455                         subHeader.HeaderSize() + equipHeaderSize;
 456 #endif
 457
 458                // Read equipment raw data
 459                AliRawData &subRaw = *equipment.GetRawData();
 460                // To be checked !
 461                //              Int_t eqSize = equipmentHeader.GetEquipmentSize() -
 462                //                              equipHeaderSize;
 463                Int_t eqSize = equipmentHeader.GetEquipmentSize();
 464                if ((status = ReadRawData(subRaw, eqSize, ebdata)) != eqSize) {
 465                   if (status == 0) {
 466                      Error("Run", "unexpected EOF reading sub-event raw data");
 467                      break;
 468                   }
 469                   return 1;
 470                }
 471                toRead  -= eqSize;
 472                rawSize -= eqSize;
 473
 474             }
 475
 476          } else {  // Read only raw data but no equipment header
 477             AliRawEquipment &equipment = *subEvent->NextEquipment();
 478             AliRawData &subRaw = *equipment.GetRawData();
 479             if ((status = ReadRawData(subRaw, rawSize, ebdata)) != rawSize) {
 480                if (status == 0) {
 481                   Error("Run", "unexpected EOF reading sub-event raw data");
 482                   break;
 483                }
 484                return 1;
 485             }
 486             toRead  -= rawSize;
 487
 488          }
 489
 490          nsub++;
 491       }
 492
 493       //HLT
 494       if (callFilter) {
 495 #ifdef ALI_DATE
 496         if(header.GetType() == AliRawEventHeader::kPhysicsEvent ||
 497            header.GetType() == AliRawEventHeader::kCalibrationEvent)
 498           Filter(
 499 #ifdef USE_HLT
 500                  event,esd
 501 #endif
 502                  );
 503 #endif
 504       }
 505
 506       // Set stat info for first event of this file
 507       if (rawdb->GetEvents() == 0)
 508          stats->SetFirstId(header.GetRunNumber(), header.GetEventInRun());
 509
 510       // Store raw event in tree
 511       rawdb->Fill();
 512
 513       // Store header in tree
 514       if (tagdb) tagdb->Fill();
 515
 516       fNumEvents++;
 517
 518       if (!(fNumEvents%10))
 519          printf("Processed event %d (%d)\n", fNumEvents, rawdb->GetEvents());
 520
 521       // Filling time statistics
 522       if (rawdb->GetBytesWritten() > nextChunk) {
 523          tnew = timer.RealTime();
 524          stats->Fill(tnew-told);
 525          told = tnew;
 526          timer.Continue();
 527          nextChunk += chunkSize;
 528       }
 529
 530       // Check size of raw db. If bigger than maxFileSize, close file
 531       // and continue with new file.
 532       if (rawdb->FileFull()) {
 533
 534          printf("Written raw DB at a rate of %.1f MB/s\n",
 535                 rawdb->GetBytesWritten() / timer.RealTime() / 1000000.);
 536
 537          // Write stats object to raw db, run db, MySQL and AliEn
 538          stats->WriteToDB(rawdb);
 539          delete stats;
 540
 541          if (!rawdb->NextFile()) {
 542             Error("Run", "error opening next raw data file");
 543             return 1;
 544          }
 545
 546          printf("Filling raw DB %s\n", rawdb->GetDBName());
 547          stats = new AliStats(rawdb->GetDBName(), fCompress, fUseFilter);
 548
 549          timer.Start();
 550          told = 0, tnew = 0;
 551          nextChunk = chunkSize;
 552       }
 553
 554       // Check size of tag db
 555       if (tagdb && tagdb->FileFull()) {
 556          if (!tagdb->NextFile())
 557             tagdb = 0;
 558          else
 559             printf("Filling tag DB %s\n", tagdb->GetDBName());
 560       }
 561
 562       // Make top event object ready for next event data
 563       //printf("Event %d has %d sub-events\n", fNumEvents, event->GetNSubEvents());
 564       event->Reset();
 565 #ifdef USE_HLT
 566       // Clean up HLT ESD for the next event
 567       // Probably we could add esd->Reset() method to AliESD?
 568       esd->Reset();
 569 #endif
 570 #ifdef USE_EB
 571       if (!ebReleaseEvent(ebvec)) {
 572          Error("Run", "problem releasing event (%s)", ebGetLastError());
 573          break;
 574       }
 575 #endif
 576    }
 577
 578    printf("Written raw DB at a rate of %.1f MB/s\n",
 579           rawdb->GetBytesWritten() / timer.RealTime() / 1000000.);
 580
 581    // Write stats to raw db and run db and delete stats object
 582    stats->WriteToDB(rawdb);
 583    delete stats;
 584
 585    // Close the raw DB
 586    delete rawdb;
 587
 588    // Close the tag DB
 589    delete tagdb;
 590
 591    // Close input source
 592    close(fFd);
 593
 594 #if 0
 595    // Cleanup fifo
 596    if (fUseFifo && ::unlink(fgkFifo) == -1) {
 597       SysError("Run", "unlink");
 598       return 1;
 599    }
 600 #endif
 601
 602 #ifdef USE_EB
 603    // Print eor flag
 604    if (eorFlag) {
 605       Info("Run", "event builder reported end of run (%d)", eorFlag);
 606    }
 607 #endif
 608
 609    return 0;
 610 }
 611
 612 //______________________________________________________________________________
 613 Int_t AliMDC::Read(void *buffer, Int_t length)
 614 {
 615    // Read exactly length bytes into buffer. Returns number of bytes
 616    // received, returns -1 in case of error and 0 for EOF.
 617
 618    errno = 0;
 619
 620    if (fFd < 0) return -1;
 621
 622    Int_t n, nrecv = 0;
 623    char *buf = (char *)buffer;
 624
 625    for (n = 0; n < length; n += nrecv) {
 626       if ((nrecv = read(fFd, buf+n, length-n)) <= 0) {
 627          if (nrecv == 0)
 628             break;        // EOF
 629          if (errno != EINTR)
 630             SysError("Read", "read");
 631          return -1;
 632       }
 633    }
 634    return n;
 635 }
 636
 637 //______________________________________________________________________________
 638 Int_t AliMDC::ReadHeader(AliRawEventHeader &header, void *eb)
 639 {
 640    // Read header info from DATE data stream. Returns bytes read (i.e.
 641    // AliRawEventHeader::HeaderSize()), -1 in case of error and 0 for EOF.
 642
 643    Int_t nrecv;
 644
 645    if (eb) {
 646       // read from event builder memory area
 647       memcpy(header.HeaderBegin(), eb, header.HeaderSize());
 648       nrecv = header.HeaderSize();
 649    } else {
 650       // read from fifo or file
 651       if ((nrecv = Read(header.HeaderBegin(), header.HeaderSize())) !=
 652            header.HeaderSize()) {
 653          if (nrecv == 0)
 654             return 0;
 655          return -1;
 656       }
 657    }
 658
 659    // Swap header data if needed
 660    if (header.IsSwapped())
 661       header.Swap();
 662
 663    // Is header valid...
 664    if (!header.IsValid()) {
 665       Error("ReadHeader", "invalid header format");
 666       // try recovery... how?
 667       return -1;
 668    }
 669    if (header.GetEventSize() < (UInt_t)header.HeaderSize()) {
 670       Error("ReadHeader", "invalid header size");
 671       // try recovery... how?
 672       return -1;
 673    }
 674
 675    return nrecv;
 676 }
 677
 678 //______________________________________________________________________________
 679 Int_t AliMDC::ReadEquipmentHeader(AliRawEquipmentHeader &header,
 680                                   Bool_t isSwapped, void *eb)
 681 {
 682    // Read equipment header info from DATE data stream. Returns bytes read
 683    // (i.e. AliRawEquipmentHeader::HeaderSize()), -1 in case of error and
 684    // 0 for EOF. If isSwapped is kTRUE the event data is byte swapped
 685    // and we will swap the header to host format.
 686
 687    Int_t nrecv;
 688
 689    if (eb) {
 690       // read from event builder memory area
 691       memcpy(header.HeaderBegin(), eb, header.HeaderSize());
 692       nrecv = header.HeaderSize();
 693    } else {
 694       // read from fifo or file
 695       if ((nrecv = Read(header.HeaderBegin(), header.HeaderSize())) !=
 696            header.HeaderSize()) {
 697          if (nrecv == 0)
 698             return 0;
 699          return -1;
 700       }
 701    }
 702
 703    // Swap equipment header data if needed
 704    if (isSwapped)
 705       header.Swap();
 706
 707    if (header.GetEquipmentSize() < (UInt_t)header.HeaderSize()) {
 708       Error("ReadEquipmentHeader", "invalid equipment header size");
 709       // try recovery... how?
 710       return -1;
 711    }
 712
 713    return nrecv;
 714 }
 715
 716 //______________________________________________________________________________
 717 Int_t AliMDC::ReadRawData(AliRawData &raw, Int_t size, void *eb)
 718 {
 719    // Read raw data from DATE data stream. Returns bytes read (i.e.
 720    // AliRawEventHeader::HeaderSize()), -1 in case of error and 0 for EOF.
 721
 722    Int_t nrecv;
 723
 724    if (eb) {
 725       // read from event builder memory area
 726       raw.SetBuffer(eb, size);
 727       nrecv = size;
 728    } else {
 729       // read from fifo or file
 730       raw.SetSize(size);
 731       if ((nrecv = Read(raw.GetBuffer(), size)) != size) {
 732          if (nrecv == 0) {
 733             Error("ReadRawData", "unexpected EOF");
 734             return 0;
 735          }
 736          return -1;
 737       }
 738    }
 739
 740    return nrecv;
 741 }
 742
 743 //______________________________________________________________________________
 744 Int_t AliMDC::DumpEvent(Int_t toRead)
 745 {
 746    // This case should not happen, but if it does try to handle it
 747    // gracefully by reading the rest of the event and discarding it.
 748    // Returns bytes read, -1 in case of fatal error and 0 for EOF.
 749
 750    Error("DumpEvent", "dumping %d bytes of event %d", toRead, fNumEvents);
 751
 752    Int_t nrecv;
 753    char *tbuf = new char[toRead];
 754    if ((nrecv = Read(tbuf, toRead)) != toRead) {
 755       if (nrecv == 0) {
 756          Error("DumpEvent", "unexpected EOF");
 757          return 0;
 758       }
 759       return -1;
 760    }
 761    delete [] tbuf;
 762
 763    return nrecv;
 764 }
 765
 766 //______________________________________________________________________________
 767 Int_t AliMDC::Filter(
 768 #ifdef USE_HLT
 769                      AliRawEvent *event,AliESD *esd
 770 #endif
 771                      )
 772 {
 773   // Call 3rd level filter for this raw data event.
 774
 775 #ifdef USE_HLT
 776
 777   // Run the HLT code
 778   {
 779     TStopwatch timer;
 780     timer.Start();
 781
 782     AliL3Hough *hough1 = new AliL3Hough();
 783
 784     hough1->SetThreshold(4);
 785     hough1->SetTransformerParams(76,140,0.4,-1);
 786     hough1->SetPeakThreshold(70,-1);
 787     // Attention Z of the vertex to be taken from the event head!
 788     // So far for debug purposes it is fixed by hand...
 789     hough1->Init(100,4,event,3.82147);
 790     hough1->SetAddHistograms();
 791
 792     AliL3Hough *hough2 = new AliL3Hough();
 793
 794     hough2->SetThreshold(4);
 795     hough2->SetTransformerParams(76,140,0.4,-1);
 796     hough2->SetPeakThreshold(70,-1);
 797     hough2->Init(100,4,event,3.82147);
 798     hough2->SetAddHistograms();
 799
 800     Int_t nglobaltracks = 0;
 801     /* In case we run HLT code in 2 threads */
 802     hough1->StartProcessInThread(0,17);
 803     hough2->StartProcessInThread(18,35);
 804
 805     if(hough1->WaitForThreadFinish())
 806       ::Fatal("AliL3Hough::WaitForThreadFinish"," Can not join the required thread! ");
 807     if(hough2->WaitForThreadFinish())
 808       ::Fatal("AliL3Hough::WaitForThreadFinish"," Can not join the required thread! ");
 809
 810     /* In case we run HLT code in the main thread
 811     for(Int_t slice=0; slice<=17; slice++)
 812       {
 813         hough1->ReadData(slice,0);
 814         hough1->Transform();
 815         hough1->AddAllHistogramsRows();
 816         hough1->FindTrackCandidatesRow();
 817         hough1->AddTracks();
 818       }
 819     for(Int_t slice=18; slice<=35; slice++)
 820       {
 821         hough2->ReadData(slice,0);
 822         hough2->Transform();
 823         hough2->AddAllHistogramsRows();
 824         hough2->FindTrackCandidatesRow();
 825         hough2->AddTracks();
 826       }
 827     */
 828
 829     nglobaltracks += hough1->FillESD(esd);
 830     nglobaltracks += hough2->FillESD(esd);
 831
 832     /* In case we want to debug the ESD
 833     gSystem->MakeDirectory("hough1");
 834     hough1->WriteTracks("./hough1");
 835     gSystem->MakeDirectory("hough2");
 836     hough2->WriteTracks("./hough2");
 837     */
 838
 839     delete hough1;
 840     delete hough2;
 841
 842     printf("Filter called for event %d\n", fNumEvents);
 843     printf("Filter has found %d TPC tracks in %f seconds\n", nglobaltracks,timer.RealTime());
 844   }
 845
 846 #else
 847
 848   printf("Filter called for event %d\n", fNumEvents);
 849
 850 #endif
 851
 852   return 0;
 853 }
 854
 855 //______________________________________________________________________________
 856 AliMDC::AliMDCInterruptHandler::AliMDCInterruptHandler(const
 857                                                        AliMDCInterruptHandler&
 858                                                        handler):
 859   TSignalHandler(handler)
 860 {
 861 // copy constructor
 862
 863   Fatal("AliMDCInterruptHandler", "copy constructor not implemented");
 864 }
 865
 866 //______________________________________________________________________________
 867 AliMDC::AliMDCInterruptHandler&
 868   AliMDC::AliMDCInterruptHandler::operator = (const AliMDCInterruptHandler&
 869                                               /*handler*/)
 870 {
 871 // assignment operator
 872
 873   Fatal("operator =", "assignment operator not implemented");
 874   return *this;
 875 }