New TOF online calibration object classes implemented, both for channel
authorzampolli <zampolli@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 18 Jun 2008 16:16:07 +0000 (16:16 +0000)
committerzampolli <zampolli@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 18 Jun 2008 16:16:07 +0000 (16:16 +0000)
status and delay: single objects containing arrays of chars (for the status)
and of floats (for the delays) now used.
Updates in the macro to create the calibration objects,
and to the macro for the TOF preprocessors.
README updated with TOF calibration description.

23 files changed:
TOF/AliTOFChannelOnlineArray.cxx [new file with mode: 0644]
TOF/AliTOFChannelOnlineArray.h [new file with mode: 0644]
TOF/AliTOFChannelOnlineStatusArray.cxx [new file with mode: 0644]
TOF/AliTOFChannelOnlineStatusArray.h [new file with mode: 0644]
TOF/AliTOFClusterFinder.cxx
TOF/AliTOFPreprocessor.cxx
TOF/AliTOFPreprocessor.h
TOF/AliTOFReconstructor.cxx
TOF/AliTOFcalib.cxx
TOF/AliTOFcalib.h
TOF/AliTOFtracker.cxx
TOF/AliTOFtrackerV1.cxx
TOF/CreateCalibPars_Ideal.C
TOF/CreateCalibPars_Miscalibrated.C
TOF/CreateCalibPars_Miscalibrated_Scaled.C
TOF/CreateConfigMap.C [new file with mode: 0644]
TOF/CreateIdealOnlineCalibPars.C
TOF/CreateOnlineCalibPars.C
TOF/CreateRecPars_CDB.C
TOF/README
TOF/TOFPreprocessor.C
TOF/TOFbaseLinkDef.h
TOF/libTOFbase.pkg

diff --git a/TOF/AliTOFChannelOnlineArray.cxx b/TOF/AliTOFChannelOnlineArray.cxx
new file mode 100644 (file)
index 0000000..3b170fc
--- /dev/null
@@ -0,0 +1,80 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, 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.                  *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// class for TOF Online calibration: defining channel delay                  //
+// using an array instead of a TObjArray                                     //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include <AliTOFChannelOnlineArray.h>
+#include <AliLog.h>
+
+ClassImp(AliTOFChannelOnlineArray)
+
+//________________________________________________________________
+AliTOFChannelOnlineArray::AliTOFChannelOnlineArray():
+       TObject(),
+       fSize(0),
+       fArray(0x0)
+{
+       //default constructor
+}
+//________________________________________________________________
+AliTOFChannelOnlineArray::AliTOFChannelOnlineArray(Int_t size):
+       TObject(),
+       fSize(size),
+       fArray(new Float_t[size])
+{
+       // ctor with size
+       for (Int_t ich = 0; ich<size; ich ++){
+         SetDelay(ich,0);
+       }
+}
+//________________________________________________________________
+AliTOFChannelOnlineArray::AliTOFChannelOnlineArray(const AliTOFChannelOnlineArray & source):
+      TObject(),
+      fSize(0),
+      fArray(0x0)
+{ 
+       // copy constructor
+       this->fSize= source.fSize;
+       this->fArray= source.fArray;
+}
+//________________________________________________________________
+AliTOFChannelOnlineArray &AliTOFChannelOnlineArray::operator=(const AliTOFChannelOnlineArray & source) 
+{ 
+       // assignment operator
+       this->fSize= source.fSize;
+       this->fArray= source.fArray;
+       return *this;
+}
+//________________________________________________________________
+void AliTOFChannelOnlineArray::SetDelay(Int_t pos, Float_t parr)
+{
+       // setting status for channel at position = pos
+       AliDebug(2,Form("status = %d",(Float_t)parr));
+       if (pos>-1 && pos < fSize)fArray[pos] = parr;
+       AliDebug(2,Form("fArray[%d] = %d",pos,(Float_t)fArray[pos]));
+}
+//________________________________________________________________
+Float_t AliTOFChannelOnlineArray::GetDelay(Int_t pos) const 
+{
+       // getting the status for channel at position = pos 
+       Float_t parr = 0x0; 
+       if  (pos>-1 && pos < fSize)parr = fArray[pos];
+       return parr;
+}
diff --git a/TOF/AliTOFChannelOnlineArray.h b/TOF/AliTOFChannelOnlineArray.h
new file mode 100644 (file)
index 0000000..14457e9
--- /dev/null
@@ -0,0 +1,44 @@
+#ifndef ALITOFCHANNELONLINEARRAY_H
+#define ALITOFCHANNELONLINEARRAY_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+/* $Id$ */
+
+////////////////////////////////////////////////
+//  class for TOF Online calibration          //
+//  to define the delay of the channels.      //
+//  New object created, to use an array       //
+//  instead of a TObjArray.                   // 
+////////////////////////////////////////////////
+
+#include "TObject.h"
+
+class AliTOFChannelOnlineArray: public TObject {
+
+public:
+
+  enum{
+    kTOFOnlineUnknown=0x0, kTOFOnlineOk=0x15, kTOFOnlineBad=0x2a, 
+           kTOFHWUnknown=0x0, kTOFHWOk=0x1, kTOFHWBad=0x2, kTOFHWReset=0xfc, kTOFHW=0x3,
+           kTOFPulserUnknown=0x0, kTOFPulserOk=0x4, kTOFPulserBad=0x8, kTOFPulserReset=0xf3, kTOFPulser=0xc,
+           kTOFNoiseUnknown=0x0, kTOFNoiseOk=0x10, kTOFNoiseBad=0x20, kTOFNoiseReset=0xcf, kTOFNoise=0x30
+      };
+
+  AliTOFChannelOnlineArray();
+  AliTOFChannelOnlineArray(Int_t size);
+  AliTOFChannelOnlineArray(const AliTOFChannelOnlineArray &source);
+  AliTOFChannelOnlineArray& operator= (const AliTOFChannelOnlineArray &source);
+  virtual ~AliTOFChannelOnlineArray(){};
+  Int_t GetSize() const {return fSize;}
+  void  SetDelay(Int_t pos, Float_t parr);
+  Float_t  GetDelay(Int_t pos) const;
+
+private:
+  Int_t fSize;      // Size of the array of UChar_t
+  Float_t * fArray; //[fSize]
+
+  ClassDef(AliTOFChannelOnlineArray,1)    // TOF Sensor Online Calibration object
+};
+
+#endif
diff --git a/TOF/AliTOFChannelOnlineStatusArray.cxx b/TOF/AliTOFChannelOnlineStatusArray.cxx
new file mode 100644 (file)
index 0000000..79cf42e
--- /dev/null
@@ -0,0 +1,148 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, 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.                  *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// class for TOF Online calibration: defining channel status                 //
+// New object created, to use an array instead of a TObjArray.               //
+// Storing all the info coming from HW FEE map, pulser runs, and noise       //
+// runs in a single object (char).                                           // 
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include <AliTOFChannelOnlineStatusArray.h>
+#include <AliLog.h>
+
+ClassImp(AliTOFChannelOnlineStatusArray)
+
+//________________________________________________________________
+AliTOFChannelOnlineStatusArray::AliTOFChannelOnlineStatusArray():
+       TObject(),
+       fSize(0),
+       fArray(0x0)
+{
+       //default constructor
+}
+//________________________________________________________________
+AliTOFChannelOnlineStatusArray::AliTOFChannelOnlineStatusArray(Int_t size):
+       TObject(),
+       fSize(size),
+       fArray(new UChar_t[size])
+{
+       // ctor with size
+       for (Int_t ich = 0; ich<size; ich ++){
+         SetStatus(ich,kTOFOnlineUnknown);
+       }
+}
+//________________________________________________________________
+AliTOFChannelOnlineStatusArray::AliTOFChannelOnlineStatusArray(const AliTOFChannelOnlineStatusArray & source):
+      TObject(),
+      fSize(0),
+      fArray(0x0)
+{ 
+       // copy constructor
+       this->fSize= source.fSize;
+       this->fArray= source.fArray;
+}
+//________________________________________________________________
+AliTOFChannelOnlineStatusArray &AliTOFChannelOnlineStatusArray::operator=(const AliTOFChannelOnlineStatusArray & source) 
+{ 
+       // assignment operator
+       this->fSize= source.fSize;
+       this->fArray= source.fArray;
+       return *this;
+}
+//________________________________________________________________
+void AliTOFChannelOnlineStatusArray::SetStatus(Int_t pos, UChar_t parr)
+{
+       // setting status for channel at position = pos
+       AliDebug(2,Form("status = %d",(UInt_t)parr));
+       if (pos>-1 && pos < fSize)fArray[pos] = parr;
+       AliDebug(2,Form("fArray[%d] = %d",pos,(UInt_t)fArray[pos]));
+}
+//________________________________________________________________
+void AliTOFChannelOnlineStatusArray::SetHWStatus(Int_t pos, UChar_t parr)
+{
+       // setting status for channel at position = pos
+       AliDebug(2,Form("HW status = %d",(UInt_t)parr));
+       if (pos>-1 && pos < fSize) {
+               fArray[pos] &= kTOFHWReset;
+               fArray[pos] |= parr;
+       }
+       AliDebug(2,Form("fArray[%d] = %d",pos,(UInt_t)fArray[pos]));
+}
+//________________________________________________________________
+void AliTOFChannelOnlineStatusArray::SetPulserStatus(Int_t pos, UChar_t parr)
+{
+       // setting status for channel at position = pos
+       AliDebug(2,Form("Pulser status = %d",(UInt_t)parr));
+       if (pos>-1 && pos < fSize){
+               fArray[pos] &= kTOFPulserReset;
+               fArray[pos] |= parr;
+       }
+       AliDebug(2,Form("fArray[%d] = %d",pos,(UInt_t)fArray[pos]));
+}
+//________________________________________________________________
+void AliTOFChannelOnlineStatusArray::SetNoiseStatus(Int_t pos, UChar_t parr)
+{
+       // setting status for channel at position = pos
+       AliDebug(2,Form("Noise status = %d",(UInt_t)parr));
+       if (pos>-1 && pos < fSize){
+               fArray[pos] &= kTOFNoiseReset;
+               fArray[pos] |= parr;
+       }
+       AliDebug(2,Form("fArray[%d] = %d",pos,(UInt_t)fArray[pos]));
+}
+//________________________________________________________________
+UChar_t AliTOFChannelOnlineStatusArray::GetStatus(Int_t pos) const 
+{
+       // getting the status for channel at position = pos 
+       UChar_t parr = 0x0; 
+       if  (pos>-1 && pos < fSize)parr = fArray[pos];
+       return parr;
+}
+//________________________________________________________________
+UChar_t AliTOFChannelOnlineStatusArray::GetHWStatus(Int_t pos) const 
+{
+       // getting the HW status for channel at position = pos 
+       UChar_t parr = 0x0; 
+       if  (pos>-1 && pos < fSize)parr = fArray[pos];
+       AliDebug(2,Form("parr = %d ",(UInt_t)parr));
+       UChar_t hwSt = parr & kTOFHW;
+       //UChar_t hwSt = parr & 0x3;
+       return hwSt;
+}
+//________________________________________________________________
+UChar_t AliTOFChannelOnlineStatusArray::GetPulserStatus(Int_t pos) const 
+{
+       // getting the Pulser status for channel at position = pos 
+       UChar_t parr = 0x0; 
+       if  (pos>-1 && pos < fSize)parr = fArray[pos];
+       AliDebug(2,Form("parr = %d ",(UInt_t)parr));
+       UChar_t pulserSt = parr & kTOFPulser;
+       //UChar_t pulserSt = parr & 0xc;
+       return pulserSt;
+    }
+//________________________________________________________________
+UChar_t AliTOFChannelOnlineStatusArray::GetNoiseStatus(Int_t pos) const 
+{
+       // getting the noise status for channel at position = pos 
+       UChar_t parr = 0x0; 
+       if  (pos>-1 && pos < fSize)parr = fArray[pos];
+       AliDebug(2,Form("parr = %d ",(UInt_t)parr));
+       UChar_t noiseSt = parr & kTOFNoise;
+       //      UChar_t noiseSt = parr & 0x30;
+       return noiseSt; 
+}
diff --git a/TOF/AliTOFChannelOnlineStatusArray.h b/TOF/AliTOFChannelOnlineStatusArray.h
new file mode 100644 (file)
index 0000000..ea1058a
--- /dev/null
@@ -0,0 +1,53 @@
+#ifndef ALITOFCHANNELONLINESTATUSARRAY_H
+#define ALITOFCHANNELONLINESTATUSARRAY_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+/* $Id$ */
+
+////////////////////////////////////////////////
+//  class for TOF Online calibration          //
+//  to define the status of the channels      //
+//  New object created, to use an array       //
+//  instead of a TObjArray.                   //
+//  Storing all the info coming from          // 
+//  HW FEE map, pulser runs, and noise runs   //
+//  in a single object (char).                // 
+////////////////////////////////////////////////
+
+#include "TObject.h"
+
+class AliTOFChannelOnlineStatusArray: public TObject {
+
+public:
+
+  enum{
+    kTOFOnlineUnknown=0x0, kTOFOnlineOk=0x15, kTOFOnlineBad=0x2a, 
+           kTOFHWUnknown=0x0, kTOFHWOk=0x1, kTOFHWBad=0x2, kTOFHWReset=0xfc, kTOFHW=0x3,
+           kTOFPulserUnknown=0x0, kTOFPulserOk=0x4, kTOFPulserBad=0x8, kTOFPulserReset=0xf3, kTOFPulser=0xc,
+           kTOFNoiseUnknown=0x0, kTOFNoiseOk=0x10, kTOFNoiseBad=0x20, kTOFNoiseReset=0xcf, kTOFNoise=0x30
+      };
+
+  AliTOFChannelOnlineStatusArray();
+  AliTOFChannelOnlineStatusArray(Int_t size);
+  AliTOFChannelOnlineStatusArray(const AliTOFChannelOnlineStatusArray &source);
+  AliTOFChannelOnlineStatusArray& operator= (const AliTOFChannelOnlineStatusArray &source);
+  virtual ~AliTOFChannelOnlineStatusArray(){};
+  Int_t GetSize() const {return fSize;}
+  void  SetStatus(Int_t pos, UChar_t parr);
+  void  SetHWStatus(Int_t pos, UChar_t parr);
+  void  SetPulserStatus(Int_t pos, UChar_t parr);
+  void  SetNoiseStatus(Int_t pos, UChar_t parr);
+  UChar_t  GetStatus(Int_t pos) const;
+  UChar_t  GetHWStatus(Int_t pos) const;
+  UChar_t  GetPulserStatus(Int_t pos) const;
+  UChar_t  GetNoiseStatus(Int_t pos) const;
+
+private:
+  Int_t fSize;      // Size of the array of UChar_t
+  UChar_t * fArray; //[fSize]
+
+  ClassDef(AliTOFChannelOnlineStatusArray,1)    // TOF Sensor Online Calibration object
+};
+
+#endif
index 75c8f50..347c9a1 100644 (file)
@@ -117,8 +117,8 @@ Revision 0.01  2005/07/25 A. De Caro
 #include <AliGeomManager.h>
 
 #include "AliTOFcalib.h"
