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