coverity fix
[u/mrichter/AliRoot.git] / TRD / AliTRDPreprocessor.cxx
index 50b3d42..7707000 100644 (file)
 //                                                                        //
 // Authors:                                                               //
 //   R. Bailhache (R.Bailhache@gsi.de)                                    //
+//   J. Book (jbook@ikf.uni-frankfurt.de)                                 //
 //   W. Monange   (w.monange@gsi.de)                                      //
 //   F. Kramer    (kramer@ikf.uni-frankfurt.de)                           //
 //                                                                        //
 ////////////////////////////////////////////////////////////////////////////
 
+#include <fstream>
+
 #include <TFile.h>
 #include <TProfile2D.h>
-#include <TStopwatch.h>
 #include <TObjString.h>
 #include <TString.h>
 #include <TList.h>
-#include <TCollection.h>
 #include <TSAXParser.h>
 
 #include "AliCDBMetaData.h"
 #include "AliTRDCalibraMode.h"
 #include "AliTRDCalibPadStatus.h"
 #include "AliTRDSaxHandler.h"
-#include "Cal/AliTRDCalDet.h"
+#include "AliTRDgeometry.h"
+#include "AliTRDCalibChamberStatus.h"
 #include "Cal/AliTRDCalPad.h"
 #include "Cal/AliTRDCalPadStatus.h"
-#include "Cal/AliTRDCalDCS.h"
+#include "Cal/AliTRDCalDCSv2.h"
 #include "Cal/AliTRDCalSingleChamberStatus.h"
+#include "Cal/AliTRDCalChamberStatus.h"
 #include "Cal/AliTRDCalROC.h"
 
-
 ClassImp(AliTRDPreprocessor)
 
 //______________________________________________________________________________________________
 AliTRDPreprocessor::AliTRDPreprocessor(AliShuttleInterface *shuttle)
   :AliPreprocessor("TRD", shuttle)
+  ,fCalDCSObjSOR(0)
+  ,fCalDCSObjEOR(0)
   ,fVdriftHLT(0)
 {
   //
   // Constructor
   //
 
- AddRunType("PHYSICS");
- AddRunType("STANDALONE");
- AddRunType("PEDESTAL");
 
+  AddRunType("PHYSICS");
+  AddRunType("STANDALONE");
+  AddRunType("PEDESTAL");
+  AddRunType("DAQ");
+  
+  
+}
+//______________________________________________________________________________________________
+ AliTRDPreprocessor::AliTRDPreprocessor(const AliTRDPreprocessor&  ) :
+   AliPreprocessor("TRD",0),
+   fCalDCSObjSOR(0),
+   fCalDCSObjEOR(0),
+   fVdriftHLT(0)
+{
+  
+  Fatal("AliTRDPreprocessor", "copy constructor not implemented");
+  
 }
-
 //______________________________________________________________________________________________
 AliTRDPreprocessor::~AliTRDPreprocessor()
 {
@@ -82,8 +99,22 @@ AliTRDPreprocessor::~AliTRDPreprocessor()
   // Destructor
   //
 
-}
+  if (fCalDCSObjSOR != NULL) {
+    delete fCalDCSObjSOR;
+    fCalDCSObjSOR =0;
+  }
+  if (fCalDCSObjEOR != NULL) {
+    delete fCalDCSObjEOR;
+    fCalDCSObjEOR =0;
+  }
 
+}
+//______________________________________________________________________________________________
+AliTRDPreprocessor& AliTRDPreprocessor::operator = (const AliTRDPreprocessor& )
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
 //______________________________________________________________________________________________
 void AliTRDPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
 {
@@ -92,7 +123,7 @@ void AliTRDPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
   //
 
   AliPreprocessor::Initialize(run,startTime,endTime);
-
+  
 }
 
 //______________________________________________________________________________________________
@@ -106,34 +137,39 @@ UInt_t AliTRDPreprocessor::Process(TMap* dcsAliasMap)
   Log(Form("runtype %s\n",runType.Data()));
   
   // always process the configuration data
-/*  Int_t resultDCSC = */ProcessDCSConfigData(); // for testing!
-  // if there was an error, return with its code
-//  if (resultDCSC != 0) return resultDCSC; // for testing!
+  Int_t DCSConfigReturn = ProcessDCSConfigData();
+  if(DCSConfigReturn) return DCSConfigReturn; 
 
   if (runType=="PEDESTAL"){
     if(ExtractPedestals()) return 1;
     return 0;
   } 
 