-#include "AliTOFChannelOnline.h"
-#include "AliTOFChannelOnlineStatus.h"
+#include "AliTOFChannelOnlineArray.h"
+#include "AliTOFChannelOnlineStatusArray.h"
 #include "AliTOFChannelOffline.h"
 #include "AliTOFClusterFinder.h"
 #include "AliTOFcluster.h"
@@ -931,10 +931,8 @@ void AliTOFClusterFinder::CalibrateRecPoint()
   Int_t   tdcCorr;
   AliInfo(" Calibrating TOF Clusters: ")
   
-  TObjArray *calTOFArrayOnline = fTOFcalib->GetTOFCalArrayOnline();  
-  TObjArray *calTOFArrayOnlinePulser = fTOFcalib->GetTOFCalArrayOnlinePulser();  
-  TObjArray *calTOFArrayOnlineNoise = fTOFcalib->GetTOFCalArrayOnlineNoise();  
-  TObjArray *calTOFArrayOnlineHW = fTOFcalib->GetTOFCalArrayOnlineHW();  
+  AliTOFChannelOnlineArray *calDelay = fTOFcalib->GetTOFOnlineDelay();  
+  AliTOFChannelOnlineStatusArray *calStatus = fTOFcalib->GetTOFOnlineStatus();  
   TObjArray *calTOFArrayOffline = fTOFcalib->GetTOFCalArrayOffline();
   TString validity = (TString)fTOFcalib->GetOfflineValidity();
   AliInfo(Form(" validity = %s",validity.Data()));
@@ -953,33 +951,23 @@ void AliTOFClusterFinder::CalibrateRecPoint()
 
     Int_t index = AliTOFGeometry::GetIndex(detectorIndex);
      
