[u/mrichter/AliRoot.git] / RAW / AliRawDB.cxx

// @(#)alimdc:$Name:  $:$Id$
// Author: Fons Rademakers  26/11/99

/**************************************************************************
 * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// AliRawDB                                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#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 <TObjString.h>

#include "AliESDEvent.h"
#include "AliRawEvent.h"
#include "AliRawDataArray.h"
#include "AliRawEventHeaderBase.h"
#include "AliRawEquipment.h"
#include "AliRawEquipmentHeader.h"
#include "AliStats.h"

#include "AliRawDB.h"


ClassImp(AliRawDB)

const char *AliRawDB::fgkAliRootTag = "$Rev$";

// Split TPC into 9 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,
		   AliESDEvent *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

  for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
    fDetRawData[iDet] = new AliRawDataArray*[fgkDetBranches[iDet]];
    Int_t nDDLsPerBranch = AliDAQ::NumberOfDdls(iDet)/fgkDetBranches[iDet];
    for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
      fDetRawData[iDet][iBranch] = new AliRawDataArray(nDDLsPerBranch);
  }

  fDetRawData[AliDAQ::kNDetectors] = new AliRawDataArray*[fgkDetBranches[AliDAQ::kNDetectors]];
  for (Int_t iBranch = 0; iBranch < fgkDetBranches[AliDAQ::kNDetectors]; iBranch++)
    fDetRawData[AliDAQ::kNDetectors][iBranch] = new AliRawDataArray(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
{
   // Check for at least fMaxSize bytes of free space on the file system.
   // If the space is not available return kFALSE, kTRUE otherwise.

   Long_t id, bsize, blocks, bfree;

   if (gSystem->GetFsInfo(fs, &id, &bsize, &blocks, &bfree) == 1) {
      Error("FSHasSpace", "could not stat file system %s", fs);
      return kFALSE;
   }

   // Leave 5 percent of diskspace free
   Double_t avail = Double_t(bfree) * 0.95;
   if (avail*bsize > fMaxSize)
      return kTRUE;

   Warning("FSHasSpace", "no space on file system %s", fs);
   return kFALSE;
}

//______________________________________________________________________________
const char *AliRawDB::GetFileName() const
{
   // Return filename based on hostname and date and time. This will make
   // each file unique. Also makes sure (via FSHasSpace()) that there is
   // enough space on the file system to store the file. Returns 0 in
   // case of error or interrupt signal.

   static TString fname;
   static Bool_t  fstoggle = kFALSE;

   TString fs = fstoggle ? fFS2 : fFS1;
   TDatime dt;

   TString hostname = gSystem->HostName();
   Int_t pos;
   if ((pos = hostname.Index(".")) != kNPOS)
      hostname.Remove(pos);

   if (!FSHasSpace(fs)) {
      while (1) {
         fstoggle = !fstoggle;
         fs = fstoggle ? fFS2 : fFS1;
         if (FSHasSpace(fs)) break;
         Info("GetFileName", "sleeping 30 seconds before retrying...");
         gSystem->Sleep(30000);   // sleep for 30 seconds
         if (fStop) return 0;
      }
   }

   fname = fs + "/" + hostname + "_";
   fname += dt.GetDate();
   fname += "_";
   fname += dt.GetTime();
   fname += ".root";

   fstoggle = !fstoggle;

   return fname;
}

//______________________________________________________________________________
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 = 1;
   const Int_t kMaxSleep = 1;      // seconds
   const Int_t kMaxSleepLong = 10; // seconds
   Int_t retry = 0;

again:
   if (fStop) return kFALSE;

   const char *fname = fileName;
   if (!fname) fname = GetFileName();
   if (!fname) {
      Error("Create", "error getting raw DB file name");
      return kFALSE;
   }

   retry++;

   fRawDB = TFile::Open(fname, GetOpenOption(),
			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...",
                 kMaxSleep, kMaxSleep==1 ? "second" : "seconds");
         gSystem->Sleep(kMaxSleep*1000);
         goto again;
      }
      Error("Create", "failure to open file %s after %d tries", fname, kMaxRetry);
      return kFALSE;
   }
   if (retry > 1)
      Warning("Create", "succeeded to open file after %d retries", retry);

   if (fRawDB->IsZombie()) {
      if (fRawDB->GetErrno() == ENOSPC ||
          fRawDB->GetErrno() == 1018   ||   // SECOMERR
          fRawDB->GetErrno() == 1027) {     // SESYSERR
         fRawDB->ResetErrno();
         delete fRawDB;
         Warning("Create", "file is a zombie (no space), sleeping %d %s before retrying...",
                 kMaxSleepLong, kMaxSleepLong==1 ? "second" : "seconds");
         gSystem->Sleep(kMaxSleepLong*1000);   // sleep 10 seconds before retrying
         goto again;
      }
      Error("Create", "file %s is zombie", fname);
      fRawDB->ResetErrno();
      delete fRawDB;
      fRawDB = 0;
      if (retry < kMaxRetry) {
         Warning("Create", "file is a zombie, sleeping %d %s before retrying...",
                 kMaxSleep, kMaxSleep==1 ? "second" : "seconds");
         gSystem->Sleep(kMaxSleep*1000);
         goto again;
      }
      Error("Create", "failure to open file %s after %d tries", fname, kMaxRetry);
      return kFALSE;
   }

   // Create raw data TTree
   MakeTree();

   return kTRUE;
}

//______________________________________________________________________________
void AliRawDB::MakeTree()
{
   // Create ROOT Tree object container.

   fTree = new TTree("RAW", Form("ALICE raw-data tree (%s)", GetAliRootTag()));
   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);

   // Make brach for each sub-detector
   for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
     for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
       fTree->Branch(Form("%s%d",AliDAQ::DetectorName(iDet),iBranch),"AliRawDataArray",
		     &fDetRawData[iDet][iBranch],bufsize,split);
   }
   // Make special branch for unrecognized raw-data payloads
   for (Int_t iBranch = 0; iBranch < fgkDetBranches[AliDAQ::kNDetectors]; iBranch++)
     fTree->Branch(Form("Common%d",iBranch),"AliRawDataArray",
		   &fDetRawData[AliDAQ::kNDetectors][iBranch],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(21000000000LL);  // autosave when 21 Gbyte written
     split   = 0;
     fESDTree->Branch("ESD", "AliESDEvent", &fESD, bufsize, split);
   }

}

//______________________________________________________________________________
Long64_t AliRawDB::Close()
{
   // Close raw DB.
   if (!fRawDB) return 0;

   if (!fRawDB->IsOpen()) return 0;

   fRawDB->cd();

   // Write the tree.
   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();

   Long64_t filesize = fRawDB->GetEND();

   if (fDeleteFiles) {
      gSystem->Unlink(fRawDB->GetName());
      delete fRawDB;
      fRawDB = 0;
      if(!error)
	return filesize;
      else
	return -1;
   }

   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

  for (Int_t iDet = 0; iDet < (AliDAQ::kNDetectors + 1); iDet++)
    for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
      fDetRawData[iDet][iBranch]->ClearData();

   // Move the raw-data payloads to the corresponding branches
  for(Int_t iSubEvent = 0; iSubEvent < fEvent->GetNSubEvents(); iSubEvent++) {
    AliRawEvent *subEvent = fEvent->GetSubEvent(iSubEvent);
    for(Int_t iEquipment = 0; iEquipment < subEvent->GetNEquipments(); iEquipment++) {
      AliRawEquipment *equipment = subEvent->GetEquipment(iEquipment);
      Int_t iDet = AliDAQ::kNDetectors;
      Int_t iBranch = 0; // can we split somehow the unrecognized data??? For the moment - no
      if(equipment->GetEquipmentHeader()->GetEquipmentSize()) {
	UInt_t eqId = equipment->GetEquipmentHeader()->GetId();
	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);
      }
      equipment->SetRawDataRef(fDetRawData[iDet][iBranch]);
    }
  }

   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;
}

//______________________________________________________________________________
Long64_t AliRawDB::GetTotalSize()
{
   // Return the total size of the trees
  Long64_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 += (Long64_t)skey + fTree->GetZipBytes();
  }

  if(fESDTree)
    {
      Int_t skey = 0;
      TDirectory *dir = fESDTree->GetDirectory();
      if (dir) {
	TKey *key = dir->GetKey(fESDTree->GetName());
	if (key) skey = key->GetKeylen();
      }
      total += (Long64_t)skey + fESDTree->GetZipBytes();
    }

  return total;
}

//______________________________________________________________________________
Long64_t AliRawDB::AutoSave()
{
  // Auto-save the raw-data and
  // esd (if any) trees

  Long64_t nbytes = fTree->AutoSave();

  if (fESDTree) nbytes += fESDTree->AutoSave();

  return nbytes;
}

//______________________________________________________________________________
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.GetP("Id")[0]);
   stats->SetFileSize(GetBytesWritten());
   stats->SetCompressionFactor(GetCompressionFactor());
   stats->SetEndTime();
   stats->Write("stats");
   ds->cd();
}

//______________________________________________________________________________
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(fileName)) return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Float_t AliRawDB::GetCompressionFactor() const
{
   // Return compression factor.

   if (fTree->GetZipBytes() == 0.)
      return 1.0;
   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.

  static TString version = fgkAliRootTag;
  version.Remove(TString::kBoth,'$');
  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;
}
Commit	Line	Data
60838f24	1	// @(#)alimdc:$Name: $:$Id$
a197a4ce	2	// Author: Fons Rademakers 26/11/99
	3
	4	/**************************************************************************
	5	* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
	6	* *
	7	* Author: The ALICE Off-line Project. *
	8	* Contributors are mentioned in the code where appropriate. *
	9	* *
	10	* Permission to use, copy, modify and distribute this software and its *
	11	* documentation strictly for non-commercial purposes is hereby granted *
	12	* without fee, provided that the above copyright notice appears in all *
	13	* copies and that both the copyright notice and this permission notice *
	14	* appear in the supporting documentation. The authors make no claims *
	15	* about the suitability of this software for any purpose. It is *
	16	* provided "as is" without express or implied warranty. *
	17	**************************************************************************/
	18
	19	//////////////////////////////////////////////////////////////////////////
	20	// //
	21	// AliRawDB //
	22	// //
	23	//////////////////////////////////////////////////////////////////////////
	24
	25	#include <errno.h>
