make GetSubevent() const.
[u/mrichter/AliRoot.git] / RAW / AliRawEvent.cxx
1 // @(#)alimdc:$Name$:$Id$
2 // Author: Fons Rademakers  26/11/99
3 // Updated: Dario Favretto  15/04/2003
4
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #if defined(__DECCXX)
8 #include <sys/statvfs.h>
9 #else
10 #if defined(__APPLE__)
11 #include <sys/param.h>
12 #include <sys/mount.h>
13 #else
14 #include <sys/vfs.h>
15 #endif
16 #endif
17 #include <unistd.h>
18 #include <stdlib.h>
19 #include <fcntl.h>
20 #include <errno.h>
21
22 #include <TBuffer.h>
23 #include <TH1.h>
24 #include <TSystem.h>
25 #include <TError.h>
26 #include <TStopwatch.h>
27 #include <TSQLServer.h>
28 #include <TSQLResult.h>
29
30 #if defined(__APPLE__)
31 #undef Free
32 #endif
33 #include "AliRawEvent.h"
34
35 // Good for Linux
36 #define long32 int
37 #include "DateEvent.h"
38
39 #ifdef USE_EB
40 #include "libDateEb.h"
41 #endif
42
43
44 ClassImp(AliRawEvent)
45 ClassImp(AliRawEventHeader)
46 ClassImp(AliRawEquipmentHeader)
47 ClassImp(AliRawData)
48 ClassImp(AliStats)
49 ClassImp(AliRawDB)
50 ClassImp(AliRawRFIODB)
51 ClassImp(AliRawRootdDB)
52 ClassImp(AliRawNullDB)
53 ClassImp(AliTagDB)
54 ClassImp(AliTagNullDB)
55 ClassImp(AliRunDB)
56 ClassImp(AliMDC)
57
58 // Which MDC is this...
59 const Int_t kMDC = 4;
60
61 // Fixed file system locations for the different DB's
62 #ifdef USE_RDM
63 const char *kFifo       = "/tmp/alimdc.fifo";
64 const char *kRawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
65 const char *kTagDBFS    = "/tmp/mdc1/tags";
66 const char *kRunDBFS    = "/tmp/mdc1/meta";
67 const char *kRFIOFS     = "rfio:/castor/cern.ch/user/r/rdm";
68 const char *kRootdFS    = "root://localhost//tmp/mdc1";
69 #else
70 const char *kFifo       = "/tmp/alimdc.fifo";
71 const char *kRawDBFS[2] = { "/scratch/mdc1", "/scratch/mdc2" };
72 const char *kTagDBFS    = "/scratch/mdc1/tags";
73 const char *kRunDBFS    = "/scratch/mdc1/meta";
74 const char *kRFIOFS     = "rfio:/castor/cern.ch/lcg/alicemdc4";
75 const char *kRootdFS    = "root://localhost//tmp/mdc1";
76 #endif
77
78 // Maximum size of tag db files
79 const Double_t kMaxTagFileSize = 2.5e8;    // 250MB
80
81 Bool_t AliMDC::fgDeleteFiles = kFALSE;
82
83 AliMDC *gAliMDC = 0;
84
85
86 //______________________________________________________________________________
87 Bool_t AliRawEventHeader::DataIsSwapped() const
88 {
89    // Returns true if event data is swapped.
90
91    if (TEST_SYSTEM_ATTRIBUTE(fTypeAttribute, ATTR_EVENT_SWAPPED))
92       return kTRUE;
93    return kFALSE;
94 }
95
96 //______________________________________________________________________________
97 void AliRawEventHeader::Swap()
98 {
99    // Swap header data.
100
101    if (IsSwapped()) {
102       fSize         = net2host(fSize);
103       fMagic        = net2host(fMagic);
104       fHeadLen      = net2host(fHeadLen);
105       fVersion      = net2host(fVersion);
106       fType         = net2host(fType);
107       fRunNb        = net2host(fRunNb);
108       for (int i = 0; i < kIdWords; i++)
109          fId[i] = net2host(fId[i]);
110       for (int i = 0; i < kTriggerWords; i++)
111          fTriggerPattern[i] = net2host(fTriggerPattern[i]);
112       for (int i = 0; i < kDetectorWords; i++)
113          fDetectorPattern[i] = net2host(fDetectorPattern[i]);
114       for (int i = 0; i < kAttributeWords; i++)
115          fTypeAttribute[i] = net2host(fTypeAttribute[i]);
116       fLDCId        = net2host(fLDCId);
117       fGDCId        = net2host(fGDCId);
118    }
119 }
120
121 //______________________________________________________________________________
122 UInt_t AliRawEventHeader::GetEventInRun() const
123 {
124    // Get event number in run. Correct for fixed target mode which is used
125    // in the Data Challenge Setup.
126
127    if (!TEST_SYSTEM_ATTRIBUTE(fTypeAttribute, ATTR_ORBIT_BC)) {
128       return EVENT_ID_GET_NB_IN_RUN(fId);
129    }
130    return 0;
131 }
132
133 //______________________________________________________________________________
134 const char *AliRawEventHeader::GetTypeName() const
135 {
136    // Get event type as a string.
137
138    switch (GetType()) {
139       case kStartOfRun:
140          return "START_OF_RUN";
141          break;
142       case kEndOfRun:
143          return "END_OF_RUN";
144          break;
145       case kStartOfRunFiles:
146          return "START_OF_RUN_FILES";
147          break;
148       case kEndOfRunFiles:
149          return "END_OF_RUN_FILES";
150          break;
151       case kStartOfBurst:
152          return "START_OF_BURST";
153          break;
154       case kEndOfBurst:
155          return "END_OF_BURST";
156          break;
157       case kPhysicsEvent:
158          return "PHYSICS_EVENT";
159          break;
160       case kCalibrationEvent:
161          return "CALIBRATION_EVENT";
162          break;
163       case kFormatError:
164          return "EVENT_FORMAT_ERROR";
165          break;
166       default:
167          return "*** UNKNOWN EVENT TYPE ***";
168          break;
169    }
170 }
171
172
173 //______________________________________________________________________________
174 void AliRawEquipmentHeader::Swap()
175 {
176    // Swap equipment header data. There is no way to see if the data
177    // has already been swapped. This method is only called when the
178    // header is read from the DATE event builder (GDC).
179
180    fSize                 = net2host(fSize);
181    fEquipmentType        = net2host(fEquipmentType);
182    fEquipmentID          = net2host(fEquipmentID);
183    fBasicElementSizeType = net2host(fBasicElementSizeType);
184    for (int i = 0; i < kAttributeWords; i++)
185       fTypeAttribute[i] = net2host(fTypeAttribute[i]);
186 }
187
188
189 //______________________________________________________________________________
190 AliRawEvent::AliRawEvent()
191 {
192    // Create ALICE event object. If ownData is kFALSE we will use a static
193    // raw data object, otherwise a private copy will be made.
194
195    fNSubEvents = 0;
196    fEvtHdr     = new AliRawEventHeader;
197    fEqpHdr     = 0;
198    fRawData    = 0;
199    fSubEvents  = 0;
200 }
201
202 //______________________________________________________________________________
203 AliRawEquipmentHeader *AliRawEvent::GetEquipmentHeader()
204 {
205    // Get equipment header part of AliRawEvent.
206
207    if (!fEqpHdr)
208       fEqpHdr = new AliRawEquipmentHeader;
209
210    return fEqpHdr;
211 }
212
213 //______________________________________________________________________________
214 AliRawData *AliRawEvent::GetRawData()
215 {
216    // Get raw data part of AliRawEvent.
217
218    if (!fRawData)
219       fRawData = new AliRawData;
220
221    return fRawData;
222 }
223
224 //______________________________________________________________________________
225 AliRawEvent *AliRawEvent::NextSubEvent()
226 {
227    // Returns next sub-event object.
228
229    if (!fSubEvents)
230       fSubEvents = new TObjArray(100); // arbitrary, probably enough to prevent resizing
231
232    if (fSubEvents->GetSize() <= fNSubEvents) {
233       fSubEvents->Expand(fNSubEvents+10);
234       Warning("NextSubEvent", "expanded fSubEvents by 10 to %d",
235               fSubEvents->GetSize());
236    }
237
238    AliRawEvent *ev;
239    if (!(ev = (AliRawEvent *)fSubEvents->At(fNSubEvents))) {
240       ev = new AliRawEvent;
241       fSubEvents->AddAt(ev, fNSubEvents);
242    }
243
244    fNSubEvents++;
245
246    return ev;
247 }
248
249 //______________________________________________________________________________
250 AliRawEvent *AliRawEvent::GetSubEvent(Int_t index) const
251 {
252    // Get specified sub event. Returns 0 if sub event does not exist.
253
254    if (!fSubEvents)
255       return 0;
256
257    return (AliRawEvent *) fSubEvents->At(index);
258 }
259
260 //______________________________________________________________________________
261 void AliRawEvent::Reset()
262 {
263    // Reset the event in case it needs to be re-used (avoiding costly
264    // new/delete cycle). We reset the size marker for the AliRawData
265    // objects and the sub event counter.
266
267    for (int i = 0; i < fNSubEvents; i++) {
268       AliRawEvent *ev = (AliRawEvent *)fSubEvents->At(i);
269       ev->GetRawData()->SetSize(0);
270    }
271    fNSubEvents = 0;
272 }
273
274 //______________________________________________________________________________
275 AliRawEvent::~AliRawEvent()
276 {
277    // Clean up event object. Delete also, possible, private raw data.
278
279    delete fEvtHdr;
280    delete fEqpHdr;
281    delete fRawData;
282    if (fSubEvents)
283       fSubEvents->Delete();
284    delete fSubEvents;
285 }
286
287 //______________________________________________________________________________
288 AliStats::AliStats(const char *filename, Int_t compmode, Bool_t filter)
289 {
290    // Create statistics object.
291
292    fEvents     = 0;
293    fFirstRun   = 0;
294    fFirstEvent = 0;
295    fLastRun    = 0;
296    fLastEvent  = 0;
297    fChunk      = -0.5;
298    fFileName   = filename;
299    fCompMode   = compmode;
300    fFilter     = filter;
301    fRTHist     = 0;
302 }
303
304 //______________________________________________________________________________
305 AliStats::~AliStats()
306 {
307    // Cleanup stats object.
308
309    delete fRTHist;
310 }
311
312 //______________________________________________________________________________
313 AliStats &AliStats::operator=(const AliStats &rhs)
314 {
315    // AliStats assignment operator.
316
317    if (this != &rhs) {
318       TObject::operator=(rhs);
319       fEvents     = rhs.fEvents;
320       fFirstRun   = rhs.fFirstRun;
321       fFirstEvent = rhs.fFirstEvent;
322       fLastRun    = rhs.fLastRun;
323       fLastEvent  = rhs.fLastEvent;
324       fBegin      = rhs.fBegin;
325       fEnd        = rhs.fEnd;
326       fFileName   = rhs.fFileName;
327       fFileSize   = rhs.fFileSize;
328       fCompFactor = rhs.fCompFactor;
329       fCompMode   = rhs.fCompMode;
330       fFilter     = rhs.fFilter;
331       fRTHist     = rhs.fRTHist ? (TH1F*) rhs.fRTHist->Clone() : 0;
332       fChunk      = rhs.fChunk;
333    }
334    return *this;
335 }
336
337 //______________________________________________________________________________
338 void AliStats::Fill(Float_t time)
339 {
340    // Fill histogram. This histogram shows the (hopefully constant) time
341    // it takes to fill the ROOT DB.
342    // Expects to be called 100 times for each file.
343
344    if (!fRTHist) {
345       fRTHist = new TH1F("rtime","Real-time to write data chunk", 100, 0, 100);
346       fRTHist->SetDirectory(0);
347    }
348
349    fRTHist->Fill(fChunk, time);
350    fChunk += 1.0;
351 }
352
353 //______________________________________________________________________________
354 void AliStats::WriteToDB(AliRawDB *rawdb)
355 {
356    // Write stats to raw DB, local run DB and global MySQL DB.
357
358    AliRawEventHeader &header = *rawdb->GetEvent()->GetHeader();
359
360    // Write stats into RawDB
361    TDirectory *ds = gDirectory;
362    rawdb->GetDB()->cd();
363    SetEvents(rawdb->GetEvents());
364    SetLastId(header.GetRunNumber(), header.GetEventInRun());
365    SetFileSize(rawdb->GetBytesWritten());
366    SetCompressionFactor(rawdb->GetCompressionFactor());
367    SetEndTime();
368    Write("stats");
369    ds->cd();
370
371    // Write stats also in the bookkeeping RunDB
372    AliRunDB *rundb = new AliRunDB;
373    rundb->Update(this);
374    rundb->UpdateRDBMS(this);
375    delete rundb;
376 }
377
378 //______________________________________________________________________________
379 AliRawDB::AliRawDB(AliRawEvent *event, Double_t maxsize, Int_t compress,
380                    Bool_t create)
381 {
382    // Create a new raw DB containing at most maxsize bytes.
383
384    fEvent    = event;
385    fMaxSize  = maxsize;
386    fCompress = compress;
387
388    // Consistency check with DATE header file
389    if (fEvent->GetHeader()->HeaderSize() != EVENT_HEAD_BASE_SIZE) {
390       Error("AliRawDB", "inconsistency between DATE and AliRawEvent headers");
391       MakeZombie();
392       return;
393    }
394
395    if (create) {
396       if (!Create())
397          MakeZombie();
398    }
399 }
400
401 //______________________________________________________________________________
402 Bool_t AliRawDB::FSHasSpace(const char *fs)
403 {
404    // Check for at least fMaxSize bytes of free space on the file system.
405    // If the space is not available return kFALSE, kTRUE otherwise.
406
407    Long_t id, bsize, blocks, bfree;
408
409    if (gSystem->GetFsInfo(fs, &id, &bsize, &blocks, &bfree) == 1) {
410       Error("FSHasSpace", "could not stat file system %s", fs);
411       return kFALSE;
412    }
413
414    // Leave 5 percent of diskspace free
415    Double_t avail = Double_t(bfree) * 0.95;
416    if (avail*bsize > fMaxSize)
417       return kTRUE;
418
419    Warning("FSHasSpace", "no space on file system %s", fs);
420    return kFALSE;
421 }
422
423 //______________________________________________________________________________
424 const char *AliRawDB::GetFileName()
425 {
426    // Return filename based on hostname and date and time. This will make
427    // each file unique. Also makes sure (via FSHasSpace()) that there is
428    // enough space on the file system to store the file. Returns 0 in
429    // case of error or interrupt signal.
430
431    static TString fname;
432    static Bool_t  fstoggle = kFALSE;
433
434    TString fs = fstoggle ? kRawDBFS[1] : kRawDBFS[0];
435    TDatime dt;
436
437    TString hostname = gSystem->HostName();
438    Int_t pos;
439    if ((pos = hostname.Index(".")) != kNPOS)
440       hostname.Remove(pos);
441
442    if (!FSHasSpace(fs)) {
443       while (1) {
444          fstoggle = !fstoggle;
445          fs = fstoggle ? kRawDBFS[1] : kRawDBFS[0];
446          if (FSHasSpace(fs)) break;
447          Info("GetFileName", "sleeping 30 seconds before retrying...");
448          gSystem->Sleep(30000);   // sleep for 30 seconds
449          if (gAliMDC && gAliMDC->StopLoop())
450             return 0;
451       }
452    }
453
454    fname = fs + "/" + hostname + "_";
455    fname += dt.GetDate();
456    fname += "_";
457    fname += dt.GetTime();
458    fname += ".root";
459
460    fstoggle = !fstoggle;
461
462    return fname;
463 }
464
465 //______________________________________________________________________________
466 Bool_t AliRawDB::Create()
467 {
468    // Create a new raw DB.
469
470 again:
471    const char *fname = GetFileName();
472    if (!fname) return kFALSE;
473
474    fRawDB = TFile::Open(fname, "RECREATE",
475                         Form("ALICE MDC%d raw DB", kMDC), fCompress);
476    if (!fRawDB) {
477       Error("Create", "did not find right plugin to open file");
478       return kFALSE;
479    }
480    if (fRawDB->IsZombie()) {
481       if (fRawDB->GetErrno() == ENOSPC ||
482           fRawDB->GetErrno() == 1018   ||   // SECOMERR
483           fRawDB->GetErrno() == 1027) {     // SESYSERR
484          fRawDB->ResetErrno();
485          delete fRawDB;
486          Warning("Create", "file is zombie, sleeping 10 seconds before retrying...");
487          gSystem->Sleep(10000);   // sleep 10 seconds before retrying
488          goto again;
489       }
490       Error("Create", "error opening raw DB");
491       fRawDB = 0;
492       return kFALSE;
493    }
494
495    // Create raw data TTree
496    MakeTree();
497
498    return kTRUE;
499 }
500
501 //______________________________________________________________________________
502 void AliRawDB::MakeTree()
503 {
504    // Create ROOT Tree object container.
505
506    fTree = new TTree("RAW", Form("ALICE MDC%d raw data tree", kMDC));
507    fTree->SetAutoSave(2000000000);  // autosave when 2 Gbyte written
508
509    Int_t bufsize = 256000;
510    // splitting 29.6 MB/s, no splitting 35.3 MB/s on P4 2GHz 15k SCSI
511    //Int_t split   = 1;
512    Int_t split   = 0;
513    fTree->Branch("rawevent", "AliRawEvent", &fEvent, bufsize, split);
514 }
515
516 //______________________________________________________________________________
517 void AliRawDB::Close()
518 {
519    // Close raw DB.
520
521    if (!fRawDB) return;
522
523    fRawDB->cd();
524
525    // Write the tree.
526    fTree->Write();
527
528    // Close DB, this also deletes the fTree
529    fRawDB->Close();
530
531    if (AliMDC::DeleteFiles()) {
532       gSystem->Unlink(fRawDB->GetName());
533       delete fRawDB;
534       fRawDB = 0;
535       return;
536    }
537
538    // Create semaphore to say this file is finished
539    Int_t tfd = ::creat(Form("%s.done", fRawDB->GetName()), 0644);
540    close(tfd);
541
542    delete fRawDB;
543    fRawDB = 0;
544 }
545
546 //______________________________________________________________________________
547 Bool_t AliRawDB::NextFile()
548 {
549    // Close te current file and open a new one.
550    // Returns kFALSE in case opening failed.
551
552    Close();
553
554    if (!Create()) return kFALSE;
555    return kTRUE;
556 }
557
558 //______________________________________________________________________________
559 Float_t AliRawDB::GetCompressionFactor() const
560 {
561    // Return compression factor.
562
563    if (fTree->GetZipBytes() == 0.)
564       return 1.0;
565    else
566       return fTree->GetTotBytes()/fTree->GetZipBytes();
567 }
568
569
570 //______________________________________________________________________________
571 AliRawRFIODB::AliRawRFIODB(AliRawEvent *event, Double_t maxsize, Int_t compress)
572    : AliRawDB(event, maxsize, compress, kFALSE)
573 {
574    // Create a new raw DB that will be accessed via RFIO.
575
576 #ifndef USE_RDM
577    static int init = 0;
578    // Set STAGE_POOL environment variable to current host
579    if (!init) {
580       // THESE ENVIRONMENT SYMBOLS ARE NOW DEFINED BY THE ALICE DATE SETUP
581       // THEREFORE WE SHALL NOT USE ANY HARDCODED VALUES BUT RATHER USE
582       // WHATEVER HAS BEEN SET IN THE DATE SITE
583       //gSystem->Setenv("STAGE_POOL", "mdc4");
584       //gSystem->Setenv("STAGE_HOST", "lxshare003d");
585       init = 1;
586    }
587 #endif
588
589    if (!Create())
590       MakeZombie();
591    else
592       fRawDB->UseCache(50, 0x200000);  //0x100000 = 1MB)
593 }
594
595 //______________________________________________________________________________
596 const char *AliRawRFIODB::GetFileName()
597 {
598    // Return filename based on hostname and date and time. This will make
599    // each file unique. Also the directory will be made unique for each
600    // day by adding the date to the fs. Assumes there is always enough
601    // space on the device.
602
603    static TString fname;
604
605    TString fs = kRFIOFS;
606    TDatime dt;
607
608    // make a new subdirectory for each day
609    fs += "/adc-";
610    fs += dt.GetDate();
611
612    Long_t id, size, flags, time;
613    if (gSystem->GetPathInfo(fs, &id, &size, &flags, &time) == 1) {
614       // directory does not exist, create it
615       if (gSystem->mkdir(fs, kTRUE) == -1) {
616          Error("GetFileName", "cannot create dir %s, using %s", fs.Data(),
617                kRFIOFS);
618          fs = kRFIOFS;
619       }
620    }
621    // FIXME: should check if fs is a directory
622
623    TString hostname = gSystem->HostName();
624    Int_t pos;
625    if ((pos = hostname.Index(".")) != kNPOS)
626       hostname.Remove(pos);
627
628    fname = fs + "/" + hostname + "_";
629    fname += dt.GetDate();
630    fname += "_";
631    fname += dt.GetTime();
632    fname += ".root";
633
634    return fname;
635 }
636
637 //______________________________________________________________________________
638 void AliRawRFIODB::Close()
639 {
640    // Close raw RFIO DB.
641
642    if (!fRawDB) return;
643
644    fRawDB->cd();
645
646    // Write the tree.
647    fTree->Write();
648
649    // Close DB, this also deletes the fTree
650    fRawDB->Close();
651
652    if (AliMDC::DeleteFiles())
653       gSystem->Exec(Form("rfrm %s", fRawDB->GetName()));
654
655    delete fRawDB;
656    fRawDB = 0;
657 }
658
659
660 //______________________________________________________________________________
661 AliRawRootdDB::AliRawRootdDB(AliRawEvent *event, Double_t maxsize, Int_t compress)
662    : AliRawDB(event, maxsize, compress, kFALSE)
663 {
664    // Create a new raw DB that will be accessed via rootd daemon.
665
666    if (!Create())
667       MakeZombie();
668    else
669       fRawDB->UseCache(50, 0x200000);  //0x100000 = 1MB)
670 }
671
672 //______________________________________________________________________________
673 const char *AliRawRootdDB::GetFileName()
674 {
675    // Return filename based on hostname and date and time. This will make
676    // each file unique. Also the directory will be made unique for each
677    // day by adding the date to the fs. Assumes there is always enough
678    // space on the device.
679
680    static TString fname;
681
682    TString fs = kRootdFS;
683    TDatime dt;
684
685 #if 0
686    // make a new subdirectory for each day
687    fs += "/adc-";
688    fs += dt.GetDate();
689
690    Long_t id, size, flags, time;
691    if (gSystem->GetPathInfo(fs, &id, &size, &flags, &time) == 1) {
692       // directory does not exist, create it
693       if (gSystem->mkdir(fs, kTRUE) == -1) {
694          Error("GetFileName", "cannot create dir %s, using %s", fs.Data(),
695                kRootdFS);
696          fs = kRootdFS;
697       }
698    }
699    // FIXME: should check if fs is a directory
700 #endif
701
702    TString hostname = gSystem->HostName();
703    Int_t pos;
704    if ((pos = hostname.Index(".")) != kNPOS)
705       hostname.Remove(pos);
706
707    fname = fs + "/" + hostname + "_";
708    fname += dt.GetDate();
709    fname += "_";
710    fname += dt.GetTime();
711    fname += ".root";
712
713    return fname;
714 }
715
716 //______________________________________________________________________________
717 void AliRawRootdDB::Close()
718 {
719    // Close raw rootd DB.
720
721    if (!fRawDB) return;
722
723    fRawDB->cd();
724
725    // Write the tree.
726    fTree->Write();
727
728    // Close DB, this also deletes the fTree
729    fRawDB->Close();
730
731 #if 0
732    // can use services of TFTP
733    if (AliMDC::DeleteFiles())
734       gSystem->Exec(Form("rfrm %s", fRawDB->GetName()));
735 #endif
736
737    delete fRawDB;
738    fRawDB = 0;
739 }
740
741
742 //______________________________________________________________________________
743 AliRawNullDB::AliRawNullDB(AliRawEvent *event, Double_t maxsize, Int_t compress)
744    : AliRawDB(event, maxsize, compress, kFALSE)
745 {
746    // Create a new raw DB that will wrtie to /dev/null.
747
748    if (!Create())
749       MakeZombie();
750 }
751
752 //______________________________________________________________________________
753 const char *AliRawNullDB::GetFileName()
754 {
755    // Return /dev/null as filename.
756
757    return "/dev/null";
758 }
759
760 //______________________________________________________________________________
761 void AliRawNullDB::Close()
762 {
763    // Close raw RFIO DB.
764
765    if (!fRawDB) return;
766
767    fRawDB->cd();
768
769    // Write the tree.
770    fTree->Write();
771
772    // Close DB, this also deletes the fTree
773    fRawDB->Close();
774
775    delete fRawDB;
776    fRawDB = 0;
777 }
778
779
780 //______________________________________________________________________________
781 AliTagDB::AliTagDB(AliRawEventHeader *header, Double_t maxsize, Bool_t create)
782 {
783    // Create tag DB.
784
785    fHeader   = header;
786    fMaxSize  = maxsize;
787
788    if (create) {
789       if (!Create())
790          MakeZombie();
791    }
792 }
793
794 //______________________________________________________________________________
795 Bool_t AliTagDB::Create()
796 {
797    // Create a new tag DB.
798
799    fTagDB = new TFile(GetFileName(), "RECREATE",
800                       Form("ALICE MDC%d tag DB", kMDC), 1);
801    if (fTagDB->IsZombie()) {
802       Error("Create", "error opening tag DB");
803       fTagDB = 0;
804       return kFALSE;
805    }
806
807    // Create ROOT Tree object container
808    fTree = new TTree("TAG", Form("ALICE MDC%d header data tree", kMDC));
809    fTree->SetAutoSave(100000000);  // autosave when 100 Mbyte written
810
811    Int_t bufsize = 32000;
812    Int_t split   = 1;
813    fTree->Branch("header", "AliRawEventHeader", &fHeader, bufsize, split);
814
815    return kTRUE;
816 }
817
818 //______________________________________________________________________________
819 void AliTagDB::Close()
820 {
821    // Close tag DB.
822
823    if (!fTagDB) return;
824
825    fTagDB->cd();
826
827    // Write the tree.
828    fTree->Write();
829
830    // Close DB, this also deletes the fTree
831    fTagDB->Close();
832
833    if (AliMDC::DeleteFiles())
834       gSystem->Unlink(fTagDB->GetName());
835
836    delete fTagDB;
837    fTagDB = 0;
838 }
839
840 //______________________________________________________________________________
841 Bool_t AliTagDB::NextFile()
842 {
843    // Close te current file and open a new one.
844    // Returns kFALSE in case opening failed.
845
846    Close();
847
848    if (!Create()) return kFALSE;
849    return kTRUE;
850 }
851
852 //______________________________________________________________________________
853 Float_t AliTagDB::GetCompressionFactor() const
854 {
855    // Return compression factor.
856
857    if (fTree->GetZipBytes() == 0.)
858       return 1.0;
859    else
860       return fTree->GetTotBytes()/fTree->GetZipBytes();
861 }
862
863 //______________________________________________________________________________
864 const char *AliTagDB::GetFileName()
865 {
866    // Return filename based on hostname and date and time. This will make
867    // each file unique. The tags will be stored in the /data1/tags directory.
868
869    static char fname[64];
870    const char *fs = kTagDBFS;
871
872    // check that fs exists (crude check fails if fs is a file)
873    gSystem->MakeDirectory(fs);
874
875    char hostname[64];
876
877    strcpy(hostname, gSystem->HostName());
878
879    char *s;
880    if ((s = strchr(hostname, '.')))
881       *s = 0;
882
883    TDatime dt;
884
885    sprintf(fname, "%s/%s_%d_%d.root", fs, hostname, dt.GetDate(), dt.GetTime());
886
887    return fname;
888 }
889
890
891 //______________________________________________________________________________
892 AliTagNullDB::AliTagNullDB(AliRawEventHeader *header, Double_t maxsize) :
893    AliTagDB(header, maxsize, kFALSE)
894 {
895    // Create tag db writing to /dev/null.
896
897    if (!Create())
898       MakeZombie();
899 }
900
901 //______________________________________________________________________________
902 const char *AliTagNullDB::GetFileName()
903 {
904    // Return /dev/null as filename.
905
906    return "/dev/null";
907 }
908
909 //______________________________________________________________________________
910 void AliTagNullDB::Close()
911 {
912    // Close null tag DB.
913
914    if (!fTagDB) return;
915
916    fTagDB->cd();
917
918    // Write the tree.
919    fTree->Write();
920
921    // Close DB, this also deletes the fTree
922    fTagDB->Close();
923
924    delete fTagDB;
925    fTagDB = 0;
926 }
927
928
929 //______________________________________________________________________________
930 AliRunDB::AliRunDB()
931 {
932    // Open run database, and get or create tree.
933
934    // Get hostname
935    char hostname[64], filename[64];
936    const char *fs = kRunDBFS;
937
938    // check that fs exists (crude check fails if fs is a file)
939    gSystem->MakeDirectory(fs);
940
941    strcpy(hostname, gSystem->HostName());
942
943    char *s;
944    if ((s = strchr(hostname, '.')))
945       *s = 0;
946
947    sprintf(filename, "%s/%s_rundb.root", fs, hostname);
948
949    if (!gSystem->AccessPathName(filename, kFileExists))
950       fRunDB = new TFile(filename, "UPDATE");
951    else
952       fRunDB = new TFile(filename, "CREATE", Form("ALICE MDC%d Run DB", kMDC));
953 }
954
955 //______________________________________________________________________________
956 void AliRunDB::Update(AliStats *stats)
957 {
958    // Add stats object to database.
959
960    TDirectory *ds = gDirectory;
961    fRunDB->cd();
962
963    char sname[64];
964    char *s = (char*)strrchr(stats->GetFileName(), '/');
965    if (s) {
966       s++;
967       strcpy(sname, s);
968    } else
969       strcpy(sname, stats->GetFileName());
970    s = strchr(sname, '.');
971    if (s) *s = 0;
972
973    stats->Write(sname);
974
975    ds->cd();
976 }
977
978 //______________________________________________________________________________
979 void AliRunDB::UpdateRDBMS(AliStats *stats)
980 {
981    // Add stats object to central MySQL DB.
982
983    char sql[4096];
984    char bt[25], et[25];
985
986    strcpy(bt, stats->GetBeginTime().AsSQLString());
987    strcpy(et, stats->GetEndTime().AsSQLString());
988
989    sprintf(sql, "INSERT INTO mdc%dcatalog VALUES (0, '%s', %d, "
990            "%d, %d, %d, %d, %d, %d, %.2f, '%s', '%s', '%s')", kMDC,
991            stats->GetFileName(), (int)stats->GetFileSize(), stats->GetEvents(),
992            stats->GetFirstRun(), stats->GetFirstEvent(), stats->GetLastRun(),
993            stats->GetLastEvent(), stats->GetCompressionMode(),
994            stats->GetCompressionFactor(), stats->GetFilterState() ? "on" : "off",
995            bt, et);
996
997    // open connection to MySQL server on pcsalo
998    TSQLServer *db = TSQLServer::Connect("mysql://pcsalo.cern.ch/mdc", "alice", "amdc");
999
1000    if (!db || db->IsZombie()) {
1001       Error("UpdateRDBMS", "failed to connect to MySQL server on pcsalo");
1002       printf("%s\n", sql);
1003       delete db;
1004       return;
1005    }
1006
1007    TSQLResult *res = db->Query(sql);
1008
1009    if (!res) {
1010       Error("UpdateRDBMS", Form("insert into mdc%dcatalog failed", kMDC));
1011       printf("%s\n", sql);
1012    }
1013
1014    delete res;
1015    delete db;
1016 }
1017
1018 //______________________________________________________________________________
1019 void AliRunDB::Close()
1020 {
1021    // Close run database.
1022
1023    fRunDB->Close();
1024    delete fRunDB;
1025 }
1026
1027 //----------------- Use SIGUSR1 to interupt endless loop -----------------------
1028 class AliMDCInterruptHandler : public TSignalHandler {
1029 private:
1030    AliMDC *fMDC;   // alimdc to signal
1031 public:
1032    AliMDCInterruptHandler(AliMDC *mdc) : TSignalHandler(kSigUser1, kFALSE), fMDC(mdc) { }
1033    Bool_t Notify() { fMDC->SetStopLoop(); return kTRUE; }
1034 };
1035
1036 //______________________________________________________________________________
1037 AliMDC::AliMDC(Int_t fd, Int_t compress, Double_t maxFileSize, Bool_t useFilter,
1038                Bool_t useRFIO, Bool_t useROOTD, Bool_t useDEVNULL,
1039                Bool_t useLoop, Bool_t delFiles)
1040 {
1041    // Create MDC processor object.
1042
1043    fFd           = fd;
1044    fCompress     = compress;
1045    fMaxFileSize  = maxFileSize;
1046    fUseFilter    = useFilter;
1047    fUseRFIO      = useRFIO;
1048    fUseRootd     = useROOTD;
1049    fUseDevNull   = useDEVNULL;
1050    fUseLoop      = useLoop;
1051    fUseFifo      = kFALSE;
1052    fUseEb        = kFALSE;
1053    fStopLoop     = kFALSE;
1054    fNumEvents    = 0;
1055    fDebugLevel   = 0;
1056    fgDeleteFiles = delFiles;
1057
1058    if (fFd == -1) {
1059 #ifdef USE_EB
1060      if (!ebRegister()) {
1061         Error("AliMDC", "cannot register with the event builder (%s)",
1062               ebGetLastError());
1063         return;
1064      }
1065      fUseEb = kTRUE;
1066 #else
1067      if ((mkfifo(kFifo, 0644) < 0) && (errno != EEXIST)) {
1068          Error("AliMDC", "cannot create fifo %s", kFifo);
1069          return;
1070       }
1071       if ((chmod(kFifo, 0666) == -1) && (errno != EPERM)) {
1072          Error("AliMDC", "cannot change permission of fifo %s", kFifo);
1073          return;
1074       }
1075       if ((fFd = open(kFifo, O_RDONLY)) == -1) {
1076          Error("AliMDC", "cannot open input file %s", kFifo);
1077          return;
1078       }
1079       fUseFifo = kTRUE;
1080 #endif
1081       fUseLoop = kFALSE;
1082    }
1083
1084    printf("<AliMDC::AliMDC>: input = %s, rawdb size = %f, filter = %s, "
1085           "looping = %s, compression = %d, delete files = %s",
1086           fUseFifo ? "fifo" : (fUseEb ? "eb" : "file"), fMaxFileSize,
1087           fUseFilter ? "on" : "off", fUseLoop ? "yes" : "no", fCompress,
1088           fgDeleteFiles ? "yes" : "no");
1089    if (fUseRFIO)
1090       printf(", use RFIO\n");
1091    else if (fUseRootd)
1092       printf(", use rootd\n");
1093    else if (fUseDevNull)
1094       printf(", write raw data to /dev/null\n");
1095    else
1096       printf("\n");
1097
1098    // install SIGUSR1 handler to allow clean interrupts
1099    gSystem->AddSignalHandler(new AliMDCInterruptHandler(this));
1100
1101    gAliMDC = this;
1102 }
1103
1104 //______________________________________________________________________________
1105 Int_t AliMDC::Run()
1106 {
1107    // Run the MDC processor. Read from the input stream and only return
1108    // when the input gave and EOF or a fatal error occured. On success 0
1109    // is returned, 1 in case of a fatality.
1110
1111    TStopwatch timer;
1112    Int_t status;
1113
1114    // Make sure needed directories exist
1115    const char *dirs[4];
1116    dirs[0] = kRawDBFS[0];
1117    dirs[1] = kRawDBFS[1];
1118    dirs[2] = kTagDBFS;
1119    dirs[3] = kRunDBFS;
1120    for (int idir = 0; idir < 4; idir++) {
1121       gSystem->ResetErrno();
1122       gSystem->MakeDirectory(dirs[idir]);
1123       if (gSystem->GetErrno() && gSystem->GetErrno() != EEXIST) {
1124          SysError("Run", "mkdir %s", dirs[idir]);
1125          return 1;
1126       }
1127    }
1128
1129    // Used for statistics
1130    timer.Start();
1131    Double_t told = 0, tnew = 0;
1132    Float_t  chunkSize = fMaxFileSize/100, nextChunk = chunkSize;
1133
1134    // Event object used to store event data.
1135    AliRawEvent *event = new AliRawEvent;
1136
1137    // Create new raw DB.
1138    AliRawDB *rawdb;
1139    if (fUseRFIO)
1140       rawdb = new AliRawRFIODB(event, fMaxFileSize, fCompress);
1141    else if (fUseRootd)
1142       rawdb = new AliRawRootdDB(event, fMaxFileSize, fCompress);
1143    else if (fUseDevNull)
1144       rawdb = new AliRawNullDB(event, fMaxFileSize, fCompress);
1145    else
1146       rawdb = new AliRawDB(event, fMaxFileSize, fCompress);
1147
1148    if (rawdb->IsZombie()) return 1;
1149    printf("Filling raw DB %s\n", rawdb->GetDBName());
1150
1151    // Create new tag DB.
1152    AliTagDB *tagdb;
1153    if (fUseDevNull)
1154       tagdb = new AliTagNullDB(event->GetHeader(), kMaxTagFileSize);
1155    else
1156       tagdb = new AliTagDB(event->GetHeader(), kMaxTagFileSize);
1157    if (tagdb->IsZombie())
1158       tagdb = 0;
1159    else
1160       printf("Filling tag DB %s\n", tagdb->GetDBName());
1161
1162    // Create AliStats object
1163    AliStats *stats = new AliStats(rawdb->GetDBName(), fCompress, fUseFilter);
1164
1165    // Shortcut for easy header access
1166    AliRawEventHeader &header = *event->GetHeader();
1167
1168    // Process input stream
1169 #ifdef USE_EB
1170    while (!ebEor()) {
1171       struct iovec *ebvec;
1172       if ((ebvec = ebGetNextEvent()) == (void *)-1) {
1173          Error("Run", "error getting next event (%s)", ebGetLastError());
1174          break;
1175       }
1176       if (ebvec == 0) {
1177          // no event, sleep for 1 second and try again
1178          gSystem->Sleep(1000);
1179          continue;
1180       }
1181       char *ebdata = (char *) ebvec[0].iov_base;
1182 #else
1183    while (1) {
1184       char *ebdata = 0;
1185 #endif
1186
1187       // Read event header
1188       if ((status = ReadHeader(header, ebdata)) != header.HeaderSize()) {
1189          if (status == 0) {
1190             if (fUseLoop) {
1191 #ifndef USE_EB
1192                ::lseek(fFd, 0, SEEK_SET);
1193 #endif
1194                continue;
1195             }
1196             printf("<AliMDC::Run>: EOF, processed %d events\n", fNumEvents);
1197             break;
1198          }
1199          return 1;
1200       }
1201
1202       // If we were in looping mode stop directly after a SIGUSR1 signal
1203       if (StopLoop()) {
1204          Info("Run", "SIGUSR1, processed %d events", fNumEvents);
1205          break;
1206       }
1207
1208       // Check if event has any hard track flagged
1209       Bool_t callFilter = kFALSE;
1210       // This needs to be re-engineered for the next ADC...
1211       //if (fUseFilter && TEST_USER_ATTRIBUTE(header.GetTypeAttribute(), 0))
1212       //   callFilter = kTRUE;
1213
1214       // Check event type and skip "Start of Run", "End of Run",
1215       // "Start of Run Files" and "End of Run Files"
1216       switch (header.GetType()) {
1217          case kStartOfRun:
1218          case kEndOfRun:
1219          case kStartOfRunFiles:
1220          case kEndOfRunFiles:
1221             {
1222                Int_t skip = header.GetEventSize() - header.HeaderSize();
1223 #ifndef USE_EB
1224                ::lseek(fFd, skip, SEEK_CUR);
1225 #endif
1226                ALIDEBUG(1)
1227                   Info("Run", "Skipping %s (%d bytes)", header.GetTypeName(), skip);
1228                continue;
1229             }
1230             break;
1231          default:
1232             ALIDEBUG(1) {
1233                Int_t s = header.GetEventSize() - header.HeaderSize();
1234                Info("Run", "Processing %s (%d bytes)", header.GetTypeName(), s);
1235             }
1236       }
1237
1238       // Amount of data left to read for this event
1239       Int_t toRead = header.GetEventSize() - header.HeaderSize();
1240
1241       // If there is less data for this event than the next sub-event
1242       // header, something is wrong. Skip to next event...
1243       if (toRead < header.HeaderSize()) {
1244          if ((status = DumpEvent(toRead)) != toRead) {
1245             if (status == 0)
1246                break;
1247             return 1;
1248          }
1249          Error("Run", "discarding event %d (too little data for header)", fNumEvents);
1250          continue;
1251       }
1252
1253       // Loop over all sub-events... (LDCs)
1254       while (toRead > 0) {
1255          Int_t nsub = 1;
1256 #ifdef USE_EB
1257          ebdata = (char *)ebvec[nsub].iov_base;
1258 #endif
1259
1260          ALIDEBUG(1)
1261             Info("Run", "reading LDC %d", nsub);
1262
1263          AliRawEvent *subEvent = event->NextSubEvent();
1264
1265          // Read sub-event header
1266          AliRawEventHeader &subHeader = *subEvent->GetHeader();
1267          if ((status = ReadHeader(subHeader, ebdata)) != subHeader.HeaderSize()) {
1268             if (status == 0) {
1269                Error("Run", "unexpected EOF reading sub-event header");
1270                break;
1271             }
1272             return 1;
1273          }
1274
1275          toRead -= subHeader.HeaderSize();
1276
1277 #ifdef USE_EB
1278          ebdata = (char *)(ebvec[nsub].iov_base) + subHeader.HeaderSize();
1279 #endif
1280
1281          Int_t rawSize = subHeader.GetEventSize() - subHeader.HeaderSize();
1282
1283          // Read Equipment Header (in case of physics or calibration event)
1284          if (header.GetType() == kPhysicsEvent ||
1285              header.GetType() == kCalibrationEvent) {
1286             AliRawEquipmentHeader &equipment = *subEvent->GetEquipmentHeader();
1287             Int_t equipHeaderSize = equipment.HeaderSize();
1288             if ((status = ReadEquipmentHeader(equipment, header.DataIsSwapped(),
1289                                               ebdata)) != equipHeaderSize) {
1290                if (status == 0) {
1291                   Error("Run", "unexpected EOF reading equipment-header");
1292                   break;
1293                }
1294                return 1;
1295             }
1296             toRead  -= equipHeaderSize;
1297             rawSize -= equipHeaderSize;
1298 #ifdef USE_EB
1299             ebdata = (char *)(ebvec[nsub].iov_base) + subHeader.HeaderSize() +
1300                      equipHeaderSize;
1301 #endif
1302          }
1303
1304          // Make sure raw data less than left over bytes for current event
1305          if (rawSize > toRead) {
1306             if ((status = DumpEvent(toRead)) != toRead) {
1307                if (status == 0)
1308                   break;
1309                return 1;
1310             }
1311             Error("Run", "discarding event %d (too much data)", fNumEvents);
1312             continue;
1313          }
1314
1315          // Read sub-event raw data
1316          AliRawData &subRaw = *subEvent->GetRawData();
1317          if ((status = ReadRawData(subRaw, rawSize, ebdata)) != rawSize) {
1318             if (status == 0) {
1319                Error("Run", "unexpected EOF reading sub-event raw data");
1320                break;
1321             }
1322             return 1;
1323          }
1324
1325          if (callFilter) {
1326             if (TEST_USER_ATTRIBUTE(subHeader.GetTypeAttribute(), 0))
1327                Filter(subRaw);
1328             else {
1329                // set size of all sectors without hard track flag to 0
1330                subRaw.SetSize(0);
1331             }
1332          }
1333
1334          toRead -= rawSize;
1335          nsub++;
1336       }
1337
1338       // Set stat info for first event of this file
1339       if (rawdb->GetEvents() == 0)
1340          stats->SetFirstId(header.GetRunNumber(), header.GetEventInRun());
1341
1342       // Store raw event in tree
1343       rawdb->Fill();
1344
1345       // Store header in tree
1346       if (tagdb) tagdb->Fill();
1347
1348       fNumEvents++;
1349
1350       if (!(fNumEvents%10))
1351          printf("Processed event %d (%d)\n", fNumEvents, rawdb->GetEvents());
1352
1353       // Filling time statistics
1354       if (rawdb->GetBytesWritten() > nextChunk) {
1355          tnew = timer.RealTime();
1356          stats->Fill(tnew-told);
1357          told = tnew;
1358          timer.Continue();
1359          nextChunk += chunkSize;
1360       }
1361
1362       // Check size of raw db. If bigger than maxFileSize, close file
1363       // and continue with new file.
1364       if (rawdb->FileFull()) {
1365
1366          printf("Written raw DB at a rate of %.1f MB/s\n",
1367                 Float_t(fMaxFileSize / timer.RealTime() / 1000000.));
1368
1369          // Write stats object to raw db, run db and MySQL
1370          stats->WriteToDB(rawdb);
1371          delete stats;
1372
1373          if (!rawdb->NextFile()) return 1;
1374
1375          printf("Filling raw DB %s\n", rawdb->GetDBName());
1376          stats = new AliStats(rawdb->GetDBName(), fCompress, fUseFilter);
1377
1378          timer.Start();
1379          told = 0, tnew = 0;
1380          nextChunk = chunkSize;
1381       }
1382
1383       // Check size of tag db
1384       if (tagdb->FileFull()) {
1385          if (!tagdb->NextFile())
1386             tagdb = 0;
1387          else
1388             printf("Filling tag DB %s\n", tagdb->GetDBName());
1389       }
1390
1391       // Make top event object ready for next event data
1392       //printf("Event %d has %d sub-events\n", fNumEvents, event->GetNSubEvents());
1393       event->Reset();
1394
1395 #ifdef USE_EB
1396       if (!ebReleaseEvent(ebvec)) {
1397          Error("Run", "problem releasing event (%s)", ebGetLastError());
1398          break;
1399       }
1400 #endif
1401    }
1402
1403    printf("Written raw DB at a rate of %.1f MB/s\n",
1404           Float_t(fMaxFileSize / timer.RealTime() / 1000000.));
1405
1406    // Write stats to raw db and run db and delete stats object
1407    stats->WriteToDB(rawdb);
1408    delete stats;
1409
1410    // Close the raw DB
1411    delete rawdb;
1412
1413    // Close the tag DB
1414    delete tagdb;
1415
1416    // Close input source
1417    close(fFd);
1418
1419 #if 0
1420    // Cleanup fifo
1421    if (fUseFifo && ::unlink(kFifo) == -1) {
1422       SysError("Run", "unlink");
1423       return 1;
1424    }
1425 #endif
1426
1427    return 0;
1428 }
1429
1430 //______________________________________________________________________________
1431 Int_t AliMDC::Read(void *buffer, Int_t length)
1432 {
1433    // Read exactly length bytes into buffer. Returns number of bytes
1434    // received, returns -1 in case of error and 0 for EOF.
1435
1436    errno = 0;
1437
1438    if (fFd < 0) return -1;
1439
1440    Int_t n, nrecv = 0;
1441    char *buf = (char *)buffer;
1442
1443    for (n = 0; n < length; n += nrecv) {
1444       if ((nrecv = read(fFd, buf+n, length-n)) <= 0) {
1445          if (nrecv == 0)
1446             break;        // EOF
1447          if (errno != EINTR)
1448             SysError("Read", "read");
1449          return -1;
1450       }
1451    }
1452    return n;
1453 }
1454
1455 //______________________________________________________________________________
1456 Int_t AliMDC::ReadHeader(AliRawEventHeader &header, void *eb)
1457 {
1458    // Read header info from DATE data stream. Returns bytes read (i.e.
1459    // AliRawEventHeader::HeaderSize()), -1 in case of error and 0 for EOF.
1460
1461    Int_t nrecv;
1462
1463    if (eb) {
1464       // read from event builder memory area
1465       memcpy(header.HeaderBegin(), eb, header.HeaderSize());
1466       nrecv = header.HeaderSize();
1467    } else {
1468       // read from fifo or file
1469       if ((nrecv = Read(header.HeaderBegin(), header.HeaderSize())) !=
1470            header.HeaderSize()) {
1471          if (nrecv == 0)
1472             return 0;
1473          return -1;
1474       }
1475    }
1476
1477    // Swap header data if needed
1478    if (header.IsSwapped())
1479       header.Swap();
1480
1481    // Is header valid...
1482    if (!header.IsValid()) {
1483       Error("ReadHeader", "invalid header format");
1484       // try recovery... how?
1485       return -1;
1486    }
1487    if (header.GetEventSize() < (UInt_t)header.HeaderSize()) {
1488       Error("ReadHeader", "invalid header size");
1489       // try recovery... how?
1490       return -1;
1491    }
1492
1493    return nrecv;
1494 }
1495
1496 //______________________________________________________________________________
1497 Int_t AliMDC::ReadEquipmentHeader(AliRawEquipmentHeader &header,
1498                                   Bool_t isSwapped, void *eb)
1499 {
1500    // Read equipment header info from DATE data stream. Returns bytes read
1501    // (i.e. AliRawEquipmentHeader::HeaderSize()), -1 in case of error and
1502    // 0 for EOF. If isSwapped is kTRUE the event data is byte swapped
1503    // and we will swap the header to host format.
1504
1505    Int_t nrecv;
1506
1507    if (eb) {
1508       // read from event builder memory area
1509       memcpy(header.HeaderBegin(), eb, header.HeaderSize());
1510       nrecv = header.HeaderSize();
1511    } else {
1512       // read from fifo or file
1513       if ((nrecv = Read(header.HeaderBegin(), header.HeaderSize())) !=
1514            header.HeaderSize()) {
1515          if (nrecv == 0)
1516             return 0;
1517          return -1;
1518       }
1519    }
1520
1521    // Swap equipment header data if needed
1522    if (isSwapped)
1523       header.Swap();
1524
1525    if (header.GetEquipmentSize() < (UInt_t)header.HeaderSize()) {
1526       Error("ReadEquipmentHeader", "invalid equipment header size");
1527       // try recovery... how?
1528       return -1;
1529    }
1530
1531    return nrecv;
1532 }
1533
1534 //______________________________________________________________________________
1535 Int_t AliMDC::ReadRawData(AliRawData &raw, Int_t size, void *eb)
1536 {
1537    // Read raw data from DATE data stream. Returns bytes read (i.e.
1538    // AliRawEventHeader::HeaderSize()), -1 in case of error and 0 for EOF.
1539
1540    Int_t nrecv;
1541
1542    if (eb) {
1543       // read from event builder memory area
1544       raw.SetBuffer(eb, size);
1545       nrecv = size;
1546    } else {
1547       // read from fifo or file
1548       raw.SetSize(size);
1549       if ((nrecv = Read(raw.GetBuffer(), size)) != size) {
1550          if (nrecv == 0) {
1551             Error("ReadRawData", "unexpected EOF");
1552             return 0;
1553          }
1554          return -1;
1555       }
1556    }
1557
1558    return nrecv;
1559 }
1560
1561 //______________________________________________________________________________
1562 Int_t AliMDC::DumpEvent(Int_t toRead)
1563 {
1564    // This case should not happen, but if it does try to handle it
1565    // gracefully by reading the rest of the event and discarding it.
1566    // Returns bytes read, -1 in case of fatal error and 0 for EOF.
1567
1568    Error("DumpEvent", "dumping %d bytes of event %d", toRead, fNumEvents);
1569
1570    Int_t nrecv;
1571    char *tbuf = new char[toRead];
1572    if ((nrecv = Read(tbuf, toRead)) != toRead) {
1573       if (nrecv == 0) {
1574          Error("DumpEvent", "unexpected EOF");
1575          return 0;
1576       }
1577       return -1;
1578    }
1579    delete [] tbuf;
1580
1581    return nrecv;
1582 }
1583
1584 #ifdef USE_HLT
1585 #include <AliTPCL3Tunnel.h>
1586 #endif
1587
1588 //______________________________________________________________________________
1589 Int_t AliMDC::Filter(AliRawData &raw)
1590 {
1591    // Call 3rd level filter for this raw data segment.
1592
1593 #ifdef USE_HLT
1594    AliTPCL3Tunnel *tunnel = 0;
1595    if (!tunnel) {
1596       // initialisation
1597       tunnel = new AliTPCL3Tunnel(Form("%s/TPCparams.root",
1598                                        gSystem->Getenv("ALITPC")));
1599    }
1600
1601    Int_t obytes, nbytes;
1602    obytes = nbytes = raw.GetSize();
1603    char *outbuf = tunnel->EvalTrack((char *)raw.GetBuffer(), nbytes);
1604
1605    raw.SetSize(nbytes);
1606    memcpy(raw.GetBuffer(), outbuf, nbytes);
1607
1608    printf("Filter called for event %d: reduced from %d to %d\n", fNumEvents,
1609           obytes, nbytes);
1610
1611 #else
1612
1613    raw.GetSize();
1614    printf("Filter called for event %d\n", fNumEvents);
1615
1616 #endif
1617
1618    return 0;
1619 }