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