a1377739	26	#include <Riostream.h>
a197a4ce	27
e6694ae0	28	#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,0)
	29	#include <TBufferFile.h>
	30	#else
	31	#include <TBuffer.h>
	32	#endif
	33
a197a4ce	34	#include <TSystem.h>
d21e9888	35	#include <TKey.h>
a197a4ce	36
5d315e4d	37	#include <TObjString.h>
5d315e4d	38
af885e0f	39	#include "AliESDEvent.h"
a197a4ce	40	#include "AliRawEvent.h"
6605cb7a	41	#include "AliRawDataArray.h"
f2dc6b20	42	#include "AliRawEventHeaderBase.h"
6605cb7a	43	#include "AliRawEquipment.h"
6605cb7a	44	#include "AliRawEquipmentHeader.h"
b7d09bb3	45	#include "AliStats.h"
a109e73e	46
a197a4ce	47	#include "AliRawDB.h"
	48
	49
	50	ClassImp(AliRawDB)
	51
60838f24	52	const char *AliRawDB::fgkAliRootTag = "$Rev$";
a197a4ce	53
30d59ac8	54	// Split TPC into 9 branches in order to avoid problems with big memory
30d59ac8	55	// consumption in case of TPC events w/o zero-suppression
7034c7a7	56	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};
30d59ac8	57
a197a4ce	58	//______________________________________________________________________________
a109e73e	59	AliRawDB::AliRawDB(AliRawEvent *event,
af885e0f	60	AliESDEvent *esd,
e10815f1	61	Int_t compress,
	62	const char* fileName) :
	63	fRawDB(NULL),
	64	fTree(NULL),
	65	fEvent(event),
	66	fESDTree(NULL),
	67	fESD(esd),
	68	fCompress(compress),
	69	fMaxSize(-1),
	70	fFS1(""),
	71	fFS2(""),
	72	fDeleteFiles(kFALSE),