-  if ((runType=="PHYSICS") || (runType=="STANDALONE")){
-    // HLT if On
-    //TString runPar = GetRunParameter("HLTStatus");
-    //if(runPar=="1") {
-    if(GetHLTStatus()) {
-      /*if(*/ExtractHLT()/*) return 1*/; // for testing!
-    } 
-    // DAQ if HLT failed
-    if(!fVdriftHLT) {
-      /*if(*/ExtractDriftVelocityDAQ()/*) return 1*/; // for testing!
-    }
+  if ((runType=="PHYSICS") || (runType=="STANDALONE") || (runType=="DAQ")){
     // DCS
     if(ProcessDCS(dcsAliasMap)) return 1;
+    if(runType=="PHYSICS"){
+      // HLT if On
+      //TString runPar = GetRunParameter("HLTStatus");
+      //if(runPar=="1") {
+      if(GetHLTStatus()) {
+       //if(ExtractHLT()) return 1; // for testing!
+       ExtractHLT();
+      } 
+      // DAQ if HLT failed
+      if(!fVdriftHLT) {
+       //if(ExtractDriftVelocityDAQ()) return 1; 
+       ExtractDriftVelocityDAQ(); // for testing!
+      }
+    }
+    //if((runType=="PHYSICS") || (runType=="STANDALONE")) {
+      //      if(ExtractHalfChamberStatusDAQ()) return 1;
+    //}
   }
   
   return 0;  
   
 }
-
 //______________________________________________________________________________
 Bool_t AliTRDPreprocessor::ProcessDCS()
 {
@@ -165,7 +201,7 @@ Bool_t AliTRDPreprocessor::ProcessDCS(TMap *dcsAliasMap)
 
   Log("****** DCS ******\n");
        
-  TObjArray * list=AliTRDSensorArray::GetList ();
+  TObjArray * list=AliTRDSensorArray::GetList();
        
   if (list == 0x0) {
     Log ("Error during AliTRDSensorArray::GetList");
@@ -197,19 +233,19 @@ Bool_t AliTRDPreprocessor::ProcessDCS(TMap *dcsAliasMap)
     if (nGraph [iAlias] == 0) {
       Log("No TGraph for this dcsDatapointAlias : not stored");
       results [iAlias] = kFALSE;
-      error  = kTRUE;
+      //error  = kTRUE;
       continue;
     }
                
     oneTRDDCS->SetGraph(map);
-    results[iAlias]=Store("Calib", oneTRDDCS->GetStoreName().Data(), oneTRDDCS, &metaData, 0, kTRUE); 
+    results[iAlias]=Store("Calib", oneTRDDCS->GetStoreName().Data(), oneTRDDCS, &metaData, 0, kFALSE); 
     delete map;                
 
     //results [iAlias] = StoreReferenceData("Calib", oneTRDDCS->GetStoreName ().Data (), oneTRDDCS, &metaData); 
 
     if (!results[iAlias]) {
       AliError("Problem during StoreRef DCS");
-      error=kTRUE;
+      //error=kTRUE;
     }
 
     //BEGIN TEST (should not be removed ...)
@@ -245,6 +281,16 @@ Bool_t AliTRDPreprocessor::ProcessDCS(TMap *dcsAliasMap)
     //END TEST
 
   }
+
+  // Check errors
+  Int_t nbCount = 0;
+  for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
+    if (results[iAlias]) {
+      nbCount++;
+    }
+  }
+  if(nbCount == 0) error = kTRUE;
+
                
   Log ("         Summury of DCS :\n");
   Log (Form("%30s %10s %10s", "dcsDatapointAlias", "Stored ?", "# graph"));
@@ -257,13 +303,104 @@ Bool_t AliTRDPreprocessor::ProcessDCS(TMap *dcsAliasMap)
   }
   Log ("*********** End of DCS **********");
   
-  delete results;
-  delete nGraph;
+  delete [] results;
+  delete [] nGraph;
 
   return error;
 
 }
