conversion of raw data DDL files to a DATE and a root file
authortkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 15 Jun 2004 10:43:22 +0000 (10:43 +0000)
committertkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 15 Jun 2004 10:43:22 +0000 (10:43 +0000)
STEER/AliSimulation.cxx
STEER/AliSimulation.h

index 71da5a69e9e41aae542bb46f7f4c6679bdab842e..22daf93f88089150fd30f326f9de024935e05a8f 100644 (file)
 //                                                                           //
 //   sim.SetWriteRawData("MUON");   // write raw data for MUON               //
 //                                                                           //
+// The default output format of the raw data are DDL files. They are         //
+// converted to a DATE file, if a file name is given as second argument.     //
+// For this conversion the program "dateStream" is required. If the file     //
+// name has the extension ".root", the DATE file is converted to a root      //
+// file. The program "alimdc" is used for this purpose. For the conversion   //
+// to DATE and root format the two conversion programs have to be installed. //
+// Only the raw data in the final format is kept if the third argument is    //
+// kTRUE.                                                                    //
+//                                                                           //
 // The methods RunSimulation, RunSDigitization, RunDigitization,             //
 // RunHitsDigitization and WriteRawData can be used to run only parts of     //
-// the full simulation chain.                                                //
+// the full simulation chain. The creation of raw data DDL files and their   //
+// conversion to the DATE or root format can be run directly by calling      //
+// the methods WriteRawFiles, ConvertRawFilesToDate and ConvertDateToRoot.   //
 //                                                                           //
 // The default number of events per file, which is usually set in the        //
 // config file, can be changed for individual detectors and data types       //