19359f9c	73	fStop(kFALSE)
a197a4ce	74	{
e10815f1	75	// Create a new raw DB
a197a4ce	76
30d59ac8	77	for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
	78	fDetRawData[iDet] = new AliRawDataArray*[fgkDetBranches[iDet]];
	79	Int_t nDDLsPerBranch = AliDAQ::NumberOfDdls(iDet)/fgkDetBranches[iDet];
	80	for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
	81	fDetRawData[iDet][iBranch] = new AliRawDataArray(nDDLsPerBranch);
	82	}
6605cb7a	83
30d59ac8	84	fDetRawData[AliDAQ::kNDetectors] = new AliRawDataArray*[fgkDetBranches[AliDAQ::kNDetectors]];
	85	for (Int_t iBranch = 0; iBranch < fgkDetBranches[AliDAQ::kNDetectors]; iBranch++)
	86	fDetRawData[AliDAQ::kNDetectors][iBranch] = new AliRawDataArray(100);
6605cb7a	87
e10815f1	88	if (fileName) {
e10815f1	89	if (!Create(fileName))
a197a4ce	90	MakeZombie();
	91	}
	92	}
	93
6605cb7a	94
	95	//______________________________________________________________________________
	96	AliRawDB::~AliRawDB() {
	97	// Destructor
	98
	99	if(Close()==-1) Error("~AliRawDB", "cannot close output file!");
	100
30d59ac8	101	for (Int_t iDet = 0; iDet < (AliDAQ::kNDetectors + 1); iDet++) {
	102	for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
	103	delete fDetRawData[iDet][iBranch];
	104	delete [] fDetRawData[iDet];
	105	}
6605cb7a	106	}
6605cb7a	107
a197a4ce	108	//______________________________________________________________________________
	109	Bool_t AliRawDB::FSHasSpace(const char *fs) const
	110	{
	111	// Check for at least fMaxSize bytes of free space on the file system.
	112	// If the space is not available return kFALSE, kTRUE otherwise.
	113
	114	Long_t id, bsize, blocks, bfree;
	115
	116	if (gSystem->GetFsInfo(fs, &id, &bsize, &blocks, &bfree) == 1) {
	117	Error("FSHasSpace", "could not stat file system %s", fs);
	118	return kFALSE;
	119	}
	120
	121	// Leave 5 percent of diskspace free
	122	Double_t avail = Double_t(bfree) * 0.95;
	123	if (avail*bsize > fMaxSize)
	124	return kTRUE;
	125
	126	Warning("FSHasSpace", "no space on file system %s", fs);
	127	return kFALSE;
	128	}
	129
	130	//______________________________________________________________________________
	131	const char *AliRawDB::GetFileName() const
	132	{
	133	// Return filename based on hostname and date and time. This will make
	134	// each file unique. Also makes sure (via FSHasSpace()) that there is
	135	// enough space on the file system to store the file. Returns 0 in
	136	// case of error or interrupt signal.
	137
	138	static TString fname;
	139	static Bool_t fstoggle = kFALSE;
	140
e10815f1	141	TString fs = fstoggle ? fFS2 : fFS1;
a197a4ce	142	TDatime dt;
	143
	144	TString hostname = gSystem->HostName();
	145	Int_t pos;
	146	if ((pos = hostname.Index(".")) != kNPOS)
	147	hostname.Remove(pos);
	148
	149	if (!FSHasSpace(fs)) {
	150	while (1) {
	151	fstoggle = !fstoggle;
e10815f1	152	fs = fstoggle ? fFS2 : fFS1;
a197a4ce	153	if (FSHasSpace(fs)) break;
	154	Info("GetFileName", "sleeping 30 seconds before retrying...");
	155	gSystem->Sleep(30000); // sleep for 30 seconds
e10815f1	156	if (fStop) return 0;
a197a4ce	157	}
	158	}
	159
	160	fname = fs + "/" + hostname + "_";
	161	fname += dt.GetDate();
	162	fname += "_";
	163	fname += dt.GetTime();
	164	fname += ".root";
	165
	166	fstoggle = !fstoggle;
	167
	168	return fname;
	169	}
	170
	171	//______________________________________________________________________________