+//______________________________________________________________________________________________
+Bool_t AliTRDPreprocessor::ExtractHalfChamberStatusDAQ()
+{
+  //
+  // Half chamber status algorithm running on DAQ
+  //
+
+  Bool_t error = kFALSE;
+
+  AliCDBMetaData metaData;
+  metaData.SetBeamPeriod(0);
+  metaData.SetResponsible("Raphaelle Bailhache");
+  metaData.SetComment("TRD calib test");
+  
+  // Take the output of the DA on DAQ
+  TList * listpad = GetFileSources(kDAQ,"HALFCHAMBERSTATUS");
+  if (!listpad) {
+    Log("No list found for the HalfChamberStatus");
+    return kTRUE;
+  }
+
+  AliTRDCalibChamberStatus *calPed = 0x0;
+    
+  // loop through all files (only one normally)
+  UInt_t index = 0;
+  while (listpad->At(index)!=NULL) {
+    TObjString* fileNameEntry = (TObjString*) listpad->At(index);
+    if (fileNameEntry != NULL)
+      {
+        TString fileName = GetFile(kDAQ, "HALFCHAMBERSTATUS",
+                                  fileNameEntry->GetString().Data());
+       if(fileName.Length() ==0){
+         Log(Form("Error by retrieving the file %d for the halfchamberstatus",(Int_t)index));
+         delete listpad;
+         return kTRUE;
+       }
+       
+       TFile *f = TFile::Open(fileName);
+       f->GetObject("calibchamberstatus",calPed);
+       
+       if(calPed) {
+         
+         // store as reference data
+         TString name("HalfChamberStatus");
+         if(!StoreReferenceData("DAQData",(const char *)name,(TObject *) calPed,&metaData)){
+           Log(Form("Error storing AliTRDCalibPadStatus object %d as reference data",(Int_t)index));
+           error = kTRUE;
+         }
+       } // calPed
+       else Log(Form("Error getting AliTRDCalibChamberStatus onject from file"));
+                
+      } // fileNameEntry
+    ++index;
+  }// while (list)
+
+  Log(Form("%d elements found in the list for the halfchamberstatus",(Int_t)index));
+  if(index!=1){
+    delete listpad;
+    return kTRUE;
+  }
+
+  //
+  // Produce the AliTRDCalChamberStatus  name calHalfChamberStatus
+  //
+  AliTRDCalChamberStatus *calHalfChamberStatus = 0x0;
+  if(calPed) {
+    //calPed->AnalyseHisto();   // check number of events, create calHalfChamberStatus (done on DAQ)
+    if(fCalDCSObjEOR) {
+      calPed->CheckEORStatus((AliTRDCalDCSv2 *)fCalDCSObjEOR);
+    }
+    calHalfChamberStatus=(AliTRDCalChamberStatus *)calPed->GetCalChamberStatus();
+  }
+
+  //
+  // Store  
+  //  
 
+  AliCDBMetaData md3; 
+  md3.SetObjectClassName("AliTRDCalChamberStatus");
+  md3.SetResponsible("Raphaelle Bailhache");
+  md3.SetBeamPeriod(1);
+  md3.SetComment("TRD calib test");
+  if(!Store("Calib","ChamberStatus"    ,(TObject *)calHalfChamberStatus, &md3, 0, kTRUE)){
+    Log("Error storing the pedestal");
+    delete listpad;
+    return kTRUE;
+  }
+  
+  delete listpad;
+  return error; 
+  
+}
 //______________________________________________________________________________________________
 Bool_t AliTRDPreprocessor::ExtractPedestals()
 {
@@ -316,8 +453,6 @@ Bool_t AliTRDPreprocessor::ExtractPedestals()
        
        if(calPed){
          
-         Int_t ldc = 0; 
-
          // analyse
          //calPed->AnalyseHisto();
                  
@@ -326,7 +461,6 @@ Bool_t AliTRDPreprocessor::ExtractPedestals()
            AliTRDCalROC *rocMean  = calPed->GetCalRocMean(idet, kFALSE);
            if ( rocMean )  {
              calPedSum.SetCalRocMean(rocMean,idet);
-             ldc = (Int_t) (idet / 30);
            }
            AliTRDCalROC *rocRMS = calPed->GetCalRocRMS(idet, kFALSE);
            if ( rocRMS )  {
@@ -342,13 +476,9 @@ Bool_t AliTRDPreprocessor::ExtractPedestals()
            }
          }// det loop
 
-         if((ldc==0) || (ldc==1) || (ldc==2) || (ldc==9) || (ldc==10) || (ldc==11)) ldc = 1;
-         if((ldc==3) || (ldc==4) || (ldc==5) || (ldc==12) || (ldc==13) || (ldc==14)) ldc = 2;
-         if((ldc==6) || (ldc==7) || (ldc==8) || (ldc==15) || (ldc==16) || (ldc==17)) ldc = 3;
-       
          // store as reference data
          TString name("PadStatus");
-         name += ldc;
+         name += index;
          if(!StoreReferenceData("DAQData",(const char *)name,(TObject *) calPed,&metaData)){
            Log(Form("Error storing AliTRDCalibPadStatus object %d as reference data",(Int_t)index));
            error = kTRUE;
@@ -480,8 +610,11 @@ Bool_t AliTRDPreprocessor::ExtractPedestals()
   return error; 
   
 }
+
 //__________________________________________________________________
-Bool_t AliTRDPreprocessor::AreThereDataPedestal(AliTRDCalSingleChamberStatus *calROCStatus, Bool_t second){
+Bool_t AliTRDPreprocessor::AreThereDataPedestal(AliTRDCalSingleChamberStatus * const calROCStatus
+                                              , Bool_t second)
+{
 
   //
   // Data for this half chamber
@@ -495,16 +628,21 @@ Bool_t AliTRDPreprocessor::AreThereDataPedestal(AliTRDCalSingleChamberStatus *ca
     nCol0 = nColE + 4;
     nColE = nCols;
   }
+
+  Int_t totalnumberofpads = 0;
+  Int_t totalnumberofdata = 0; 
+
   for(Int_t col = nCol0; col < nColE; col++){
     for(Int_t row = 0; row < calROCStatus->GetNrows(); row++){
+      totalnumberofpads++;
       //printf("ismasked %d\n",(Int_t)calROCStatus->IsMasked(col,row));
       if(!calROCStatus->GetStatus(col,row)) {
        data = kTRUE;
-       continue;
+       totalnumberofdata++;
       }
     }
-    if(data) continue;
   }
+  if(totalnumberofdata < (Int_t)(totalnumberofpads/2)) data = kFALSE;
 
   return data;
   
@@ -658,36 +796,41 @@ Bool_t AliTRDPreprocessor::ExtractDriftVelocityDAQ()
       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
        + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
       Int_t nbfit        = calibra->GetNumberFit();
+      Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
       Int_t nbE        = calibra->GetNumberEnt();
       
       // if enough statistics store the results
       if ((nbtg >                  0) && 
-         (nbfit        >= 0.95*nbE)) {
+         (nbfit        >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
        // create the cal objects
+       calibra->RemoveOutliers(1,kTRUE);
+       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
+       calibra->RemoveOutliers2(kTRUE);
+       calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
        TObjArray object      = calibra->GetVectorFit();
        AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
-       TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
+       //      TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
        object              = calibra->GetVectorFit2();
        AliTRDCalDet *objtime0det         = calibra->CreateDetObjectT0(&object,kTRUE);
-       TObject *objtime0pad         = calibra->CreatePadObjectT0();
+       //      TObject *objtime0pad         = calibra->CreatePadObjectT0();
        calibra->ResetVectorFit();
        // store
-       if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
-         Log("Error storing the calibration object for the chamber vdrift (DAQ)");
-         error = kTRUE;
-       }
-       if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
-         Log("Error storing the calibration object for the chamber t0 (DAQ)");
-         error = kTRUE;
-       }
-       if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
-         Log("Error storing the calibration object for the local drift velocity (DAQ)");
-         error = kTRUE;
-       }
-       if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
-         Log("Error storing the calibration object for the local time0 (DAQ)");
-         error = kTRUE;
-       }
+        if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
+                 Log("Error storing the calibration object for the chamber vdrift (DAQ)");
+                 error = kTRUE;
+               }
+               if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
+                 Log("Error storing the calibration object for the chamber t0 (DAQ)");
+                 error = kTRUE;
+               }
+       //      if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
+       //        Log("Error storing the calibration object for the local drift velocity (DAQ)");
+       //        error = kTRUE;
+       //      }
+       //      if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
+       //        Log("Error storing the calibration object for the local time0 (DAQ)");
+       //        error = kTRUE;
+       //      }
       }
       else{
        Log("Not enough statistics for the average pulse height (DAQ)");
@@ -756,8 +899,8 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
     
     // gain
     TH2I *histogain = (TH2I *) filehlt->Get("CH2d");
-    histogain->SetDirectory(0);
     if (histogain) {
+      histogain->SetDirectory(0);
       // store the reference data
       if(!StoreReferenceData("HLTData","Gain",(TObject *) histogain,&metaData)){
        Log("Error storing 2D histos for gain");
@@ -765,7 +908,7 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       }
       // analyse
       Log("Take the CH reference data. Now we will try to fit\n");
-      calibra->SetMinEntries(1000); // If there is less than 1000 entries in the histo: no fit
+      calibra->SetMinEntries(800); // If there is less than 1000 entries in the histo: no fit
       calibra->AnalyseCH(histogain);
       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
        + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
@@ -773,20 +916,21 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       Int_t nbE         = calibra->GetNumberEnt();
       // enough statistics
       if ((nbtg >                  0) && 
-         (nbfit        >= 0.95*nbE)) {
+         (nbfit        >= 0.5*nbE) && (nbE > 30)) {
        // create the cal objects
+       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
        TObjArray object           = calibra->GetVectorFit();
        AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object);
-       TObject *objgainpad        = calibra->CreatePadObjectGain();
+       //      TObject *objgainpad        = calibra->CreatePadObjectGain();
        // store them
        if(!Store("Calib","ChamberGainFactor",(TObject *) objgaindet         ,&md1,0,kTRUE)){
          Log("Error storing the calibration object for the chamber gain");
          error = kTRUE;
        }
-       if(!Store("Calib","LocalGainFactor"  ,(TObject *) objgainpad         ,&md2,0,kTRUE)){
-         Log("Error storing the calibration object for the local gain factor");
-         error = kTRUE;
-       }
+       //      if(!Store("Calib","LocalGainFactor"  ,(TObject *) objgainpad         ,&md2,0,kTRUE)){
+       //        Log("Error storing the calibration object for the local gain factor");
+       //        error = kTRUE;
+       //      }
       }
       calibra->ResetVectorFit();
     }// if histogain