-    AliTOFChannelOnlineStatus * calChannelOnlineStPulser = (AliTOFChannelOnlineStatus* )calTOFArrayOnlinePulser->At(index);
-    AliTOFChannelOnlineStatus * calChannelOnlineStNoise = (AliTOFChannelOnlineStatus* )calTOFArrayOnlineNoise->At(index);
-    AliTOFChannelOnlineStatus * calChannelOnlineStHW = (AliTOFChannelOnlineStatus* )calTOFArrayOnlineHW->At(index);
-
-    // Get channel status 
-    UChar_t statusPulser=calChannelOnlineStPulser->GetStatus();
-    UChar_t statusNoise=calChannelOnlineStNoise->GetStatus();
-    UChar_t statusHW=calChannelOnlineStHW->GetStatus();
-
-    //check the status, also unknow is fine!!!!!!!
-
-    UChar_t status = 0x0;
-    status |= statusPulser;
-    status |= statusNoise;
-    status |= statusHW;
-    // set status of the cluster to false if at least one of the three status (Pulser/Noise/HW) is bad
-    if((statusPulser & AliTOFChannelOnlineStatus::kTOFPulserBad)==(AliTOFChannelOnlineStatus::kTOFPulserBad)||(statusNoise & AliTOFChannelOnlineStatus::kTOFNoiseBad)==(AliTOFChannelOnlineStatus::kTOFNoiseBad)||(statusHW & AliTOFChannelOnlineStatus::kTOFHWBad)==(AliTOFChannelOnlineStatus::kTOFHWBad)){
+    UChar_t statusPulser=calStatus->GetPulserStatus(index);
+    UChar_t statusNoise=calStatus->GetNoiseStatus(index);
+    UChar_t statusHW=calStatus->GetHWStatus(index);
+    UChar_t status=calStatus->GetStatus(index);
+
+    //check the status, also unknown is fine!!!!!!!
+
+    AliDebug(2, Form(" Status for channel %i = %i",index, (Int_t)status));
+    if((statusPulser & AliTOFChannelOnlineStatusArray::kTOFPulserBad)==(AliTOFChannelOnlineStatusArray::kTOFPulserBad)||(statusNoise & AliTOFChannelOnlineStatusArray::kTOFNoiseBad)==(AliTOFChannelOnlineStatusArray::kTOFNoiseBad)||(statusHW & AliTOFChannelOnlineStatusArray::kTOFHWBad)==(AliTOFChannelOnlineStatusArray::kTOFHWBad)){
       AliDebug(2, Form(" Bad Status for channel %i",index));
       fTofClusters[ii]->SetStatus(kFALSE); //odd convention, to avoid conflict with calibration objects currently in the db (temporary solution).
     }
     else {
       AliDebug(2, Form(" Good Status for channel %i",index));
     }
-    //    if((status & AliTOFChannelOnlineStatus::kTOFOnlineOk)!=(AliTOFChannelOnline::kTOFOnlineOk))fTofClusters[ii]->SetStatus(kFALSE); //odd convention, to avoid conflict with calibration objects currently in the db (temporary solution).
     // Get Rough channel online equalization 
-    AliTOFChannelOnline * calChannelOnline = (AliTOFChannelOnline* )calTOFArrayOnline->At(index);
-    Double_t roughDelay=(Double_t)calChannelOnline->GetDelay();  // in ns
+    Double_t roughDelay=(Double_t)calDelay->GetDelay(index);  // in ns
     AliDebug(2,Form(" channel delay (ns) = %f", roughDelay));
     // Get Refined channel offline calibration parameters
     if (calibration ==1){
index 0f366c8..9da5cae 100644 (file)
@@ -20,9 +20,6 @@
 //#include <stdlib.h>
 
 #include <TFile.h>
-//#include <TH1.h>
-//#include <TH1F.h>
-//#include <TH1S.h>
 #include <TH2S.h>
 #include <TMath.h>
 #include <TObjArray.h>
 #include "AliCDBMetaData.h"
 #include "AliCDBEntry.h"
 #include "AliLog.h"
-#include "AliTOFChannelOnline.h"
-#include "AliTOFChannelOnlineStatus.h"
+#include "AliTOFChannelOnlineArray.h"
+#include "AliTOFChannelOnlineStatusArray.h"
 #include "AliTOFDataDCS.h"
 #include "AliTOFGeometry.h"
 #include "AliTOFPreprocessor.h"
 #include "AliTOFFEEReader.h"
 
-//class TF1;
-//class AliDCSValue;
-//class AliTOFGeometry;
-
 // TOF preprocessor class.
 // It takes data from DCS and passes them to the class AliTOFDataDCS, which
 // processes them. The result is then written to the CDB.
-// analogously, it takes data form DAQ (both at Run level and inclusive - 
+// Analogously, it takes data form DAQ (both at Run level and inclusive - 
 // of all the runs - level, processes them, and stores both Reference Data
 // and Online Calibration files in the CDB. 
-// Processing of Pulser/Noise Run data and of TOF FEE DCS map
+// Processing of Pulser/Noise Run data and of TOF FEE DCS map included also.
 
 // return codes:
 // return=0 : all ok
@@ -71,6 +64,7 @@
 // return=16: failed to retrieve FEE data from OCDB
 // return=17: failed to store FEE data in OCDB
 // return=18: failed to store FEE reference data in OCDB
+// return=20: failed in retrieving status variable
 
 ClassImp(AliTOFPreprocessor)
 
@@ -85,11 +79,10 @@ AliTOFPreprocessor::AliTOFPreprocessor(AliShuttleInterface* shuttle) :
   fData(0),
   fh2(0),
   fCal(0),
-  fCalStatus(0),
-  fFEEStatus(0),
   fNChannels(0),
   fStoreRefData(kTRUE),
-  fFDRFlag(kTRUE)
+  fFDRFlag(kFALSE),
+  fStatus(0)
 {
   // constructor
   AddRunType("PHYSICS");
@@ -116,13 +109,9 @@ AliTOFPreprocessor::~AliTOFPreprocessor()
     delete fCal;
     fCal = 0;
   }
-  if (fCalStatus){
-    delete fCalStatus;
-    fCalStatus = 0;
-  }
-  if (fFEEStatus){
-    delete fFEEStatus;
-    fFEEStatus = 0;
+  if (fStatus){
+    delete fStatus;
+    fStatus = 0;
   }
 }
 
@@ -142,24 +131,6 @@ void AliTOFPreprocessor::Initialize(Int_t run, UInt_t startTime,
        fData->SetFDRFlag(fFDRFlag);
        fh2 = 0x0;
        fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
-       fCal = new TObjArray(fNChannels);
-       fCal->SetOwner();
-       for (Int_t ich = 0; ich<fNChannels; ich ++){
-         AliTOFChannelOnline * calChOnline = new AliTOFChannelOnline();
-         fCal->AddAt(calChOnline,ich);
-       }
-       fCalStatus = new TObjArray(fNChannels);
-       fCalStatus->SetOwner();
-       for (Int_t ich = 0; ich<fNChannels; ich ++){
-         AliTOFChannelOnlineStatus * calChOnlineStatus = new AliTOFChannelOnlineStatus();
-         fCalStatus->AddAt(calChOnlineStatus,ich);
-       }
-       fFEEStatus = new TObjArray(fNChannels);
-       fFEEStatus->SetOwner();
-       for (Int_t ich = 0; ich<fNChannels; ich ++){
-         AliTOFChannelOnlineStatus * calChOnlineStatus = new AliTOFChannelOnlineStatus();
-         fFEEStatus->AddAt(calChOnlineStatus,ich);
-       }
 }
 //_____________________________________________________________________________
 Bool_t AliTOFPreprocessor::ProcessDCS(){
@@ -226,6 +197,73 @@ UInt_t AliTOFPreprocessor::ProcessOnlineDelays()
 
   Log("Processing DAQ delays");
 
+  // reading configuration map 
+  TString compDelays = "kFALSE";
+  Int_t deltaStartingRun = fRun;
+  Int_t startingRun = fRun-deltaStartingRun;
+  Int_t binRangeAve = fgkBinRangeAve;
+  Double_t integralThr = fgkIntegralThr;
+  Double_t thrPar = fgkThrPar;
+
+  AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Config");
+  if (!cdbEntry) {
+         Log(Form("No Configuration entry found in CDB, using default values: ComputingDelays = %s, StartingRun = %i",compDelays.Data(), startingRun));
+  }
+  else {
+         TMap *configMap = (TMap*)cdbEntry->GetObject();
+         if (!configMap){
+                 Log(Form("No map found in Config entry in CDB, using default values: ComputingDelays = %s, StartingRun = %i",compDelays.Data(), startingRun));
+         }
+         else{
+                 TObjString *strDelays = (TObjString*)configMap->GetValue("ComputingDelays");
+                 if (strDelays) {
+                         compDelays = (TString) strDelays->GetString();
+                 }
+                 else {
+                         Log(Form("No ComputingDelays value found in Map from Config entry in CDB, using default value: ComputingDelays =  %s",compDelays.Data()));
+                 }
+                 TObjString *strRun = (TObjString*)configMap->GetValue("StartingRun");
+                 if (strRun) {
+                         TString tmpstr = strRun->GetString();
+                         startingRun = tmpstr.Atoi();
+                         deltaStartingRun = fRun - startingRun;
+                 }
+                 else {
+                         Log(Form("No StartingRun value found in Map from Config entry in CDB, using default value: StartingRun = %i",startingRun));
+                 }
+                 TObjString *strBinRangeAve = (TObjString*)configMap->GetValue("BinRangeAve");
+                 if (strBinRangeAve) {
+                         TString tmpstr = strBinRangeAve->GetString();
+                         binRangeAve = tmpstr.Atoi();
+                 }
+                 else {
+                         Log(Form("No BinRangeAve value found in Map from Config entry in CDB, using default value: BinRangeAve = %i",binRangeAve));
+                 }
+                 TObjString *strIntegralThr = (TObjString*)configMap->GetValue("IntegralThr");
+                 if (strIntegralThr) {
+                         TString tmpstr = strIntegralThr->GetString();
+                         integralThr = tmpstr.Atof();
+                 }
+                 else {
+                         Log(Form("No IntegralThr value found in Map from Config entry in CDB, using default value: IntegralThr = %i",integralThr));
+                 }
+                 TObjString *strThrPar = (TObjString*)configMap->GetValue("ThrPar");
+                 if (strThrPar) {
+                         TString tmpstr = strThrPar->GetString();
+                         thrPar = tmpstr.Atof();
+                 }
+                 else {
+                         Log(Form("No ThrPar value found in Map from Config entry in CDB, using default value: ThrPar = %i",thrPar));
+                 }
+         }
+  }
+  if (compDelays == "kTRUE") fFDRFlag = kFALSE;
+  else fFDRFlag = kTRUE;
+
+  Log(Form("ComputingDelays = %s, StartingRun = %i",compDelays.Data(),startingRun));
+
+  fCal = new AliTOFChannelOnlineArray(fNChannels);
+
   TH1::AddDirectory(0);
 
   Bool_t resultDAQRef=kFALSE;
@@ -236,153 +274,155 @@ UInt_t AliTOFPreprocessor::ProcessOnlineDelays()
   
   if(fStoreRefData){
     //retrieving data at Run level
-    TList* list = GetFileSources(kDAQ, "RUNLevel");
-    if (list !=0x0 && list->GetEntries()!=0)
-      {
-       AliInfo("The following sources produced files with the id RUNLevel");
-       list->Print();
-       for (Int_t jj=0;jj<list->GetEntries();jj++){
-         TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
-         AliInfo(Form("found source %s", str->String().Data()));
-         // file to be stored run per run
-         TString fileNameRun = GetFile(kDAQ, "RUNLevel", str->GetName());
-         if (fileNameRun.Length()>0){
-           AliInfo(Form("Got the file %s, now we can store the Reference Data for the current Run.", fileNameRun.Data()));
-           daqFile = new TFile(fileNameRun.Data(),"READ");
-           fh2 = (TH2S*) daqFile->Get("htof");
-           AliCDBMetaData metaDataHisto;
-           metaDataHisto.SetBeamPeriod(0);
-           metaDataHisto.SetResponsible("Chiara Zampolli");
-           metaDataHisto.SetComment("This preprocessor stores the array of histos object as Reference Data.");
-           AliInfo("Storing Reference Data");
-           resultDAQRef = StoreReferenceData("Calib","DAQData",fh2, &metaDataHisto);
-           if (!resultDAQRef){
-             Log("some problems occurred::No Reference Data stored, TOF exiting from Shuttle");
-             return 5;//return error code for failure in storing Ref Data 
-           }
-           daqFile->Close();
-           delete daqFile;
-         }
-         
+         TList* list = GetFileSources(kDAQ, "RUNLevel");
+         if (list !=0x0 && list->GetEntries()!=0)
+                 {
+                         AliInfo("The following sources produced files with the id RUNLevel");
+                         list->Print();
+                         for (Int_t jj=0;jj<list->GetEntries();jj++){
+                                 TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
+                                 AliInfo(Form("found source %s", str->String().Data()));
+                                 // file to be stored run per run
+                                 TString fileNameRun = GetFile(kDAQ, "RUNLevel", str->GetName());
+                                 if (fileNameRun.Length()>0){
+                                         AliInfo(Form("Got the file %s, now we can store the Reference Data for the current Run.", fileNameRun.Data()));
+                                         daqFile = new TFile(fileNameRun.Data(),"READ");
+                                         fh2 = (TH2S*) daqFile->Get("htof");
+                                         AliCDBMetaData metaDataHisto;
+                                         metaDataHisto.SetBeamPeriod(0);
+                                         metaDataHisto.SetResponsible("Chiara Zampolli");
+                                         metaDataHisto.SetComment("This preprocessor stores the array of histos object as Reference Data.");
+                                         AliInfo("Storing Reference Data");
+                                         resultDAQRef = StoreReferenceData("Calib","DAQData",fh2, &metaDataHisto);
+                                         if (!resultDAQRef){
+                                                 Log("some problems occurred::No Reference Data stored, TOF exiting from Shuttle");
+                                                 return 5;//return error code for failure in storing Ref Data 
+                                         }
+                                         daqFile->Close();
+                                         delete daqFile;
+                                 }
+                                 
+                                 else{
+                                         Log("The input data file from DAQ (run-level) was not found, TOF exiting from Shuttle "); 
+                                         return 4;//return error code for failure in retrieving Ref Data 
+                                 }
+                         }
+                         delete list;
+                 }
          else{
-           Log("The input data file from DAQ (run-level) was not found, TOF exiting from Shuttle "); 
-           return 4;//return error code for failure in retrieving Ref Data 
-         }
-       }
-       delete list;
-      }
-    else{
-      Log("The input data file list from DAQ (run-level) was not found, TOF exiting from Shuttle "); 
-      return 4;//return error code for failure in retrieving Ref Data 
-    }  
+                 Log("The input data file list from DAQ (run-level) was not found, TOF exiting from Shuttle "); 
+                 return 4;//return error code for failure in retrieving Ref Data 
+         }     
   }
 
 
-//Total files, with cumulative histos
+  //Total files, with cumulative histos
   
   TList* listTot = GetFileSources(kDAQ, "DELAYS");
   if (listTot !=0x0 && listTot->GetEntries()!=0)
-    {
-      AliInfo("The following sources produced files with the id DELAYS");
-      listTot->Print();
-      for (Int_t jj=0;jj<listTot->GetEntries();jj++){
-       TObjString * str = dynamic_cast<TObjString*> (listTot->At(jj));
-       AliInfo(Form("found source %s", str->String().Data()));
-
-       // file with summed histos, to extract calib params
-       TString fileName = GetFile(kDAQ, "DELAYS", str->GetName());
-       if (fileName.Length()>0){
-         AliInfo(Form("Got the file %s, now we can extract some values.", fileName.Data()));
-
-         daqFile = new TFile(fileName.Data(),"READ");
-         if (fh2) delete fh2;
-         fh2 = (TH2S*) daqFile->Get("htoftot");
-         if (!fh2){
-           Log("some problems occurred:: No histo retrieved, TOF exiting from Shuttle");
-           delete daqFile;
-           return 7; //return error code for histograms not existing/junky
-         }
-         else {
-           static const Int_t kSize=fh2->GetNbinsX();
-           static const Int_t kNBins=fh2->GetNbinsY();
-           static const Double_t kXBinmin=fh2->GetYaxis()->GetBinLowEdge(1);
-           if (kSize != fNChannels){
-             Log(" number of bins along x different from number of pads, found only a subset of the histograms, TOF exiting from Shuttle");
-             delete daqFile;
-              return 7; //return error code for histograms not existing/junky
-           }
-           Int_t nNotStatistics = 0; // number of channel with not enough statistics
-           for (Int_t ich=0;ich<kSize;ich++){
-             /* check whether channel has been read out during current run.
-                 * if the status is bad it means it has not been read out.
-                 * in this case skip channel in order to not affect the mean */ 
-             if (((AliTOFChannelOnlineStatus *)fFEEStatus->At(ich))->GetStatus() == AliTOFChannelOnlineStatus::kTOFHWBad){
-               AliDebug(2,Form(" Channel %i found bad according to FEEmap, skipping from delay computing",ich));
-               continue;
-              }
-              AliDebug(2,Form(" Channel %i found ok according to FEEmap, starting delay computing",ich));
-             TH1S *h1 = new TH1S("h1","h1",kNBins,kXBinmin-0.5,kNBins*1.+kXBinmin-0.5);
-             for (Int_t ibin=0;ibin<kNBins;ibin++){
-               h1->SetBinContent(ibin+1,fh2->GetBinContent(ich+1,ibin+1));
-             }
-             if(h1->Integral()<fgkIntegralThr) {
-               nNotStatistics++;
-               if (!fFDRFlag)  Log(Form(" Not enough statistics for bin %i, skipping this channel",ich));  // printing message only if not in FDR runs
-               delete h1;
-               h1=0x0;
-               continue;
-             }
-             if (!fFDRFlag) {  // not computing delays if in FDR runs
-               Bool_t found=kFALSE; 
-               Float_t minContent=h1->Integral()*fgkThrPar; 
-               Int_t nbinsX = h1->GetNbinsX();
-               Int_t startBin=1;
-               for (Int_t j=1; j<=nbinsX; j++){
-                 if ((
-                      h1->GetBinContent(j) +     
-                      h1->GetBinContent(j+1)+
-                      h1->GetBinContent(j+2)+ 
-                      h1->GetBinContent(j+3))>minContent){
-                   found=kTRUE;
-                   startBin=j;
-                   break;
+         {
+                 AliInfo("The following sources produced files with the id DELAYS");
+                 listTot->Print();
+                 for (Int_t jj=0;jj<listTot->GetEntries();jj++){
+                         TObjString * str = dynamic_cast<TObjString*> (listTot->At(jj));
+                         AliInfo(Form("found source %s", str->String().Data()));
+                         
+                         // file with summed histos, to extract calib params
+                         TString fileName = GetFile(kDAQ, "DELAYS", str->GetName());
+                         if (fileName.Length()>0){
+                                 AliInfo(Form("Got the file %s, now we can extract some values.", fileName.Data()));
+                                 
+                                 daqFile = new TFile(fileName.Data(),"READ");
+                                 if (fh2) delete fh2;
+                                 fh2 = (TH2S*) daqFile->Get("htoftot");
+                                 if (!fh2){
+                                         Log("some problems occurred:: No histo retrieved, TOF exiting from Shuttle");
+                                         delete daqFile;
+                                         return 7; //return error code for histograms not existing/junky
+                                 }
+                                 else {
+                                         static const Int_t kSize=fh2->GetNbinsX();
+                                         static const Int_t kNBins=fh2->GetNbinsY();
+                                         static const Double_t kXBinmin=fh2->GetYaxis()->GetBinLowEdge(1);
+                                         if (kSize != fNChannels){
+                                                 Log(" number of bins along x different from number of pads, found only a subset of the histograms, TOF exiting from Shuttle");
+                                                 delete daqFile;
+                                                 return 7; //return error code for histograms not existing/junky
+                                         }
+                                         Int_t nNotStatistics = 0; // number of channel with not enough statistics
+                                         if (fFDRFlag) Log(" Not computing delays according to flag set in Config entry in OCDB!");
+
+                                         else {  // computing delays if not in FDR runs
+                                                 for (Int_t ich=0;ich<kSize;ich++){
+                                                         /* check whether channel has been read out during current run.
+                                                          * if the status is bad it means it has not been read out.
+                                                          * in this case skip channel in order to not affect the mean */ 
+                                                         if (fStatus->GetHWStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFHWBad){
+                                                                 AliDebug(2,Form(" Channel %i found bad according to FEEmap, (HW status = %i), skipping from delay computing",ich, (Int_t)fStatus->GetHWStatus(ich)));
+                                                                 continue;
+                                                         }
+                                                         AliDebug(2,Form(" Channel %i found ok according to FEEmap, starting delay computing",ich));
+                                                         TH1S *h1 = new TH1S("h1","h1",kNBins,kXBinmin-0.5,kNBins*1.+kXBinmin-0.5);
+                                                         for (Int_t ibin=0;ibin<kNBins;ibin++){
+                                                                 h1->SetBinContent(ibin+1,fh2->GetBinContent(ich+1,ibin+1));
+                                                         }
+                                                         if(h1->Integral()<integralThr) {
+                                                                 nNotStatistics++;
+                                                                 Log(Form(" Not enough statistics for bin %i, skipping this channel",ich));  // printing message only if not in FDR runs
+                                                                 delete h1;
+                                                                 h1=0x0;
+                                                                 continue;
+                                                         }
+                                                         Bool_t found=kFALSE; 
+                                                         Float_t minContent=h1->Integral()*thrPar; 
+                                                         Int_t nbinsX = h1->GetNbinsX();
+                                                         Int_t startBin=1;
+                                                         for (Int_t j=1; j<=nbinsX; j++){
+                                                                 if ((
+                                                                      h1->GetBinContent(j) +     
+                                                                      h1->GetBinContent(j+1)+
+                                                                      h1->GetBinContent(j+2)+ 
+                                                                      h1->GetBinContent(j+3))>minContent){
+                                                                         found=kTRUE;
+                                                                         startBin=j;
+                                                                         break;
+                                                                 }
+                                                         }
+                                                         if(!found) AliInfo(Form("WARNING!!! no start of fit found for histo # %i",ich));
+                                                         // Now calculate the mean over the interval. 
+                                                         Double_t mean = 0;
+                                                         Double_t sumw2 = 0;
+                                                         Double_t nent = 0;
+                                                         for(Int_t k=0;k<binRangeAve;k++){
+                                                                 mean=mean+h1->GetBinCenter(startBin+k)*h1->GetBinContent(startBin+k);                 
+                                                                 nent=nent+h1->GetBinContent(startBin+k);                 
+                                                                 sumw2=sumw2+(h1->GetBinCenter(startBin+k))*(h1->GetBinCenter(startBin+k))*(h1->GetBinContent(startBin+k));
+                                                         }
+                                                         mean= mean/nent; //<x>
+                                                         sumw2=sumw2/nent; //<x^2>
+                                                         Double_t rmsmean= 0;
+                                                         rmsmean = TMath::Sqrt((sumw2-mean*mean)/nent);
+                                                         if (ich<fNChannels) {
+                                                                 Float_t delay = mean*AliTOFGeometry::TdcBinWidth()*1.E-3; // delay in ns
+                                                                 fCal->SetDelay(ich,delay);  // delay in ns
+                                                                 AliDebug(2,Form("Setting delay %f (ns) for channel %i",delay,ich));
+                                                         }
+                                                         delete h1;
+                                                         h1=0x0;
+                                                 }
+                                         }
+                                         if (nNotStatistics!=0) Log(Form("Too little statistics for %d channels!",nNotStatistics)); 
+                                 }
+                                 daqFile->Close();
+                                 delete daqFile;
+                         }
+                         else{
+                                 Log("The Cumulative data file from DAQ does not exist, TOF exiting from Shuttle"); 
+                                 return 6;//return error code for problems in retrieving DAQ data 
+                         }
                  }
-               }
-               if(!found) AliInfo(Form("WARNING!!! no start of fit found for histo # %i",ich));
-               // Now calculate the mean over the interval. 
-               Double_t mean = 0;
-               Double_t sumw2 = 0;
-               Double_t nent = 0;
-               for(Int_t k=0;k<fgkBinRangeAve;k++){
-                 mean=mean+h1->GetBinCenter(startBin+k)*h1->GetBinContent(startBin+k);                 
-                 nent=nent+h1->GetBinContent(startBin+k);                 
-                 sumw2=sumw2+(h1->GetBinCenter(startBin+k))*(h1->GetBinCenter(startBin+k))*(h1->GetBinContent(startBin+k));
-               }
-               mean= mean/nent; //<x>
-               sumw2=sumw2/nent; //<x^2>
-               Double_t rmsmean= 0;
-               rmsmean = TMath::Sqrt((sumw2-mean*mean)/nent);
-               if (ich<fNChannels) {
-                 AliTOFChannelOnline * ch = (AliTOFChannelOnline *)fCal->At(ich);
-                 ch->SetDelay((Double_t)mean*AliTOFGeometry::TdcBinWidth()*1.E-3);  // delay in ns
-                 // ch->SetStatus(1);  // calibrated channel, removed for the time being from AliTOFChannelOnline
-               }
-             }
-           delete h1;
-           h1=0x0;
-           }
-           if (nNotStatistics!=0) Log(Form("Too little statistics for %d channels!",nNotStatistics)); 
+                 delete listTot;
          }
-         daqFile->Close();
-         delete daqFile;
-       }
-       else{
-         Log("The Cumulative data file from DAQ does not exist, TOF exiting from Shuttle"); 
-          return 6;//return error code for problems in retrieving DAQ data 
-       }
-      }
-      delete listTot;
-    }
   else{
     Log("Problem: no list for Cumulative data file from DAQ was found, TOF exiting from Shuttle");
     return 6; //return error code for problems in retrieving DAQ data 
@@ -392,9 +432,9 @@ UInt_t AliTOFPreprocessor::ProcessOnlineDelays()
   AliCDBMetaData metaData;
   metaData.SetBeamPeriod(0);
   metaData.SetResponsible("Chiara Zampolli");
-  metaData.SetComment("This preprocessor fills a TObjArray object.");
+  metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineArray object for online calibration - delays.");
   AliInfo("Storing Calibration Data");
-  resultTOFPP = Store("Calib","ParOnline",fCal, &metaData,0,kTRUE);
+  resultTOFPP = Store("Calib","ParOnlineDelay",fCal, &metaData,deltaStartingRun,kTRUE);
   if(!resultTOFPP){
     Log("Some problems occurred while storing online object resulting from DAQ data processing");
     return 8;//return error code for problems in storing DAQ data 
@@ -410,28 +450,22 @@ UInt_t AliTOFPreprocessor::ProcessPulserData()
 
   Log("Processing Pulser");
 
-  TH1::AddDirectory(0);
+  if (fStatus==0x0){
+         AliError("No valid fStatus found, some errors must have occurred!!");
+         return 20;
+  }
 
+  TH1::AddDirectory(0);
+  
   Bool_t resultPulserRef=kFALSE;
   Bool_t resultPulser=kFALSE;
-
+  
   static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
   TH1S * htofPulser = new TH1S("hTOFpulser","histo with signals on TOF during pulser", kSize,-0.5,kSize-0.5);
   for (Int_t ibin =1;ibin<=kSize;ibin++){
-    htofPulser->SetBinContent(ibin,-1);
-  }
-
-  // retrieving last stored pulser object, and copying
-
-  AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Pulser");
-  if (cdbEntry!=0x0){
-    TObjArray *currentCalStatus = (TObjArray*)cdbEntry->GetObject();
-    for (Int_t ich = 0; ich<fNChannels; ich ++){
-      AliTOFChannelOnlineStatus * calChOnlineSt = (AliTOFChannelOnlineStatus*)fCalStatus->At(ich);
-      calChOnlineSt->SetStatus(((AliTOFChannelOnlineStatus*)currentCalStatus->At(ich))->GetStatus());
-    }
+         htofPulser->SetBinContent(ibin,-1);
   }
-
+  
   // processing pulser
   
   TFile * daqFile=0x0;
@@ -443,7 +477,9 @@ UInt_t AliTOFPreprocessor::ProcessPulserData()
     {
       AliInfo("The following sources produced files with the id PULSER");
       listPulser->Print();
+      Int_t nPulser = 0;
       for (Int_t jj=0;jj<listPulser->GetEntries();jj++){
+       Int_t nPulserSource = 0;
        TObjString * str = dynamic_cast<TObjString*> (listPulser->At(jj));
        AliInfo(Form("found source %s", str->String().Data()));
        // file to be stored run per run
@@ -470,79 +506,81 @@ UInt_t AliTOFPreprocessor::ProcessPulserData()
          Int_t nreadNotEmpty=0;
          for (Int_t ientry=1;ientry<=h1->GetNbinsX();ientry++){
 
+                 AliDebug(3,Form(" channel %i pulser status before pulser = %i, with global status = %i",ientry,(Int_t)fStatus->GetPulserStatus(ientry),(Int_t)fStatus->GetStatus(ientry)));
            /* check whether channel has been read out during current run.
             * if the status is bad it means it has not been read out.
             * in this case skip channel in order to not affect the mean */ 
-           if (((AliTOFChannelOnlineStatus *)fFEEStatus->At(ientry-1))->GetStatus() == AliTOFChannelOnlineStatus::kTOFHWBad)
-                   continue;
-
-           if (h1->GetBinContent(ientry)==-1) continue;
-           else {
-             if (h1->GetBinContent(ientry)>0) {
-               nreadNotEmpty++;
-               AliDebug(1,Form(" channel %i is ok with entry = %f; so far %i channels added ",ientry-1,h1->GetBinContent(ientry),nreadNotEmpty));
-             }
-             mean+=h1->GetBinContent(ientry);
-             nread++;
-           }
+                 if (fStatus->GetHWStatus(ientry-1) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
+                         continue;
+                 nPulser++;
+                 nPulserSource++;
+                 if (h1->GetBinContent(ientry)==-1) continue;
+                 else {
+                         if (h1->GetBinContent(ientry)>0) {
+                                 nreadNotEmpty++;
+                                 AliDebug(2,Form(" channel %i is ok with entry = %f; so far %i channels added ",ientry-1,h1->GetBinContent(ientry),nreadNotEmpty));
+                         }
+                         mean+=h1->GetBinContent(ientry);
+                         nread++;
+                 }
          }
          if (nread!=0) {
                  mean/=nread;
-                 AliDebug(1,Form(" nread =  %i , mean = %f",nread,mean));
+                 AliDebug(2,Form(" nread =  %i , nreadNotEmpty = %i, mean = %f",nread,nreadNotEmpty,mean));
                  for (Int_t ich =0;ich<fNChannels;ich++){
-                         AliTOFChannelOnlineStatus * chSt = (AliTOFChannelOnlineStatus *)fCalStatus->At(ich);
                          if (h1->GetBinContent(ich+1)==-1) continue;
-                         AliDebug(1,Form(" channel %i ",ich));
-                         AliDebug(1,Form(" channel status before pulser = %i",(Int_t)chSt->GetStatus()));
+                         AliDebug(3,Form(" channel %i pulser status before pulser = %i",ich,(Int_t)fStatus->GetPulserStatus(ich)));
                          
                          /* check whether channel has been read out during current run.
                           * if the status is bad it means it has not been read out.
                           * in this case skip channel in order to leave its status 
                           * unchanged */
-                                 if (((AliTOFChannelOnlineStatus *)fFEEStatus->At(ich))->GetStatus() == AliTOFChannelOnlineStatus::kTOFHWBad)
-                         continue;
+                                 if (fStatus->GetHWStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
+                                 continue;
                          
                          if (h1->GetBinContent(ich+1)<0.05*mean){
-                                 chSt->SetStatus(chSt->GetStatus()|AliTOFChannelOnlineStatus::kTOFPulserBad);  // bad status for pulser
-                                 AliDebug(1,Form(" channel status after pulser = %i",(Int_t)chSt->GetStatus()));
+                                 fStatus->SetPulserStatus(ich,AliTOFChannelOnlineStatusArray::kTOFPulserBad);  // bad status for pulser
+                                 AliDebug(2,Form( " channel %i pulser status after pulser = %i (bad, content = %f), with global status = %i",ich,(Int_t)fStatus->GetPulserStatus(ich),h1->GetBinContent(ich+1),(Int_t)fStatus->GetStatus(ich)));
                          }
                          else {
-                                 chSt->SetStatus(chSt->GetStatus()|AliTOFChannelOnlineStatus::kTOFPulserOk);  // bad status for pulser
-                                 AliDebug(1,Form(" channel status after pulser = %i",(Int_t)chSt->GetStatus()));
+                                 fStatus->SetPulserStatus(ich,AliTOFChannelOnlineStatusArray::kTOFPulserOk);  // good status for pulser
+                                 AliDebug(2,Form( " channel %i pulser status after pulser = %i (good), with global status = %i",ich,(Int_t)fStatus->GetPulserStatus(ich),(Int_t)fStatus->GetStatus(ich)));
                          }
                  }
          }
          else {
                  Log("No channels read!! No action taken, keeping old status");
          }
-
+         
          daqFile->Close();
          delete daqFile;
          delete h1;
        }
        
        else{
-         Log("The input data file from DAQ (pulser) was not found, TOF exiting from Shuttle "); 
-         return 10;//return error code for failure in retrieving Ref Data 
+               Log("The input data file from DAQ (pulser) was not found, TOF exiting from Shuttle "); 
+               return 10;//return error code for failure in retrieving Ref Data 
        }
+       AliDebug(2,Form(" Number of channels processed during pulser run from source %i = %i",jj, nPulserSource));
        
       }
+      AliDebug(2,Form(" Number of channels processed during pulser run = %i",nPulser));
       delete listPulser;
     }
   
   else{
-    Log("The input data file list from DAQ (pulser) was not found, TOF exiting from Shuttle "); 
-    return 10;//return error code for failure in retrieving Ref Data 
+         Log("The input data file list from DAQ (pulser) was not found, TOF exiting from Shuttle "); 
+         return 10;//return error code for failure in retrieving Ref Data 
   }    
-
+  
   //storing in OCDB  
-
+  
   AliCDBMetaData metaData;
   metaData.SetBeamPeriod(0);
   metaData.SetResponsible("Chiara Zampolli");
-  metaData.SetComment("This preprocessor fills a TObjArray object for Pulser data.");
+  metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object after a Pulser run.");
   AliInfo("Storing Calibration Data from Pulser Run");
-  resultPulser = Store("Calib","Pulser",fCalStatus, &metaData,0,kTRUE);
+  resultPulser = Store("Calib","Status",fStatus, &metaData,0,kTRUE);
   if(!resultPulser){
     Log("Some problems occurred while storing online object resulting from Pulser data processing");
     return 11;//return error code for problems in storing Pulser data 
@@ -554,7 +592,7 @@ UInt_t AliTOFPreprocessor::ProcessPulserData()
     metaDataHisto.SetBeamPeriod(0);
     metaDataHisto.SetResponsible("Chiara Zampolli");
     char comment[200];
-    sprintf(comment,"This preprocessor stores the result of the pulser run");
+    sprintf(comment,"This preprocessor stores the Ref data from a pulser run.");
     metaDataHisto.SetComment(comment);
     AliInfo("Storing Reference Data");
     resultPulserRef = StoreReferenceData("Calib","PulserData",htofPulser, &metaDataHisto);
@@ -577,28 +615,22 @@ UInt_t AliTOFPreprocessor::ProcessNoiseData()
 
   Log("Processing Noise");
 
+  if (fStatus==0x0){
+         AliError("No valid fStatus found, some errors must have occurred!!");
+         return 20;
+  }
+
   TH1::AddDirectory(0);
 
   Bool_t resultNoiseRef=kFALSE;
   Bool_t resultNoise=kFALSE;
 
   static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
-  TH1F * htofNoise = new TH1F("hTOFnoise","histo with signals on TOF during pulser", kSize,-0.5,kSize-0.5);
+  TH1F * htofNoise = new TH1F("hTOFnoise","histo with signals on TOF during noise", kSize,-0.5,kSize-0.5);
   for (Int_t ibin =1;ibin<=kSize;ibin++){
-    htofNoise->SetBinContent(ibin,-1);
+         htofNoise->SetBinContent(ibin,-1);
   }
-
-  // retrieving last stored noise object, and copying
-
-  AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Noise");
-  if (cdbEntry!=0x0){
-    TObjArray *currentCalStatus = (TObjArray*)cdbEntry->GetObject();
-    for (Int_t ich = 0; ich<fNChannels; ich ++){
-      AliTOFChannelOnlineStatus * calChOnlineSt = (AliTOFChannelOnlineStatus*)fCalStatus->At(ich);
-      calChOnlineSt->SetStatus(((AliTOFChannelOnlineStatus*)currentCalStatus->At(ich))->GetStatus());
-    }
-  }
-
+  
   // processing noise
   
   TFile * daqFile=0x0;
@@ -610,13 +642,15 @@ UInt_t AliTOFPreprocessor::ProcessNoiseData()
     {
       AliInfo("The following sources produced files with the id NOISE");
       listNoise->Print();
+      Int_t nNoise = 0;
       for (Int_t jj=0;jj<listNoise->GetEntries();jj++){
+       Int_t nNoiseSource = 0;
        TObjString * str = dynamic_cast<TObjString*> (listNoise->At(jj));
        AliInfo(Form("found source %s", str->String().Data()));
        // file to be stored run per run
        TString fileNameNoise = GetFile(kDAQ, "NOISE", str->GetName());
        if (fileNameNoise.Length()>0){
-         // storing refernce data
+         // storing reference data
          AliInfo(Form("Got the file %s, now we can process noise data.", fileNameNoise.Data()));
          daqFile = new TFile(fileNameNoise.Data(),"READ");
          h1 = (TH1F*) daqFile->Get("hTOFnoise");
@@ -632,25 +666,26 @@ UInt_t AliTOFPreprocessor::ProcessNoiseData()
          }
          // elaborating infos
          for (Int_t ich =0;ich<fNChannels;ich++){
-           AliTOFChannelOnlineStatus * chSt = (AliTOFChannelOnlineStatus *)fCalStatus->At(ich);
            if (h1->GetBinContent(ich+1)==-1) continue;
-           AliDebug(1,Form( " channel %i",ich));
-           AliDebug(1,Form( " channel status before noise = %i",(Int_t)chSt->GetStatus()));
+           AliDebug(3,Form(" channel %i noise status before noise = %i, with global status = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich),(Int_t)fStatus->GetStatus(ich)));
+           //AliDebug(2,Form( " channel %i status before noise = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich)));
 
            /* check whether channel has been read out during current run.
             * if the status is bad it means it has not been read out.
             * in this case skip channel in order to leave its status 
             * unchanged */
-           if (((AliTOFChannelOnlineStatus *)fFEEStatus->At(ich))->GetStatus() == AliTOFChannelOnlineStatus::kTOFHWBad)
+           if ((fStatus->GetHWStatus(ich)) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
              continue;
 
+           nNoise++;
+           nNoiseSource++;
            if (h1->GetBinContent(ich+1)>=1){  // setting limit for noise to 1 kHz
-             chSt->SetStatus(chSt->GetStatus()|AliTOFChannelOnlineStatus::kTOFNoiseBad);  // bad status for noise
-             AliDebug(1,Form( " channel status after noise = %i",(Int_t)chSt->GetStatus()));
+                   fStatus->SetNoiseStatus(ich,AliTOFChannelOnlineStatusArray::kTOFNoiseBad); // bad status for noise
+                   AliDebug(2,Form( " channel %i noise status after noise = %i, with global status = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich),(Int_t)fStatus->GetStatus(ich)));
            }
            else {
-             chSt->SetStatus(chSt->GetStatus()|AliTOFChannelOnlineStatus::kTOFNoiseOk);  // bad status for noise
-             AliDebug(1,Form(" channel status after noise = %i",(Int_t)chSt->GetStatus()));
+                   fStatus->SetNoiseStatus(ich,AliTOFChannelOnlineStatusArray::kTOFNoiseOk); // good status for noise
+                   AliDebug(2,Form(" channel %i noise status after noise = %i, with global status = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich),(Int_t)fStatus->GetStatus(ich)));
            }
          }
  
@@ -665,7 +700,9 @@ UInt_t AliTOFPreprocessor::ProcessNoiseData()
          return 13;//return error code for failure in retrieving Ref Data 
        }
        
+       AliDebug(2,Form(" Number of channels processed during noise run from source %i = %i",jj, nNoiseSource));
       }
+      AliDebug(2,Form(" Number of channels processed during noise run = %i",nNoise));
       delete listNoise;
     }
   else{
@@ -680,9 +717,9 @@ UInt_t AliTOFPreprocessor::ProcessNoiseData()
   AliCDBMetaData metaData;
   metaData.SetBeamPeriod(0);
   metaData.SetResponsible("Chiara Zampolli");
-  metaData.SetComment("This preprocessor fills a TObjArray object for Noise data.");
+  metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object after a Noise run.");
   AliInfo("Storing Calibration Data from Noise Run");
-  resultNoise = Store("Calib","Noise",fCalStatus, &metaData,0,kTRUE);
+  resultNoise = Store("Calib","Status",fStatus, &metaData,0,kTRUE);
   if(!resultNoise){
     Log("Some problems occurred while storing online object resulting from Noise data processing");
     return 14;//return error code for problems in storing Noise data 
@@ -694,7 +731,7 @@ UInt_t AliTOFPreprocessor::ProcessNoiseData()
     metaDataHisto.SetBeamPeriod(0);
     metaDataHisto.SetResponsible("Chiara Zampolli");
     char comment[200];
-    sprintf(comment,"This preprocessor stores the result of the noise run, TOF exiting from Shuttle ");
+    sprintf(comment,"This preprocessor stores the Ref data from a noise run. ");
     metaDataHisto.SetComment(comment);
     AliInfo("Storing Reference Data");
     resultNoiseRef = StoreReferenceData("Calib","NoiseData",htofNoise, &metaDataHisto);
@@ -717,9 +754,7 @@ UInt_t AliTOFPreprocessor::ProcessFEEData()
 
   Bool_t updateOCDB = kFALSE;
   AliTOFFEEReader feeReader;
-  AliTOFChannelOnlineStatus *currentChannel = NULL, *storedChannel = NULL;
-  TObjArray *currentFEE = fFEEStatus;
-  
+
   TH1C hCurrentFEE("hCurrentFEE","histo with current FEE channel status", fNChannels, 0, fNChannels);
   
   /* load current TOF FEE config from DCS FXS, parse, 
@@ -731,46 +766,47 @@ UInt_t AliTOFPreprocessor::ProcessFEEData()
          return 15;
   } 
   feeReader.LoadFEEConfig(nameFile);
-  feeReader.ParseFEEConfig();
-  /* loop over channels */
-  for (Int_t iChannel = 0; iChannel < fNChannels; iChannel++) {
-    currentChannel = (AliTOFChannelOnlineStatus *)currentFEE->At(iChannel);
-    if (!currentChannel)
-      continue;
-    /* channel enabled. set FEE channel status ok */
-    if (feeReader.IsChannelEnabled(iChannel)) {
-      currentChannel->SetStatus(AliTOFChannelOnlineStatus::kTOFHWOk);
-      hCurrentFEE.SetBinContent(iChannel + 1, 1);
-    }
-    /* channel disabled. set FEE channel status bad */
-    else {
-      currentChannel->SetStatus(AliTOFChannelOnlineStatus::kTOFHWBad);
-    }
-  }
-  
+  Int_t parseFee = feeReader.ParseFEEConfig();
+  AliDebug(2,Form("%i enabled channels found in FEE configuration",parseFee));
   /* load stored TOF FEE from OCDB and compare it with current FEE.
    * if stored FEE is different from current FEE set update flag.
    * if there is no stored FEE in OCDB set update flag */
   
-  AliCDBEntry *cdbEntry = GetFromOCDB("Calib","FEE");
-  /* no CDB entry found. set update flag */
-  if (cdbEntry == NULL) {
-    updateOCDB = kTRUE;
+  AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Status");
+  if (!cdbEntry) {
+         /* no CDB entry found. set update flag */
+         Log("     ************ WARNING ************");
+         Log("No CDB Status entry found, creating a new one!");
+         Log("     *********************************");
+         fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
+         updateOCDB = kTRUE;
   }
-  /* CDB entry OK. loop over channels */
   else {
-    TObjArray *storedFEE = (TObjArray *)cdbEntry->GetObject();
-    for (Int_t iChannel = 0; iChannel < fNChannels; iChannel++){
-      currentChannel = (AliTOFChannelOnlineStatus *)currentFEE->At(iChannel);
-      storedChannel = (AliTOFChannelOnlineStatus *)storedFEE->At(iChannel);
-      /* compare current FEE channel status with stored one 
-       * if different set update flag and break loop */
-      if (currentChannel->GetStatus() != storedChannel->GetStatus()) {
-       updateOCDB = kTRUE;
-       break;
-      }
-    }
+         /* CDB entry OK. loop over channels */
+         fStatus = (AliTOFChannelOnlineStatusArray*) cdbEntry->GetObject();
   }
+  for (Int_t iChannel = 0; iChannel < fNChannels; iChannel++){
+         //AliDebug(2,Form("********** channel %i",iChannel));
+         /* compare current FEE channel status with stored one 
+          * if different set update flag and break loop */
+         //AliDebug(2,Form( " channel %i status before FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
+         if (feeReader.IsChannelEnabled(iChannel)) {
+                 hCurrentFEE.SetBinContent(iChannel + 1, 1);
+                 if (fStatus->GetHWStatus(iChannel)!=AliTOFChannelOnlineStatusArray::kTOFHWOk){
+                         updateOCDB = kTRUE;
+                         fStatus->SetHWStatus(iChannel,AliTOFChannelOnlineStatusArray::kTOFHWOk);
+                         AliDebug(2,Form( " changed into enabled: channel %i status after FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
+                 }
+         }
+         else {
+                 if (fStatus->GetHWStatus(iChannel)!=AliTOFChannelOnlineStatusArray::kTOFHWBad){
+                         updateOCDB = kTRUE;
+                         fStatus->SetHWStatus(iChannel,AliTOFChannelOnlineStatusArray::kTOFHWBad);
+                         AliDebug(2,Form( " changed into disabled: channel %i status after FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
+                 }
+         }
+  }
+
 
   /* check whether we don't have to store reference data.
    * in this case we return without errors. */
@@ -779,7 +815,7 @@ UInt_t AliTOFPreprocessor::ProcessFEEData()
          AliCDBMetaData metaDataHisto;
          metaDataHisto.SetBeamPeriod(0);
          metaDataHisto.SetResponsible("Roberto Preghenella");
-         metaDataHisto.SetComment("This preprocessor stores the FEE referece data of the current run.");
+         metaDataHisto.SetComment("This preprocessor stores the FEE Ref data of the current run.");
          AliInfo("Storing FEE reference data");
          /* store FEE reference data */
          if (!StoreReferenceData("Calib", "FEEData", &hCurrentFEE, &metaDataHisto)) {
@@ -791,22 +827,28 @@ UInt_t AliTOFPreprocessor::ProcessFEEData()
 
   /* check whether we don't need to update OCDB.
    * in this case we can return without errors and
-   * the current FEE is stored in the fFEEStatus TObjArray. */
+   * the current FEE is stored in the fStatus object. */
   if (!updateOCDB) {
     AliInfo("TOF FEE config has not changed. Do not overwrite stored file.");
     return 0; /* return ok */
   }
 
+  TString runType = GetRunType();
+  if (runType != "PHYSICS") {
+         AliInfo(Form("Run Type = %s, waiting to store status map",GetRunType()));
+    return 0; /* return ok */
+  }
+
   /* update the OCDB with the current FEE since even 
    * a little difference has been detected. */
 
   AliCDBMetaData metaData;
   metaData.SetBeamPeriod(0);
   metaData.SetResponsible("Roberto Preghenella");
-  metaData.SetComment("This preprocessor fills a TObjArray object for FEE data.");
-  AliInfo("Storing FEE data from current run");
+  metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object from FEE data.");
+  AliInfo("Storing Status data from current run after FEE parsing");
   /* store FEE data */
-  if (!Store("Calib", "FEE", fFEEStatus, &metaData, 0, kTRUE)) {
+  if (!Store("Calib", "Status", fStatus, &metaData, 0, kTRUE)) {
     /* failed */
     Log("problems while storing FEE data object");
     return 17; /* return error code for problems  while storing FEE data */
@@ -840,7 +882,7 @@ UInt_t AliTOFPreprocessor::Process(TMap* dcsAliasMap)
     Int_t iresultPulser = ProcessPulserData();
     return iresultPulser; 
   }
-  
+
   if (runType == "NOISE") { // for the time being associating noise runs with pedestal runs; proper run type to be defined 
     Int_t iresultNoise = ProcessNoiseData();
     return iresultNoise; 
index 9052ee6..54321a6 100644 (file)
@@ -13,6 +13,7 @@
 // and DAQ histograms to compute online calibration constants
 
 class AliTOFDataDCS;
+class AliTOFChannelOnlineStatusArray;
 class TObjArray;
 class TH2S;
 
@@ -40,21 +41,20 @@ class AliTOFPreprocessor : public AliPreprocessor
     UInt_t ProcessNoiseData();
     UInt_t ProcessFEEData(); // dummy, for the time being
 
-    static const Int_t fgkBinRangeAve;    // number of bins where to 
-                                          // calculate the mean
-    static const Double_t fgkIntegralThr; // min number of entries per channel 
-                                          // to perform calculation of delay
-    static const Double_t fgkThrPar;      // parameter used to trigger the 
-                                          // calculation of the delay
-    AliTOFDataDCS *fData;                 // CDB class that stores the data
-    TH2S *fh2;                            // TH2S from DAQ for histograms 
-                                          // for delays  
-    TObjArray *fCal;                      // TOF Calibration object
-    TObjArray *fCalStatus;                // TOF Calibration object from pulser/noise
-    TObjArray *fFEEStatus;                // TOF Calibration object from FEE
-    Int_t fNChannels;                     // number of TOF channels
-    Bool_t fStoreRefData;                 // Flag to decide storage of Ref Data
-    Bool_t fFDRFlag;                      // Flag for FDR runs 
-    ClassDef(AliTOFPreprocessor, 4);
+    static const Int_t fgkBinRangeAve;       // number of bins where to 
+                                             // calculate the mean
+    static const Double_t fgkIntegralThr;    // min number of entries per channel 
+                                             // to perform calculation of delay
+    static const Double_t fgkThrPar;         // parameter used to trigger the 
+                                             // calculation of the delay
+    AliTOFDataDCS *fData;                    // CDB class that stores the data
+    TH2S *fh2;                               // TH2S from DAQ for histograms 
+                                             // for delays  
+    AliTOFChannelOnlineArray *fCal;          // TOF Calibration object
+    Int_t fNChannels;                        // number of TOF channels
+    Bool_t fStoreRefData;                    // Flag to decide storage of Ref Data
+    Bool_t fFDRFlag;                         // Flag for FDR runs 
+    AliTOFChannelOnlineStatusArray *fStatus; // Array with TOF channels' status
+    ClassDef(AliTOFPreprocessor, 5);
 };
 #endif
index a9c6ea1..1afe6a9 100644 (file)
@@ -59,7 +59,10 @@ AliTOFReconstructor::AliTOFReconstructor()
   //Retrieving the TOF calibration info  
   fTOFcalib    = new AliTOFcalib();
   fTOFcalib->CreateCalArrays();
-  if(!fTOFcalib->ReadParOnlineFromCDB("TOF/Calib",-1)) {AliFatal("Exiting, no CDB object found!!!");exit(0);}  
+
+  if(!fTOFcalib->ReadParOnlineDelayFromCDB("TOF/Calib",-1)) {AliFatal("Exiting, no CDB object found!!!");exit(0);}  
+  if(!fTOFcalib->ReadParOnlineStatusFromCDB("TOF/Calib",-1)) {AliFatal("Exiting, no CDB object found!!!");exit(0);}  
+
   if(!fTOFcalib->ReadParOfflineFromCDB("TOF/Calib",-1)) {AliFatal("Exiting, no CDB object found!!!");exit(0);}  
 }
 
index e8aa6ab..39d6d6c 100644 (file)
@@ -93,6 +93,7 @@ author: Chiara Zampolli, zampolli@bo.infn.it
 #include "TProfile.h"
 #include "TGrid.h"
 #include "TMath.h"
+#include "TMap.h"
 
 #include "AliCDBEntry.h"
 #include "AliCDBRunRange.h"
@@ -105,8 +106,10 @@ author: Chiara Zampolli, zampolli@bo.infn.it
 #include "AliLog.h"
 
 #include "AliTOFcalib.h"
+#include "AliTOFChannelOnlineArray.h"
 #include "AliTOFChannelOnline.h"
 #include "AliTOFChannelOnlineStatus.h"
+#include "AliTOFChannelOnlineStatusArray.h"
 #include "AliTOFChannelOffline.h"
 #include "AliTOFGeometry.h"
 #include "AliTOFRecoParam.h"
@@ -128,13 +131,16 @@ AliTOFcalib::AliTOFcalib():
   fTOFCalOnlineNoise(0x0),
   fTOFCalOnlineHW(0x0),
   fTOFCalOffline(0x0),
+  fCal(0x0),
+  fStatus(0x0),
   fTOFSimToT(0x0),
   fkValidity(0x0),
   fTree(0x0),
   fChain(0x0),
   fNruns(0),
   fFirstRun(0),
-  fLastRun(AliCDBRunRange::Infinity())
+  fLastRun(AliCDBRunRange::Infinity()),
+  fConfigMap(new TMap)
 { 
   //TOF Calibration Class ctor
   fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
@@ -149,13 +155,16 @@ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib):
   fTOFCalOnlineNoise(0x0),
   fTOFCalOnlineHW(0x0),
   fTOFCalOffline(0x0),
+  fCal(calib.fCal),
+  fStatus(calib.fStatus),
   fTOFSimToT(calib.fTOFSimToT),
   fkValidity(calib.fkValidity),
   fTree(calib.fTree),
   fChain(calib.fChain),
   fNruns(calib.fNruns),
   fFirstRun(calib.fFirstRun),
-  fLastRun(calib.fLastRun)
+  fLastRun(calib.fLastRun),
+  fConfigMap(calib.fConfigMap)
 {
   //TOF Calibration Class copy ctor
   for (Int_t iarray = 0; iarray<fNChannels; iarray++){
@@ -169,7 +178,6 @@ AliTOFcalib::AliTOFcalib(const AliTOFcalib & calib):
     fTOFCalOnlineNoise->AddAt(calChOnlineStNoise,iarray);
     fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray);
     fTOFCalOffline->AddAt(calChOffline,iarray);
-
   }
 }
 
@@ -179,6 +187,8 @@ AliTOFcalib& AliTOFcalib::operator=(const AliTOFcalib &calib)
 {
   //TOF Calibration Class assignment operator
   this->fNChannels = calib.fNChannels;
+  this->fCal = calib.fCal;
+  this->fStatus = calib.fStatus;
   this->fTOFSimToT = calib.fTOFSimToT;
   this->fkValidity = calib.fkValidity;
   this->fTree = calib.fTree;
@@ -222,6 +232,15 @@ AliTOFcalib::~AliTOFcalib()
     if (fTOFCalOffline){
       delete fTOFCalOffline;
     }
+    if (fCal){
+      delete fCal;
+    }
+    if (fStatus){
+      delete fStatus;
+    }
+    if (fConfigMap){
+      delete fConfigMap;
+    }
   }
   if (fTree!=0x0) delete fTree;
   if (fChain!=0x0) delete fChain;
@@ -253,6 +272,128 @@ void AliTOFcalib::CreateCalArrays(){
     fTOFCalOnlineHW->AddAt(calChOnlineStHW,iarray);
     fTOFCalOffline->AddAt(calChOffline,iarray);
   }
+  fCal = new AliTOFChannelOnlineArray(fNChannels);
+  fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
+}
+//_____________________________________________________________________________
+void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+{
+  //Write calibration parameters to the CDB
+  SetFirstRun(minrun);
+  SetLastRun(maxrun);
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "Config" ;  // to be consistent with TOFPreprocessor
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliDebug(2,Form("Writing TOF configuration map for online calib on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
+  AliCDBId id(out,fFirstRun,fLastRun);
+  AliCDBMetaData *md = new AliCDBMetaData();
+  md->SetResponsible("Chiara Zampolli");
+  if (!fConfigMap) {
+    // deve uscire!!
+  }
+  man->Put(fConfigMap,id,md);
+  delete md;
+}
+//_____________________________________________________________________________
+
+void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel)
+{
+  //Write calibration parameters to the CDB with infinite validity
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "Config" ;  // to be consistent with TOFPreprocessor
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliCDBRunRange runrange(fFirstRun,fLastRun);
+  AliDebug(2,Form("Writing TOF config map for online calib on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
+  AliCDBId id(out,runrange);
+  AliCDBMetaData *md = new AliCDBMetaData();
+  md->SetResponsible("Chiara Zampolli");
+  if (!fConfigMap) {
+    // deve uscire!!
+  }
+  man->Put(fConfigMap,id,md);
+  delete md;
+}
+//_____________________________________________________________________________
+void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+{
+  //Write calibration parameters to the CDB -------> new calib objs!!!!!
+  SetFirstRun(minrun);
+  SetLastRun(maxrun);
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "ParOnlineDelay" ;  // to be consistent with TOFPreprocessor
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
+  AliCDBId id(out,fFirstRun,fLastRun);
+  AliCDBMetaData *md = new AliCDBMetaData();
+  md->SetResponsible("Chiara Zampolli");
+  if (!fCal) {
+    // deve uscire!!
+  }
+  man->Put(fCal,id,md);
+  delete md;
+}
+//_____________________________________________________________________________
+void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+{
+  //Write calibration parameters to the CDB -------> new calib objs!!!!!
+  SetFirstRun(minrun);
+  SetLastRun(maxrun);
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "Status" ;  // to be consistent with TOFPreprocessor
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
+  AliCDBId id(out,fFirstRun,fLastRun);
+  AliCDBMetaData *md = new AliCDBMetaData();
+  md->SetResponsible("Chiara Zampolli");
+  if (!fStatus) {
+    // deve uscire!!
+  }
+  man->Put(fStatus,id,md);
+  delete md;
+}
+//_____________________________________________________________________________
+
+void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel)
+{
+  //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!!
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "ParOnlineDelay" ;  // to be consistent with TOFPreprocessor
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliCDBRunRange runrange(fFirstRun,fLastRun);
+  AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
+  AliCDBId id(out,runrange);
+  AliCDBMetaData *md = new AliCDBMetaData();
+  md->SetResponsible("Chiara Zampolli");
+  if (!fCal) {
+    // deve uscire!!
+  }
+  man->Put(fCal,id,md);
+  delete md;
+}
+//_____________________________________________________________________________
+
+void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel)
+{
+  //Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!!
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "Status" ;  // to be consistent with TOFPreprocessor
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliCDBRunRange runrange(fFirstRun,fLastRun);
+  AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",runrange.GetFirstRun(),runrange.GetLastRun()));
+  AliCDBId id(out,runrange);
+  AliCDBMetaData *md = new AliCDBMetaData();
+  md->SetResponsible("Chiara Zampolli");
+  if (!fStatus) {
+    // deve uscire!!
+  }
+  man->Put(fStatus,id,md);
+  delete md;
 }
 //_____________________________________________________________________________
 void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
@@ -453,6 +594,78 @@ void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity)
 }
 //_____________________________________________________________________________
 
+Bool_t AliTOFcalib::ReadConfigMapFromCDB(Char_t *sel, Int_t nrun)
+{
+  //Read calibration parameters from the CDB
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "Config" ;
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliCDBEntry *entry = man->Get(out,nrun);
+  if (!entry) { 
+    AliFatal("Exiting, no CDB object (ConfigMap) found!!!");
+    exit(0);  
+  }
+  if(!entry->GetObject()){
+    AliFatal("Exiting, no CDB object (ConfigMap) found!!!");
+    exit(0);  
+  }  
+  
+  fConfigMap =(TMap*)entry->GetObject();
+
+  return kTRUE; 
+   
+}
+//_____________________________________________________________________________
+
+Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(Char_t *sel, Int_t nrun)
+{
+  //Read calibration parameters from the CDB -------> new calib objs!!!!!
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "ParOnlineDelay" ;
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliCDBEntry *entry = man->Get(out,nrun);
+  if (!entry) { 
+    AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!");
+    exit(0);  
+  }
+  if(!entry->GetObject()){
+    AliFatal("Exiting, no CDB object (ParOnlineDelay) found!!!");
+    exit(0);  
+  }  
+  
+  fCal =(AliTOFChannelOnlineArray*)entry->GetObject();
+
+  return kTRUE; 
+   
+}
+//_____________________________________________________________________________
+
+Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(Char_t *sel, Int_t nrun)
+{
+  //Read calibration parameters from the CDB -------> new calib objs!!!!!
+  AliCDBManager *man = AliCDBManager::Instance();
+  Char_t *sel1 = "Status" ;
+  Char_t  out[100];
+  sprintf(out,"%s/%s",sel,sel1); 
+  AliCDBEntry *entry = man->Get(out,nrun);
+  if (!entry) { 
+    AliFatal("Exiting, no CDB object (Status) found!!!");
+    exit(0);  
+  }
+  if(!entry->GetObject()){
+    AliFatal("Exiting, no CDB object (Status) found!!!");
+    exit(0);  
+  }  
+  
+  fStatus =(AliTOFChannelOnlineStatusArray*)entry->GetObject();
+
+  return kTRUE; 
+   
+}
+//_____________________________________________________________________________
+
 Bool_t AliTOFcalib::ReadParOnlineFromCDB(Char_t *sel, Int_t nrun)
 {
   //Read calibration parameters from the CDB
index eebfcee..72ec4be 100644 (file)
@@ -32,11 +32,14 @@ class TH1F;
 class TObjArray;
 class TTree;
 class TChain;
+class TMap;
 
 //class AliESD;
 
 class AliTOFCal;
 class AliTOFRecoParam;
+class AliTOFChannelOnlineStatusArray;
+class AliTOFChannelOnlineArray;
 
 class AliTOFcalib:public TTask{
 public:
@@ -46,33 +49,54 @@ public:
   virtual ~AliTOFcalib() ; // dtor
   void CreateCalArrays();
   TObjArray * GetTOFCalArrayOnline() const {return fTOFCalOnline;}
+  AliTOFChannelOnlineArray * GetTOFOnlineDelay() const {return fCal;}
+  AliTOFChannelOnlineStatusArray * GetTOFOnlineStatus() const {return fStatus;}
   TObjArray * GetTOFCalArrayOnlinePulser() const {return fTOFCalOnlinePulser;}
   TObjArray * GetTOFCalArrayOnlineNoise() const {return fTOFCalOnlineNoise;}
   TObjArray * GetTOFCalArrayOnlineHW() const {return fTOFCalOnlineHW;}
   TObjArray * GetTOFCalArrayOffline() const {return fTOFCalOffline;}
+  TMap * GetConfigMap() const {return fConfigMap;}
   TH1F * GetTOFSimToT() const {return fTOFSimToT;}
   TTree * GetTOFCalibTree() const {return fTree;}
   TChain * GetTOFCalibChain() const {return fChain;}
   const char * GetOfflineValidity() const {return fkValidity;}
   void SetOfflineValidity(const char* validity) {fkValidity = validity;}
   Int_t NChannels()const{return fNChannels;}
+
   // Methods to retrieve/write parameters from/on CDB
+  // writing
+
   void WriteSimHistoOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo);
+  void WriteConfigMapOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
+  void WriteConfigMapOnCDB(Char_t *sel);
+  // new calib objs
+  void WriteParOnlineDelayOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
+  void WriteParOnlineStatusOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
+  void WriteParOnlineDelayOnCDB(Char_t *sel);
+  void WriteParOnlineStatusOnCDB(Char_t *sel);
+  // old calib objs
   void WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
   void WriteParOnlinePulserOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
   void WriteParOnlineNoiseOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
   void WriteParOnlineHWOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
   void WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun);
   void WriteParOnlineOnCDB(Char_t *sel);
-  void WriteParOnlinePulserOnCDB(Char_t *sel);
-  void WriteParOnlineNoiseOnCDB(Char_t *sel);
-  void WriteParOnlineHWOnCDB(Char_t *sel);
+  void WriteParOnlinePulserOnCDB(Char_t *sel);  // old, before unification of status info
+  void WriteParOnlineNoiseOnCDB(Char_t *sel);   // old, before unification of status info
+  void WriteParOnlineHWOnCDB(Char_t *sel);      // old, before unification of status info
   void WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity);
+
+  // reading
   Bool_t ReadSimHistoFromCDB(Char_t *sel, Int_t nrun);
+  Bool_t ReadConfigMapFromCDB(Char_t *sel, Int_t nrun);
+  // new objs
+  Bool_t ReadParOnlineDelayFromCDB(Char_t *sel, Int_t nrun);
+  Bool_t ReadParOnlineStatusFromCDB(Char_t *sel, Int_t nrun);
+  // old objs
   Bool_t ReadParOnlineFromCDB(Char_t *sel, Int_t nrun);
-  Bool_t ReadParOnlinePulserFromCDB(Char_t *sel, Int_t nrun);
-  Bool_t ReadParOnlineNoiseFromCDB(Char_t *sel, Int_t nrun);
-  Bool_t ReadParOnlineHWFromCDB(Char_t *sel, Int_t nrun);
+  Bool_t ReadParOnlinePulserFromCDB(Char_t *sel, Int_t nrun);  // old, before unification of status info
+  Bool_t ReadParOnlineNoiseFromCDB(Char_t *sel, Int_t nrun);   // old, before unification of status info
+  Bool_t ReadParOnlineHWFromCDB(Char_t *sel, Int_t nrun);      // old, before unification of status info
   Bool_t ReadParOfflineFromCDB(Char_t *sel, Int_t nrun);
   void WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param);
   AliTOFRecoParam * ReadRecParFromCDB(Char_t *sel, Int_t nrun);
@@ -96,11 +120,18 @@ public:
 
 private:
   Int_t fNChannels; // number of TOF channels
+
+  // old calibration objects
   TObjArray *fTOFCalOnline;       // array of AliTOFChannels storing calib parameters
-  TObjArray *fTOFCalOnlinePulser; // array of AliTOFChannels storing calib status from pulser
-  TObjArray *fTOFCalOnlineNoise;  // array of AliTOFChannels storing calib status from noise
-  TObjArray *fTOFCalOnlineHW;  // array of AliTOFChannels storing calib status from hardware
+  TObjArray *fTOFCalOnlinePulser; // array of AliTOFChannels storing calib status from pulser   // old, before unification of status info
+  TObjArray *fTOFCalOnlineNoise;  // array of AliTOFChannels storing calib status from noise    // old, before unification of status info
+  TObjArray *fTOFCalOnlineHW;  // array of AliTOFChannels storing calib status from hardware    // old, before unification of status info
   TObjArray *fTOFCalOffline;       // array of AliTOFChannels storing calib parameters
+
+  // new calibration objects
+  AliTOFChannelOnlineArray *fCal; // object with delay array for TOF channels
+  AliTOFChannelOnlineStatusArray *fStatus; // object with status array for TOF channels
+
   TH1F *fTOFSimToT;        // histo with realistic ToT signal from TB Data
   const char *fkValidity;  // validity for offline calibration object
   TTree *fTree;            // tree for TOF calibration
@@ -108,8 +139,9 @@ private:
   Int_t fNruns;            // number of runs to be processed
   Int_t fFirstRun;            // first run for calibration obj validity
   Int_t fLastRun;            // last run for calib obj validity
+  TMap* fConfigMap;          // map holding configuration obj
 
-  ClassDef(AliTOFcalib,6);
+  ClassDef(AliTOFcalib,7);
 };
 
 #endif // AliTOFcalib_H
index 81e5584..daf0585 100644 (file)
@@ -443,7 +443,10 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){
       if (c->GetZ() > z+dz) break;
       if (c->IsUsed()) continue;
 
-      if (!c->GetStatus()) continue; // skip bad channels as declared in OCDB
+      if (!c->GetStatus()) {
+             AliDebug(1,"Cluster in channel declared bad!");
+             continue; // skip bad channels as declared in OCDB
+      }
 
       Double_t dph=TMath::Abs(c->GetPhi()-phi);
       if (dph>TMath::Pi()) dph-=2.*TMath::Pi();
index 7918507..691275d 100644 (file)
@@ -388,7 +388,10 @@ void AliTOFtrackerV1::MatchTracks( ){
       if(nc>kncmax)break;
       if(c->GetZ() > z+dz) break;
       if(c->IsUsed()) continue;      
-      if(!c->GetStatus()) continue; // skip bad channels as declared in OCDB  
+      if(!c->GetStatus()) {
+             AliDebug(1,"Cluster in channel declared bad!");
+             continue; // skip bad channels as declared in OCDB  
+      }
       Float_t xyz[3]; c->GetGlobalXYZ(xyz);
       Double_t clPhi=TMath::ATan2(xyz[1],xyz[0]);
       Double_t dph=TMath::Abs(clPhi-phi);
index 10bece6..8280bbf 100644 (file)
@@ -2,7 +2,7 @@ void CreateCalibPars_Ideal(){
   // Create TOF Calibration Object for Ideal calibration and 
   // write it on CDB
   AliCDBManager *man = AliCDBManager::Instance();
-  man->SetDefaultStorage("local://$ALICE");
+  man->SetDefaultStorage("local://$ALICE_ROOT");
   AliTOFcalib *tofcalib = new AliTOFcalib();
   tofcalib->CreateCalArrays();
   TObjArray *tofCalOffline = (TObjArray*) tofcalib->GetTOFCalArrayOffline(); 
index a12fd22..0d221e0 100644 (file)
@@ -34,7 +34,7 @@ void CreateCalibPars_Miscalibrated(){
   // Fill the Sim calibration object
 
   AliCDBManager *man = AliCDBManager::Instance();
-  man->SetDefaultStorage("local://$ALICE");
+  man->SetDefaultStorage("local://$ALICE_ROOT");
   TRandom *rnd   = new TRandom(4357);
   Int_t nChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
   for (Int_t ipad = 0 ; ipad<nChannels; ipad++){
index 83de82d..a611684 100644 (file)
@@ -34,7 +34,7 @@ void CreateCalibPars_Miscalibrated_Scaled(){
   // Fill the Sim calibration object
 
   AliCDBManager *man = AliCDBManager::Instance();
-  man->SetDefaultStorage("local://$ALICE");
+  man->SetDefaultStorage("local://$ALICE_ROOT");
   TRandom *rnd   = new TRandom(4357);
   Int_t nChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
   for (Int_t ipad = 0 ; ipad<nChannels; ipad++){
diff --git a/TOF/CreateConfigMap.C b/TOF/CreateConfigMap.C
new file mode 100644 (file)
index 0000000..27b1bad
--- /dev/null
@@ -0,0 +1,21 @@
+void CreateConfigMap(const char* delayFlag="kFALSE", const char* startRun="0", const char* binRangeAve="13", const char* integralThr="100", const char* thrPar="0.013"){
+
+       // Create Configuration Map entry for OCDB
+       // to configure AliTOFPreprocessor to compute delays/write online calibration obj on CDB
+       // USAGE: 
+       // - "delayFlag" should be set to kTRUE in case the delays have to be calculated, to 
+       //   kFALSE otherwise.
+       // - "startRun" indicates the starting run for the online calibration object validity
+       //   for delays
+       
+       AliTOFcalib *tofcalib = new AliTOFcalib();
+       TMap *mapTOF = (TMap*)tofcalib->GetConfigMap();
+       mapTOF->Add(new TObjString("ComputingDelays"),new TObjString(delayFlag));
+       mapTOF->Add(new TObjString("StartingRun"),new TObjString(startRun));
+       mapTOF->Add(new TObjString("BinRangeAve"),new TObjString(binRangeAve));
+       mapTOF->Add(new TObjString("IntegralThr"),new TObjString(integralThr));
+       mapTOF->Add(new TObjString("ThrPar"),new TObjString(thrPar));
+       AliCDBManager *man = AliCDBManager::Instance();
+       man->SetDefaultStorage("local://$ALICE_ROOT");
+       tofcalib->WriteConfigMapOnCDB("TOF/Calib");
+}
index 13c9442..afb83ac 100644 (file)
@@ -1,16 +1,22 @@
 void CreateIdealOnlineCalibPars(){
-  // Create TOF Dummy (delay=0, pulser/noise/HW status ok) Offline Calibration Object for reconstruction
+
+  // Create TOF Dummy (delay=0, pulser/noise/HW status ok) Online Calibration Object for reconstruction
   // and write it on CDB
+  // Both old type objects (using TObjArrays) and new type objects (using AliTOFChannelOnlineArray/
+  // AliTOFChannelOnlineStatusArray are written
+
   AliTOFcalib *tofcalib = new AliTOFcalib();
   tofcalib->CreateCalArrays();
   TObjArray *tofCalOnline = (TObjArray*) tofcalib->GetTOFCalArrayOnline(); 
   TObjArray *tofCalOnlinePulser = (TObjArray*) tofcalib->GetTOFCalArrayOnlinePulser(); 
   TObjArray *tofCalOnlineNoise = (TObjArray*) tofcalib->GetTOFCalArrayOnlineNoise(); 
   TObjArray *tofCalOnlineHW = (TObjArray*) tofcalib->GetTOFCalArrayOnlineHW(); 
+  AliTOFChannelOnlineArray *delayArr = (AliTOFChannelOnlineArray*) tofcalib->GetTOFOnlineDelay();
+  AliTOFChannelOnlineStatusArray *status = (AliTOFChannelOnlineStatusArray*) tofcalib->GetTOFOnlineStatus();
   // Write the dummy offline calibration object on CDB
 
   AliCDBManager *man = AliCDBManager::Instance();
-  man->SetDefaultStorage("local://$ALICE");
+  man->SetDefaultStorage("local://$ALICE_ROOT");
   Int_t nChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
   for (Int_t ipad = 0 ; ipad<nChannels; ipad++){
     AliTOFChannelOnline *calChannelOnline = (AliTOFChannelOnline*)tofCalOnline->At(ipad);
@@ -18,14 +24,20 @@ void CreateIdealOnlineCalibPars(){
     AliTOFChannelOnlineStatus *calChannelOnlineNoise = (AliTOFChannelOnlineStatus*)tofCalOnlineNoise->At(ipad);
     AliTOFChannelOnlineStatus *calChannelOnlineHW = (AliTOFChannelOnlineStatus*)tofCalOnlineHW->At(ipad);
     Float_t delay = 0.;
+    delayArr->SetDelay(ipad,delay);
     calChannelOnline->SetDelay(delay); 
     calChannelOnlinePulser->SetStatus(AliTOFChannelOnlineStatus::kTOFPulserOk);
     calChannelOnlineNoise->SetStatus(AliTOFChannelOnlineStatus::kTOFNoiseOk);
     calChannelOnlineHW->SetStatus(AliTOFChannelOnlineStatus::kTOFHWOk);
+    status->SetHWStatus(ipad,AliTOFChannelOnlineStatusArray::kTOFHWOk);
+    status->SetPulserStatus(ipad,AliTOFChannelOnlineStatusArray::kTOFPulserOk);
+    status->SetNoiseStatus(ipad,AliTOFChannelOnlineStatusArray::kTOFNoiseOk);
  } 
-  tofcalib->WriteParOnlineOnCDB("TOF/Calib");
-  tofcalib->WriteParOnlinePulserOnCDB("TOF/Calib");
-  tofcalib->WriteParOnlineNoiseOnCDB("TOF/Calib");
-  tofcalib->WriteParOnlineHWOnCDB("TOF/Calib");
+  tofcalib->WriteParOnlineDelayOnCDB("TOF/Calib");  // new obj
+  tofcalib->WriteParOnlineStatusOnCDB("TOF/Calib"); // new obj
+  tofcalib->WriteParOnlineOnCDB("TOF/Calib");       // old obj
+  tofcalib->WriteParOnlinePulserOnCDB("TOF/Calib"); // old obj
+  tofcalib->WriteParOnlineNoiseOnCDB("TOF/Calib");  // old obj
+  tofcalib->WriteParOnlineHWOnCDB("TOF/Calib");     // old obj
  return;
 }
index 2f56d45..5ca746f 100644 (file)
@@ -1,17 +1,23 @@
 void CreateOnlineCalibPars(){
+
   // Create TOF Online Calibration Object for reconstruction
   // and write it on CDB;
   // NB: only delay set, status still ok
+  // Both old type objects (using TObjArrays) and new type objects (using AliTOFChannelOnlineArray/
+  // AliTOFChannelOnlineStatusArray are written
+
   AliTOFcalib *tofcalib = new AliTOFcalib();
   tofcalib->CreateCalArrays();
   TObjArray *tofCalOnline = (TObjArray*) tofcalib->GetTOFCalArrayOnline(); 
   TObjArray *tofCalOnlinePulser = (TObjArray*) tofcalib->GetTOFCalArrayOnlinePulser(); 
   TObjArray *tofCalOnlineNoise = (TObjArray*) tofcalib->GetTOFCalArrayOnlineNoise(); 
   TObjArray *tofCalOnlineHW = (TObjArray*) tofcalib->GetTOFCalArrayOnlineHW(); 
-  // Write the offline calibration object on CDB
+  AliTOFChannelOnlineArray *delayObj = (AliTOFChannelOnlineArray*) tofcalib->GetTOFOnlineDelay();
+  AliTOFChannelOnlineStatusArray *status = (AliTOFChannelOnlineStatusArray*) tofcalib->GetTOFOnlineStatus();
+  // Write the online calibration object on CDB
 
   AliCDBManager *man = AliCDBManager::Instance();
-  man->SetDefaultStorage("local://$ALICE");
+  man->SetDefaultStorage("local://$ALICE_ROOT");
   Int_t nChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
   Float_t delay=0.;
   Float_t meanDelay=0.3;
@@ -23,14 +29,20 @@ void CreateOnlineCalibPars(){
     AliTOFChannelOnlineStatus *calChannelOnlineNoise = (AliTOFChannelOnlineStatus*)tofCalOnlineNoise->At(ipad);
     AliTOFChannelOnlineStatus *calChannelOnlineHW = (AliTOFChannelOnlineStatus*)tofCalOnlineHW->At(ipad);
     delay = rnd->Gaus(meanDelay,sigmaDelay);
+    delayObj->SetDelay(ipad,delay);
     calChannelOnline->SetDelay(delay);
     calChannelOnlinePulser->SetStatus(AliTOFChannelOnlineStatus::kTOFPulserOk);
     calChannelOnlineNoise->SetStatus(AliTOFChannelOnlineStatus::kTOFNoiseOk);
     calChannelOnlineHW->SetStatus(AliTOFChannelOnlineStatus::kTOFHWOk);
+    status->SetHWStatus(ipad,AliTOFChannelOnlineStatusArray::kTOFHWOk);
+    status->SetPulserStatus(ipad,AliTOFChannelOnlineStatusArray::kTOFPulserOk);
+    status->SetNoiseStatus(ipad,AliTOFChannelOnlineStatusArray::kTOFNoiseOk);
   }
-  tofcalib->WriteParOnlineOnCDB("TOF/Calib");
-  tofcalib->WriteParOnlinePulserOnCDB("TOF/Calib");
-  tofcalib->WriteParOnlineNoiseOnCDB("TOF/Calib");
-  tofcalib->WriteParOnlineHWOnCDB("TOF/Calib");
+  tofcalib->WriteParOnlineDelayOnCDB("TOF/Calib");   // new obj
+  tofcalib->WriteParOnlineStatusOnCDB("TOF/Calib");  // new obj
+  tofcalib->WriteParOnlineOnCDB("TOF/Calib");        // old object
+  tofcalib->WriteParOnlinePulserOnCDB("TOF/Calib");  // old obj
+  tofcalib->WriteParOnlineNoiseOnCDB("TOF/Calib");   // old obj
+  tofcalib->WriteParOnlineHWOnCDB("TOF/Calib");      // old obj
   return;
 }
index c28a47f..90230a9 100755 (executable)
@@ -2,7 +2,7 @@ void CreateRecPars_CDB(){
   // Create TOF Calibration Object for Ideal calibration and 
   // write it on CDB
   AliCDBManager *man = AliCDBManager::Instance();
-  man->SetDefaultStorage("local://$ALICE");
+  man->SetDefaultStorage("local://$ALICE_ROOT");
   AliTOFcalib *tofcalib = new AliTOFcalib();
   AliTOFRecoParam *param = new AliTOFRecoParam();
   tofcalib->WriteRecParOnCDB("TOF/Calib",0,999999999,param);
index 13714a1..b8f4bf4 100644 (file)
@@ -1,11 +1,11 @@
-    README file for ALICE Time Of Flight Detector Oflfine Code
+    README file for ALICE Time Of Flight Detector Offline Code
     ==========================================================
 
 Intorduction
 ------------
 
 This is a short overview of the TOF code within the AliROOT framework.
-
+Some additional details have been introduced to 
 
 Structure
 ---------
@@ -163,6 +163,185 @@ Till today (February 6th 2008), it contains the following classes
   AliTOFQADataMakerRec:
 
 
+TOF Calibration:
+----------------
+
+1. Online Calibration
+
+1.1. New Calibration Schema
+
+1.1.1. Configuration
+
+The online calibration which is performed by the TOF preprocessor is 
+configured according to a CDB object (stored in /TOF/Calib/Config), where
+a flag for the computation of the delays is set according to the type
+of data taking (cosmics ---> kFALSE / beam ---> kTRUE), and where the
+starting validity of the calibration objects that will be written in the
+OCDB is defined (see sec. 1.1.3.). The data are stored in the CDB object 
+as entries in a TMap, with IDs "ComputingDelays" and "StartingRun"
+respectively.
+
+1.1.2. Objects
+
+- AliTOFChannelOnlineArray: array of floats containing the delay value
+  calculated for each TOF channel by the TOF preprocessor starting from
+  the DAQ DA for PHYSICS runs (see TOFda.cxx). Inheriting from TObject.
+
+- AliTOFChannelOnlineStatusArray: array of chars defining the status for each 
+  TOF channel according to the processing of the data coming from PULSER and
+  NOISE runs (TOFpulserda.cxx, TOFnoiseda.cxx). The status is defined also
+  according to the FEE map written in the DCS FXS, where the status ON/OFF 
+  of the channels is stored. The first (least significant) two bits refer to the
+  FEE status, the second two to the pulser data, and the third two to the noise
+  data, leaving the last two empy. The status is always (FEE/pulser/noise) 
+  defined as:
+  00 --> Unknown;
+  01 --> Good;
+  10 --> Bad.
+  Inheriting from TObject.
+
+1.1.3. OCDB
+
+- /TOF/Calib/ParOnlineDelay: directory where the AliTOFChannelOnlineArray
+  calibration objects are stored, with validity [0, 999999999], increasing the
+  sv number every time. After offline calibration takes place, in case a reset 
+  is needed at run XYZ, the validity changes to [XYZ, 999999999], again 
+  with increasing sv. 
+
+- /TOF/Calib/Status: directory where the AliTOFChannelOnlineStatusArray
+  calibration objects are stored, with validity [current_run, 999999999]. In 
+  case of a PHYSICS run, the update occurs only if the FEE map has changed. 
+  In case of a PULSER/NOISE run, the update occurs once at the very end of the
+  processing, so to merge the information from the FEE status map and those
+  from the TOFpulserda/TOFnoiseda.
+
+1.1.4. Reference Data
+
+- /TOF/Calib/DAQData: directory to store the histograms at run level that 
+  are produced by the TOFda. 
+
+- /TOF/Calib/DCSData: directory to store the data that come out from the 
+  processing of the TOF DCS DPs.
+
+- /TOF/Calib/PulserData: directory to store the histograms that are produced 
+  by the TOFpulserda. 
+
+- /TOF/Calib/NoiseData: directory to store the histograms that are produced 
+  by the TOFnoiseda. 
+
+- /TOF/Calib/FEEData: directory to store the histogram reproducing the FEE
+  status of the TOF channels. 
+
+1.1.5. Usage in Reconstruction 
+
+During reconstruction, both the AliTOFChannelOnlineArray and the 
+AliTOFChannelOnlineStatusArray corresponding to the current run have to be
+loaded from OCDB in the AliTOFReconstructor class instance. From there, 
+they are passed to the AliTOFClusterFinder, where the status of the channel is 
+used in order to decide whether to use it or not, while the delay is used to 
+calibrate when the offline calibration information is not yet available. 
+
+1.2. Old Calibration Schema
+
+1.2.1. Configuration
+
+No OCDB configuration entry is foreseen.
+
+1.2.2. Objects
+
+- AliTOFChannelOnline: object containing the value of the delay for a 
+  certain TOF channel. Inheriting from TObject. An TObjArray of 157248 of such 
+  objects is used to store the information coming from the TOF online 
+  calibration. Inheriting from TObject.
+
+- AliTOFChannelOnlineStatus: object containing the status of a TOF channel
+  as determined during the reading of the FEE map/ during a pulser run/
+  during a noise run. Three TObjArray objects of 157248 of such objects should 
+  be present in the OCDB for each run: one related to the FEE status of the
+  channels, one related to pulser run results, and one related to noise 
+  run results. The status is defined as:
+  00 --> Unknown;
+  01 --> Good;
+  10 --> Bad.
+  Inheriting from TObject.
+    
+1.2.3. OCDB
+
+- /TOF/Calib/ParOnline: directory where a TObjArray of 157248 AliTOFChannelOnline
+  calibration objects are stored, with validity [0, 999999999], increasing the
+  sv number every time. After offline calibration takes place, in case a reset 
+  is needed at run XYZ, the validity changes to [XYZ, 999999999], again 
+  with increasing sv. 
+
+- /TOF/Calib/HW: directory where a TObjArray of 157248 AliTOFChannelOnlineStatus
+  calibration objects are stored, with validity [current_run, 999999999], as 
+  obtained from reading the FEE map from the DCS FXS. The update occurs only if 
+  the FEE map has changed. 
+
+- /TOF/Calib/Pulser: directory where a TObjArray of 157248 AliTOFChannelOnlineStatus
+  calibration objects are stored, with validity [current_run, 999999999], as 
+  obtained from a pulser run.  
+
+- /TOF/Calib/Noise: directory where a TObjArray of 157248 AliTOFChannelOnlineStatus
+  calibration objects are stored, with validity [current_run, 999999999], as 
+  obtained from a noise run.  
+
+1.2.4. Reference Data
+
+- /TOF/Calib/DAQData: directory to store the histograms at run level that 
+  are produced by the TOFda. 
+
+- /TOF/Calib/DCSData: directory to store the data that come out from the 
+  processing of the TOF DCS DPs.
+
+- /TOF/Calib/PulserData: directory to store the histograms that are produced 
+  by the TOFpulserda. 
+
+- /TOF/Calib/NoiseData: directory to store the histograms that are produced 
+  by the TOFnoiseda. 
+
+- /TOF/Calib/FEEData: directory to store the histogram reproducing the FEE
+  status of the TOF channels. 
+
+1.2.5. Usage in Reconstruction 
+
+During reconstruction, the TObjArray of AliTOFChannelOnline and the three
+TObjArray objects of AliTOFChannelOnlineStatus coming from the FEE map, the 
+pulser run data, and the noise run data corresponding to the current run have to 
+be loaded from OCDB in the AliTOFReconstructor class instance. From there, 
+they are passed to the AliTOFClusterFinder, where the status of the channel is 
+used in order to decide whether to use it or not, while the delay is used to 
+calibrate when the offline calibration information is not yet available. 
+
+2. TOF Offline Calibration
+
+2.1. Object
+
+- AliTOFChannelOffline: object containing the calibration parameters for 
+  each TOF channel that should correct both for the delay introduced by the
+  electronics and the hardware, and for the time slewing effect. A TObjArray 
+  of 157248 of such objects is stored in the CDB to perform refined calibration 
+  during reconstruction. Inheriting from TObject.
+
+2.2. OCDB
+
+- /TOF/Calib/ParOffline: directory containing the CDB entry corresponding to the
+  offline calibration of the TOF as stored in a TObjArray object of 157248
+  AliTOFChannelOffline objects with validity [0, 999999999], increasing the
+  sv number every time. In case a reset is needed at run XYZ, after collecting 
+  the statistics necessary to the offline calibration (when the online 
+  calibration object becomes valid again), the validity changes to 
+  [XYZ, 999999999], again with increasing sv. 
+
+2.3 Usage in Reconstruction
+
+The TObjArray of 157248 AliTOFChannelOffline objects is retrieved for the current
+run in AliTOFReconstructor, and passed to AliTOFClusterFinder. As soon as enough 
+statistics is collected for every channel, since the validity 
+of the offline calibration object was set, for each channel with a valid
+status, the calibration is performed using the calibration parameters present in 
+this TObjArray of AliTOFChannelOffline.
+
 Authors:
 --------
 
index da2406c..5ca4e1e 100644 (file)
@@ -15,13 +15,14 @@ void TOFPreprocessor(Char_t * RunType="PHYSICS")
 {
   gSystem->Load("$ALICE_ROOT/SHUTTLE/TestShuttle/libTestShuttle.so");
 
-  AliLog::SetClassDebugLevel("AliTOFPreprocessor",1);
+  AliLog::SetClassDebugLevel("AliTOFPreprocessor",2);
   // initialize location of CDB
   AliTestShuttle::SetMainCDB("local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB");
   AliTestShuttle::SetMainRefStorage("local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestReference");
 
   // create AliTestShuttle instance
-  AliTestShuttle* shuttle = new AliTestShuttle(0, 0, 1000);
+  Int_t nrun = 6;
+  AliTestShuttle* shuttle = new AliTestShuttle(nrun, 0, 1000);
   //setting run type to physiscs
   shuttle->SetInputRunType(RunType);
 
@@ -34,7 +35,7 @@ void TOFPreprocessor(Char_t * RunType="PHYSICS")
   // processing files. for the time being, the files are local.
   shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "DELAYS", "MON", "$ALICE_ROOT/TOF/ShuttleInput/Total.root");
   shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "RUNLevel", "MON", "$ALICE_ROOT/TOF/ShuttleInput/Partial.root");
-  shuttle->AddInputFile(AliTestShuttle::kDCS, "TOF", "TofFeeMap", "", "$ALICE_ROOT/TOF/ShuttleInput/TOFFEE.20080310.164003.4001");
+  shuttle->AddInputFile(AliTestShuttle::kDCS, "TOF", "TofFeeMap", "", "$ALICE_ROOT/TOF/ShuttleInput/TOFFEE.20080310.163032.4000");
   char filename[100];
   char LDCname[5];
 
@@ -57,7 +58,7 @@ void TOFPreprocessor(Char_t * RunType="PHYSICS")
   gBenchmark->Print("process");
 
   // checking the file which should have been created  
-  AliCDBEntry* chkEntry = AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB())->Get("TOF/Calib/ParOnline", 0);
+  AliCDBEntry* chkEntry = AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB())->Get("TOF/Calib/ParOnlineDelay", nrun);
   if (!chkEntry)
   {
     printf("The file is not there. Something went wrong.\n");
index da89018..4bbc3eb 100644 (file)
@@ -19,6 +19,8 @@
 #pragma link C++ class  AliTOFChannelOffline+;
 #pragma link C++ class  AliTOFChannelOnline+;
 #pragma link C++ class  AliTOFChannelOnlineStatus+;
+#pragma link C++ class  AliTOFChannelOnlineArray+;
+#pragma link C++ class  AliTOFChannelOnlineStatusArray+;
 #pragma link C++ class  AliTOFcalib+;
 #pragma link C++ class  AliTOFAlignment+;
 #pragma link C++ class  AliTOFPreprocessor+;
index d57929a..7303b42 100644 (file)
@@ -12,6 +12,8 @@ SRCS  = AliTOFGeometry.cxx  \
        AliTOFChannelOffline.cxx  \
        AliTOFChannelOnline.cxx  \
        AliTOFChannelOnlineStatus.cxx  \
+       AliTOFChannelOnlineArray.cxx  \
+       AliTOFChannelOnlineStatusArray.cxx  \
        AliTOFcalib.cxx \
        AliTOFAlignment.cxx \
        AliTOFPreprocessor.cxx \