e10815f1	172	void AliRawDB::SetFS(const char* fs1, const char* fs2)
	173	{
	174	// set the file system location
	175
	176	fFS1 = fs1;
	177	if (fs1 && !fFS1.Contains(":")) {
	178	gSystem->ResetErrno();
	179	gSystem->MakeDirectory(fs1);
	180	if (gSystem->GetErrno() && gSystem->GetErrno() != EEXIST) {
	181	SysError("SetFS", "mkdir %s", fs1);
	182	}
	183	}
	184
	185	fFS2 = fs2;
	186	if (fs2) {
	187	gSystem->ResetErrno();
	188	gSystem->MakeDirectory(fs2);
	189	if (gSystem->GetErrno() && gSystem->GetErrno() != EEXIST) {
	190	SysError("SetFS", "mkdir %s", fs2);
	191	}
	192	}
	193	}
	194
	195	//______________________________________________________________________________
	196	Bool_t AliRawDB::Create(const char* fileName)
a197a4ce	197	{
	198	// Create a new raw DB.
	199
f07ec911	200	const Int_t kMaxRetry = 1;
a197a4ce	201	const Int_t kMaxSleep = 1; // seconds
	202	const Int_t kMaxSleepLong = 10; // seconds
	203	Int_t retry = 0;
	204
	205	again:
e10815f1	206	if (fStop) return kFALSE;
a197a4ce	207
e10815f1	208	const char *fname = fileName;
e10815f1	209	if (!fname) fname = GetFileName();
a197a4ce	210	if (!fname) {
	211	Error("Create", "error getting raw DB file name");
	212	return kFALSE;
	213	}
	214
	215	retry++;
	216
	217	fRawDB = TFile::Open(fname, GetOpenOption(),
ee8f2a6c	218	Form("ALICE raw-data file (%s)", GetAliRootTag()), fCompress,
f07ec911	219	GetNetopt());
a197a4ce	220	if (!fRawDB) {
	221	if (retry < kMaxRetry) {
	222	Warning("Create", "failure to open file, sleeping %d %s before retrying...",
	223	kMaxSleep, kMaxSleep==1 ? "second" : "seconds");
	224	gSystem->Sleep(kMaxSleep*1000);
	225	goto again;
	226	}
	227	Error("Create", "failure to open file %s after %d tries", fname, kMaxRetry);
	228	return kFALSE;
	229	}
	230	if (retry > 1)
	231	Warning("Create", "succeeded to open file after %d retries", retry);
	232
	233	if (fRawDB->IsZombie()) {
	234	if (fRawDB->GetErrno() == ENOSPC \|\|
	235	fRawDB->GetErrno() == 1018 \|\| // SECOMERR
	236	fRawDB->GetErrno() == 1027) { // SESYSERR
	237	fRawDB->ResetErrno();
	238	delete fRawDB;
	239	Warning("Create", "file is a zombie (no space), sleeping %d %s before retrying...",
	240	kMaxSleepLong, kMaxSleepLong==1 ? "second" : "seconds");
	241	gSystem->Sleep(kMaxSleepLong*1000); // sleep 10 seconds before retrying
	242	goto again;
	243	}
	244	Error("Create", "file %s is zombie", fname);
	245	fRawDB->ResetErrno();
	246	delete fRawDB;
	247	fRawDB = 0;
	248	if (retry < kMaxRetry) {
	249	Warning("Create", "file is a zombie, sleeping %d %s before retrying...",
	250	kMaxSleep, kMaxSleep==1 ? "second" : "seconds");
	251	gSystem->Sleep(kMaxSleep*1000);
	252	goto again;
	253	}
	254	Error("Create", "failure to open file %s after %d tries", fname, kMaxRetry);
	255	return kFALSE;
	256	}
	257
	258	// Create raw data TTree
	259	MakeTree();
	260
	261	return kTRUE;
	262	}
	263
	264	//______________________________________________________________________________
	265	void AliRawDB::MakeTree()
	266	{
	267	// Create ROOT Tree object container.
	268
ee8f2a6c	269	fTree = new TTree("RAW", Form("ALICE raw-data tree (%s)", GetAliRootTag()));
60838f24	270	fTree->SetAutoSave(21000000000LL); // autosave when 21 Gbyte written
a197a4ce	271
6605cb7a	272	fTree->BranchRef();
6605cb7a	273
a197a4ce	274	Int_t bufsize = 256000;
	275	// splitting 29.6 MB/s, no splitting 35.3 MB/s on P4 2GHz 15k SCSI
	276	//Int_t split = 1;
	277	Int_t split = 0;
	278	fTree->Branch("rawevent", "AliRawEvent", &fEvent, bufsize, split);
a109e73e	279
6605cb7a	280	// Make brach for each sub-detector
6605cb7a	281	for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
30d59ac8	282	for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
	283	fTree->Branch(Form("%s%d",AliDAQ::DetectorName(iDet),iBranch),"AliRawDataArray",
	284	&fDetRawData[iDet][iBranch],bufsize,split);
6605cb7a	285	}
6605cb7a	286	// Make special branch for unrecognized raw-data payloads
30d59ac8	287	for (Int_t iBranch = 0; iBranch < fgkDetBranches[AliDAQ::kNDetectors]; iBranch++)
	288	fTree->Branch(Form("Common%d",iBranch),"AliRawDataArray",
	289	&fDetRawData[AliDAQ::kNDetectors][iBranch],bufsize,split);