@@ -121,6 +132,8 @@ AliSimulation::AliSimulation(const char* configFileName,
   fMakeDigits("ALL"),
   fMakeDigitsFromHits(""),
   fWriteRawData(""),
+  fRawDataFileName(""),
+  fDeleteIntermediateFiles(kFALSE),
   fStopOnError(kFALSE),
 
   fNEvents(1),
@@ -146,6 +159,8 @@ AliSimulation::AliSimulation(const AliSimulation& sim) :
   fMakeDigits(sim.fMakeDigits),
   fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
   fWriteRawData(sim.fWriteRawData),
+  fRawDataFileName(""),
+  fDeleteIntermediateFiles(kFALSE),
   fStopOnError(sim.fStopOnError),
 
   fNEvents(sim.fNEvents),
@@ -288,7 +303,8 @@ Bool_t AliSimulation::Run(Int_t nEvents)
 
   // digits -> raw data
   if (!fWriteRawData.IsNull()) {
-    if (!WriteRawData(fWriteRawData)) {
+    if (!WriteRawData(fWriteRawData, fRawDataFileName, 
+                     fDeleteIntermediateFiles)) {
       if (fStopOnError) return kFALSE;
     }
   }
@@ -531,18 +547,70 @@ Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
 }
 
 //_____________________________________________________________________________
-Bool_t AliSimulation::WriteRawData(const char* detectors)
+Bool_t AliSimulation::WriteRawData(const char* detectors, 
+                                  const char* fileName,
+                                  Bool_t deleteIntermediateFiles)
 {
 // convert the digits to raw data
+// First DDL raw data files for the given detectors are created.
+// If a file name is given, the DDL files are then converted to a DATE file.
+// If deleteIntermediateFiles is true, the DDL raw files are deleted 
+// afterwards.
+// If the file name has the extension ".root", the DATE file is converted
+// to a root file.
+// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
 
   TStopwatch stopwatch;
   stopwatch.Start();
 
-  AliRunLoader* runLoader = LoadRun();
+  if (!WriteRawFiles(detectors)) {
+    if (fStopOnError) return kFALSE;
+  }
+
+  TString dateFileName(fileName);
+  if (!dateFileName.IsNull()) {
+    Bool_t rootOutput = dateFileName.EndsWith(".root");
+    if (rootOutput) dateFileName += ".date";
+    if (!ConvertRawFilesToDate(dateFileName)) {
+      if (fStopOnError) return kFALSE;
+    }
+    if (deleteIntermediateFiles) {
+      AliRunLoader* runLoader = LoadRun("READ");
+      if (runLoader) for (Int_t iEvent = 0; 
+                         iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+       char command[256];
+       sprintf(command, "rm -r raw%d", iEvent);
+       gSystem->Exec(command);
+      }
+    }
+
+    if (rootOutput) {
+      if (!ConvertDateToRoot(dateFileName, fileName)) {
+       if (fStopOnError) return kFALSE;
+      }
+      if (deleteIntermediateFiles) {
+       gSystem->Unlink(dateFileName);
+      }
+    }
+  }
+
+  Info("WriteRawData", "execution time:");
+  stopwatch.Print();
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::WriteRawFiles(const char* detectors)
+{
+// convert the digits to raw data DDL files
+
+  AliRunLoader* runLoader = LoadRun("READ");
   if (!runLoader) return kFALSE;
 
+  // write raw data to DDL files
   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
-    Info("WriteRawData", "processing event %d", iEvent);
+    Info("WriteRawFiles", "processing event %d", iEvent);
     runLoader->GetEvent(iEvent);
     TString baseDir = gSystem->WorkingDirectory();
     char dirName[256];
@@ -574,23 +642,136 @@ Bool_t AliSimulation::WriteRawData(const char* detectors)
   }
 
   delete runLoader;
+  return kTRUE;
+}
 
-  Info("WriteRawData", "execution time:");
-  stopwatch.Print();
+//_____________________________________________________________________________
+Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
+{
+// convert raw data DDL files to a DATE file with the program "dateStream"
+
+  // DATE setup
+  const Int_t kNDetectors = 16;
+  const char* kDetectors[kNDetectors] = {"TPC", "ITSSPD", "ITSSDD", "ITSSSD", 
+                                         "TRD", "TOF", "PHOS", "RICH", 
+                                         "EMCAL", "MUON", "FMD", "ZDC", 
+                                         "PMD", "START", "VZERO", "CRT"};
+  const Int_t kDetectorDDLs[kNDetectors]   = {216, 20, 12, 16, 
+                                              18, 5, 10, 5, 
+                                              1, 7, 1, 1, 
+                                              6, 1, 1, 1};
+  const Float_t kDetectorLDCs[kNDetectors] = {46, 2, 2, 1, 
+                                              4, 2, 1, 2, 
+                                              1, 2, 0.5, 0.5,
+                                              1, 0.5, 0.5, 1};
+
+  char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
+  if (!path) {
+    Error("ConvertRawFilesToDate", "the program dateStream was not found");
+    if (fStopOnError) return kFALSE;
+  } else {
+    delete[] path;
+  }
 
-  return kTRUE;
+  AliRunLoader* runLoader = LoadRun("READ");
+  if (!runLoader) return kFALSE;
+
+  Info("ConvertRawFilesToDate", 
+       "converting raw data DDL files to DATE file %s", dateFileName);
+  char command[256];
+  sprintf(command, "dateStream -o %s -# %d", 
+         dateFileName, runLoader->GetNumberOfEvents());
+  FILE* pipe = gSystem->OpenPipe(command, "w");
+
+  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+    fprintf(pipe, "GDC\n");
+    Float_t ldc = 0;
+    Int_t prevLDC = -1;
+
+    // loop over detectors and DDLs
+    for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+      for (Int_t iDDL = 0; iDDL < kDetectorDDLs[iDet]; iDDL++) {
+
+        Int_t ddlID = 0x100*iDet + iDDL;
+        Int_t ldcID = Int_t(ldc + 0.0001);
+        ldc += kDetectorLDCs[iDet] / kDetectorDDLs[iDet];
+
+        char rawFileName[256];
+        sprintf(rawFileName, "raw%d/%s_%d.ddl", 
+                iEvent, kDetectors[iDet], ddlID);
+
+       // check existence and size of raw data file
+        FILE* file = fopen(rawFileName, "rb");
+        if (!file) continue;
+        fseek(file, 0, SEEK_END);
+        unsigned long size = ftell(file);
+        fseek(file, 0, SEEK_SET);
+        if (!size) {
+          fclose(file);
+          continue;
+        }
+
+        if (ldcID != prevLDC) {
+          fprintf(pipe, " LDC Id %d\n", ldcID);
+          prevLDC = ldcID;
+        }
+        fprintf(pipe, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
+      }
+    }
+  }
+
+  Int_t result = gSystem->ClosePipe(pipe);
+
+  delete runLoader;
+  return (result == 0);
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
+                                       const char* rootFileName)
+{
+// convert a DATE file to a root file with the program "alimdc"
+
+  // ALIMDC setup
+  const Int_t kDBSize = 1000000000;
+  const Bool_t kFilter = kFALSE;
+  const Int_t kCompression = 1;
+
+  char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
+  if (!path) {
+    Error("ConvertDateToRoot", "the program alimdc was not found");
+    if (fStopOnError) return kFALSE;
+  } else {
+    delete[] path;
+  }
+
+  Info("ConvertDateToRoot", "converting DATE file %s to root file %s", 
+       dateFileName, rootFileName);
+
+  gSystem->Exec("rm -rf /tmp/mdc1");
+  gSystem->Exec("rm -rf /tmp/mdc2");
+  char command[256];
+  sprintf(command, "alimdc %d %d %d %s", 
+         kDBSize, kFilter, kCompression, dateFileName);
+  Int_t result = gSystem->Exec(command);
+  sprintf(command, "mv /tmp/mdc1/*.root %s", rootFileName);
+  gSystem->Exec(command);
+  gSystem->Exec("rm -rf /tmp/mdc1");
+  gSystem->Exec("rm -rf /tmp/mdc2");
+
+  return (result == 0);
 }
 
 
 //_____________________________________________________________________________
