Removing semaphore .done files.
[u/mrichter/AliRoot.git] / RAW / AliRawDB.cxx
index 508cd71..08df5a9 100644 (file)
 #include <errno.h>
 
 #include <TSystem.h>
+#include <TKey.h>
 
-#ifdef ALI_DATE
-#include "event.h"
-#endif
-
+#include "AliESD.h"
 #include "AliRawEvent.h"
-#include "AliRawEventHeader.h"
-#include "AliMDC.h"
+#include "AliRawEventHeaderBase.h"
+#include "AliStats.h"
 
 #include "AliRawDB.h"
 
 
 ClassImp(AliRawDB)
 
+const char *AliRawDB::fgkAliRootTag = "$Name$";
 
 //______________________________________________________________________________
-AliRawDB::AliRawDB(AliRawEvent *event, Double_t maxsize, Int_t compress,
-                   Bool_t create)
+AliRawDB::AliRawDB(AliRawEvent *event,
+                  AliESD *esd, 
+                  Int_t compress,
+                   const char* fileName) :
+  fRawDB(NULL),
+  fTree(NULL),
+  fEvent(event),
+  fESDTree(NULL),
+  fESD(esd),
+  fCompress(compress),
+  fMaxSize(-1),
+  fFS1(""),
+  fFS2(""),
+  fDeleteFiles(kFALSE),
+  fStop(kFALSE)
 {
-   // Create a new raw DB containing at most maxsize bytes.
-
-   fEvent    = event;
-   fMaxSize  = maxsize;
-   fCompress = compress;
-
-   // Consistency check with DATE header file
-#ifdef ALI_DATE
-   if (fEvent->GetHeader()->HeaderSize() != EVENT_HEAD_BASE_SIZE) {
-      Error("AliRawDB", "inconsistency between DATE and AliRawEvent headers");
-      MakeZombie();
-      return;
-   }
-#endif
+   // Create a new raw DB
 
-   if (create) {
-      if (!Create())
+   if (fileName) {
+      if (!Create(fileName))
          MakeZombie();
    }
 }
 
-//______________________________________________________________________________
-AliRawDB::AliRawDB(const AliRawDB& rawDB): TObject(rawDB)
-{
-// copy constructor
-
-  Fatal("AliRawDB", "copy constructor not implemented");
-}
-
-//______________________________________________________________________________
-AliRawDB& AliRawDB::operator = (const AliRawDB& /*rawDB*/)
-{
-// assignment operator
-
-  Fatal("operator =", "assignment operator not implemented");
-  return *this;
-}
-
 //______________________________________________________________________________
 Bool_t AliRawDB::FSHasSpace(const char *fs) const
 {
@@ -115,7 +97,7 @@ const char *AliRawDB::GetFileName() const
    static TString fname;
    static Bool_t  fstoggle = kFALSE;
 
-   TString fs = fstoggle ? AliMDC::RawDBFS(1) : AliMDC::RawDBFS(0);
+   TString fs = fstoggle ? fFS2 : fFS1;
    TDatime dt;
 
    TString hostname = gSystem->HostName();
@@ -126,12 +108,11 @@ const char *AliRawDB::GetFileName() const
    if (!FSHasSpace(fs)) {
       while (1) {
          fstoggle = !fstoggle;
-         fs = fstoggle ? AliMDC::RawDBFS(1) : AliMDC::RawDBFS(0);
+         fs = fstoggle ? fFS2 : fFS1;
          if (FSHasSpace(fs)) break;
          Info("GetFileName", "sleeping 30 seconds before retrying...");
          gSystem->Sleep(30000);   // sleep for 30 seconds
-         if (AliMDC::Instance() && AliMDC::Instance()->StopLoop())
-            return 0;
+         if (fStop) return 0;
       }
    }
 
@@ -147,20 +128,44 @@ const char *AliRawDB::GetFileName() const
 }
 
 //______________________________________________________________________________
-Bool_t AliRawDB::Create()
+void AliRawDB::SetFS(const char* fs1, const char* fs2)
+{
+// set the file system location
+
+  fFS1 = fs1;
+  if (fs1 && !fFS1.Contains(":")) {
+    gSystem->ResetErrno();
+    gSystem->MakeDirectory(fs1);
+    if (gSystem->GetErrno() && gSystem->GetErrno() != EEXIST) {
+      SysError("SetFS", "mkdir %s", fs1);
+    }
+  }
+
+  fFS2 = fs2;
+  if (fs2) {
+    gSystem->ResetErrno();
+    gSystem->MakeDirectory(fs2);
+    if (gSystem->GetErrno() && gSystem->GetErrno() != EEXIST) {
+      SysError("SetFS", "mkdir %s", fs2);
+    }
+  }
+}
+
+//______________________________________________________________________________
+Bool_t AliRawDB::Create(const char* fileName)
 {
    // Create a new raw DB.
 
-   const Int_t kMaxRetry = 200;
+   const Int_t kMaxRetry = 1;
    const Int_t kMaxSleep = 1;      // seconds
    const Int_t kMaxSleepLong = 10; // seconds
    Int_t retry = 0;
 
 again:
-   if (AliMDC::Instance() && AliMDC::Instance()->StopLoop())
-      return kFALSE;
+   if (fStop) return kFALSE;
 
-   const char *fname = GetFileName();
+   const char *fname = fileName;
+   if (!fname) fname = GetFileName();
    if (!fname) {
       Error("Create", "error getting raw DB file name");
       return kFALSE;
@@ -169,8 +174,8 @@ again:
    retry++;
 
    fRawDB = TFile::Open(fname, GetOpenOption(),
-                        Form("ALICE MDC%d raw DB", AliMDC::kMDC), fCompress,
-                        GetNetopt());
+                       Form("ALICE raw-data file (%s)", GetAliRootTag()), fCompress,
+                       GetNetopt());
    if (!fRawDB) {
       if (retry < kMaxRetry) {
          Warning("Create", "failure to open file, sleeping %d %s before retrying...",
@@ -220,7 +225,7 @@ void AliRawDB::MakeTree()
 {
    // Create ROOT Tree object container.
 
-   fTree = new TTree("RAW", Form("ALICE MDC%d raw data tree", AliMDC::kMDC));
+   fTree = new TTree("RAW", Form("ALICE raw-data tree (%s)", GetAliRootTag()));
    fTree->SetAutoSave(2000000000);  // autosave when 2 Gbyte written
 
    Int_t bufsize = 256000;
@@ -228,47 +233,143 @@ void AliRawDB::MakeTree()
    //Int_t split   = 1;
    Int_t split   = 0;
    fTree->Branch("rawevent", "AliRawEvent", &fEvent, bufsize, split);
+
+   // Create tree which will contain the HLT ESD information
+
+   if (fESD) {
+     fESDTree = new TTree("esdTree", Form("ALICE HLT ESD tree (%s)", GetAliRootTag()));
+     fESDTree->SetAutoSave(2000000000);  // autosave when 2 Gbyte written
+     split   = 0;
+     fESDTree->Branch("ESD", "AliESD", &fESD, bufsize, split);
+   }
+
 }
 
 //______________________________________________________________________________
-void AliRawDB::Close()
+Int_t AliRawDB::Close()
 {
    // Close raw DB.
+   if (!fRawDB) return 0;
 
-   if (!fRawDB) return;
+   if (!fRawDB->IsOpen()) return 0;
 
    fRawDB->cd();
 
    // Write the tree.
-   fTree->Write();
+   Bool_t error = kFALSE;
+   if (fTree->Write() == 0)
+     error = kTRUE;
+   if (fESDTree)
+     if (fESDTree->Write() == 0)
+       error = kTRUE;
 
    // Close DB, this also deletes the fTree
    fRawDB->Close();
 
-   if (AliMDC::DeleteFiles()) {
+   Int_t filesize = fRawDB->GetEND();
+
+   if (fDeleteFiles) {
       gSystem->Unlink(fRawDB->GetName());
       delete fRawDB;
       fRawDB = 0;
-      return;
+      if(!error)
+       return filesize;
+      else
+       return -1;
    }
 
-   // Create semaphore to say this file is finished
-   Int_t tfd = ::creat(Form("%s.done", fRawDB->GetName()), 0644);
-   close(tfd);
-
    delete fRawDB;
    fRawDB = 0;
+   if(!error)
+     return filesize;
+   else
+     return -1;
+}
+
+//______________________________________________________________________________
+Int_t AliRawDB::Fill()
+{
+   // Fill the trees and return the number of written bytes
+
+   Double_t bytes = fRawDB->GetBytesWritten();
+   Bool_t error = kFALSE;
+   if (fTree->Fill() == -1)
+     error = kTRUE;
+   if (fESDTree) 
+     if (fESDTree->Fill() == -1)
+       error = kTRUE;
+   if(!error)
+     return Int_t(fRawDB->GetBytesWritten() - bytes);
+   else
+     return -1;
+}
+
+//______________________________________________________________________________
+Int_t AliRawDB::GetTotalSize()
+{
+   // Return the total size of the trees
+  Int_t total = 0;
+
+  {
+    Int_t skey = 0;
+    TDirectory *dir = fTree->GetDirectory();
+    if (dir) {
+      TKey *key = dir->GetKey(fTree->GetName());
+      if (key) skey = key->GetKeylen();
+    }
+    total += skey;
+    if (fTree->GetZipBytes() > 0) total += fTree->GetTotBytes();
+    TBuffer b(TBuffer::kWrite,10000);
+    TTree::Class()->WriteBuffer(b,fTree);
+    total += b.Length();
+  }
+
+  if(fESDTree)
+    {
+      Int_t skey = 0;
+      TDirectory *dir = fESDTree->GetDirectory();
+      if (dir) {
+       TKey *key = dir->GetKey(fESDTree->GetName());
+       if (key) skey = key->GetKeylen();
+      }
+      total += skey;
+      if (fESDTree->GetZipBytes() > 0) total += fESDTree->GetTotBytes();
+      TBuffer b(TBuffer::kWrite,10000);
+      TTree::Class()->WriteBuffer(b,fESDTree);
+      total += b.Length();
+    }
+
+  return total;
+}
+
+//______________________________________________________________________________
+void AliRawDB::WriteStats(AliStats* stats)
+{
+   // Write stats to raw DB, local run DB and global MySQL DB.
+
+   AliRawEventHeaderBase &header = *GetEvent()->GetHeader();
+
+   // Write stats into RawDB
+   TDirectory *ds = gDirectory;
+   GetDB()->cd();
+   stats->SetEvents(GetEvents());
+   stats->SetLastId(header.Get("RunNb"), header.GetP("Id")[0]);
+   stats->SetFileSize(GetBytesWritten());
+   stats->SetCompressionFactor(GetCompressionFactor());
+   stats->SetEndTime();
+   stats->Write("stats");
+   ds->cd();
 }
 
 //______________________________________________________________________________
-Bool_t AliRawDB::NextFile()
+Bool_t AliRawDB::NextFile(const char* fileName)
 {
    // Close te current file and open a new one.
    // Returns kFALSE in case opening failed.
 
    Close();
 
-   if (!Create()) return kFALSE;
+   if (!Create(fileName)) return kFALSE;
    return kTRUE;
 }
 
@@ -282,3 +383,17 @@ Float_t AliRawDB::GetCompressionFactor() const
    else
       return fTree->GetTotBytes()/fTree->GetZipBytes();
 }
+
+//______________________________________________________________________________
+const char *AliRawDB::GetAliRootTag()
+{
+  // Return the aliroot tag (version)
+  // used to generate the raw data file.
+  // Stored in the raw-data file title.
+
+  TString version = fgkAliRootTag;
+  version.Remove(TString::kBoth,'$');
+  version.ReplaceAll("Name","AliRoot version");
+
+  return version.Data();
+}