6605cb7a	290
a109e73e	291	// Create tree which will contain the HLT ESD information
a109e73e	292
e10815f1	293	if (fESD) {
ee8f2a6c	294	fESDTree = new TTree("esdTree", Form("ALICE HLT ESD tree (%s)", GetAliRootTag()));
60838f24	295	fESDTree->SetAutoSave(21000000000LL); // autosave when 21 Gbyte written
5f42007f	296	split = 0;
af885e0f	297	fESDTree->Branch("ESD", "AliESDEvent", &fESD, bufsize, split);
e10815f1	298	}
a109e73e	299
a197a4ce	300	}
	301
	302	//______________________________________________________________________________
d2450633	303	Long64_t AliRawDB::Close()
a197a4ce	304	{
a197a4ce	305	// Close raw DB.
f07ec911	306	if (!fRawDB) return 0;
a197a4ce	307
f07ec911	308	if (!fRawDB->IsOpen()) return 0;
a197a4ce	309
	310	fRawDB->cd();
	311
	312	// Write the tree.
f07ec911	313	Bool_t error = kFALSE;
	314	if (fTree->Write() == 0)
	315	error = kTRUE;
	316	if (fESDTree)
	317	if (fESDTree->Write() == 0)
	318	error = kTRUE;
a197a4ce	319
	320	// Close DB, this also deletes the fTree
	321	fRawDB->Close();
	322
d2450633	323	Long64_t filesize = fRawDB->GetEND();
f07ec911	324
e10815f1	325	if (fDeleteFiles) {
a197a4ce	326	gSystem->Unlink(fRawDB->GetName());
	327	delete fRawDB;
	328	fRawDB = 0;
f07ec911	329	if(!error)
	330	return filesize;
	331	else
	332	return -1;
a197a4ce	333	}
a197a4ce	334
a197a4ce	335	delete fRawDB;
a197a4ce	336	fRawDB = 0;
f07ec911	337	if(!error)
	338	return filesize;
	339	else
	340	return -1;
a197a4ce	341	}
a197a4ce	342
e10815f1	343	//______________________________________________________________________________
	344	Int_t AliRawDB::Fill()
	345	{
	346	// Fill the trees and return the number of written bytes
	347
6605cb7a	348	for (Int_t iDet = 0; iDet < (AliDAQ::kNDetectors + 1); iDet++)
30d59ac8	349	for (Int_t iBranch = 0; iBranch < fgkDetBranches[iDet]; iBranch++)
30d59ac8	350	fDetRawData[iDet][iBranch]->ClearData();
6605cb7a	351
	352	// Move the raw-data payloads to the corresponding branches
	353	for(Int_t iSubEvent = 0; iSubEvent < fEvent->GetNSubEvents(); iSubEvent++) {
	354	AliRawEvent *subEvent = fEvent->GetSubEvent(iSubEvent);
	355	for(Int_t iEquipment = 0; iEquipment < subEvent->GetNEquipments(); iEquipment++) {
	356	AliRawEquipment *equipment = subEvent->GetEquipment(iEquipment);
c3f47a4c	357	Int_t iDet = AliDAQ::kNDetectors;
	358	Int_t iBranch = 0; // can we split somehow the unrecognized data??? For the moment - no
	359	if(equipment->GetEquipmentHeader()->GetEquipmentSize()) {
	360	UInt_t eqId = equipment->GetEquipmentHeader()->GetId();
	361	Int_t ddlIndex = -1;
	362	iDet = AliDAQ::DetectorIDFromDdlID(eqId,ddlIndex);
	363	if (iDet < 0 \|\| iDet >= AliDAQ::kNDetectors)
	364	iDet = AliDAQ::kNDetectors;
	365	else
	366	iBranch = (ddlIndex * fgkDetBranches[iDet])/AliDAQ::NumberOfDdls(iDet);
30d59ac8	367	}
30d59ac8	368	equipment->SetRawDataRef(fDetRawData[iDet][iBranch]);
6605cb7a	369	}
	370	}
	371
e10815f1	372	Double_t bytes = fRawDB->GetBytesWritten();
f07ec911	373	Bool_t error = kFALSE;
	374	if (fTree->Fill() == -1)
	375	error = kTRUE;
	376	if (fESDTree)
	377	if (fESDTree->Fill() == -1)
	378	error = kTRUE;
	379	if(!error)
	380	return Int_t(fRawDB->GetBytesWritten() - bytes);
	381	else
	382	return -1;
e10815f1	383	}
e10815f1	384
d21e9888	385	//______________________________________________________________________________
60838f24	386	Long64_t AliRawDB::GetTotalSize()
d21e9888	387	{
d21e9888	388	// Return the total size of the trees
60838f24	389	Long64_t total = 0;
d21e9888	390
	391	{
	392	Int_t skey = 0;
	393	TDirectory *dir = fTree->GetDirectory();
	394	if (dir) {
	395	TKey *key = dir->GetKey(fTree->GetName());
	396	if (key) skey = key->GetKeylen();
	397	}
60838f24	398	total += (Long64_t)skey + fTree->GetZipBytes();
d21e9888	399	}
	400
	401	if(fESDTree)
	402	{
	403	Int_t skey = 0;
	404	TDirectory *dir = fESDTree->GetDirectory();
	405	if (dir) {
	406	TKey *key = dir->GetKey(fESDTree->GetName());
	407	if (key) skey = key->GetKeylen();
	408	}
60838f24	409	total += (Long64_t)skey + fESDTree->GetZipBytes();
d21e9888	410	}
	411
	412	return total;
	413	}
	414