-AliRunLoader* AliSimulation::LoadRun() const
+AliRunLoader* AliSimulation::LoadRun(const char* mode) const
 {
 // delete existing run loaders, open a new one and load gAlice
 
   while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
   AliRunLoader* runLoader = 
     AliRunLoader::Open(fGAliceFileName.Data(), 
-                      AliConfig::GetDefaultEventFolderName(), "UPDATE");
+                      AliConfig::GetDefaultEventFolderName(), mode);
   if (!runLoader) {
     Error("LoadRun", "no run loader found in file %s", 
          fGAliceFileName.Data());
index 65bdb2cdec60ccca5c649618e631e5bc3d1f93a0..62e9b3ac940a8eaf0f58d2a1f888e9e84410007f 100644 (file)
@@ -45,8 +45,11 @@ public:
                    {fMakeDigits = detectors;};
   void           SetMakeDigitsFromHits(const char* detectors)
                    {fMakeDigitsFromHits = detectors;};
-  void           SetWriteRawData(const char* detectors)
-                   {fWriteRawData = detectors;};
+  void           SetWriteRawData(const char* detectors, 
+                                const char* fileName = NULL,
+                                Bool_t deleteIntermediateFiles = kFALSE)
+                   {fWriteRawData = detectors; fRawDataFileName = fileName;
+                  fDeleteIntermediateFiles = deleteIntermediateFiles;};
 
   virtual Bool_t Run(Int_t nEvents = 0);
 
@@ -55,10 +58,16 @@ public:
   virtual Bool_t RunDigitization(const char* detectors = "ALL",
                                 const char* excludeDetectors = "");
   virtual Bool_t RunHitsDigitization(const char* detectors = "ALL");
-  virtual Bool_t WriteRawData(const char* detectors = "ALL");
+  virtual Bool_t WriteRawData(const char* detectors = "ALL",
+                             const char* fileName = NULL,
+                             Bool_t deleteIntermediateFiles = kFALSE);
+  virtual Bool_t WriteRawFiles(const char* detectors = "ALL");
+  virtual Bool_t ConvertRawFilesToDate(const char* dateFileName = "raw.date");
+  virtual Bool_t ConvertDateToRoot(const char* dateFileName = "raw.date",
+                                  const char* rootFileName = "raw.root");
 
 private:
-  AliRunLoader*  LoadRun() const;
+  AliRunLoader*  LoadRun(const char* mode = "UPDATE") const;
   Int_t          GetNSignalPerBkgrd(Int_t nEvents = 0) const;
   Bool_t         IsSelected(TString detName, TString& detectors) const;
 
@@ -68,6 +77,8 @@ private:
   TString        fMakeDigits;         // create digits for these detectors
   TString        fMakeDigitsFromHits; // create digits from hits for these detectors
   TString        fWriteRawData;       // write raw data for these detectors
+  TString        fRawDataFileName;    // file name for the raw data file
+  Bool_t         fDeleteIntermediateFiles; // delete intermediate raw data files
   Bool_t         fStopOnError;        // stop or continue on errors
 
   Int_t          fNEvents;            // number of events
@@ -79,7 +90,7 @@ private:
   Bool_t         fUseBkgrdVertex;     // use vertex from background in case of merging
   Bool_t         fRegionOfInterest;   // digitization in region of interest
 
-  ClassDef(AliSimulation, 1)  // class for running generation, simulation and digitization
+  ClassDef(AliSimulation, 2)  // class for running generation, simulation and digitization
 };
 
 #endif