@@ -794,8 +938,8 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
     // vdrift
     fVdriftHLT = kFALSE;
     TProfile2D *histodriftvelocity = (TProfile2D *) filehlt->Get("PH2d");
-    histodriftvelocity->SetDirectory(0);
     if (histodriftvelocity) {
+      histodriftvelocity->SetDirectory(0);
       // store the reference data
       if(!StoreReferenceData("HLTData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
        Log("Error storing 2D Profile for average pulse height (HLT)");
@@ -803,22 +947,27 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       }
       // analyse
       Log("Take the PH reference data. Now we will try to fit\n");
-      calibra->SetMinEntries(1000*20); // If there is less than 20000
+      calibra->SetMinEntries(800*20); // If there is less than 20000
       calibra->AnalysePH(histodriftvelocity);
       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
        + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
       Int_t nbfit        = calibra->GetNumberFit();
+      Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
       Int_t nbE          = calibra->GetNumberEnt();
       // enough statistics
       if ((nbtg >                  0) && 
-         (nbfit        >= 0.95*nbE)) {
+         (nbfit        >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
        // create the cal objects
+       calibra->RemoveOutliers(1,kTRUE);
+       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
+       calibra->RemoveOutliers2(kTRUE);
+       calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
        TObjArray object  = calibra->GetVectorFit();
        AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
-       TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();
+       //      TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();
        object              = calibra->GetVectorFit2();
        AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
-       TObject *objtime0pad       = calibra->CreatePadObjectT0();
+       //TObject *objtime0pad       = calibra->CreatePadObjectT0();
        // store them
        if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
          Log("Error storing the calibration object for the chamber vdrift (HLT)");
@@ -828,23 +977,24 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
          Log("Error storing the calibration object for the chamber t0 (HLT)");
          error = kTRUE;
        }
-       if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
-         Log("Error storing the calibration object for the local drift velocity (HLT)");
-         error = kTRUE;
-       }
-       if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
-         Log("Error storing the calibration object for the local time0 (HLT)");
-         error = kTRUE;
-       }
+       // if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
+       //        Log("Error storing the calibration object for the local drift velocity (HLT)");
+       //        error = kTRUE;
+       //      }
+       //      if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
+       //        Log("Error storing the calibration object for the local time0 (HLT)");
+       //        error = kTRUE;
+       //      }
        fVdriftHLT = kTRUE;
       }
       calibra->ResetVectorFit();
     }// if TProfile2D
     
     // prf