0cd3f979	415	//______________________________________________________________________________
	416	Long64_t AliRawDB::AutoSave()
	417	{
	418	// Auto-save the raw-data and
	419	// esd (if any) trees
	420
	421	Long64_t nbytes = fTree->AutoSave();
	422
	423	if (fESDTree) nbytes += fESDTree->AutoSave();
	424
	425	return nbytes;
	426	}
	427
b7d09bb3	428	//______________________________________________________________________________
	429	void AliRawDB::WriteStats(AliStats* stats)
	430	{
	431	// Write stats to raw DB, local run DB and global MySQL DB.
	432
f2dc6b20	433	AliRawEventHeaderBase &header = *GetEvent()->GetHeader();
b7d09bb3	434
	435	// Write stats into RawDB
	436	TDirectory *ds = gDirectory;
	437	GetDB()->cd();
	438	stats->SetEvents(GetEvents());
ad594815	439	stats->SetLastId(header.GetP("Id")[0]);
b7d09bb3	440	stats->SetFileSize(GetBytesWritten());
	441	stats->SetCompressionFactor(GetCompressionFactor());
	442	stats->SetEndTime();
	443	stats->Write("stats");
	444	ds->cd();
	445	}
	446
a197a4ce	447	//______________________________________________________________________________
e10815f1	448	Bool_t AliRawDB::NextFile(const char* fileName)
a197a4ce	449	{
	450	// Close te current file and open a new one.
	451	// Returns kFALSE in case opening failed.
	452
	453	Close();
	454
e10815f1	455	if (!Create(fileName)) return kFALSE;
a197a4ce	456	return kTRUE;
	457	}
	458
	459	//______________________________________________________________________________
	460	Float_t AliRawDB::GetCompressionFactor() const
	461	{
	462	// Return compression factor.
	463
	464	if (fTree->GetZipBytes() == 0.)
	465	return 1.0;
	466	else
	467	return fTree->GetTotBytes()/fTree->GetZipBytes();
	468	}
