changing msg to aliinfo
[u/mrichter/AliRoot.git] / RAW / AliRawDB.cxx
index c60280b..ca8c1aa 100644 (file)
@@ -1,4 +1,4 @@
-// @(#)alimdc:$Name$:$Id$
+// @(#)alimdc:$Name:  $:$Id$
 // Author: Fons Rademakers  26/11/99
 
 /**************************************************************************
 //////////////////////////////////////////////////////////////////////////
 
 #include <errno.h>
+#include <Riostream.h>
+
+#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,0)
+#include <TBufferFile.h>
+#else
+#include <TBuffer.h>
+#endif
 
 #include <TSystem.h>
 #include <TKey.h>
 
-#include "AliESD.h"
-#include "AliRawEvent.h"
+#include <TObjString.h>
+
+#include <TBranch.h>
+
+#include "AliESDEvent.h"
+#include "AliRawEventV2.h"
+#include "AliRawDataArrayV2.h"
 #include "AliRawEventHeaderBase.h"
-#include "AliStats.h"
+#include "AliRawEquipmentHeader.h"
 
 #include "AliRawDB.h"
 
 
 ClassImp(AliRawDB)
 
-const char *AliRawDB::fgkAliRootTag = "$Name$";
+const char *AliRawDB::fgkAliRootTag = "$Rev$";
+
+// Split TPC into 18 branches in order to avoid problems with big memory
+// consumption in case of TPC events w/o zero-suppression
+Int_t AliRawDB::fgkDetBranches[AliDAQ::kNDetectors+1] = {1,1,1,18,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,10,1};
 
 //______________________________________________________________________________
-AliRawDB::AliRawDB(AliRawEvent *event,
-                  AliESD *esd, 
+AliRawDB::AliRawDB(AliRawEventV2 *event,
+                  AliESDEvent *esd, 
                   Int_t compress,
-                   const char* fileName) :
+                   const char* fileName,
+                  Int_t basketsize) :
   fRawDB(NULL),
   fTree(NULL),
   fEvent(event),
   fESDTree(NULL),
   fESD(esd),
   fCompress(compress),
+  fBasketSize(basketsize),
   fMaxSize(-1),
   fFS1(""),
   fFS2(""),
@@ -58,12 +76,37 @@ AliRawDB::AliRawDB(AliRawEvent *event,
 {
    // Create a new raw DB
 
+  for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
+    fDetRawData[iDet] = new AliRawDataArrayV2*[fgkDetBranches[iDet]];
+    Int_t nDDLsPerBranch = AliDAQ::NumberOfDdls(iDet)/fgkDetBranches[iDet];
+    for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
+      fDetRawData[iDet][iBranch] = new AliRawDataArrayV2(nDDLsPerBranch);
+  }
+
+  fDetRawData[AliDAQ::kNDetectors] = new AliRawDataArrayV2*[fgkDetBranches[AliDAQ::kNDetectors]];
+  for (Int_t iBranch = 0; iBranch < fgkDetBranches[AliDAQ::kNDetectors]; iBranch++)
+    fDetRawData[AliDAQ::kNDetectors][iBranch] = new AliRawDataArrayV2(100);
+
    if (fileName) {
       if (!Create(fileName))
          MakeZombie();
    }
 }
 
+
+//______________________________________________________________________________
+AliRawDB::~AliRawDB() {
+  // Destructor
+
+  if(Close()==-1) Error("~AliRawDB", "cannot close output file!");
+
+  for (Int_t iDet = 0; iDet < (AliDAQ::kNDetectors + 1); iDet++) {
+    for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
+      delete fDetRawData[iDet][iBranch];
+    delete [] fDetRawData[iDet];
+  }
+}
+
 //______________________________________________________________________________
 Bool_t AliRawDB::FSHasSpace(const char *fs) const
 {
@@ -214,39 +257,63 @@ again:
       return kFALSE;
    }
 
-   // Create raw data TTree
-   MakeTree();
-
    return kTRUE;
 }
 
+static void BranchResetBit(TBranch *b) 
+{
+  // Reset MapObject on this branch and all the sub-branches
+
+  b->ResetBit( kBranchObject | kBranchAny ); // Or in newer ROOT: b->ResetBit( kMapObject )
+  TIter next( b->GetListOfBranches() );
+  TBranch *sub = 0;
+  while ( (sub = (TBranch*)next() ) ) {
+    BranchResetBit( sub );
+  }
+}
+
 //______________________________________________________________________________
 void AliRawDB::MakeTree()
 {
    // Create ROOT Tree object container.
 
    fTree = new TTree("RAW", Form("ALICE raw-data tree (%s)", GetAliRootTag()));
-   fTree->SetAutoSave(2000000000);  // autosave when 2 Gbyte written
+   fTree->SetAutoSave(21000000000LL);  // autosave when 21 Gbyte written
+
+   fTree->BranchRef();
 
-   Int_t bufsize = 256000;
-   // splitting 29.6 MB/s, no splitting 35.3 MB/s on P4 2GHz 15k SCSI
-   //Int_t split   = 1;
-   Int_t split   = 0;
-   fTree->Branch("rawevent", "AliRawEvent", &fEvent, bufsize, split);
+   Int_t split   = 99;
+   TBranch *b = fTree->Branch("rawevent", "AliRawEventV2", &fEvent, fBasketSize, split);
+   BranchResetBit(b);
+
+   // Make brach for each sub-detector
+   for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
+     for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++) {
+       b = fTree->Branch(Form("%s%d",AliDAQ::DetectorName(iDet),iBranch),"AliRawDataArrayV2",
+                        &fDetRawData[iDet][iBranch],fBasketSize,split);
+       BranchResetBit(b);
+     }
+   }
+   // Make special branch for unrecognized raw-data payloads
+   for (Int_t iBranch = 0; iBranch < fgkDetBranches[AliDAQ::kNDetectors]; iBranch++) {
+     b = fTree->Branch(Form("Common%d",iBranch),"AliRawDataArrayV2",
+                      &fDetRawData[AliDAQ::kNDetectors][iBranch],fBasketSize,split);
+     BranchResetBit(b);
+   }
 
    // 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
+     fESDTree->SetAutoSave(21000000000LL);  // autosave when 21 Gbyte written
      split   = 0;
-     fESDTree->Branch("ESD", "AliESD", &fESD, bufsize, split);
+     fESDTree->Branch("ESD", "AliESDEvent", &fESD, fBasketSize, split);
    }
 
 }
 
 //______________________________________________________________________________
-Int_t AliRawDB::Close()
+Long64_t AliRawDB::Close()
 {
    // Close raw DB.
    if (!fRawDB) return 0;
@@ -257,8 +324,9 @@ Int_t AliRawDB::Close()
 
    // Write the tree.
    Bool_t error = kFALSE;
-   if (fTree->Write() == 0)
-     error = kTRUE;
+   if (fTree)
+     if (fTree->Write() == 0)
+       error = kTRUE;
    if (fESDTree)
      if (fESDTree->Write() == 0)
        error = kTRUE;
@@ -266,7 +334,9 @@ Int_t AliRawDB::Close()
    // Close DB, this also deletes the fTree
    fRawDB->Close();
 
-   Int_t filesize = fRawDB->GetEND();
+   fTree = NULL;
+
+   Long64_t filesize = fRawDB->GetEND();
 
    if (fDeleteFiles) {
       gSystem->Unlink(fRawDB->GetName());
@@ -289,7 +359,10 @@ Int_t AliRawDB::Close()
 //______________________________________________________________________________
 Int_t AliRawDB::Fill()
 {
-   // Fill the trees and return the number of written bytes
+  // Fill the trees and return the number of written bytes
+
+  // Create raw data TTree if it not yet done
+  if (!fTree) MakeTree();
 
    Double_t bytes = fRawDB->GetBytesWritten();
    Bool_t error = kFALSE;
@@ -305,23 +378,19 @@ Int_t AliRawDB::Fill()
 }
 
 //______________________________________________________________________________
-Int_t AliRawDB::GetTotalSize()
+Long64_t AliRawDB::GetTotalSize()
 {
    // Return the total size of the trees
-  Int_t total = 0;
+  Long64_t total = 0;
 
-  {
+  if (fTree) {
     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();
+    total += (Long64_t)skey + fTree->GetZipBytes();
   }
 
   if(fESDTree)
@@ -332,33 +401,23 @@ Int_t AliRawDB::GetTotalSize()
        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();
+      total += (Long64_t)skey + fESDTree->GetZipBytes();
     }
 
   return total;
 }
 
 //______________________________________________________________________________
-void AliRawDB::WriteStats(AliStats* stats)
+Long64_t AliRawDB::AutoSave()
 {
-   // 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.GetP("Id")[0]);
-   stats->SetFileSize(GetBytesWritten());
-   stats->SetCompressionFactor(GetCompressionFactor());
-   stats->SetEndTime();
-   stats->Write("stats");
-   ds->cd();
+  // Auto-save the raw-data and
+  // esd (if any) trees
+
+  Long64_t nbytes = fTree->AutoSave();
+
+  if (fESDTree) nbytes += fESDTree->AutoSave();
+
+  return nbytes;
 }
 
 //______________________________________________________________________________
@@ -391,9 +450,78 @@ const char *AliRawDB::GetAliRootTag()
   // used to generate the raw data file.
   // Stored in the raw-data file title.
 
-  TString version = fgkAliRootTag;
+  static TString version = fgkAliRootTag;
   version.Remove(TString::kBoth,'$');
-  version.ReplaceAll("Name","AliRoot version");
+  version.ReplaceAll("Rev","AliRoot version");
 
   return version.Data();
 }
+
+//______________________________________________________________________________
+Bool_t AliRawDB::WriteGuidFile(TString &guidFileFolder)
+{
+  // Write the guid file
+  // in the specified folder or
+  // in the folder where the raw data
+  // file is.
+
+   TString guidFileName;
+   if (!guidFileFolder.IsNull()) {
+     guidFileName = guidFileFolder;
+
+     TString pathStr = fRawDB->GetName();
+     TObjArray *pathArr = pathStr.Tokenize('/');
+     guidFileName.Append("/");
+     guidFileName.Append(((TObjString *)pathArr->Last())->String());
+     pathArr->Delete();
+     delete pathArr;
+   }
+   else
+     guidFileName = fRawDB->GetName();
+
+   guidFileName += ".guid";
+
+   ofstream fguid(guidFileName.Data());
+   if (!fguid.is_open()) {
+     Error("WriteGuidFile", "failure to open guid file %s", guidFileName.Data());
+     return kFALSE;
+   }
+   TString guid = fRawDB->GetUUID().AsString();
+   fguid << "guid: \t" << guid.Data();
+   fguid.close();
+
+   return kTRUE;
+}
+
+
+//______________________________________________________________________________
+void AliRawDB::Reset()
+{
+  // Clear the raw-data arrays
+  // Should be done before processing the raw-data event
+
+  for (Int_t iDet = 0; iDet < (AliDAQ::kNDetectors + 1); iDet++)
+    for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
+      fDetRawData[iDet][iBranch]->ClearData();
+}
+
+//______________________________________________________________________________
+AliRawDataArrayV2 *AliRawDB::GetRawDataArray(UInt_t eqSize, UInt_t eqId) const
+{
+  // Return the corresponding raw-datra array (branch)
+  // depending on the equipment ID
+
+  Int_t iDet = AliDAQ::kNDetectors;
+  Int_t iBranch = 0; // can we split somehow the unrecognized data??? For the moment - no
+  if(eqSize) {
+    Int_t ddlIndex = -1;
+    iDet = AliDAQ::DetectorIDFromDdlID(eqId,ddlIndex);
+    if (iDet < 0 || iDet >= AliDAQ::kNDetectors)
+      iDet = AliDAQ::kNDetectors;
+    else
+      iBranch = (ddlIndex * fgkDetBranches[iDet])/AliDAQ::NumberOfDdls(iDet);
+  }
+
+  return fDetRawData[iDet][iBranch];
+}
+