+    /*
     TProfile2D *histoprf = (TProfile2D *) filehlt->Get("PRF2d");
-    histoprf->SetDirectory(0);
     if (histoprf) {
+      histoprf->SetDirectory(0);    
       // store reference data
       if(!StoreReferenceData("HLTData","PRF",(TObject *) histoprf,&metaData)){
        Log("Error storing the 2D Profile for Pad Response Function");
@@ -860,7 +1010,7 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       Int_t nbE          = calibra->GetNumberEnt();
       // enough statistics
       if ((nbtg >                  0) && 
-         (nbfit        >= 0.95*nbE)) {
+         (nbfit        >= 0.95*nbE) && (nbE > 30)) {
        // create cal pad objects 
        TObjArray object            = calibra->GetVectorFit();
        TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
@@ -872,6 +1022,7 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       }
       calibra->ResetVectorFit();
     }// if PRF
+    */
   }// if fileNameEntry
   
   delete listhlt;
@@ -882,58 +1033,110 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
 //_____________________________________________________________________________
 UInt_t AliTRDPreprocessor::ProcessDCSConfigData()
 {
-  // 
   // process the configuration of FEE, PTR and GTU
-  // reteive XML file from the DCS FXS
-  // parse it and store TObjArrays in the CDB
-  // return 0 for success, otherwise:
-  // 5: could not get the file from the FXS
-  // 6: ERROR in XML validation: something wrong with the file
-  // 7: ERROR while creating calibration objects in the handler
-  // 8: error while storing data in the CDB
-  // > 100: SaxHandler error code
-  //
+  // reteive XML filei(s) from the DCS FXS
+  // parse it/them and store TObjArrays in the CDB
+
+  Log("Processing the DCS config summary files.");
+
+  if(fCalDCSObjSOR) delete fCalDCSObjSOR;
+  if(fCalDCSObjEOR) delete fCalDCSObjEOR;
+
+  TString xmlFile[2];
+  TString esor[2] = {"SOR", "EOR"};
+  // get the XML files
+  xmlFile[0] = GetFile(kDCS,"CONFIGSUMMARYSOR","");
+  xmlFile[1] = GetFile(kDCS,"CONFIGSUMMARYEOR","");
+
+
+  // check both files
+  for (Int_t iFile=0; iFile<2; iFile++) {
+
+    // check if the file are there
+    if (xmlFile[iFile].IsNull()) {
+      Log(Form("Warning: %s file not found!", esor[iFile].Data()));
+      continue;
+    }
+    Log(Form("%s file found: %s", esor[iFile].Data(), xmlFile[iFile].Data()));
+
+    // test the file
+    std::ifstream fileTest;
+    fileTest.open(xmlFile[iFile].Data(), std::ios_base::binary | std::ios_base::in);
+    if (!fileTest.good() || fileTest.eof() || !fileTest.is_open()) {
+      Log(Form("Warning: %s file not valid!", esor[iFile].Data()));
+      continue;
+    } 
+    // check if the file is empty
+    fileTest.seekg(0, std::ios_base::end);
+    if (static_cast<int>(fileTest.tellg()) < 2) {
+      Log(Form("Warning: %s file empty!", esor[iFile].Data()));
+      continue;
+    }
+    Log(Form("%s file is valid.", esor[iFile].Data()));
+
+    // make a robust XML validation
+    TSAXParser testParser;
+    if (testParser.ParseFile(xmlFile[iFile].Data()) < 0 ) {
+      Log(Form("Warning: %s XML content is not well-formed!", esor[iFile].Data()));
+      continue;
+    }
+    Log(Form("%s XML content is well-formed.", esor[iFile].Data()));
 
-  Log("Processing the DCS config summary file.");
+    // create parser and parse
+    TSAXParser saxParser;
+    AliTRDSaxHandler saxHandler;
+    saxParser.ConnectToHandler("AliTRDSaxHandler", &saxHandler);
+    saxParser.ParseFile(xmlFile[iFile].Data());
 
-  // get the XML file
-  const char * xmlFile = GetFile(kDCS,"CONFIGSUMMARY","");
-  if (xmlFile == NULL) {
-    return 5;
-    Log(Form("File %s not found!",xmlFile));
+    // report errors of the parser if present
+    if (saxParser.GetParseCode() != 0) {
+      Log(Form("Warning: %s XML file validation failed! Parse code: %d", esor[iFile].Data(), saxParser.GetParseCode()));
+      continue;
+    }
+    Log(Form("%s XML validation OK.", esor[iFile].Data()));
+
+    // report errors of the handler if present
+    if (saxHandler.GetHandlerStatus() != 0) {
+      Log(Form("Warning: Creating %s calibration object failed! Error code: %d", esor[iFile].Data(), saxHandler.GetHandlerStatus()));
+      continue;
+    }
+    Log(Form("%s SAX handler reports no errors.", esor[iFile].Data()));
+
+    // get the calibration object storing the data from the handler
+    AliTRDCalDCSv2 *calDCSObj = (AliTRDCalDCSv2*)saxHandler.GetCalDCSObj()->Clone();
+    calDCSObj->EvaluateGlobalParameters();
+    calDCSObj->SetRunType(GetRunType());
+    calDCSObj->SetStartTime(GetStartTimeDCSQuery());
+    calDCSObj->SetEndTime(GetEndTimeDCSQuery());
+    if (iFile == 0) fCalDCSObjSOR = calDCSObj;
+    if (iFile == 1) fCalDCSObjEOR = calDCSObj;
   }
 
-  // create parser and parse
-  TSAXParser saxParser;
-  AliTRDSaxHandler saxHandler;
-  saxParser.ConnectToHandler("AliTRDSaxHandler", &saxHandler);
-  saxParser.ParseFile(xmlFile);
+  if (!fCalDCSObjSOR && !fCalDCSObjEOR) { Log("ERROR: Failed reading both files!"); return 1; }
 
-  // report errors if present
-  if (saxParser.GetParseCode() == 0) {
-    Log("XML file validation OK");
-  } else {
-    Log(Form("ERROR in XML file validation. Parsecode: %s", saxParser.GetParseCode()));
-    return 6;
+  // put both objects in one TObjArray to store them
+  TObjArray* calObjArray = new TObjArray(2);
+  calObjArray->SetOwner();
+
+  if (fCalDCSObjSOR) {
+    calObjArray->AddAt(fCalDCSObjSOR,0);
+    Log("TRDCalDCS object for SOR created.");
   }
-  if (saxHandler.GetHandlerStatus() != 0) {
-    Log(Form("ERROR while creating calibration objects. Error code: %s", saxHandler.GetHandlerStatus()));
-    return 7;
+  if (fCalDCSObjEOR) {
+    calObjArray->AddAt(fCalDCSObjEOR,1);
+    Log("TRDCalDCS object for EOR created.");
   }
 
-  // get the calibration object storing the data from the handler
-  AliTRDCalDCS* fCalDCSObj = saxHandler.GetCalDCSObj();
-
   // store the DCS calib data in the CDB
   AliCDBMetaData metaData1;
   metaData1.SetBeamPeriod(0);
   metaData1.SetResponsible("Frederick Kramer");
-  metaData1.SetComment("DCS configuration data in one AliTRDCalDCS object.");
-  if (!Store("Calib", "DCSCONFIG", fCalDCSObj, &metaData1, 0, kTRUE)) {
-    Log("problems while storing DCS config data object");
-    return 8;
-  }
+  metaData1.SetComment("DCS configuration data in two AliTRDCalDCSv2 objects in one TObjArray (0:SOR, 1:EOR).");
+  if (!Store("Calib", "DCS", calObjArray, &metaData1, 0, kTRUE)) { Log("ERROR: Storing DCS config data object failed!"); return 1; }
+
+  delete calObjArray;
 
+  Log("SUCCESS: Processing of the DCS config summary file DONE.");  
   return 0;
 }