ee8f2a6c	469
	470	//______________________________________________________________________________
	471	const char *AliRawDB::GetAliRootTag()
	472	{
	473	// Return the aliroot tag (version)
	474	// used to generate the raw data file.
	475	// Stored in the raw-data file title.
	476
544dec61	477	static TString version = fgkAliRootTag;
ee8f2a6c	478	version.Remove(TString::kBoth,'$');
ff5606a9	479	version.ReplaceAll("Rev","AliRoot version");
ee8f2a6c	480
	481	return version.Data();
	482	}
5d315e4d	483
5d315e4d	484	//______________________________________________________________________________
581835ab	485	Bool_t AliRawDB::WriteGuidFile(TString &guidFileFolder)
5d315e4d	486	{
5d315e4d	487	// Write the guid file
19359f9c	488	// in the specified folder or
	489	// in the folder where the raw data
	490	// file is.
5d315e4d	491
5d315e4d	492	TString guidFileName;
581835ab	493	if (!guidFileFolder.IsNull()) {
19359f9c	494	guidFileName = guidFileFolder;
5d315e4d	495
	496	TString pathStr = fRawDB->GetName();
	497	TObjArray *pathArr = pathStr.Tokenize('/');
	498	guidFileName.Append("/");
	499	guidFileName.Append(((TObjString *)pathArr->Last())->String());
	500	pathArr->Delete();
	501	delete pathArr;
	502	}
	503	else
	504	guidFileName = fRawDB->GetName();
	505
	506	guidFileName += ".guid";
	507
	508	ofstream fguid(guidFileName.Data());
19359f9c	509	if (!fguid.is_open()) {
	510	Error("WriteGuidFile", "failure to open guid file %s", guidFileName.Data());
	511	return kFALSE;
	512	}
5d315e4d	513	TString guid = fRawDB->GetUUID().AsString();
	514	fguid << "guid: \t" << guid.Data();
	515	fguid.close();
19359f9c	516
19359f9c	517	return kTRUE;
5d315e4d	518	}