ITSSPDPHYSda: New detector algorithm for finding dead and noisy pixels.
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Nov 2007 16:31:40 +0000 (16:31 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Nov 2007 16:31:40 +0000 (16:31 +0000)
ITSSPDSCANda: The old algorithm (ITSSPDda) updated and with new name.
AliITSCalibrationSPD: Split OCDB entries into SPDDead and SPDNoisy.
Both will use this class.
AliITSOnlineCalibrationSPD: Use online coordinates instead of offline.
AliITSOnlineCalibrationSPDhandler: Reorganization of noisy and dead pixel data.
AliITSPreprocessorSPD: Added code for the new online algorithms.
AliITSRawStreamSPD: Fixed SPD geometry required changes in the online to
offline coordinate conversions. Added static functions to make the conversions
easier and kept in one place only.
(H. Tydesjo)

34 files changed:
ITS/AliITSCalibrationSPD.cxx
ITS/AliITSCalibrationSPD.h
ITS/AliITSDetTypeRec.cxx
ITS/AliITSDetTypeSim.cxx
ITS/AliITSIntMap.cxx
ITS/AliITSIntMap.h
ITS/AliITSOnlineCalibrationSPD.cxx
ITS/AliITSOnlineCalibrationSPD.h
ITS/AliITSOnlineCalibrationSPDhandler.cxx
ITS/AliITSOnlineCalibrationSPDhandler.h
ITS/AliITSOnlineSPDHitArray.h
ITS/AliITSOnlineSPDphys.cxx [new file with mode: 0644]
ITS/AliITSOnlineSPDphys.h [new file with mode: 0644]
ITS/AliITSOnlineSPDphysAnalyzer.cxx [new file with mode: 0644]
ITS/AliITSOnlineSPDphysAnalyzer.h [new file with mode: 0644]
ITS/AliITSOnlineSPDphysInfo.cxx [new file with mode: 0644]
ITS/AliITSOnlineSPDphysInfo.h [new file with mode: 0644]
ITS/AliITSOnlineSPDscan.h
ITS/AliITSOnlineSPDscanAnalyzer.cxx
ITS/AliITSOnlineSPDscanAnalyzer.h
ITS/AliITSPreprocessorSPD.cxx
ITS/AliITSRawStreamSPD.cxx
ITS/AliITSRawStreamSPD.h
ITS/AliITSRawStreamSPD_NEWGEO.cxx [new file with mode: 0644]
ITS/AliITSsimulationSPD.cxx
ITS/AliITSv11GeometrySSD.cxx
ITS/Calib/CalibSPD/Run0_9999999_v0_s0.root [deleted file]
ITS/Calib/CalibSPD/Run0_9999999_v0_s0.root.pdc06standardDead [deleted file]
ITS/Calib/SPDDead/Run0_9999999_v0_s0.root [new file with mode: 0644]
ITS/Calib/SPDNoisy/Run0_9999999_v0_s0.root [new file with mode: 0644]
ITS/ITSSPDPHYSda.cxx [new file with mode: 0644]
ITS/ITSSPDSCANda.cxx [moved from ITS/ITSSPDda.cxx with 77% similarity]
ITS/ITSrecLinkDef.h
ITS/libITSrec.pkg

index 0fbe1a2..9d4d869 100644 (file)
@@ -21,7 +21,7 @@
 //
 //  Modified by D. Elia, G.E. Bruno, H. Tydesjo
 //  March-April 2006
-//  Last mod:  H. Tydesjo  January 2007
+//  Last mod:  H. Tydesjo  Oct 2007
 //  September   2007: CouplingRowDefault = 0.055 (was 0.047)
 //
 ///////////////////////////////////////////////////////////////////////////
@@ -43,10 +43,8 @@ fSigma(fgkSigmaDefault),
 fCouplCol(fgkCouplColDefault),
 fCouplRow(fgkCouplRowDefault),
 fBiasVoltage(fgkBiasVoltageDefault),
-fNrDead(0),
-fDeadChannels(0),
-fNrNoisy(0),
-fNoisyChannels(0){
+fNrBad(0),
+fBadChannels(0){
   // constructor
 
    SetThresholds(fgkThreshDefault,fgkSigmaDefault);
@@ -55,86 +53,43 @@ fNoisyChannels(0){
    SetNoiseParam(0.,0.);
    SetDataType("simulated");
 }
-//_________________________________________________________________________
-
-void AliITSCalibrationSPD::AddDead(UInt_t col, UInt_t row) {
-  //
-  // Add a dead channel to fDeadChannel array
-  //
-  fDeadChannels.Set(fNrDead*2+2);
-  fDeadChannels.AddAt(col,fNrDead*2);
-  fDeadChannels.AddAt(row,fNrDead*2+1);
-  fNrDead++;
-}
-//_________________________________________________________________________
-Int_t AliITSCalibrationSPD::GetDeadColAt(UInt_t index) {
-  // 
-  // Returns column of index-th dead channel
-  //
-  if (index<fNrDead) {
-    return fDeadChannels.At(index*2);
-  }
-  return -1;
-}
-//_________________________________________________________________________
-Int_t AliITSCalibrationSPD::GetDeadRowAt(UInt_t index) {
-  // 
-  // Returns row of index-th dead channel
-  //
-  if (index<fNrDead) {
-    return fDeadChannels.At(index*2+1);
-  }
-  return -1;
-}
-//_________________________________________________________________________
-Bool_t AliITSCalibrationSPD::IsPixelDead(Int_t col, Int_t row) const {
-  //
-  // Check if pixel (col,row) is dead
-  //
-  for (UInt_t i=0; i<fNrDead; i++) { 
-    if (fDeadChannels.At(i*2)==col && fDeadChannels.At(i*2+1)==row) {
-      return true;
-    }
-  }
-  return false;
-}
 //____________________________________________________________________________
-void AliITSCalibrationSPD::AddNoisy(UInt_t col, UInt_t row) {
+void AliITSCalibrationSPD::AddBad(UInt_t col, UInt_t row) {
   //
-  // add noisy pixel 
+  // add bad pixel 
   //
-  fDeadChannels.Set(fNrNoisy*2+2);
-  fNoisyChannels.AddAt(col,fNrNoisy*2);
-  fNoisyChannels.AddAt(row,fNrNoisy*2+1);
-  fNrNoisy++;
+  fBadChannels.Set(fNrBad*2+2);
+  fBadChannels.AddAt(col,fNrBad*2);
+  fBadChannels.AddAt(row,fNrBad*2+1);
+  fNrBad++;
 }
 //____________________________________________________________________________
-Int_t AliITSCalibrationSPD::GetNoisyColAt(UInt_t index) {
+Int_t AliITSCalibrationSPD::GetBadColAt(UInt_t index) {
   //
-  // Get column of index-th noisy pixel
+  // Get column of index-th bad pixel
   //
-  if (index<fNrNoisy) {
-    return fNoisyChannels.At(index*2);
+  if (index<fNrBad) {
+    return fBadChannels.At(index*2);
   }
   return -1;
 }
 //____________________________________________________________________________
-Int_t AliITSCalibrationSPD::GetNoisyRowAt(UInt_t index) {
+Int_t AliITSCalibrationSPD::GetBadRowAt(UInt_t index) {
   //
-  // Get row of index-th noisy pixel
+  // Get row of index-th bad pixel
   //
-  if (index<fNrNoisy) {
-    return fNoisyChannels.At(index*2+1);
+  if (index<fNrBad) {
+    return fBadChannels.At(index*2+1);
   }
   return -1;
 }
 //____________________________________________________________________________
-Bool_t AliITSCalibrationSPD::IsPixelNoisy(Int_t col, Int_t row) const {
+Bool_t AliITSCalibrationSPD::IsPixelBad(Int_t col, Int_t row) const {
   //
-  // Check if pixel (col,row) is noisy
+  // Check if pixel (col,row) is bad
   //
-  for (UInt_t i=0; i<fNrNoisy; i++) { 
-    if (fNoisyChannels.At(i*2)==col && fNoisyChannels.At(i*2+1)==row) {
+  for (UInt_t i=0; i<fNrBad; i++) { 
+    if (fBadChannels.At(i*2)==col && fBadChannels.At(i*2+1)==row) {
       return true;
     }
   }
index dc37da4..384e82f 100644 (file)
@@ -72,24 +72,15 @@ class AliITSCalibrationSPD :  public AliITSCalibration {
     virtual void SetSigmaDiffusionAsymmetry(Double_t ecc) {((AliITSresponseSPD*)fResponse)->SetSigmaDiffusionAsymmetry(ecc);}
     virtual void GetSigmaDiffusionAsymmetry(Double_t &ecc) const {((AliITSresponseSPD*)fResponse)->GetSigmaDiffusionAsymmetry(ecc);}
     
-    void   AddDead(UInt_t col, UInt_t row);
-    Int_t  GetNrDead() const {return fNrDead;}
-    Int_t  GetDeadColAt(UInt_t index); //returns -1 if out of bounds
-    Int_t  GetDeadRowAt(UInt_t index); //returns -1 if out of bounds
-    void   ClearDead() {fDeadChannels.Reset(); fNrDead=0;}
-    Bool_t IsPixelDead(Int_t col, Int_t row) const ;
+    void   AddBad(UInt_t col, UInt_t row);
+    Int_t  GetNrBad() const {return fNrBad;}
+    Int_t  GetBadColAt(UInt_t index); //returns -1 if out of bounds
+    Int_t  GetBadRowAt(UInt_t index); //returns -1 if out of bounds
+    void   ClearBad() {fBadChannels.Reset(); fNrBad=0;}
+    Bool_t IsPixelBad(Int_t col, Int_t row) const ;
 
-    void   AddNoisy(UInt_t col, UInt_t row);
-    Int_t  GetNrNoisy() const {return fNrNoisy;}
-    Int_t  GetNoisyColAt(UInt_t index); //returns -1 if out of bounds
-    Int_t  GetNoisyRowAt(UInt_t index); //returns -1 if out of bounds
-    void   ClearNoisy() {fNoisyChannels.Reset(); fNrNoisy=0;}
-    Bool_t IsPixelNoisy(Int_t col, Int_t row) const ;
-
-    void   SetDeadList(TArrayI deadlist) {fDeadChannels=deadlist;}
-    void   SetNoisyList(TArrayI noisylist) {fNoisyChannels=noisylist;}
-    void   SetNrDead(UInt_t nr) {fNrDead=nr;}
-    void   SetNrNoisy(UInt_t nr) {fNrNoisy=nr;}
+    void   SetBadList(TArrayI badlist) {fBadChannels=badlist;}
+    void   SetNrBad(UInt_t nr) {fNrBad=nr;}
 
  protected:
     // static const Double_t fgkDiffCoeffDefault; //default for fDiffCoeff
@@ -105,12 +96,10 @@ class AliITSCalibrationSPD :  public AliITSCalibration {
     Double_t fCouplCol;        // Coupling parameter along the cols
     Double_t fCouplRow;        // Coupling parameter along the rows
     Double_t fBiasVoltage;     // Bias Voltage for the SPD (used to compute DistanceOverVoltage)
-    UInt_t   fNrDead;           // Nr of dead pixels
-    TArrayI fDeadChannels;     // Array with dead channels info (col0,row0,col1...rowN) N = fNrDead
-    UInt_t   fNrNoisy;          // Nr of noisy pixels
-    TArrayI fNoisyChannels;    // Array with noisy channels info (col0,row0,col1...rowN) N = fNrNoisy
+    UInt_t   fNrBad;           // Nr of bad pixels
+    TArrayI  fBadChannels;     // Array with bad channels info (col0,row0,col1...rowN) N = fNrBad
 
-    ClassDef(AliITSCalibrationSPD,4) // SPD response
+    ClassDef(AliITSCalibrationSPD,5) // SPD response
 };
 
 #endif
index 72f8658..4494f8d 100644 (file)
@@ -387,7 +387,7 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
     fCalibration->Clear();
   }
 
-  AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD");
+  AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead");
   AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
  
  //  AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD");
index e506be4..54be5e6 100644 (file)
@@ -448,7 +448,7 @@ Bool_t AliITSDetTypeSim::GetCalibration() {
 
   AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
 
-  AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", run);
+  AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead", run);
   AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run);
   AliCDBEntry *mapASDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsAnodeSDD",run);
   AliCDBEntry *mapTSDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsTimeSDD",run);
@@ -835,7 +835,7 @@ void AliITSDetTypeSim::StoreCalibration(Int_t firstRun, Int_t lastRun,
     AliError("AliITSCalibration classes are not defined - nothing done");
     return;
   }
-  AliCDBId idRespSPD("ITS/Calib/CalibSPD",firstRun, lastRun);
+  AliCDBId idRespSPD("ITS/Calib/SPDDead",firstRun, lastRun);
   AliCDBId idRespSDD("ITS/Calib/CalibSDD",firstRun, lastRun);
   AliCDBId idRespSSD("ITS/Calib/CalibSSD",firstRun, lastRun);
 
index b65aaf9..e786e87 100644 (file)
@@ -249,6 +249,7 @@ void AliITSIntMap::ClearFastAccess(){
 
 void AliITSIntMap::InitFastAccess(){
   // initializes the fast access array
+  if (fFastAccess) return;
   ClearFastAccess();
   if (fNrEntries>0) {
     fFastAccessArray = new AliITSIntMapNode*[fNrEntries];
@@ -268,6 +269,7 @@ void AliITSIntMap::InitFastAccessNode(AliITSIntMapNode* node) {
 
 void AliITSIntMap::InitFastAccessSerialize(){
   // initializes the fast access array
+  if (fFastAccessSerialize) return;
   ClearFastAccess();
   if (fNrEntries>0) {
     fFastAccessArray = new AliITSIntMapNode*[fNrEntries];
index 9a8f9f8..1531e75 100644 (file)
@@ -35,12 +35,13 @@ class AliITSIntMap {
   void               PrintEntries() const;
   void               Balance();
   void               PrepareSerialize() {InitFastAccessSerialize();}
+  void               PrepareSerializeOrdered() {InitFastAccess();}
   UInt_t             GetTreeHeight() const;
 
  private:
   UInt_t             fNrEntries;          // nr of entries in map
   AliITSIntMapNode*  fRoot;               // link to first node of tree
-  Bool_t             fFastAccess;         // is the array below initialized (key ordered)?
+  Bool_t             fFastAccess;         // is fast access array initialized (key ordered)?
   Bool_t             fFastAccessSerialize;// is fast access array initialized (tree ordered)?
   AliITSIntMapNode** fFastAccessArray;    // array of pointers to nodes
   UInt_t             fDummyIndex;         // dummy index used when traversing tree
index 198bc4e..4981f1b 100644 (file)
@@ -9,93 +9,15 @@
 ClassImp(AliITSOnlineCalibrationSPD)   
 
 AliITSOnlineCalibrationSPD::AliITSOnlineCalibrationSPD():
-fModuleNr(0),
-fNrDead(0),
-fDeadChannels(0),
-fNrNoisy(0),
-fNoisyChannels(0)
+fEqNr(0),
+fNrBad(0),
+fBadChannels(0)
 {}
-//_________________________________________________________________________
-void AliITSOnlineCalibrationSPD::AddDead(UInt_t col, UInt_t row) {
-  //
-  // Add a dead channel to fDeadChannel array
-  //
-  fDeadChannels.Set(fNrDead*2+2);
-  fDeadChannels.AddAt(col,fNrDead*2);
-  fDeadChannels.AddAt(row,fNrDead*2+1);
-  fNrDead++;
-}
-//_________________________________________________________________________
-Int_t AliITSOnlineCalibrationSPD::GetDeadColAt(UInt_t index) const {
-  // 
-  // Returns column of index-th dead channel
-  //
-  if (index<fNrDead) {
-    return fDeadChannels.At(index*2);
-  }
-  return -1;
-}
-//_________________________________________________________________________
-Int_t AliITSOnlineCalibrationSPD::GetDeadRowAt(UInt_t index) const {
-  // 
-  // Returns row of index-th dead channel
-  //
-  if (index<fNrDead) {
-    return fDeadChannels.At(index*2+1);
-  }
-  return -1;
-}
-//_________________________________________________________________________
-Bool_t AliITSOnlineCalibrationSPD::IsPixelDead(Int_t col, Int_t row) const {
-  //
-  // Check if pixel (col,row) is dead
-  //
-  for (UInt_t i=0; i<fNrDead; i++) { 
-    if (fDeadChannels.At(i*2)==col && fDeadChannels.At(i*2+1)==row) {
-      return kTRUE;
-    }
-  }
-  return kFALSE;
-}
 //____________________________________________________________________________
-void AliITSOnlineCalibrationSPD::AddNoisy(UInt_t col, UInt_t row) {
-  //
-  // add noisy pixel 
-  //
-  fDeadChannels.Set(fNrNoisy*2+2);
-  fNoisyChannels.AddAt(col,fNrNoisy*2);
-  fNoisyChannels.AddAt(row,fNrNoisy*2+1);
-  fNrNoisy++;
-}
-//____________________________________________________________________________
-Int_t AliITSOnlineCalibrationSPD::GetNoisyColAt(UInt_t index) const {
-  //
-  // Get column of index-th noisy pixel
-  //
-  if (index<fNrNoisy) {
-    return fNoisyChannels.At(index*2);
+Int_t AliITSOnlineCalibrationSPD::GetKeyAt(UInt_t index) const {
+  // Get key of index-th bad pixel
+  if (index<fNrBad) {
+    return fBadChannels.At(index);
   }
   return -1;
 }
-//____________________________________________________________________________
-Int_t AliITSOnlineCalibrationSPD::GetNoisyRowAt(UInt_t index) const {
-  //
-  // Get row of index-th noisy pixel
-  //
-  if (index<fNrNoisy) {
-    return fNoisyChannels.At(index*2+1);
-  }
-  return -1;
-}
-//____________________________________________________________________________
-Bool_t AliITSOnlineCalibrationSPD::IsPixelNoisy(Int_t col, Int_t row) const {
-  //
-  // Check if pixel (col,row) is noisy
-  //
-  for (UInt_t i=0; i<fNrNoisy; i++) { 
-    if (fNoisyChannels.At(i*2)==col && fNoisyChannels.At(i*2+1)==row) {
-      return kTRUE;
-    }
-  }
-  return kFALSE;
-}
index db0f805..43c831e 100644 (file)
@@ -4,7 +4,7 @@
 ///////////////////////////////////////////////////////////////////////
 // Author: Henrik Tydesjo                                            //
 // This class is used as a container to keep the dead and noisy      //
-// pixels online. Each object corresponds to one module.             //
+// pixels online. Each object corresponds to one DDL (eq).           //
 // Note: This class should not be used directly.                     //
 // Use it via AliITSOnlineCalibrationSPDhandler instead.             //
 ///////////////////////////////////////////////////////////////////////
@@ -18,32 +18,20 @@ class AliITSOnlineCalibrationSPD : public TObject {
     AliITSOnlineCalibrationSPD();
     virtual ~AliITSOnlineCalibrationSPD() {}
 
-    void   SetModuleNr(UInt_t mod) {fModuleNr=mod;}
-    UInt_t GetModuleNr() const {return fModuleNr;}
-    void   SetDeadList(TArrayI deadlist) {fDeadChannels=deadlist;}
-    void   SetNoisyList(TArrayI noisylist) {fNoisyChannels=noisylist;}
-    void   SetNrDead(UInt_t nr) {fNrDead=nr;}
-    void   SetNrNoisy(UInt_t nr) {fNrNoisy=nr;}
-
-    void   AddDead(UInt_t col, UInt_t row);
-    Int_t  GetNrDead() const {return fNrDead;}
-    Int_t  GetDeadColAt(UInt_t index) const; //returns -1 if out of bounds
-    Int_t  GetDeadRowAt(UInt_t index) const; //returns -1 if out of bounds
-    void   ClearDead() {fDeadChannels.Reset(); fNrDead=0;}
-    Bool_t IsPixelDead(Int_t col, Int_t row) const ;
-    void   AddNoisy(UInt_t col, UInt_t row);
-    Int_t  GetNrNoisy() const {return fNrNoisy;}
-    Int_t  GetNoisyColAt(UInt_t index) const; //returns -1 if out of bounds
-    Int_t  GetNoisyRowAt(UInt_t index) const; //returns -1 if out of bounds
-    void   ClearNoisy() {fNoisyChannels.Reset(); fNrNoisy=0;}
-    Bool_t IsPixelNoisy(Int_t col, Int_t row) const ;
+    void   SetEqNr(UInt_t mod) {fEqNr=mod;}
+    UInt_t GetEqNr() const {return fEqNr;}
+    void   SetBadList(TArrayI badlist) {fBadChannels=badlist;}
+    void   SetNrBad(UInt_t nr) {fNrBad=nr;}
+
+    UInt_t GetNrBad() const {return fNrBad;}
+    Int_t  GetKeyAt(UInt_t index) const; //returns -1 if out of bounds
+
+    void   ClearBad() {fBadChannels.Reset(); fNrBad=0;}
 
  private:
-    UInt_t   fModuleNr;       // module nr
-    UInt_t   fNrDead;         // nr of dead pixels
-    TArrayI  fDeadChannels;   // index 0 is nr of dead, then pairs of col and row
-    UInt_t   fNrNoisy;        // nr of noisy pixels
-    TArrayI  fNoisyChannels;  // index 0 is nr of noisy, then pairs of col and row
+    UInt_t   fEqNr;         // eq nr
+    UInt_t   fNrBad;        // nr of bad pixels
+    TArrayI  fBadChannels;  // array of keys for the bad
 
     ClassDef(AliITSOnlineCalibrationSPD,1)
 };
index 538a1d1..9e4642d 100644 (file)
@@ -1,21 +1,3 @@
-/**************************************************************************
- * Copyright(c) 2007-2009, 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.                  *
- **************************************************************************/
-
-
-/* $Id$ */
-
 //////////////////////////////////////////////////////////////////////
 // Author: Henrik Tydesjo                                           //
 // For easier handling of dead and noisy pixels they are kept in    //
 #include "AliCDBEntry.h"
 #endif
 
+//____________________________________________________________________________________________
 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
-  fFileLocation("."),
-  fModuleMapInited(kFALSE)
+  fFileLocation(".")
 {
   // constructor
-  for (UInt_t module=0; module<240; module++) {
-    fNrDead[module]=0;
-    fNrNoisy[module]=0;
-    fDeadPixelMap[module] = new AliITSIntMap();
-    fNoisyPixelMap[module] = new AliITSIntMap();
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    fNrDead[gloChip]=0;
+    fNrNoisy[gloChip]=0;
+    fDeadPixelMap[gloChip] = new AliITSIntMap();
+    fNoisyPixelMap[gloChip] = new AliITSIntMap();
   }
 }
-
 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): 
-  fFileLocation("."),
-  fModuleMapInited(kFALSE)
+  fFileLocation(".")
 {
   // copy constructor
-  for (UInt_t module=0; module<240; module++) {
-    fNrDead[module] = handle.fNrDead[module];
-    fNrNoisy[module] = handle.fNrNoisy[module];
-    fDeadPixelMap[module] = handle.fDeadPixelMap[module]->Clone();
-    fNoisyPixelMap[module] = handle.fNoisyPixelMap[module]->Clone();
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    fNrDead[gloChip] = handle.fNrDead[gloChip];
+    fNrNoisy[gloChip] = handle.fNrNoisy[gloChip];
+    fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
+    fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
   }
   fFileLocation = handle.fFileLocation;
 }
-
 AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
-  ClearMaps();
+  //  ClearMaps();
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    delete fDeadPixelMap[gloChip];
+    delete fNoisyPixelMap[gloChip];
+  }
 }
-
 AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(const AliITSOnlineCalibrationSPDhandler& handle) {
   // assignment operator
   if (this!=&handle) {
     this->ClearMaps();
-    for (UInt_t module=0; module<240; module++) {
-      fNrDead[module] = handle.fNrDead[module];
-      fNrNoisy[module] = handle.fNrNoisy[module];
-      fDeadPixelMap[module] = handle.fDeadPixelMap[module]->Clone();
-      fNoisyPixelMap[module] = handle.fNoisyPixelMap[module]->Clone();
+    for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+      fNrDead[gloChip] = handle.fNrDead[gloChip];
+      fNrNoisy[gloChip] = handle.fNrNoisy[gloChip];
+      fDeadPixelMap[gloChip] = handle.fDeadPixelMap[gloChip]->Clone();
+      fNoisyPixelMap[gloChip] = handle.fNoisyPixelMap[gloChip]->Clone();
     }
     fFileLocation = handle.fFileLocation;
   }
   return *this;
 }
-
+//____________________________________________________________________________________________
 void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
   // clear the lists of dead and noisy
   ResetDead();
   ResetNoisy();
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() {
-  // read dead and noisy files from file location. returns true if at least one file found
-  Bool_t returnval=kFALSE;
-  for (UInt_t module=0; module<240; module++) {
-    if (ReadFromFile(module)) {
-      returnval=kTRUE;
-    }
+void AliITSOnlineCalibrationSPDhandler::ResetDead() {
+  // reset the dead pixel map
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    fNrDead[gloChip]=0;
+    fDeadPixelMap[gloChip]->Clear();
   }
-  return returnval;
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile(UInt_t module) {
-  // read dead and noisy files for module from file location. 
-  TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
-  return ReadFromFileName(fileName.Data());
+void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
+  // clear the list of noisy pixels
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    fNrNoisy[gloChip]=0;
+    fNoisyPixelMap[gloChip]->Clear();
+  }
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFileName(const char *fileName) {
-  // read dead and noisy from file fileName
-  AliITSOnlineCalibrationSPD* calib;
-  FILE* fp0 = fopen(fileName, "r");
-  if (fp0 == NULL) {return kFALSE;}
-  else {
-    fclose(fp0);
-    TFile file(fileName, "READ");
-    if (file.IsOpen()) {
-      file.GetObject("AliITSOnlineCalibrationSPD", calib);
-      file.Close();
-      if (calib!=NULL) {
-       UInt_t module = calib->GetModuleNr();
-       Int_t nrDead=calib->GetNrDead();
-       for (Int_t index=0; index<nrDead; index++) {
-         UInt_t colM=calib->GetDeadColAt(index);
-         UInt_t row=calib->GetDeadRowAt(index);
-         SetDeadPixelM(module,colM,row);
-       }
-       Int_t nrNoisy=calib->GetNrNoisy();
-       for (Int_t index=0; index<nrNoisy; index++) {
-         UInt_t colM=calib->GetNoisyColAt(index);
-         UInt_t row=calib->GetNoisyRowAt(index);
-         SetNoisyPixelM(module,colM,row);
-       }
+void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eq, UInt_t hs, UInt_t chip) {
+  // clear the dead pixels for this chip
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  for (UInt_t col=0; col<32; col++) {
+    for (UInt_t row=0; row<256; row++) {
+      Int_t key = GetKey(eq,hs,chip,col,row);
+      if (fDeadPixelMap[gloChip]->Remove(key)) {
+       fNrDead[gloChip]--;
       }
     }
   }
-  return kTRUE;
 }
+void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eq, UInt_t hs, UInt_t chip) {
+  // clear the noisy pixels for this chip
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip","global chip nr (%d) out of bounds\n",gloChip);
+    return;
+  }
+  for (UInt_t col=0; col<32; col++) {
+    for (UInt_t row=0; row<256; row++) {
+      Int_t key = GetKey(eq,hs,chip,col,row);
+      if (fNoisyPixelMap[gloChip]->Remove(key)) {
+       fNrNoisy[gloChip]--;
+      }
+    }
+  }
+}
+void AliITSOnlineCalibrationSPDhandler::ResetDeadForEq(UInt_t eq) {
+  // clear the dead pixels for this eq
+  if (eq>=20) {
+    Error("AliITSOnlineCalibrationSPDhandler::ResetDeadForEq", "eq (%d) out of bounds.",eq);
+    return;
+  }
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      ResetDeadForChip(eq, hs, chip);
+    }
+  }
+}
+void AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq(UInt_t eq) {
+  // clear the noisy pixels for this eq
+  if (eq>=20) {
+    Error("AliITSOnlineCalibrationSPDhandler::ResetNoisyForEq", "eq (%d) out of bounds.",eq);
+    return;
+  }
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      ResetNoisyForChip(eq, hs, chip);
+    }
+  }
+}
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFiles() {
+  // read dead and noisy files from file location. returns true if at least one file found
+  Bool_t b1 = ReadNoisyFromFiles();
+  Bool_t b2 = ReadDeadFromFiles();
+  return (b1 && b2);
+}
+
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFiles() {
   // read dead files from file location. returns true if at least one file found
   Bool_t returnval=kFALSE;
-  for (UInt_t module=0; module<240; module++) {
-    if (ReadDeadFromFile(module)) {
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (ReadDeadFromFile(eq)) {
+      returnval=kTRUE;
+    }
+  }
+  return returnval;
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() {
+  // read noisy files from file location. returns true if at least one file found
+  Bool_t returnval=kFALSE;
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (ReadNoisyFromFile(eq)) {
       returnval=kTRUE;
     }
   }
   return returnval;
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t module) {
-  // read dead for module from file location. 
-  TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(UInt_t eq) {
+  // read dead file for module from file location. 
+  TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
   return ReadDeadFromFileName(fileName.Data());
 }
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t eq) {
+  // read noisy file for module from file location. 
+  TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq);
+  return ReadNoisyFromFileName(fileName.Data());
+}
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName) {
   // read dead from file fileName
   AliITSOnlineCalibrationSPD* calib;
@@ -164,33 +189,21 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileN
       file.GetObject("AliITSOnlineCalibrationSPD", calib);
       file.Close();
       if (calib!=NULL) {
-       UInt_t module = calib->GetModuleNr();
-       Int_t nrDead=calib->GetNrDead();
-       for (Int_t index=0; index<nrDead; index++) {
-         UInt_t colM=calib->GetDeadColAt(index);
-         UInt_t row=calib->GetDeadRowAt(index);
-         SetDeadPixelM(module,colM,row);
+       UInt_t nrDead=calib->GetNrBad();
+       for (UInt_t index=0; index<nrDead; index++) {
+         UInt_t key = calib->GetKeyAt(index);
+         UInt_t eq = GetEqIdFromKey(key);
+         UInt_t hs = GetHSFromKey(key);
+         UInt_t chip = GetChipFromKey(key);
+         UInt_t col = GetColFromKey(key);
+         UInt_t row = GetRowFromKey(key);
+         SetDeadPixel(eq,hs,chip,col,row);
        }
       }
     }
   }
   return kTRUE;
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFiles() {
-  // read noisy files from file location. returns true if at least one file found
-  Bool_t returnval=kFALSE;
-  for (UInt_t module=0; module<240; module++) {
-    if (ReadNoisyFromFile(module)) {
-      returnval=kTRUE;
-    }
-  }
-  return returnval;
-}
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(UInt_t module) {
-  // read noisy for module from file location. 
-  TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
-  return ReadNoisyFromFileName(fileName.Data());
-}
 Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *fileName) {
   // read noisy from file fileName
   AliITSOnlineCalibrationSPD* calib;
@@ -203,38 +216,42 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFileName(const char *file
       file.GetObject("AliITSOnlineCalibrationSPD", calib);
       file.Close();
       if (calib!=NULL) {
-       UInt_t module = calib->GetModuleNr();
-       Int_t nrNoisy=calib->GetNrNoisy();
-       for (Int_t index=0; index<nrNoisy; index++) {
-         UInt_t colM=calib->GetNoisyColAt(index);
-         UInt_t row=calib->GetNoisyRowAt(index);
-         SetNoisyPixelM(module,colM,row);
+       UInt_t nrNoisy=calib->GetNrBad();
+       for (UInt_t index=0; index<nrNoisy; index++) {
+         UInt_t key = calib->GetKeyAt(index);
+         UInt_t eq = GetEqIdFromKey(key);
+         UInt_t hs = GetHSFromKey(key);
+         UInt_t chip = GetChipFromKey(key);
+         UInt_t col = GetColFromKey(key);
+         UInt_t row = GetRowFromKey(key);
+         SetNoisyPixel(eq,hs,chip,col,row);
        }
       }
     }
   }
   return kTRUE;
 }
-
-
-UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName) {
-  // read dead from a text file (lines with eqId,hs,chip,col,row). returns nr of pixels added (not already there)
+UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName, UInt_t module) {
+  // read dead from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here)
+  // insert only those pixels that belong to module (or all if module=240). 
   UInt_t newNrDead=0;
   ifstream textFile;
   textFile.open(fileName, ifstream::in);
   if (textFile.fail()) {
-    Error("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No noisy text file (%s) present.",fileName);
+    Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No dead text file (%s) present.",fileName);
   }
   else {
     while(1) {
-      UInt_t eqId,hs,chip,col,row;
-      textFile >> eqId; if (textFile.eof()) break;
+      UInt_t eq,hs,chip,col,row;
+      textFile >> eq; if (textFile.eof()) break;
       textFile >> hs; if (textFile.eof()) break;
       textFile >> chip; if (textFile.eof()) break;
       textFile >> col; if (textFile.eof()) break;
       textFile >> row; 
-      if (SetDeadPixel(eqId,hs,chip,col,row)) {
-       newNrDead++;
+      if (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){
+       if (SetDeadPixel(eq,hs,chip,col,row)) {
+         newNrDead++;
+       }
       }
       if (textFile.eof()) break;
     }
@@ -242,25 +259,27 @@ UInt_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromText(const char *fileName)
   }
   return newNrDead;
 }
-
-UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName) {
-  // read noisy from a text file (lines with eqId,hs,chip,col,row). returns nr of pixels added (not already here)
+UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName, UInt_t module) {
+  // read noisy from a text file (lines with eq,hs,chip,col,row). returns nr of pixels added (not already here)
+  // insert only those pixels that belong to module (or all if module=240). 
   UInt_t newNrNoisy=0;
   ifstream textFile;
   textFile.open(fileName, ifstream::in);
   if (textFile.fail()) {
-    Error("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText","No noisy text file (%s) present.",fileName);
+    Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText","No noisy text file (%s) present.",fileName);
   }
   else {
     while(1) {
-      UInt_t eqId,hs,chip,col,row;
-      textFile >> eqId; if (textFile.eof()) break;
+      UInt_t eq,hs,chip,col,row;
+      textFile >> eq; if (textFile.eof()) break;
       textFile >> hs; if (textFile.eof()) break;
       textFile >> chip; if (textFile.eof()) break;
       textFile >> col; if (textFile.eof()) break;
       textFile >> row; 
-      if (SetNoisyPixel(eqId,hs,chip,col,row)) {
-       newNrNoisy++;
+      if (module==240 || (Int_t)module==AliITSRawStreamSPD::GetModuleNumber(eq,hs,chip)){
+       if (SetNoisyPixel(eq,hs,chip,col,row)) {
+         newNrNoisy++;
+       }
       }
       if (textFile.eof()) break;
     }
@@ -268,85 +287,255 @@ UInt_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromText(const char *fileName
   }
   return newNrNoisy;
 }
-
-
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::WriteToFilesAlways() {
+  // write the lists of dead and noisy to files
+  for (UInt_t eq=0; eq<20; eq++) {
+    WriteDeadToFile(eq);
+    WriteNoisyToFile(eq);
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::WriteToFiles() {
+  // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels) , returns nr of files produced
+  return (WriteNoisyToFiles() + WriteDeadToFiles());
+}
+void AliITSOnlineCalibrationSPDhandler::WriteDeadToFilesAlways() {
+  // write the lists of dead to files
+  for (UInt_t eq=0; eq<20; eq++) {
+      WriteDeadToFile(eq);
+  }
+}
+void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFilesAlways() {
+  // write the lists of noisy to files
+  for (UInt_t eq=0; eq<20; eq++) {
+    WriteNoisyToFile(eq);
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
+  // write the list of dead to file (only if there are >0 dead pixels) , returns nr of files produced
+  UInt_t nrFiles=0;
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (GetNrDeadEq(eq) > 0) {
+      WriteDeadToFile(eq);
+      nrFiles++;
+    }
+  }
+  return nrFiles;
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
+  // write the list of noisy to file (only if there are >0 noisy pixels) , returns nr of files produced
+  UInt_t nrFiles=0;
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (GetNrNoisyEq(eq) > 0) {
+      WriteNoisyToFile(eq);
+      nrFiles++;
+    }
+  }
+  return nrFiles;
+}
+void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t eq) {
+  // write the lists of dead and noisy for module to file
+  AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
+  calib->SetEqNr(eq);
+  calib->SetBadList(GetDeadArrayOnline(eq));
+  calib->SetNrBad(GetNrDeadEq(eq));
+  TString fileName = Form("%s/SPD_Dead_%d.root",fFileLocation.Data(),eq);
+  TFile file(fileName.Data(), "RECREATE");
+  file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
+  file.Close();
+  delete calib;
+}
+void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t eq) {
+  // write the lists of noisy and noisy for module to file
+  AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
+  calib->SetEqNr(eq);
+  calib->SetBadList(GetNoisyArrayOnline(eq));
+  calib->SetNrBad(GetNrNoisyEq(eq));
+  TString fileName = Form("%s/SPD_Noisy_%d.root",fFileLocation.Data(),eq);
+  TFile file(fileName.Data(), "RECREATE");
+  file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
+  file.Close();
+  delete calib;
+}
+//____________________________________________________________________________________________
 #ifndef SPD_DA_OFF
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadModuleFromDB(UInt_t module, Int_t runNr) {
-  // reads dead and noisy pixels from DB for given module and runNr
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial) {
+  // reads dead pixels from DB for given module and runNr
   AliCDBManager* man = AliCDBManager::Instance();
   if(!man->IsDefaultStorageSet()) {
     man->SetDefaultStorage("local://$ALICE_ROOT");
   }
-  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", runNr);
+  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDDead", runNr);
   TObjArray* spdEntry;
   if(cdbEntry) {
     spdEntry = (TObjArray*)cdbEntry->GetObject();
     if(!spdEntry) return kFALSE;
   }
   else {
-    Warning("AliITSOnlineCalibrationSPDhandler::ReadModuleFromDB","Calibration for run %d not found in database.",runNr);
+    Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadModuleFromDB","Calibration for run %d not found in database.",runNr);
     return kFALSE;
   }
   AliITSCalibrationSPD* calibSPD;
   calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
-  UInt_t nrDead = calibSPD->GetNrDead();
-  for (UInt_t index=0; index<nrDead; index++) {
-    UInt_t colM = calibSPD->GetDeadColAt(index);
-    UInt_t row  = calibSPD->GetDeadRowAt(index);
-    SetDeadPixelM(module,colM,row);
-  }
-  UInt_t nrNoisy = calibSPD->GetNrNoisy();
-  for (UInt_t index=0; index<nrNoisy; index++) {
-    UInt_t colM = calibSPD->GetNoisyColAt(index);
-    UInt_t row  = calibSPD->GetNoisyRowAt(index);
-    SetNoisyPixelM(module,colM,row);
+  UInt_t nrDead = calibSPD->GetNrBad();
+  if (nrDead>0) {
+    if (!treeSerial) RecursiveInsertDead(calibSPD,module,0,nrDead-1);
+    else {
+      for (UInt_t index=0; index<nrDead; index++) {
+       UInt_t colM = calibSPD->GetBadColAt(index);
+       UInt_t rowM = calibSPD->GetBadRowAt(index);
+       SetDeadPixelM(module,colM,rowM);
+      }
+    }
   }
   spdEntry->SetOwner(kTRUE);
   spdEntry->Clear();
   return kTRUE;
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr) {
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial) {
+  // reads noisy pixels from DB for given module and runNr
+  AliCDBManager* man = AliCDBManager::Instance();
+  if(!man->IsDefaultStorageSet()) {
+    man->SetDefaultStorage("local://$ALICE_ROOT");
+  }
+  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr);
+  TObjArray* spdEntry;
+  if(cdbEntry) {
+    spdEntry = (TObjArray*)cdbEntry->GetObject();
+    if(!spdEntry) return kFALSE;
+  }
+  else {
+    Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyModuleFromDB","Calibration for run %d not found in database.",runNr);
+    return kFALSE;
+  }
+  AliITSCalibrationSPD* calibSPD;
+  calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
+  UInt_t nrNoisy = calibSPD->GetNrBad();
+  if (nrNoisy>0) {
+    if (!treeSerial) RecursiveInsertNoisy(calibSPD,module,0,nrNoisy-1);
+    else {
+      for (UInt_t index=0; index<nrNoisy; index++) {
+       UInt_t colM = calibSPD->GetBadColAt(index);
+       UInt_t rowM = calibSPD->GetBadRowAt(index);
+       SetNoisyPixelM(module,colM,rowM);
+      }
+    }
+  }
+  spdEntry->SetOwner(kTRUE);
+  spdEntry->Clear();
+  return kTRUE;
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr, Bool_t treeSerial) {
   // reads dead and noisy pixels from DB for given runNr
   // note that you may want to clear the lists (if they are not empty) before reading
+  return (ReadNoisyFromDB(runNr,treeSerial) && ReadDeadFromDB(runNr,treeSerial));
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB(Int_t runNr, Bool_t treeSerial) {
+  // reads dead pixels from DB for given runNr
+  // note that you may want to clear the list (if it is not empty) before reading
   AliCDBManager* man = AliCDBManager::Instance();
   if(!man->IsDefaultStorageSet()) {
     man->SetDefaultStorage("local://$ALICE_ROOT");
   }
-  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", runNr);
+  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDDead", runNr);
   TObjArray* spdEntry;
   if(cdbEntry) {
     spdEntry = (TObjArray*)cdbEntry->GetObject();
     if(!spdEntry) return kFALSE;
   }
   else {
-    Warning("AliITSOnlineCalibrationSPDhandler::ReadFromDB","Calibration for run %d not found in database.",runNr);
+    Warning("AliITSOnlineCalibrationSPDhandler::ReadDeadFromDB","Calibration for run %d not found in database.",runNr);
     return kFALSE;
   }
   AliITSCalibrationSPD* calibSPD;
   for (UInt_t module=0; module<240; module++) {
     //    printf("Reading module %d\n",module);
     calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
-    UInt_t nrDead = calibSPD->GetNrDead();
-    for (UInt_t index=0; index<nrDead; index++) {
-      UInt_t colM = calibSPD->GetDeadColAt(index);
-      UInt_t row  = calibSPD->GetDeadRowAt(index);
-      SetDeadPixelM(module,colM,row);
+    UInt_t nrDead = calibSPD->GetNrBad();
+    if (nrDead>0) {    
+      if (!treeSerial) RecursiveInsertDead(calibSPD,module,0,nrDead-1);
+      else {
+       for (UInt_t index=0; index<nrDead; index++) {
+         UInt_t colM = calibSPD->GetBadColAt(index);
+         UInt_t rowM = calibSPD->GetBadRowAt(index);
+         SetDeadPixelM(module,colM,rowM);
+       }
+      }
     }
-    UInt_t nrNoisy = calibSPD->GetNrNoisy();
-    for (UInt_t index=0; index<nrNoisy; index++) {
-      UInt_t colM = calibSPD->GetNoisyColAt(index);
-      UInt_t row  = calibSPD->GetNoisyRowAt(index);
-      SetNoisyPixelM(module,colM,row);
+  }
+  spdEntry->SetOwner(kTRUE);
+  spdEntry->Clear();
+  return kTRUE;
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB(Int_t runNr, Bool_t treeSerial) {
+  // reads noisy pixels from DB for given runNr
+  // note that you may want to clear the list (if it is not empty) before reading
+  AliCDBManager* man = AliCDBManager::Instance();
+  if(!man->IsDefaultStorageSet()) {
+    man->SetDefaultStorage("local://$ALICE_ROOT");
+  }
+  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/SPDNoisy", runNr);
+  TObjArray* spdEntry;
+  if(cdbEntry) {
+    spdEntry = (TObjArray*)cdbEntry->GetObject();
+    if(!spdEntry) return kFALSE;
+  }
+  else {
+    Warning("AliITSOnlineCalibrationSPDhandler::ReadNoisyFromDB","Calibration for run %d not found in database.",runNr);
+    return kFALSE;
+  }
+  AliITSCalibrationSPD* calibSPD;
+  for (UInt_t module=0; module<240; module++) {
+    //    printf("Reading module %d\n",module);
+    calibSPD = (AliITSCalibrationSPD*) spdEntry->At(module);
+    UInt_t nrNoisy = calibSPD->GetNrBad();
+    if (nrNoisy>0) {    
+      if (!treeSerial) {
+       printf("*** mod %d nrnoisy=%d\n",module,nrNoisy);
+       RecursiveInsertNoisy(calibSPD,module,0,nrNoisy-1);
+      }
+      else {
+       for (UInt_t index=0; index<nrNoisy; index++) {
+         UInt_t colM = calibSPD->GetBadColAt(index);
+         UInt_t rowM = calibSPD->GetBadRowAt(index);
+         SetNoisyPixelM(module,colM,rowM);
+       }
+      }
     }
   }
   spdEntry->SetOwner(kTRUE);
   spdEntry->Clear();
   return kTRUE;
 }
-
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromCalibObj(TObjArray* calObj) {
+  // reads dead pixels from calib object
+  for (UInt_t module=0; module<240; module++) {
+    for (Int_t i=0; i<((AliITSCalibrationSPD*)calObj->At(module))->GetNrBad(); i++) {
+      SetDeadPixelM(module,
+                   ((AliITSCalibrationSPD*)calObj->At(module))->GetBadColAt(i),
+                   ((AliITSCalibrationSPD*)calObj->At(module))->GetBadRowAt(i));
+    }
+  }
+  return kTRUE;
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromCalibObj(TObjArray* calObj) {
+  // reads noisy pixels from calib object
+  for (UInt_t module=0; module<240; module++) {
+    for (Int_t i=0; i<((AliITSCalibrationSPD*)calObj->At(module))->GetNrBad(); i++) {
+      SetNoisyPixelM(module,
+                    ((AliITSCalibrationSPD*)calObj->At(module))->GetBadColAt(i),
+                    ((AliITSCalibrationSPD*)calObj->At(module))->GetBadRowAt(i));
+    }
+  }
+  return kTRUE;
+}
 Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runNrEnd) {
-  // writes dead and noisy pixels to DB for given runNr
+  // writes dead and noisy pixels to DB for given runNrs
+  // overwrites any previous entries
+  return (WriteNoisyToDB(runNrStart,runNrEnd) && WriteDeadToDB(runNrStart,runNrEnd));
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::WriteDeadToDB(Int_t runNrStart, Int_t runNrEnd) {
+  // writes dead pixels to DB for given runNrs
   // overwrites any previous entries
   AliCDBManager* man = AliCDBManager::Instance();
   if(!man->IsDefaultStorageSet()) {
@@ -355,7 +544,7 @@ Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runN
   AliCDBMetaData* metaData = new AliCDBMetaData();
   metaData->SetResponsible("Henrik Tydesjo");
   metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
-  AliCDBId idCalSPD("ITS/Calib/CalibSPD",runNrStart,runNrEnd);
+  AliCDBId idCalSPD("ITS/Calib/SPDDead",runNrStart,runNrEnd);
   TObjArray* spdEntry = new TObjArray(240);
   spdEntry->SetOwner(kTRUE);
   for(UInt_t module=0; module<240; module++){
@@ -366,7 +555,6 @@ Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runN
     calObj->SetThresholds(3000, 250);
     calObj->SetBiasVoltage(18.182);
     calObj->SetNoiseParam(0,0);
-    // CouplingRaw changed to 0.055 (fine tuning), was 0.047 in PDC06
     calObj->SetCouplingParam(0.,0.055);
     // *** remove later...
     // ************************************************************
@@ -374,10 +562,8 @@ Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runN
     spdEntry->Add(calObj);
   }
   for(UInt_t module=0; module<240; module++){
-    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrDead( GetNrDead(module) );
-    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetDeadList( GetDeadArray(module) );
-    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrNoisy( GetNrNoisy(module) );
-    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNoisyList( GetNoisyArray(module) );
+    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrBad( GetNrDead(module) );
+    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetBadList( GetDeadArray(module) );
   }
   AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
   man->Put(cdbEntry);
@@ -386,684 +572,1365 @@ Bool_t AliITSOnlineCalibrationSPDhandler::WriteToDB(Int_t runNrStart, Int_t runN
   delete metaData;
   return kTRUE;
 }
-#endif
-
-void AliITSOnlineCalibrationSPDhandler::WriteToFilesAlways() {
-  // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels)
-  for (UInt_t module=0; module<240; module++) {
-    WriteToFile(module);
+Bool_t AliITSOnlineCalibrationSPDhandler::WriteNoisyToDB(Int_t runNrStart, Int_t runNrEnd) {
+  // writes noisy pixels to DB for given runNrs
+  // overwrites any previous entries
+  AliCDBManager* man = AliCDBManager::Instance();
+  if(!man->IsDefaultStorageSet()) {
+    man->SetDefaultStorage("local://$ALICE_ROOT");
   }
-}
-void AliITSOnlineCalibrationSPDhandler::WriteToFiles() {
-  // write the lists of dead and noisy to files (only if there are >0 dead or noisy pixels)
-  for (UInt_t module=0; module<240; module++) {
-    if (fNrDead[module]+fNrNoisy[module] > 0) {
-      WriteToFile(module);
-    }
+  AliCDBMetaData* metaData = new AliCDBMetaData();
+  metaData->SetResponsible("Henrik Tydesjo");
+  metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
+  AliCDBId idCalSPD("ITS/Calib/SPDNoisy",runNrStart,runNrEnd);
+  TObjArray* spdEntry = new TObjArray(240);
+  spdEntry->SetOwner(kTRUE);
+  for(UInt_t module=0; module<240; module++){
+    AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
+
+    // *** this is temporarily hard coded here ********************
+    // (later these parameters will be separated from the cal.obj.)
+    calObj->SetThresholds(3000, 250);
+    calObj->SetBiasVoltage(18.182);
+    calObj->SetNoiseParam(0,0);
+    calObj->SetCouplingParam(0.,0.055);
+    // *** remove later...
+    // ************************************************************
+
+    spdEntry->Add(calObj);
   }
-}
-void AliITSOnlineCalibrationSPDhandler::WriteToFile(UInt_t module) {
-  // write the lists of dead and noisy for module to file
-  AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
-  calib->SetModuleNr(module);
-  calib->SetDeadList(GetDeadArray(module));
-  calib->SetNoisyList(GetNoisyArray(module));
-  calib->SetNrDead(GetNrDead(module));
-  calib->SetNrNoisy(GetNrNoisy(module));
-  TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
-  TFile file(fileName.Data(), "RECREATE");
-  file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
-  file.Close();
-  delete calib;
-}
-void AliITSOnlineCalibrationSPDhandler::WriteDeadToFiles() {
-  // write the lists of dead to files (only if there are >0 dead pixels)
-  for (UInt_t module=0; module<240; module++) {
-    if (fNrDead[module] > 0) {
-      WriteDeadToFile(module);
-    }
+  for(UInt_t module=0; module<240; module++){
+    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrBad( GetNrNoisy(module) );
+    ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetBadList( GetNoisyArray(module) );
   }
+  AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
+  man->Put(cdbEntry);
+  delete spdEntry;
+  delete cdbEntry;
+  delete metaData;
+  return kTRUE;
 }
-void AliITSOnlineCalibrationSPDhandler::WriteDeadToFile(UInt_t module) {
-  // write the lists of dead for module to file
-  AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
-  calib->SetModuleNr(module);
-  calib->SetDeadList(GetDeadArray(module));
-  calib->SetNrDead(GetNrDead(module));
-  TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
-  TFile file(fileName.Data(), "RECREATE");
-  file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
-  file.Close();
-  delete calib;
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::RecursiveInsertDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) {
+  // inserts dead pixels recursively, used when reading from db
+  if (lowInd>highInd) return;
+  Int_t thisInd = lowInd+(highInd-lowInd)/2;
+  SetDeadPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd));
+  RecursiveInsertDead(calibSPD,module,lowInd,thisInd-1);
+  RecursiveInsertDead(calibSPD,module,thisInd+1,highInd);
+}
+void AliITSOnlineCalibrationSPDhandler::RecursiveInsertNoisy(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd) {
+  // inserts noisy pixels recursively, used when reading from db
+  printf("Rec mod %d : %d,%d\n",module,lowInd,highInd);
+  if (lowInd>highInd) return;
+  Int_t thisInd = lowInd+(highInd-lowInd)/2;
+  SetNoisyPixelM(module,calibSPD->GetBadColAt(thisInd),calibSPD->GetBadRowAt(thisInd));
+  RecursiveInsertNoisy(calibSPD,module,lowInd,thisInd-1);
+  RecursiveInsertNoisy(calibSPD,module,thisInd+1,highInd);
 }
-void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFiles() {
-  // write the lists of noisy to files (only if there are >0 dead pixels)
+
+#endif
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) {
+  // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0)
+  ofstream dcsfile;
+  dcsfile.open(fileName);
+  dcsfile << "[SPD SCAN]\n";
+  dcsfile << "RunNumber=" << "0" << "\n"; // dummy value
+  dcsfile << "Type=" << "4" << "\n";
+  dcsfile << "Router=" << "0" << "\n"; // dummy value
+  dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values
+  dcsfile << "[NOISY]\n";
   for (UInt_t module=0; module<240; module++) {
-    if (fNrNoisy[module] > 0) {
-      printf("writing noisy to file for module %d\n",module);
-      WriteNoisyToFile(module);
+    UInt_t headkey=20*10*6;
+    for (UInt_t ind=0; ind<GetNrNoisy(module); ind++) {
+      UInt_t newkey = GetNoisyEqIdAt(module,ind)*10*6 +
+       GetNoisyHSAt(module,ind)*10 +
+       GetNoisyChipAt(module,ind);
+      if (newkey!=headkey) { // print eq,hs,chip header
+       headkey = newkey;
+       dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
+      }
+      dcsfile << GetNoisyColAt(module,ind) << "," << GetNoisyRowAt(module,ind) << "\n";
     }
   }
+  dcsfile.close();
 }
-void AliITSOnlineCalibrationSPDhandler::WriteNoisyToFile(UInt_t module) {
-  // write the lists of noisy for module to file
-  AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
-  calib->SetModuleNr(module);
-  calib->SetNoisyList(GetNoisyArray(module));
-  calib->SetNrNoisy(GetNrNoisy(module));
-  TString fileName = Form("%s/SPD_DeadNoisy_%d.root",fFileLocation.Data(),module);
-  TFile file(fileName.Data(), "RECREATE");
-  file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
-  file.Close();
-  delete calib;
-}
-
-TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module) {
+//____________________________________________________________________________________________
+TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray(UInt_t module, Bool_t treeSerial) {
   // get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object)
   TArrayI returnArray;
-  returnArray.Set(GetNrDead(module)*2);
-  fDeadPixelMap[module]->PrepareSerialize(); // for tree ordered values
-  for (UInt_t index=0; index<GetNrDead(module); index++) {
-    Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
-    Int_t colM = GetColMFromKey(key);
-    Int_t row = GetRowFromKey(key);
-    returnArray.AddAt(colM,index*2);
-    returnArray.AddAt(row,index*2+1);
+
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t size=0;
+  for (UInt_t chip=0; chip<5; chip++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+    size += fNrDead[gloChip];
+  }
+  returnArray.Set(size*2);
+  UInt_t gloIndex=0;
+  for (UInt_t chip=0; chip<5; chip++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+    if (treeSerial) fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
+    else fDeadPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
+    for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
+      Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+      Int_t colM = GetColMFromKey(key);
+      Int_t rowM = GetRowMFromKey(key);
+      returnArray.AddAt(colM,gloIndex*2);
+      returnArray.AddAt(rowM,gloIndex*2+1);
+      gloIndex++;
+    }
   }
   return returnArray;
 }
-TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module) {
+TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module, Bool_t treeSerial) {
   // get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object)
   TArrayI returnArray;
-  returnArray.Set(GetNrNoisy(module)*2);
-  fNoisyPixelMap[module]->PrepareSerialize(); // for tree ordered values
-  for (UInt_t index=0; index<GetNrNoisy(module); index++) {
-    Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
-    Int_t colM = GetColMFromKey(key);
-    Int_t row = GetRowFromKey(key);
-    returnArray.AddAt(colM,index*2);
-    returnArray.AddAt(row,index*2+1);
+
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t size=0;
+  for (UInt_t chip=0; chip<5; chip++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+    size += fNrNoisy[gloChip];
+  }
+  returnArray.Set(size*2);
+  UInt_t gloIndex=0;
+  for (UInt_t chip=0; chip<5; chip++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+    if (treeSerial) fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
+    else fNoisyPixelMap[gloChip]->PrepareSerializeOrdered(); // for key ordered values
+    for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
+      Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+      Int_t colM = GetColMFromKey(key);
+      Int_t rowM = GetRowMFromKey(key);
+      returnArray.AddAt(colM,gloIndex*2);
+      returnArray.AddAt(rowM,gloIndex*2+1);
+      gloIndex++;
+    }
   }
   return returnArray;
 }
-
-void AliITSOnlineCalibrationSPDhandler::ResetDead() {
-  // reset the dead pixel map
-  for (UInt_t module=0; module<240; module++) {
-    fNrDead[module]=0;
-    fDeadPixelMap[module]->Clear();
+TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArrayOnline(UInt_t eq) {
+  // get a TArrayI of the dead pixels (format for the AliITSOnlineCalibrationSPD object)
+  TArrayI returnArray;
+  // fix size of array
+  UInt_t size=0;
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      UInt_t gloChip = GetGloChip(eq,hs,chip);
+      size+=fNrDead[gloChip];
+    }
   }
+  returnArray.Set(size);
+  // put keys in array
+  UInt_t gloIndex=0;
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      UInt_t gloChip = GetGloChip(eq,hs,chip);
+      fDeadPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
+      for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
+       Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+       returnArray.AddAt(key,gloIndex);
+       gloIndex++;
+      }
+    }
+  }
+  return returnArray;
 }
-
-void AliITSOnlineCalibrationSPDhandler::ResetDeadForChip(UInt_t eqId, UInt_t hs, UInt_t chip) {
-  // clear the noisy pixels for this chip
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  for (UInt_t col=0; col<32; col++) {
-    for (UInt_t row=0; row<256; row++) {
-      Int_t key = GetKey(eqId,hs,chip,col,row);
-      if (fDeadPixelMap[module]->Remove(key)) {
-       fNrDead[module]--;
+TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArrayOnline(UInt_t eq) {
+  // get a TArrayI of the noisy pixels (format for the AliITSOnlineCalibrationSPD object)
+  TArrayI returnArray;
+  // fix size of array
+  UInt_t size=0;
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      UInt_t gloChip = GetGloChip(eq,hs,chip);
+      size+=fNrNoisy[gloChip];
+    }
+  }
+  returnArray.Set(size);
+  // put keys in array
+  UInt_t gloIndex=0;
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      UInt_t gloChip = GetGloChip(eq,hs,chip);
+      fNoisyPixelMap[gloChip]->PrepareSerialize(); // for tree ordered values
+      for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
+       Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+       returnArray.AddAt(key,gloIndex);
+       gloIndex++;
       }
     }
   }
+  return returnArray;
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
-  // set a dead pixel, returns false if pixel is already dead
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-//!!!  // if noisy we dont want to add it...
-//!!!  if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE;
-  if (fDeadPixelMap[module]->Insert(key,module)) {
-    fNrDead[module]++;
-    return kTRUE;
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::PrintEqSummary() {
+// print summary (nr of dead and noisy) for each equipment
+  printf("-----------\n");
+  printf("Eq summary:\n");
+  printf("-----------\n");
+  for (UInt_t eq=0; eq<20; eq++) {
+    printf("Eq %*d: %*d dead , %*d noisy\n",2,eq,5,GetNrDeadEq(eq),5,GetNrNoisyEq(eq));
   }
-  return kFALSE;
 }
+void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
+  // print the dead pixels to screen
+  printf("------------------------------------------------------\n");
+  printf("Dead Pixels: (eq,hs,chip,col,row  |  module,colM,rowM)\n");
+  printf("------------------------------------------------------\n");
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t index=0; index<fNrDead[gloChip]; index++) {
+      Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+      UInt_t eq = GetEqIdFromKey(key);
+      UInt_t hs = GetHSFromKey(key);
+      UInt_t chip = GetChipFromKey(key);
+      UInt_t col = GetColFromKey(key);
+      UInt_t row = GetRowFromKey(key);
 
-Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row) {
-  // set a dead pixel, returns false if pixel is already dead
-  UInt_t eqId = GetEqIdFromOffline(module);
-  UInt_t hs = GetHSFromOffline(module);
-  UInt_t chip = GetChipFromOffline(module,colM);
-  UInt_t col = GetColFromOffline(colM);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-//!!!  // if noisy we dont want to add it...
-//!!!  if (fNoisyPixelMap[module]->Find(key) != NULL) return kFALSE;
-  if (fDeadPixelMap[module]->Insert(key,module)) {
-    fNrDead[module]++;
-    return kTRUE;
+      UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
+      UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
+      UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
+
+      printf("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d\n",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
+    }
   }
-  return kFALSE;
 }
+void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
+  // print the dead pixels to screen
+  printf("-------------------------------------------------------\n");
+  printf("Noisy Pixels: (eq,hs,chip,col,row  |  module,colM,rowM)\n");
+  printf("-------------------------------------------------------\n");
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t index=0; index<fNrNoisy[gloChip]; index++) {
+      Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+      UInt_t eq = GetEqIdFromKey(key);
+      UInt_t hs = GetHSFromKey(key);
+      UInt_t chip = GetChipFromKey(key);
+      UInt_t col = GetColFromKey(key);
+      UInt_t row = GetRowFromKey(key);
 
-Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
-  // unset a dead pixel, returns false if pixel is not dead
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-  if (fDeadPixelMap[module]->Remove(key)) {
-    fNrDead[module]--;
-    return kTRUE;
+      UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
+      UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
+      UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
+
+      printf("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d\n",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
+    }
   }
-  return kFALSE;
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row) {
-  // unset a dead pixel, returns false if pixel is not dead
-  UInt_t eqId = GetEqIdFromOffline(module);
-  UInt_t hs = GetHSFromOffline(module);
-  UInt_t chip = GetChipFromOffline(module,colM);
-  UInt_t col = GetColFromOffline(colM);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-  if (fDeadPixelMap[module]->Remove(key)) {
-    fNrDead[module]--;
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
+  // set a dead pixel, returns false if pixel is already dead
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::SetDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
+  }
+  if (col>=32 && row>=256) {
+    Error("AliITSOnlineCalibrationSPDhandler::SetDeadPixel", "col,row nrs (%d,%d) out of bounds.",col,row);
+    return kFALSE;
+  }
+  Int_t key = GetKey(eq,hs,chip,col,row);
+  // if noisy we dont want to add it...
+  if (fNoisyPixelMap[gloChip]->Find(key) != NULL) return kFALSE;
+  if (fDeadPixelMap[gloChip]->Insert(key,gloChip)) {
+    fNrDead[gloChip]++;
     return kTRUE;
   }
   return kFALSE;
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
-  // is this pixel noisy?
-  UInt_t eqId = GetEqIdFromKey(key);
-  UInt_t hs = GetHSFromKey(key);
-  UInt_t chip = GetChipFromKey(key);
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  return IsPixelDeadMKey(module,key);
-}
-
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadMKey(UInt_t module, Int_t key) const {
-  // is this pixel dead?
-  if ( fDeadPixelMap[module]->Find(key) != NULL ) {
-    return kTRUE;
+Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
+  // set a noisy pixel, returns false if pixel is already noisy
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::SetNoisyPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
   }
-  else {
+  if (col>=32 && row>=256) {
+    Error("AliITSOnlineCalibrationSPDhandler::SetNoisyPixel", "col,row nrs (%d,%d) out of bounds.",col,row);
     return kFALSE;
   }
+  Int_t key = GetKey(eq,hs,chip,col,row);
+  // if dead before - remove from the dead list 
+  if (fDeadPixelMap[gloChip]->Remove(key)) {
+    fNrDead[gloChip]--;
+  }
+  if (fNoisyPixelMap[gloChip]->Insert(key,gloChip)) {
+    fNrNoisy[gloChip]++;
+    return kTRUE;
+  }
+  return kFALSE;
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
-  // is the pixel dead?
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-  return IsPixelDeadMKey(module,key);
-}
-
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t row) {
-  // is the pixel dead?
-  UInt_t eqId = GetEqIdFromOffline(module);
+Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
+  // set a dead pixel, returns false if pixel is already dead
+  UInt_t eq = GetEqIdFromOffline(module);
   UInt_t hs = GetHSFromOffline(module);
   UInt_t chip = GetChipFromOffline(module,colM);
-  UInt_t col = GetColFromOffline(colM);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-  return IsPixelDeadMKey(module,key);
+  UInt_t col = GetColFromOffline(module,colM);
+  UInt_t row = GetRowFromOffline(module,rowM);
+  return SetDeadPixel(eq,hs,chip,col,row);
 }
-
-UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
-  // returns the total nr of dead pixels
-  UInt_t nrDead = 0;
-  for (UInt_t module=0; module<240; module++) {
-    nrDead+=fNrDead[module];
-  }
-  return nrDead;
+Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
+  // set a noisy pixel, returns false if pixel is already noisy
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t chip = GetChipFromOffline(module,colM);
+  UInt_t col = GetColFromOffline(module,colM);
+  UInt_t row = GetRowFromOffline(module,rowM);
+  return SetNoisyPixel(eq,hs,chip,col,row);
 }
-
-UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
-  // returns the number of dead pixels for a certain module
-  if (module<240) {
-    return fNrDead[module];
+Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
+  // unset a dead pixel, returns false if pixel is not dead
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::UnSetDeadPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
   }
-  else {
-    return 0;
+  Int_t key = GetKey(eq,hs,chip,col,row);
+  if (fDeadPixelMap[gloChip]->Remove(key)) {
+    fNrDead[gloChip]--;
+    return kTRUE;
   }
+  return kFALSE;
 }
-
-UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) {
-  // get eqId for the dead pixel at position index in list of dead
-  if (index<GetNrDead(module)) {
-    Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
-    return GetEqIdFromKey(key);
+Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
+  // unset a noisy pixel, returns false if pixel is not noisy
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
   }
-  else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt", "Index %d out of bounds.", index);
-    return 0;
+  Int_t key = GetKey(eq,hs,chip,col,row);
+  if (fNoisyPixelMap[gloChip]->Remove(key)) {
+    fNrNoisy[gloChip]--;
+    return kTRUE;
   }
+  return kFALSE;
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) {
-  // get hs for the dead pixel at position index in list of dead
-  if (index<GetNrDead(module)) {
-    Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
-    return GetHSFromKey(key);
-  }
-  else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAt", "Index %d out of bounds.", index);
-    return 0;
-  }
+Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
+  // unset a dead pixel, returns false if pixel is not dead
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t chip = GetChipFromOffline(module,colM);
+  UInt_t col = GetColFromOffline(module,colM);
+  UInt_t row = GetRowFromOffline(module,rowM);
+  return UnSetDeadPixel(eq,hs,chip,col,row);
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) {
-  // get chip for the dead pixel at position index in list of dead
-  if (index<GetNrDead(module)) {
-    Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
-    return GetChipFromKey(key);
-  }
-  else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAt", "Index %d out of bounds.", index);
-    return 0;
-  }
+Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t rowM) {
+  // unset a noisy pixel, returns false if pixel is not noisy
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t chip = GetChipFromOffline(module,colM);
+  UInt_t col = GetColFromOffline(module,colM);
+  UInt_t row = GetRowFromOffline(module,rowM);
+  return UnSetNoisyPixel(eq,hs,chip,col,row);
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) {
-  // get column for the dead pixel at position index in list of dead
-  if (index<GetNrDead(module)) {
-    Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
-    return GetColFromKey(key);
-  }
-  else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAt", "Index %d out of bounds.", index);
-    return 0;
+UInt_t AliITSOnlineCalibrationSPDhandler::SetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip) {
+  // set a full chip dead, returns nr of new dead pixels
+  UInt_t nrNew = 0;
+  for (UInt_t col=0; col<32; col++) {
+    for (UInt_t row=0; row<256; row++) {
+      if (SetDeadPixel(eq,hs,chip,col,row)) {
+       nrNew++;
+      }
+    }
   }
+  return nrNew;
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) {
-  // get row for the dead pixel at position index in list of dead
-  if (index<GetNrDead(module)) {
-    Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
-    return GetRowFromKey(key);
-  }
-  else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAt", "Index %d out of bounds.", index);
-    return 0;
+UInt_t AliITSOnlineCalibrationSPDhandler::SetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) {
+  // set a full chip noisy, returns nr of new noisy pixels
+  UInt_t nrNew = 0;
+  for (UInt_t col=0; col<32; col++) {
+    for (UInt_t row=0; row<256; row++) {
+      if (SetNoisyPixel(eq,hs,chip,col,row)) {
+       nrNew++;
+      }
+    }
   }
+  return nrNew;
 }
-
-void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
-  // clear the list of noisy pixels
-  for (UInt_t module=0; module<240; module++) {
-    fNrNoisy[module]=0;
-    fNoisyPixelMap[module]->Clear();
+Bool_t AliITSOnlineCalibrationSPDhandler::UnSetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip) {
+  // unset a full dead chip, returns false if it was not all dead before
+  UInt_t nrUnset = 0;
+  for (UInt_t col=0; col<32; col++) {
+    for (UInt_t row=0; row<256; row++) {
+      if (UnSetDeadPixel(eq,hs,chip,col,row)) {
+       nrUnset++;
+      }
+    }
   }
+  if (nrUnset+GetNrNoisyC(eq,hs,chip)<8192) return kFALSE;
+  else return kTRUE;
 }
-void AliITSOnlineCalibrationSPDhandler::ResetNoisyForChip(UInt_t eqId, UInt_t hs, UInt_t chip) {
-  // clear the noisy pixels for this chip
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
+Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) {
+  // unset a full noisy chip, returns false if it was not all noisy before
+  UInt_t nrUnset = 0;
   for (UInt_t col=0; col<32; col++) {
     for (UInt_t row=0; row<256; row++) {
-      Int_t key = GetKey(eqId,hs,chip,col,row);
-      if (fNoisyPixelMap[module]->Remove(key)) {
-       fNrNoisy[module]--;
+      if (UnSetNoisyPixel(eq,hs,chip,col,row)) {
+       nrUnset++;
       }
     }
   }
+  if (nrUnset<8192) return kFALSE;
+  else return kTRUE;
 }
-
-
-Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
-  // set a noisy pixel, returns false if already there
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-//!!!  // if dead before - remove from the dead list 
-//!!!  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-//!!!  if (fDeadPixelMap.Remove(key)) {
-//!!!    fNrDead[module]--;
-//!!!  }
-  if (fNoisyPixelMap[module]->Insert(key,col)) {
-    fNrNoisy[module]++;
-    return kTRUE;
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
+  // is the pixel dead?
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsPixelDead", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
   }
-  return kFALSE;
-}
-
-Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row) {
-  // set a noisy pixel, returns false if already there
-  UInt_t eqId = GetEqIdFromOffline(module);
-  UInt_t hs = GetHSFromOffline(module);
-  UInt_t chip = GetChipFromOffline(module,colM);
-  UInt_t col = GetColFromOffline(colM);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-//!!!  // if dead before - remove from the dead list 
-//!!!  if (fDeadPixelMap[module]->Remove(key)) {
-//!!!    fNrDead[module]--;
-//!!!  }
-  if (fNoisyPixelMap[module]->Insert(key,col)) {
-    fNrNoisy[module]++;
+  UInt_t key = GetKey(eq,hs,chip,col,row);
+  if ( fDeadPixelMap[gloChip]->Find(key) != NULL ) {
     return kTRUE;
   }
-  return kFALSE;
+  else {
+    return kFALSE;
+  }
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) {
-  // unset a noisy pixel, returns false if not there
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-  if (fNoisyPixelMap[module]->Remove(key)) {
-    fNrNoisy[module]--;
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
+  // is the pixel noisy?
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsPixelNoisy", "eq,hs,chip nrs (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
+  }
+  UInt_t key = GetKey(eq,hs,chip,col,row);
+  if ( fNoisyPixelMap[gloChip]->Find(key) != NULL ) {
     return kTRUE;
   }
-  return kFALSE;
+  else {
+    return kFALSE;
+  }
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row) {
-  // unset a noisy pixel, returns false if not there
-  UInt_t eqId = GetEqIdFromOffline(module);
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t rowM) const {
+  // is the pixel dead?
+  UInt_t eq = GetEqIdFromOffline(module);
   UInt_t hs = GetHSFromOffline(module);
   UInt_t chip = GetChipFromOffline(module,colM);
-  UInt_t col = GetColFromOffline(colM);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-  if (fNoisyPixelMap[module]->Remove(key)) {
-    fNrNoisy[module]--;
-    return kTRUE;
-  }
-  return kFALSE;
+  UInt_t col = GetColFromOffline(module,colM);
+  UInt_t row = GetRowFromOffline(module,rowM);
+  return IsPixelDead(eq,hs,chip,col,row);
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t rowM) const  {
+  // is the pixel noisy?
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  UInt_t chip = GetChipFromOffline(module,colM);
+  UInt_t col = GetColFromOffline(module,colM);
+  UInt_t row = GetRowFromOffline(module,rowM);
+  return IsPixelNoisy(eq,hs,chip,col,row);
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDeadKey(Int_t key) const {
+  // is this pixel dead?
+  UInt_t eq = GetEqIdFromKey(key);
+  UInt_t hs = GetHSFromKey(key);
+  UInt_t chip = GetChipFromKey(key);
+  UInt_t col = GetColFromKey(key);
+  UInt_t row = GetRowFromKey(key);
+  return IsPixelDead(eq,hs,chip,col,row);
 }
-
 Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(Int_t key) const {
   // is this pixel noisy?
-  UInt_t eqId = GetEqIdFromKey(key);
+  UInt_t eq = GetEqIdFromKey(key);
   UInt_t hs = GetHSFromKey(key);
   UInt_t chip = GetChipFromKey(key);
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  return IsPixelNoisyMKey(module,key);
+  UInt_t col = GetColFromKey(key);
+  UInt_t row = GetRowFromKey(key);
+  return IsPixelNoisy(eq,hs,chip,col,row);
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyMKey(UInt_t module, Int_t key) const {
-  // is this pixel noisy?
-  if ( fNoisyPixelMap[module]->Find(key) != NULL ) {
-    return kTRUE;
-  }
-  else {
-    return kFALSE;
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead() const {
+  // returns the total nr of dead pixels
+  UInt_t nrDead = 0;
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    nrDead+=fNrDead[gloChip];
   }
+  return nrDead;
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const {
-  // is this pixel noisy?
-  UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,hs,chip);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-  return IsPixelNoisyMKey(module,key);
-}
-
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t row) {
-  // is this pixel noisy?
-  UInt_t eqId = GetEqIdFromOffline(module);
-  UInt_t hs = GetHSFromOffline(module);
-  UInt_t chip = GetChipFromOffline(module,colM);
-  UInt_t col = GetColFromOffline(colM);
-  Int_t key = GetKey(eqId,hs,chip,col,row);
-  return IsPixelNoisyMKey(module,key);
-}
-
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy() const {
   // returns the total nr of noisy pixels
   UInt_t nrNoisy = 0;
-  for (UInt_t module=0; module<240; module++) {
-    nrNoisy+=fNrNoisy[module];
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    nrNoisy+=fNrNoisy[gloChip];
   }
   return nrNoisy;
 }
-
-UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
-// returns the number of noisy pixels for a certain module
-  if (module<240) {
-    return fNrNoisy[module];
-  }
-  else {
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t index) {
+  // get eq for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotDead(index,gloChip,chipIndex);
+  return GetDeadEqIdAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t index) {
+  // get eq for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
+  return GetNoisyEqIdAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotDead(index,gloChip,chipIndex);
+  return GetDeadHSAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
+  return GetNoisyHSAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t index) {
+  // get chip for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotDead(index,gloChip,chipIndex);
+  return GetDeadChipAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t index) {
+  // get chip for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
+  return GetNoisyChipAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotDead(index,gloChip,chipIndex);
+  return GetDeadColAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
+  return GetNoisyColAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotDead(index,gloChip,chipIndex);
+  return GetDeadRowAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexTotNoisy(index,gloChip,chipIndex);
+  return GetNoisyRowAtC2(gloChip,chipIndex);
+}
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
+  // returns the number of dead pixels for a certain module
+  if (module>=240) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNrDead", "module nr (%d) out of bounds.",module);
     return 0;
   }
-}
+  UInt_t nrDead = 0;
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  for (UInt_t chip=0; chip<5; chip++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+    nrDead+=fNrDead[gloChip];
 
-UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) {
-  // get chip for the noisy pixel at position index in list of noisy
-  if (index<GetNrNoisy(module)) {
-    Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
-    return GetEqIdFromKey(key);
   }
-  else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt", "Index %d out of bounds.", index);
+  return nrDead;
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisy(UInt_t module) const {
+  // returns the number of noisy pixels for a certain module
+  if (module>=240) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNrNoisy", "module nr (%d) out of bounds.",module);
     return 0;
   }
+  UInt_t nrNoisy = 0;
+  UInt_t eq = GetEqIdFromOffline(module);
+  UInt_t hs = GetHSFromOffline(module);
+  for (UInt_t chip=0; chip<5; chip++) {
+    UInt_t gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+    nrNoisy+=fNrNoisy[gloChip];
+
+  }
+  return nrNoisy;
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt(UInt_t module, UInt_t index) {
+  // get eq for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexDead(module,index,gloChip,chipIndex);
+  return GetDeadEqIdAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAt(UInt_t module, UInt_t index) {
+  // get eq for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
+  return GetNoisyEqIdAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAt(UInt_t module, UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexDead(module,index,gloChip,chipIndex);
+  return GetDeadHSAtC2(gloChip,chipIndex);
 }
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(UInt_t module, UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
+  return GetNoisyHSAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAt(UInt_t module, UInt_t index) {
+  // get chip for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexDead(module,index,gloChip,chipIndex);
+  return GetDeadChipAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) {
   // get chip for the noisy pixel at position index in list of noisy
-  if (index<GetNrNoisy(module)) {
-    Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
-    return GetHSFromKey(key);
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
+  return GetNoisyChipAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t module, UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexDead(module,index,gloChip,chipIndex);
+  return GetDeadColAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
+  return GetNoisyColAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t module, UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexDead(module,index,gloChip,chipIndex);
+  return GetDeadRowAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexNoisy(module,index,gloChip,chipIndex);
+  return GetNoisyRowAtC2(gloChip,chipIndex);
+}
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadEq(UInt_t eq) const {
+  // returns nr of dead for eq
+  UInt_t returnval=0;
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      returnval+=GetNrDeadC(eq,hs,chip);
+    }
   }
-  else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt", "Index %d out of bounds.", index);
-    return 0;
+  return returnval;
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyEq(UInt_t eq) const {
+  // returns nr of noisy for eq
+  UInt_t returnval=0;
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      returnval+=GetNrNoisyC(eq,hs,chip);
+    }
   }
+  return returnval;
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt(UInt_t module, UInt_t index) {
-  // get chip for the noisy pixel at position index in list of noisy
-  if (index<GetNrNoisy(module)) {
-    Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
-    return GetChipFromKey(key);
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtEq(UInt_t eq, UInt_t index) const {
+  // get eq for the dead pixel at position index in list of dead
+  if (eq<20 && index<GetNrDeadEq(eq)) {
+    return eq;
   }
   else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt", "Index %d out of bounds.", index);
-    return 0;
+    return 20;
   }
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t module, UInt_t index) {
-  // get column for the noisy pixel at position index in list of noisy
-  if (index<GetNrNoisy(module)) {
-    Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
-    return GetColFromKey(key);
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtEq(UInt_t eq, UInt_t index) const {
+  // get eq for the noisy pixel at position index in list of noisy
+  if (eq<20 && index<GetNrNoisyEq(eq)) {
+    return eq;
   }
   else {
-    Warning("AliITSOnlineCalibrationSPDhandler::GetNoisyColAt", "Index %d out of bounds.", index);
-    return 0;
+    return 20;
   }
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t module, UInt_t index) {
-  // get row for the noisy pixel at position index in list of noisy
-  if (index<GetNrNoisy(module)) {
-    Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
-    return GetRowFromKey(key);
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtEq(UInt_t eq, UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
+  return GetDeadHSAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtEq(UInt_t eq, UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
+  return GetNoisyHSAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtEq(UInt_t eq, UInt_t index) {
+  // get chip for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
+  return GetDeadChipAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtEq(UInt_t eq, UInt_t index) {
+  // get chip for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
+  return GetNoisyChipAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtEq(UInt_t eq, UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
+  return GetDeadColAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtEq(UInt_t eq, UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
+  return GetNoisyColAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtEq(UInt_t eq, UInt_t index) {
+  // get hs for the dead pixel at position index in list of dead
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexEqDead(eq,index,gloChip,chipIndex);
+  return GetDeadRowAtC2(gloChip,chipIndex);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtEq(UInt_t eq, UInt_t index) {
+  // get hs for the noisy pixel at position index in list of noisy
+  UInt_t gloChip;
+  UInt_t chipIndex;
+  GetChipAndIndexEqNoisy(eq,index,gloChip,chipIndex);
+  return GetNoisyRowAtC2(gloChip,chipIndex);
+}
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC(UInt_t eq, UInt_t hs, UInt_t chip) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetNrDeadC2(gloChip);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC(UInt_t eq, UInt_t hs, UInt_t chip) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetNrNoisyC2(gloChip);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetDeadEqIdAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetNoisyEqIdAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetDeadHSAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetNoisyHSAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetDeadChipAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetNoisyChipAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetDeadColAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetNoisyColAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetDeadRowAtC2(gloChip,index);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  return GetNoisyRowAtC2(gloChip,index);
+}
+//____________________________________________________________________________________________
+const Char_t* AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  // get a string of dead pixel info
+  TString returnMess = "";
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC", "global chip nr (%d) out of bounds.",gloChip);
+    return returnMess.Data();
+  }
+  if (index<fNrDead[gloChip]) {
+    Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+    UInt_t eq = GetEqIdFromKey(key);
+    UInt_t hs = GetHSFromKey(key);
+    UInt_t chip = GetChipFromKey(key);
+    UInt_t col = GetColFromKey(key);
+    UInt_t row = GetRowFromKey(key);    
+    UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
+    UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
+    UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
+    returnMess = Form("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d\n",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
+    return returnMess.Data();
   }
   else {
-    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt", "Index %d out of bounds.", index);
-    return 0;
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadPixelAsTextC", "Index %d out of bounds.", index);
+    return returnMess.Data();
+  }
+}
+const Char_t* AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const {
+  // get a string of noisy pixel info
+  TString returnMess = "";
+  UInt_t gloChip = GetGloChip(eq,hs,chip);
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC", "global chip nr (%d) out of bounds.",gloChip);
+    return returnMess.Data();
+  }
+  if (index<fNrNoisy[gloChip]) {
+    Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+    UInt_t eq = GetEqIdFromKey(key);
+    UInt_t hs = GetHSFromKey(key);
+    UInt_t chip = GetChipFromKey(key);
+    UInt_t col = GetColFromKey(key);
+    UInt_t row = GetRowFromKey(key);    
+    UInt_t module = AliITSRawStreamSPD::GetOfflineModuleFromOnline(eq,hs,chip);
+    UInt_t colM = AliITSRawStreamSPD::GetOfflineColFromOnline(eq,hs,chip,col);
+    UInt_t rowM = AliITSRawStreamSPD::GetOfflineRowFromOnline(eq,hs,chip,row);
+    returnMess = Form("%*d,%*d,%*d,%*d,%*d  |  %*d,%*d,%*d\n",2,eq,1,hs,1,chip,2,col,3,row,3,module,3,colM,3,rowM);
+    return returnMess.Data();
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyPixelAsTextC", "Index %d out of bounds.", index);
+    return returnMess.Data();
   }
 }
-
-void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
-  // print the dead pixels to screen
-  printf("-----------------------------------\n");
-  printf("Dead Pixels: (eqId,hs,chip,col,row)\n");
-  printf("-----------------------------------\n");
-  for (UInt_t module=0; module<240; module++) {
-    for (UInt_t index=0; index<GetNrDead(module); index++) {
-      Int_t key = fDeadPixelMap[module]->GetKeyIndex(index);
-      UInt_t eqId = GetEqIdFromKey(key);
-      UInt_t hs = GetHSFromKey(key);
-      UInt_t chip = GetChipFromKey(key);
-      UInt_t col = GetColFromKey(key);
-      UInt_t row = GetRowFromKey(key);
-      printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row);
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::AddDeadFrom(AliITSOnlineCalibrationSPDhandler* other) {
+  // returns number of new dead pixels in this' list
+  UInt_t returnval=0;
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t ind1=0; ind1<other->fNrDead[gloChip]; ind1++) {
+      UInt_t eq = other->GetDeadEqIdAtC2(gloChip,ind1);
+      UInt_t hs   = other->GetDeadHSAtC2(gloChip,ind1);
+      UInt_t chip = other->GetDeadChipAtC2(gloChip,ind1);
+      UInt_t col  = other->GetDeadColAtC2(gloChip,ind1);
+      UInt_t row  = other->GetDeadRowAtC2(gloChip,ind1);
+      if (SetDeadPixel(eq,hs,chip,col,row)) {
+       returnval++;
+      }
     }
   }
+  return returnval;
 }
-
-void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
-  // print the dead pixels to screen
-  printf("-----------------------------------\n");
-  printf("Noisy Pixels: (eqId,hs,chip,col,row)\n");
-  printf("-----------------------------------\n");
-  for (UInt_t module=0; module<240; module++) {
-    for (UInt_t index=0; index<GetNrNoisy(module); index++) {
-      Int_t key = fNoisyPixelMap[module]->GetKeyIndex(index);
-      UInt_t eqId = GetEqIdFromKey(key);
-      UInt_t hs = GetHSFromKey(key);
-      UInt_t chip = GetChipFromKey(key);
-      UInt_t col = GetColFromKey(key);
-      UInt_t row = GetRowFromKey(key);
-      printf("%d,%d,%d,%d,%d\n",eqId,hs,chip,col,row);
+UInt_t AliITSOnlineCalibrationSPDhandler::AddNoisyFrom(AliITSOnlineCalibrationSPDhandler* other) {
+  // returns number of new noisy pixels in this' list
+  UInt_t returnval=0;
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t ind1=0; ind1<other->fNrNoisy[gloChip]; ind1++) {
+      UInt_t eq = other->GetNoisyEqIdAtC2(gloChip,ind1);
+      UInt_t hs   = other->GetNoisyHSAtC2(gloChip,ind1);
+      UInt_t chip = other->GetNoisyChipAtC2(gloChip,ind1);
+      UInt_t col  = other->GetNoisyColAtC2(gloChip,ind1);
+      UInt_t row  = other->GetNoisyRowAtC2(gloChip,ind1);
+      if (SetNoisyPixel(eq,hs,chip,col,row)) {
+       returnval++;
+      }
     }
   }
+  return returnval;
+}
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const {
+  // returns nr of dead/noisy in this' lists and not in other's lists
+  return GetNrDeadDiff(other) + GetNrNoisyDiff(other);
 }
-
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns nr of dead in this' lists and not in other's lists
   UInt_t returnval=0;
-  for (UInt_t module=0; module<240; module++) {
-    for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
-      Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
-      UInt_t eqId = GetEqIdFromKey(key);
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
+      Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
+      UInt_t eq = GetEqIdFromKey(key);
       UInt_t hs = GetHSFromKey(key);
       UInt_t chip = GetChipFromKey(key);
       UInt_t col = GetColFromKey(key);
       UInt_t row = GetRowFromKey(key);
-      if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
+      if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
        returnval++;
       }
     }
   }
   return returnval;
 }
-
 UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns nr of noisy in this' lists and not in other's lists
   UInt_t returnval=0;
-  for (UInt_t module=0; module<240; module++) {
-    for (UInt_t ind1=0; ind1<fNrNoisy[module]; ind1++) {
-      Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind1);
-      UInt_t eqId = GetEqIdFromKey(key);
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t ind1=0; ind1<fNrNoisy[gloChip]; ind1++) {
+      Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind1);
+      UInt_t eq = GetEqIdFromKey(key);
       UInt_t hs = GetHSFromKey(key);
       UInt_t chip = GetChipFromKey(key);
       UInt_t col = GetColFromKey(key);
       UInt_t row = GetRowFromKey(key);
-      if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
+      if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
        returnval++;
       }
     }
   }
   return returnval;
 }
-
-UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const {
-  // returns nr of dead/noisy in this' lists and not in other's lists
-  return GetNrDeadDiff(other) + GetNrNoisyDiff(other);
-}
-
 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns handler with dead/noisy in this' lists, except for those in other's lists
   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
-  for (UInt_t module=0; module<240; module++) {
-    for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
-      Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
-      UInt_t eqId = GetEqIdFromKey(key);
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
+      Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
+      UInt_t eq = GetEqIdFromKey(key);
       UInt_t hs = GetHSFromKey(key);
       UInt_t chip = GetChipFromKey(key);
       UInt_t col = GetColFromKey(key);
       UInt_t row = GetRowFromKey(key);
-      if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
-       newHandler->SetDeadPixel(eqId,hs,chip,col,row);
+      if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
+       newHandler->SetDeadPixel(eq,hs,chip,col,row);
       }
     }
-    for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
-      Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
-      UInt_t eqId = GetEqIdFromKey(key);
+    for (UInt_t ind2=0; ind2<fNrNoisy[gloChip]; ind2++) {
+      Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind2);
+      UInt_t eq = GetEqIdFromKey(key);
       UInt_t hs = GetHSFromKey(key);
       UInt_t chip = GetChipFromKey(key);
       UInt_t col = GetColFromKey(key);
       UInt_t row = GetRowFromKey(key);
-      if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
-       newHandler->SetNoisyPixel(eqId,hs,chip,col,row);
+      if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
+       newHandler->SetNoisyPixel(eq,hs,chip,col,row);
       }
     }
   }
   return newHandler;
 }
-
 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns handler with dead in this' lists, except for those in other's lists
   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
-  for (UInt_t module=0; module<240; module++) {
-    for (UInt_t ind1=0; ind1<fNrDead[module]; ind1++) {
-      Int_t key = fDeadPixelMap[module]->GetKeyIndex(ind1);
-      UInt_t eqId = GetEqIdFromKey(key);
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t ind1=0; ind1<fNrDead[gloChip]; ind1++) {
+      Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(ind1);
+      UInt_t eq = GetEqIdFromKey(key);
       UInt_t hs = GetHSFromKey(key);
       UInt_t chip = GetChipFromKey(key);
       UInt_t col = GetColFromKey(key);
       UInt_t row = GetRowFromKey(key);
-      if (!(other->IsPixelDead(eqId,hs,chip,col,row))) {
-       newHandler->SetDeadPixel(eqId,hs,chip,col,row);
+      if (!(other->IsPixelDead(eq,hs,chip,col,row))) {
+       newHandler->SetDeadPixel(eq,hs,chip,col,row);
       }
     }
   }
   return newHandler;
 }
-
 AliITSOnlineCalibrationSPDhandler* AliITSOnlineCalibrationSPDhandler::GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const {
   // returns handler with noisy in this' lists, except for those in other's lists
   AliITSOnlineCalibrationSPDhandler* newHandler = new AliITSOnlineCalibrationSPDhandler();
-  for (UInt_t module=0; module<240; module++) {
-    for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
-      Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
-      UInt_t eqId = GetEqIdFromKey(key);
+  for (UInt_t gloChip=0; gloChip<1200; gloChip++) {
+    for (UInt_t ind2=0; ind2<fNrNoisy[gloChip]; ind2++) {
+      Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(ind2);
+      UInt_t eq = GetEqIdFromKey(key);
       UInt_t hs = GetHSFromKey(key);
       UInt_t chip = GetChipFromKey(key);
       UInt_t col = GetColFromKey(key);
       UInt_t row = GetRowFromKey(key);
-      if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
-       newHandler->SetNoisyPixel(eqId,hs,chip,col,row);
+      if (!(other->IsPixelNoisy(eq,hs,chip,col,row))) {
+       newHandler->SetNoisyPixel(eq,hs,chip,col,row);
       }
     }
   }
   return newHandler;
 }
+//____________________________________________________________________________________________
+void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
+  // find gloChip and chipIndex from module and index
+  if (index<GetNrDead(module)) {
+    UInt_t eq = GetEqIdFromOffline(module);
+    UInt_t hs = GetHSFromOffline(module);
+    
+    UInt_t glVal=0;
+    for (UInt_t chip=0; chip<5; chip++) {
+      gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+      if (glVal+fNrDead[gloChip]>index) {
+       chipIndex = index-glVal;
+       break;
+      }
+      else {
+       glVal+=fNrDead[gloChip];
+      }
+    }
 
-void AliITSOnlineCalibrationSPDhandler::InitModuleMaps() {
-  // initializes the module mapping arrays needed for the methods below (GetEqIdFromOffline etc.)
-  for (UInt_t iDDL=0; iDDL<20; iDDL++) {
-    for (UInt_t iModule=0; iModule<12; iModule++) {
-      UInt_t module = AliITSRawStreamSPD::GetModuleNumber(iDDL,iModule);
-      fiDDL[module] = iDDL;
-      fiModule[module] = iModule;
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexDead", "Index %d out of bounds.", index);
+  }
+}
+void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
+  // find gloChip and chipIndex from module and index
+  if (index<GetNrNoisy(module)) {
+    UInt_t eq = GetEqIdFromOffline(module);
+    UInt_t hs = GetHSFromOffline(module);
+    
+    UInt_t glVal=0;
+    for (UInt_t chip=0; chip<5; chip++) {
+      gloChip = GetGloChip(eq,hs,GetChipFromOffline(module,chip*32));
+      if (glVal+fNrNoisy[gloChip]>index) {
+       chipIndex = index-glVal;
+       break;
+      }
+      else {
+       glVal+=fNrNoisy[gloChip];
+      }
     }
+
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexNoisy", "Index %d out of bounds.", index);
   }
 }
+void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
+  // find gloChip and chipIndex from module and index
+  if (index<GetNrDeadEq(eq)) {
 
-void AliITSOnlineCalibrationSPDhandler::GenerateDCSConfigFile(const Char_t* fileName) {
-  // generates an ascii file in the format as the one produced by online da (but with dummy runNr=0)
-  ofstream dcsfile;
-  dcsfile.open(fileName);
-  dcsfile << "[SPD SCAN]\n";
-  dcsfile << "RunNumber=" << "0" << "\n"; // dummy value
-  dcsfile << "Type=" << "4" << "\n";
-  dcsfile << "Router=" << "0" << "\n"; // dummy value
-  dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values
-  dcsfile << "[NOISY]\n";
-  for (UInt_t module=0; module<240; module++) {
-    UInt_t headkey=20*10*6;
-    for (UInt_t ind=0; ind<fNrNoisy[module]; ind++) {
-      UInt_t newkey = GetNoisyEqIdAt(module,ind)*10*6 +
-       GetNoisyHSAt(module,ind)*10 +
-       GetNoisyChipAt(module,ind);
-      if (newkey!=headkey) { // print eqId,hs,chip header
-       headkey = newkey;
-       dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
+    UInt_t glVal=0;
+    for (UInt_t hs=0; hs<6; hs++) {
+      for (UInt_t chip=0; chip<10; chip++) {
+       gloChip = GetGloChip(eq,hs,chip);
+       if (glVal+fNrDead[gloChip]>index) {
+         chipIndex = index-glVal;
+         break;
+       }
+       else {
+         glVal+=fNrDead[gloChip];
+       }
       }
-      dcsfile << GetNoisyColAt(module,ind) << "," << GetNoisyRowAt(module,ind) << "\n";
     }
+
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqDead", "Index %d out of bounds.", index);
   }
-  dcsfile.close();
 }
+void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
+  // find gloChip and chipIndex from module and index
+  if (index<GetNrNoisyEq(eq)) {
+
+    UInt_t glVal=0;
+    for (UInt_t hs=0; hs<6; hs++) {
+      for (UInt_t chip=0; chip<10; chip++) {
+       gloChip = GetGloChip(eq,hs,chip);
+       if (glVal+fNrNoisy[gloChip]>index) {
+         chipIndex = index-glVal;
+         break;
+       }
+       else {
+         glVal+=fNrNoisy[gloChip];
+       }
+      }
+    }
+
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexEqNoisy", "Index %d out of bounds.", index);
+  }
+}
+void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
+  // find gloChip and chipIndex from global index
+  if (index<GetNrDead()) {
+    
+    UInt_t glVal=0;
+    for (gloChip=0; gloChip<1200; gloChip++) {
+      if (glVal+fNrDead[gloChip]>index) {
+       chipIndex = index-glVal;
+       break;
+      }
+      else {
+       glVal+=fNrDead[gloChip];
+      }
+    }
+
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotDead", "Index %d out of bounds.", index);
+  }
+}
+void AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex) {
+  // find gloChip and chipIndex from global index
+  if (index<GetNrNoisy()) {
+    
+    UInt_t glVal=0;
+    for (gloChip=0; gloChip<1200; gloChip++) {
+      if (glVal+fNrNoisy[gloChip]>index) {
+       chipIndex = index-glVal;
+       break;
+      }
+      else {
+       glVal+=fNrNoisy[gloChip];
+      }
+    }
 
-UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) {
-  // module to eqId mapping
-  if (!fModuleMapInited) InitModuleMaps();
-  return fiDDL[module];
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetChipAndIndexTotNoisy", "Index %d out of bounds.", index);
+  }
+}
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) const {
+  // module to eq mapping
+  if (module>=240) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline", "module nr (%d) out of bounds.",module);
+    return 20;
+  }
+  return AliITSRawStreamSPD::GetOnlineEqIdFromOffline(module);
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) {
+UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) const {
   // module to hs mapping
-  if (!fModuleMapInited) InitModuleMaps();
-  return fiModule[module]/2;
+  if (module>=240) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetHSFromOffline", "module nr (%d) out of bounds.",module);
+    return 6;
+  }
+  return AliITSRawStreamSPD::GetOnlineHSFromOffline(module);
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) {
+UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) const {
   // module,colM to chip mapping
-  if (!fModuleMapInited) InitModuleMaps();
-  return colM/32 + 5*(fiModule[module]%2);
+  if (module>=240 || colM>=160) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetChipFromOffline", "module,colM nrs (%d,%d) out of bounds.",module,colM);
+    return 10;
+  }
+  return AliITSRawStreamSPD::GetOnlineChipFromOffline(module,colM);
 }
-UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t colM) const {
+UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t module, UInt_t colM) const {
   // colM to col mapping
-  return colM%32;
+  if (colM>=160) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetColFromOffline", "colM nr (%d) out of bounds.",colM);
+    return 160;
+  }
+  return AliITSRawStreamSPD::GetOnlineColFromOffline(module,colM);
 }
+
+UInt_t AliITSOnlineCalibrationSPDhandler::GetRowFromOffline(UInt_t module, UInt_t rowM) const {
+  // rowM to row mapping
+  if (rowM>=256) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetRowFromOffline", "rowM nr (%d) out of bounds.",rowM);
+    return 256;
+  }
+  return AliITSRawStreamSPD::GetOnlineRowFromOffline(module,rowM);
+}
+//____________________________________________________________________________________________
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDeadC2(UInt_t gloChip) const {
+  // returns nr of dead pixels on this chip
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNrDeadC2", "global chip nr (%d) out of bounds.",gloChip);
+    return 0;
+  }
+  return fNrDead[gloChip];
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2(UInt_t gloChip) const {
+  // returns nr of noisy pixels on this chip
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNrNoisyC2", "global chip nr (%d) out of bounds.",gloChip);
+    return 0;
+  }
+  return fNrNoisy[gloChip];
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC2(UInt_t gloChip, UInt_t index) const {
+  // get eq for the dead pixel at position index in list of dead
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrDead[gloChip]) {
+    Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+    return GetEqIdFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC2(UInt_t gloChip, UInt_t index) const {
+  // get eq for the noisy pixel at position index in list of noisy
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrNoisy[gloChip]) {
+    Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+    return GetEqIdFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyEqIdAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC2(UInt_t gloChip, UInt_t index) const {
+  // get hs for the dead pixel at position index in list of dead
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrDead[gloChip]) {
+    Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+    return GetHSFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadHSAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC2(UInt_t gloChip, UInt_t index) const {
+  // get hs for the noisy pixel at position index in list of noisy
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrNoisy[gloChip]) {
+    Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+    return GetHSFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC2(UInt_t gloChip, UInt_t index) const {
+  // get chip for the dead pixel at position index in list of dead
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrDead[gloChip]) {
+    Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+    return GetChipFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadChipAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC2(UInt_t gloChip, UInt_t index) const {
+  // get chip for the noisy pixel at position index in list of noisy
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrNoisy[gloChip]) {
+    Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+    return GetChipFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2(UInt_t gloChip, UInt_t index) const {
+  // get col for the dead pixel at position index in list of dead
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrDead[gloChip]) {
+    Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+    return GetColFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadColAtC2", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC2(UInt_t gloChip, UInt_t index) const {
+  // get col for the noisy pixel at position index in list of noisy
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrNoisy[gloChip]) {
+    Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+    return GetColFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyColAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC2(UInt_t gloChip, UInt_t index) const {
+  // get row for the dead pixel at position index in list of dead
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrDead[gloChip]) {
+    Int_t key = fDeadPixelMap[gloChip]->GetKeyIndex(index);
+    return GetRowFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadRowAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC2(UInt_t gloChip, UInt_t index) const {
+  // get row for the noisy pixel at position index in list of noisy
+  if (gloChip>=1200) {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "global chip nr (%d) out of bounds.",gloChip);
+    return 20;
+  }
+  if (index<fNrNoisy[gloChip]) {
+    Int_t key = fNoisyPixelMap[gloChip]->GetKeyIndex(index);
+    return GetRowFromKey(key);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAtC", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
index 248d5a6..36cb815 100644 (file)
@@ -1,11 +1,6 @@
 #ifndef ALI_ITS_ONLINECALIBRATIONSPDHANDLER_H
 #define ALI_ITS_ONLINECALIBRATIONSPDHANDLER_H
 
-/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
 //////////////////////////////////////////////////////////////////////////
 // Author: Henrik Tydesjo                                               //
 // Class that  simplifies the managing of dead and noisy pixels.        //
 // through reading and writing to TFile.                                //
 //////////////////////////////////////////////////////////////////////////
 
-
 #include "AliITSRawStreamSPD.h"
 #include <TString.h>
 
 class TArrayI;
 class AliITSIntMap;
+class AliITSCalibrationSPD;
 
 class AliITSOnlineCalibrationSPDhandler {
 
@@ -32,73 +27,133 @@ class AliITSOnlineCalibrationSPDhandler {
   TString GetFileLocation() const {return fFileLocation;}
 
   void    ClearMaps();
+  void    ResetDead();
+  void    ResetNoisy();
+  void    ResetDeadForChip(UInt_t eq, UInt_t hs, UInt_t chip);
+  void    ResetNoisyForChip(UInt_t eq, UInt_t hs, UInt_t chip);
+  void    ResetDeadForEq(UInt_t eq);
+  void    ResetNoisyForEq(UInt_t eq);
 
   Bool_t  ReadFromFiles();
   Bool_t  ReadDeadFromFiles();
   Bool_t  ReadNoisyFromFiles();
-  Bool_t  ReadFromFile(UInt_t module);
-  Bool_t  ReadDeadFromFile(UInt_t module);
-  Bool_t  ReadNoisyFromFile(UInt_t module);
-  Bool_t  ReadFromFileName(const char *fileName);
+  Bool_t  ReadDeadFromFile(UInt_t eq);
+  Bool_t  ReadNoisyFromFile(UInt_t eq);
   Bool_t  ReadDeadFromFileName(const char *fileName);
   Bool_t  ReadNoisyFromFileName(const char *fileName);
+  UInt_t  ReadDeadFromText(const char *fileName, UInt_t module);
+  UInt_t  ReadNoisyFromText(const char *fileName, UInt_t module);
 
   void    WriteToFilesAlways();
-  void    WriteToFiles();
-  void    WriteDeadToFiles();
-  void    WriteNoisyToFiles();
-  void    WriteToFile(UInt_t module);  
-  void    WriteDeadToFile(UInt_t module);
-  void    WriteNoisyToFile(UInt_t module);
+  UInt_t  WriteToFiles();
+  void    WriteDeadToFilesAlways();
+  void    WriteNoisyToFilesAlways();
+  UInt_t  WriteDeadToFiles();
+  UInt_t  WriteNoisyToFiles();
+  void    WriteDeadToFile(UInt_t eq);
+  void    WriteNoisyToFile(UInt_t eq);
 
 #ifndef SPD_DA_OFF
-  Bool_t  ReadModuleFromDB(UInt_t module, Int_t runNr);
-  Bool_t  ReadFromDB(Int_t runNr);
+  Bool_t  ReadDeadModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial=kFALSE);
+  Bool_t  ReadNoisyModuleFromDB(UInt_t module, Int_t runNr, Bool_t treeSerial=kFALSE);
+  Bool_t  ReadFromDB(Int_t runNr, Bool_t treeSerial=kFALSE);
+  Bool_t  ReadDeadFromDB(Int_t runNr, Bool_t treeSerial=kFALSE);
+  Bool_t  ReadNoisyFromDB(Int_t runNr, Bool_t treeSerial=kFALSE);
+  Bool_t  ReadDeadFromCalibObj(TObjArray* calObj);
+  Bool_t  ReadNoisyFromCalibObj(TObjArray* calObj);
   Bool_t  WriteToDB(Int_t runNrStart, Int_t runNrEnd);
+  Bool_t  WriteDeadToDB(Int_t runNrStart, Int_t runNrEnd);
+  Bool_t  WriteNoisyToDB(Int_t runNrStart, Int_t runNrEnd);
 #endif
-  UInt_t  ReadNoisyFromText(const char *fileName);
-  UInt_t  ReadDeadFromText(const char *fileName);
-  void    GenerateDCSConfigFile(const Char_t* fileName);
 
-  TArrayI GetDeadArray(UInt_t module);
-  TArrayI GetNoisyArray(UInt_t module);
+  void    GenerateDCSConfigFile(const Char_t* fileName);
 
-  void    ResetDead();
-  void    ResetDeadForChip(UInt_t eqId, UInt_t hs, UInt_t chip);
-  Bool_t  SetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
-  Bool_t  SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row);
-  Bool_t  UnSetDeadPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
-  Bool_t  UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row);
-  Bool_t  IsPixelDead(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const;
-  Bool_t  IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t row);
+  TArrayI GetDeadArray(UInt_t module, Bool_t treeSerial=kFALSE);
+  TArrayI GetNoisyArray(UInt_t module, Bool_t treeSerial=kFALSE);
+  TArrayI GetDeadArrayOnline(UInt_t eq);
+  TArrayI GetNoisyArrayOnline(UInt_t eq);
 
-  UInt_t  GetNrDead(UInt_t module) const;
-  UInt_t  GetDeadEqIdAt(UInt_t module,UInt_t index);
-  UInt_t  GetDeadHSAt(UInt_t module,UInt_t index);
-  UInt_t  GetDeadChipAt(UInt_t module,UInt_t index);
-  UInt_t  GetDeadColAt(UInt_t module,UInt_t index);
-  UInt_t  GetDeadRowAt(UInt_t module,UInt_t index);
+  void    PrintEqSummary();
+  void    PrintDead() const;
+  void    PrintNoisy() const;
 
-  void    ResetNoisy();
-  void    ResetNoisyForChip(UInt_t eqId, UInt_t hs, UInt_t chip);
-  Bool_t  SetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
+  Bool_t  SetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
+  Bool_t  SetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
+  Bool_t  SetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row);
   Bool_t  SetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row);
-  Bool_t  UnSetNoisyPixel(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
+  Bool_t  UnSetDeadPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
+  Bool_t  UnSetNoisyPixel(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row);
+  Bool_t  UnSetDeadPixelM(UInt_t module, UInt_t colM, UInt_t row);
   Bool_t  UnSetNoisyPixelM(UInt_t module, UInt_t colM, UInt_t row);
-  Bool_t  IsPixelNoisy(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const;
-  Bool_t  IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t row);
+  UInt_t  SetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip);
+  UInt_t  SetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip);
+  Bool_t  UnSetDeadChip(UInt_t eq, UInt_t hs, UInt_t chip);
+  Bool_t  UnSetNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip);
+
+  Bool_t  IsPixelDead(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const;
+  Bool_t  IsPixelNoisy(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const;
+  Bool_t  IsPixelDeadM(UInt_t module, UInt_t colM, UInt_t row) const;
+  Bool_t  IsPixelNoisyM(UInt_t module, UInt_t colM, UInt_t row) const;
+  Bool_t  IsPixelDeadKey(Int_t key) const;
+  Bool_t  IsPixelNoisyKey(Int_t key) const;
 
+  UInt_t  GetNrDead() const;
+  UInt_t  GetNrNoisy() const;
+  UInt_t  GetDeadEqIdAt(UInt_t index);
+  UInt_t  GetNoisyEqIdAt(UInt_t index);
+  UInt_t  GetDeadHSAt(UInt_t index);
+  UInt_t  GetNoisyHSAt(UInt_t index);
+  UInt_t  GetDeadChipAt(UInt_t index);
+  UInt_t  GetNoisyChipAt(UInt_t index);
+  UInt_t  GetDeadColAt(UInt_t index);
+  UInt_t  GetNoisyColAt(UInt_t index);
+  UInt_t  GetDeadRowAt(UInt_t index);
+  UInt_t  GetNoisyRowAt(UInt_t index);
+
+  UInt_t  GetNrDead(UInt_t module) const;
   UInt_t  GetNrNoisy(UInt_t module) const;
+  UInt_t  GetDeadEqIdAt(UInt_t module,UInt_t index);
   UInt_t  GetNoisyEqIdAt(UInt_t module, UInt_t index);
+  UInt_t  GetDeadHSAt(UInt_t module,UInt_t index);
   UInt_t  GetNoisyHSAt(UInt_t module, UInt_t index);
+  UInt_t  GetDeadChipAt(UInt_t module,UInt_t index);
   UInt_t  GetNoisyChipAt(UInt_t module, UInt_t index);
+  UInt_t  GetDeadColAt(UInt_t module,UInt_t index);
   UInt_t  GetNoisyColAt(UInt_t module, UInt_t index);
+  UInt_t  GetDeadRowAt(UInt_t module,UInt_t index);
   UInt_t  GetNoisyRowAt(UInt_t module, UInt_t index);
 
-  UInt_t  GetNrDead() const;
-  UInt_t  GetNrNoisy() const;
-  void    PrintDead() const;
-  void    PrintNoisy() const;
+  UInt_t  GetNrDeadEq(UInt_t eq) const;
+  UInt_t  GetNrNoisyEq(UInt_t eq) const;
+  UInt_t  GetDeadEqIdAtEq(UInt_t eq, UInt_t index) const;
+  UInt_t  GetNoisyEqIdAtEq(UInt_t eq, UInt_t index) const;
+  UInt_t  GetDeadHSAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetNoisyHSAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetDeadChipAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetNoisyChipAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetDeadColAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetNoisyColAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetDeadRowAtEq(UInt_t eq, UInt_t index);
+  UInt_t  GetNoisyRowAtEq(UInt_t eq, UInt_t index);
+
+  UInt_t  GetNrDeadC(UInt_t eq, UInt_t hs, UInt_t chip) const;
+  UInt_t  GetNrNoisyC(UInt_t eq, UInt_t hs, UInt_t chip) const;
+  UInt_t  GetDeadEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNoisyEqIdAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetDeadHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNoisyHSAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetDeadChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNoisyChipAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetDeadColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNoisyColAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetDeadRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  UInt_t  GetNoisyRowAtC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+
+  const Char_t* GetDeadPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+  const Char_t* GetNoisyPixelAsTextC(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t index) const;
+
+  UInt_t  AddDeadFrom(AliITSOnlineCalibrationSPDhandler* other);
+  UInt_t  AddNoisyFrom(AliITSOnlineCalibrationSPDhandler* other);
 
   UInt_t  GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const;
   UInt_t  GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const;
@@ -109,19 +164,14 @@ class AliITSOnlineCalibrationSPDhandler {
 
 
  private:
-  TString fFileLocation;             // location (dir) of files to read and write from
-  AliITSIntMap* fDeadPixelMap[240];  // lists of dead pixels for each module
-  AliITSIntMap* fNoisyPixelMap[240]; // lists of noisy pixels for each module
-  UInt_t fNrDead[240];               // nr of dead pixels for each module
-  UInt_t fNrNoisy[240];              // nr of noisy pixels for each module
+  TString fFileLocation;              // location (dir) of files to read and write from
+  AliITSIntMap* fDeadPixelMap[1200];  // lists of dead pixels for each chip
+  AliITSIntMap* fNoisyPixelMap[1200]; // lists of noisy pixels for each chip
+  UInt_t fNrDead[1200];               // nr of dead pixels for each chip
+  UInt_t fNrNoisy[1200];              // nr of noisy pixels for each chip
                                     
-  Bool_t fModuleMapInited;           // flag to know if arrays below are filled 
-  UInt_t fiDDL[240];                 // iDDL value for each module (inited when used, fModuleMapInited flag)
-  UInt_t fiModule[240];              // iModule value for each module (inited when used, fModuleMapInited flag)
-
-  Int_t    GetKey(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const 
-    {return eqId*6*10*32*256 + hs*10*32*256 + chip*32*256 + col*256 + row;}
-
+  Int_t    GetKey(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row) const 
+    {return eq*6*10*32*256 + hs*10*32*256 + chip*32*256 + col*256 + row;}
   UInt_t   GetEqIdFromKey(Int_t key) const 
     {return key/(6*10*32*256);}
   UInt_t   GetHSFromKey(Int_t key) const 
@@ -133,20 +183,43 @@ class AliITSOnlineCalibrationSPDhandler {
   UInt_t   GetRowFromKey(Int_t key) const 
     {return (((key%(6*10*32*256))%(10*32*256))%(32*256))%256;}
   UInt_t   GetModuleFromKey(Int_t key) const
-    {return AliITSRawStreamSPD::GetModuleNumber(GetEqIdFromKey(key),GetHSFromKey(key),GetChipFromKey(key));}
+    {return AliITSRawStreamSPD::GetOfflineModuleFromOnline(GetEqIdFromKey(key),GetHSFromKey(key),GetChipFromKey(key));}
   UInt_t   GetColMFromKey(Int_t key) const 
-    {return GetColFromKey(key) + 32 * (GetChipFromKey(key) % 5);}
-
-  void     InitModuleMaps();
-  UInt_t   GetEqIdFromOffline(UInt_t module);
-  UInt_t   GetHSFromOffline(UInt_t module);
-  UInt_t   GetChipFromOffline(UInt_t module, UInt_t colM);
-  UInt_t   GetColFromOffline(UInt_t colM) const;
-
-  Bool_t   IsPixelDeadKey(Int_t key) const;
-  Bool_t   IsPixelDeadMKey(UInt_t module, Int_t key) const;
-  Bool_t   IsPixelNoisyKey(Int_t key) const;
-  Bool_t   IsPixelNoisyMKey(UInt_t module, Int_t key) const;
+    {return AliITSRawStreamSPD::GetOfflineColFromOnline(GetEqIdFromKey(key),GetHSFromKey(key),GetChipFromKey(key),GetColFromKey(key));}
+  UInt_t   GetRowMFromKey(Int_t key) const 
+    {return AliITSRawStreamSPD::GetOfflineRowFromOnline(GetEqIdFromKey(key),GetHSFromKey(key),GetChipFromKey(key),GetRowFromKey(key));}
+  
+  UInt_t   GetGloChip(UInt_t eq, UInt_t hs, UInt_t chip) const
+    {return eq*6*10 + hs*10 + chip;}
+
+  void     GetChipAndIndexDead(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex);
+  void     GetChipAndIndexNoisy(UInt_t module, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex);
+  void     GetChipAndIndexEqDead(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex);
+  void     GetChipAndIndexEqNoisy(UInt_t eq, UInt_t index, UInt_t& gloChip, UInt_t& chipIndex);
+  void     GetChipAndIndexTotDead(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex);
+  void     GetChipAndIndexTotNoisy(UInt_t index, UInt_t& gloChip, UInt_t& chipIndex);
+
+  UInt_t   GetEqIdFromOffline(UInt_t module) const;
+  UInt_t   GetHSFromOffline(UInt_t module) const;
+  UInt_t   GetChipFromOffline(UInt_t module, UInt_t colM) const;
+  UInt_t   GetColFromOffline(UInt_t module, UInt_t colM) const;
+  UInt_t   GetRowFromOffline(UInt_t module, UInt_t rowM) const;
+
+  void     RecursiveInsertDead(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd);
+  void     RecursiveInsertNoisy(AliITSCalibrationSPD* calibSPD, UInt_t module, Int_t lowInd, Int_t highInd);
+
+  UInt_t   GetNrDeadC2(UInt_t gloChip) const;
+  UInt_t   GetNrNoisyC2(UInt_t gloChip) const;
+  UInt_t   GetDeadEqIdAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetNoisyEqIdAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetDeadHSAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetNoisyHSAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetDeadChipAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetNoisyChipAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetDeadColAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetNoisyColAtC2(UInt_t gloChip, UInt_t index) const;
+  UInt_t   GetDeadRowAtC2(UInt_t gloChip, UInt_t index) const;   
+  UInt_t   GetNoisyRowAtC2(UInt_t gloChip, UInt_t index) const;
 
 };
 
index 7b9ec5d..0a3b522 100644 (file)
@@ -7,7 +7,7 @@
 // One object for each half stave and step in a scan. It keeps //
 // the nr of hits in each pixel.                               //
 // This class should only be used through the interface of the //
-// AliITSOnlineSPDscan class.                                  //
+// AliITSOnlineSPDscan and AliITSOnlineSPDphys classes.        //
 /////////////////////////////////////////////////////////////////
 
 #include <TObject.h>
diff --git a/ITS/AliITSOnlineSPDphys.cxx b/ITS/AliITSOnlineSPDphys.cxx
new file mode 100644 (file)
index 0000000..635211a
--- /dev/null
@@ -0,0 +1,273 @@
+////////////////////////////////////////////////////////////
+// Author: Henrik Tydesjo                                 //
+// Interface class to the containers of an online scan.   //
+// Directly connected to a TFile with all containers.     //
+// Handles reading and writing of this TFile. Hitmaps are //
+// stored in this file (AliITSOnlineSPDHitArray).         //
+// Also some general information is stored                //
+// (AliITSOnlineSPDphysInfo).                             //
+////////////////////////////////////////////////////////////
+
+#include <math.h>
+
+#include <TFile.h>
+#include "AliITSOnlineSPDphys.h"
+#include "AliITSOnlineSPDphysInfo.h"
+#include "AliITSOnlineSPDHitArray.h"
+
+AliITSOnlineSPDphys::AliITSOnlineSPDphys(const Char_t *fileName) :
+  fFile(NULL),
+  fWrite(kFALSE),
+  fModified(kFALSE),
+  fInfoModified(kFALSE),
+  fPhysInfo(NULL),
+  fFileName(fileName)
+{
+  // constructor, open file for reading or writing
+  // look for a previously saved info object 
+  // (if file not found create a new one and return, else read)
+  FILE* fp0 = fopen(fFileName.Data(), "r");
+  if (fp0 == NULL) {
+    fPhysInfo = new AliITSOnlineSPDphysInfo();
+    fInfoModified=kTRUE;
+    fFile = new TFile(fFileName.Data(), "RECREATE");
+    fWrite=kTRUE;
+    InitHitmap();
+  }
+  else {
+    fclose(fp0);
+    fFile = new TFile(fFileName.Data(), "READ");
+    fWrite=kFALSE;
+    fFile->GetObject("AliITSOnlineSPDphysInfo", fPhysInfo);
+    ReadHitmap();
+  }
+}
+
+AliITSOnlineSPDphys::AliITSOnlineSPDphys(const AliITSOnlineSPDphys& /*phys*/) :
+  fFile(NULL),
+  fWrite(kFALSE),
+  fModified(kFALSE),
+  fInfoModified(kFALSE),
+  fPhysInfo(NULL),
+  fFileName(".")
+{
+  printf("This object should not be copied!");
+}
+
+AliITSOnlineSPDphys::~AliITSOnlineSPDphys() {
+  // destructor
+  if (fModified) {
+    SaveHitmap();
+  }
+  for (UInt_t hs=0; hs<6; hs++) {
+    if (fHitArray[hs]!=NULL) {
+      delete fHitArray[hs];
+      fHitArray[hs]=NULL;
+    }
+  }
+  if (fInfoModified) {
+    if (!fWrite) {
+      fFile->Close();
+      delete fFile;
+      fFile = new TFile(fFileName.Data(), "UPDATE");
+      fWrite=kTRUE;
+    }
+    fFile->Delete("AliITSOnlineSPDphysInfo;*");
+    fFile->WriteTObject(fPhysInfo, "AliITSOnlineSPDphysInfo");
+    fFile->Close();
+    delete fFile;
+  }
+}
+
+AliITSOnlineSPDphys& AliITSOnlineSPDphys::operator=(const AliITSOnlineSPDphys& phys) {
+  // assignment operator (should not be used)
+  printf("This object should not be copied!");
+  if (this!=&phys) {
+    // still do nothing...
+  }
+  return *this;
+}
+
+void AliITSOnlineSPDphys::ClearThis() {
+  // clear this phys, close file and open new
+  for (UInt_t hs=0; hs<6; hs++) {
+    if (fHitArray[hs]!=NULL) {
+      delete fHitArray[hs];
+    }
+    fHitArray[hs] = NULL;
+  }
+  InitHitmap();
+  fPhysInfo->ClearThis();
+  fFile->Close();
+  delete fFile;
+  fFile = new TFile(fFileName.Data(), "RECREATE");
+  fWrite=kTRUE;
+  fFile->WriteTObject(fPhysInfo, "AliITSOnlineSPDphysInfo");
+  fInfoModified=kTRUE;
+}
+
+void AliITSOnlineSPDphys::InitHitmap() {
+  // init hit arrays and hit events
+  for (UInt_t hs=0; hs<6; hs++) {
+    fHitArray[hs] = new AliITSOnlineSPDHitArray();
+  }
+  fModified=kTRUE;
+}
+
+void AliITSOnlineSPDphys::AddPhys(AliITSOnlineSPDphys* phys2) {
+  // add hitmap and info from another phys object
+  if (phys2==NULL) return;
+  if (GetEqNr()!=phys2->GetEqNr() && GetEqNr()!=999) {
+    printf("AliITSOnlineSPDphys::AddPhys eqNr mismatch!\n");
+    return;
+  }
+  if (GetEqNr()==999) {
+    SetEqNr(phys2->GetEqNr());
+  }
+  UInt_t nrRuns = phys2->GetNrRuns();
+  for (UInt_t i=0; i<nrRuns; i++) {
+    AddRunNr(phys2->GetRunNr(i));
+  }
+  SetNrEvents(GetNrEvents() + phys2->GetNrEvents());
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      for (UInt_t col=0; col<32; col++) {
+       for (UInt_t row=0; row<256; row++) {
+         SetHits(hs,chip,col,row,GetHits(hs,chip,col,row)+phys2->GetHits(hs,chip,col,row));
+       }
+      }
+    }
+  }
+}
+
+void AliITSOnlineSPDphys::ReadHitmap() {
+  // read hitmap into memory
+  for (UInt_t hs=0; hs<6; hs++) {
+    TString hName = Form("HitArray_HS%d",hs);
+    fFile->GetObject(hName.Data(), fHitArray[hs]);
+  }
+}
+
+void AliITSOnlineSPDphys::SaveHitmap() {
+  // save hitmap to file
+  if (!fWrite) {
+    fFile->Close();
+    delete fFile;
+    fFile = new TFile(fFileName.Data(), "UPDATE");
+    fWrite=kTRUE;
+  }
+  for (UInt_t hs=0; hs<6; hs++) {
+    TString hName = Form("HitArray_HS%d",hs);
+    TString hDelete = Form("%s;*",hName.Data());
+    fFile->Delete(hDelete.Data());
+    fFile->WriteTObject(fHitArray[hs], hName.Data());
+  }
+  fModified=kFALSE;
+}
+
+void AliITSOnlineSPDphys::SetHits(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi, UInt_t val) {
+  // set nr of hits for pixel
+  fHitArray[hs]->SetHits(chipi,coli,rowi,val);
+  fModified=kTRUE;
+}
+void AliITSOnlineSPDphys::AddHits(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi, Int_t val) {
+  // add val nr of hits for pixel (val could be negative)
+  Int_t summedVal = fHitArray[hs]->GetHits(chipi,coli,rowi)+val;
+  if (summedVal>0) {
+    fHitArray[hs]->SetHits(chipi,coli,rowi,(UInt_t)summedVal);
+  }
+  else {
+    fHitArray[hs]->SetHits(chipi,coli,rowi,0);
+  }
+  fModified=kTRUE;
+}
+void AliITSOnlineSPDphys::IncrementHits(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
+  // increment nr of hits for pixel
+  fHitArray[hs]->IncrementHits(chipi,coli,rowi);
+  fModified=kTRUE;
+}
+
+UInt_t AliITSOnlineSPDphys::GetHits(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
+  // get nr of hits for pixel
+  return fHitArray[hs]->GetHits(chipi,coli,rowi);
+}
+Float_t AliITSOnlineSPDphys::GetHitsEfficiency(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
+  // get the hit efficiency for pixel
+  UInt_t ntr = GetNrEvents();
+  if (ntr>0) {
+    return ((Float_t)GetHits(hs,chipi,coli,rowi))/ntr;
+  }
+  else {
+    return 0;
+  }
+}
+Float_t AliITSOnlineSPDphys::GetHitsEfficiencyError(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
+  // get error in hit efficiency for pixel
+  Float_t hits = GetHits(hs,chipi,coli,rowi);
+  UInt_t ntr = GetNrEvents();
+  return sqrt(hits*(ntr-hits)/ntr)/ntr;
+}
+Float_t AliITSOnlineSPDphys::GetAverageMultiplicity(UInt_t hs, UInt_t chipi) {
+  // get average multiplicity for a chip
+  Float_t nrhits = 0;
+  for (UInt_t chip=0;chip<10;chip++) {
+    if (chipi==10 || chip==chipi) {
+      for (Int_t col=0; col<32; col++) {
+       for (Int_t row=0; row<256; row++) {
+         nrhits+=GetHits(hs,chip,col,row);
+       }
+      }
+    }
+  }
+  UInt_t ntr = GetNrEvents();
+  if (ntr>0) {
+    return nrhits/ntr;
+  }
+  else {
+    return 0;
+  }
+}
+Float_t AliITSOnlineSPDphys::GetAverageMultiplicityTot(UInt_t hs) {
+  // get average multiplicity for 10 chips
+  return GetAverageMultiplicity(hs,10);
+}
+
+void AliITSOnlineSPDphys::AddRunNr(UInt_t val) {
+  // add a run nr
+  fPhysInfo->AddRunNr(val);
+  fInfoModified=kTRUE;
+}
+void AliITSOnlineSPDphys::SetEqNr(UInt_t val) {
+  // set router nr
+  fPhysInfo->SetEqNr(val);
+  fInfoModified=kTRUE;
+}
+void AliITSOnlineSPDphys::SetNrEvents(UInt_t val) {
+  // set nr of events
+  fPhysInfo->SetNrEvents(val);
+  fInfoModified=kTRUE;
+}
+void AliITSOnlineSPDphys::AddNrEvents(Int_t val) {
+  // add val nr of events (val could be negative)
+  fPhysInfo->AddNrEvents(val);
+  fInfoModified=kTRUE;
+}
+void AliITSOnlineSPDphys::IncrementNrEvents() {
+  // increment nr of events
+  fPhysInfo->IncrementNrEvents(); 
+  fInfoModified=kTRUE;
+}
+
+
+UInt_t AliITSOnlineSPDphys::GetNrRuns() const {
+  return fPhysInfo->GetNrRuns();
+}
+UInt_t AliITSOnlineSPDphys::GetRunNr(UInt_t posi) const {
+  return fPhysInfo->GetRunNr(posi);
+}
+UInt_t AliITSOnlineSPDphys::GetEqNr() const {
+  return fPhysInfo->GetEqNr();
+}
+UInt_t AliITSOnlineSPDphys::GetNrEvents() const {
+  return fPhysInfo->GetNrEvents();
+}
diff --git a/ITS/AliITSOnlineSPDphys.h b/ITS/AliITSOnlineSPDphys.h
new file mode 100644 (file)
index 0000000..bc7befe
--- /dev/null
@@ -0,0 +1,70 @@
+#ifndef ALI_ITS_ONLINESPDPHYS_H
+#define ALI_ITS_ONLINESPDPHYS_H
+
+////////////////////////////////////////////////////////////
+// Author: Henrik Tydesjo                                 //
+// Interface class to the containers of an online         //
+// physics run.                                           //
+// Directly connected to a TFile with all containers.     //
+// Handles reading and writing of this TFile. Hitmaps are //
+// stored in this file (AliITSOnlineSPDHitArray).         //
+// Also some general information is stored                //
+// (AliITSOnlineSPDphysInfo).                             //
+////////////////////////////////////////////////////////////
+
+#include <TString.h>
+
+class TFile;
+class AliITSOnlineSPDphysInfo;
+class AliITSOnlineSPDHitArray;
+
+class AliITSOnlineSPDphys {
+
+ public:
+  AliITSOnlineSPDphys():fFile(NULL),fWrite(kFALSE),fModified(kFALSE),fInfoModified(kFALSE),fPhysInfo(NULL),fFileName("."){}
+  AliITSOnlineSPDphys(const Char_t *fileName);
+  AliITSOnlineSPDphys(const AliITSOnlineSPDphys& phys);
+  virtual ~AliITSOnlineSPDphys();
+  AliITSOnlineSPDphys& operator=(const AliITSOnlineSPDphys& phys);
+
+  virtual void       AddPhys(AliITSOnlineSPDphys* phys2);
+  virtual void       ClearThis();
+  // SET METHODS ***********************************
+  void     AddRunNr(UInt_t val);
+  void     SetEqNr(UInt_t val);
+
+  void     SetNrEvents(UInt_t val);
+  void     AddNrEvents(Int_t val);
+  void     IncrementNrEvents();
+
+  void     SetHits(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi, UInt_t val);
+  void     AddHits(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi, Int_t val);
+  void     IncrementHits(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi);
+  // GET METHODS ***********************************
+  UInt_t   GetNrRuns() const;
+  UInt_t   GetRunNr(UInt_t posi) const;
+  UInt_t   GetEqNr() const;
+  UInt_t   GetNrEvents() const;
+
+  UInt_t   GetHits(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi);
+  Float_t  GetHitsEfficiency(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi);
+  Float_t  GetHitsEfficiencyError(UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi);
+  Float_t  GetAverageMultiplicity(UInt_t hs, UInt_t chipi);
+  Float_t  GetAverageMultiplicityTot(UInt_t hs);
+
+ protected:
+  TFile    *fFile;                  // file to read and write from
+  Bool_t   fWrite;                  // is file opened for writing?
+  Bool_t   fModified;               // is the hitmap modified (needs saving)?
+  Bool_t   fInfoModified;           // is the overall phys information modified (needs saving)?
+  AliITSOnlineSPDphysInfo *fPhysInfo;    // overall phys information
+  AliITSOnlineSPDHitArray *fHitArray[6]; // hit array, one for each halfstave
+  TString  fFileName;                    // filename of file to read write
+
+  void     InitHitmap();
+  void     ReadHitmap();
+  void     SaveHitmap();
+  
+};
+
+#endif
diff --git a/ITS/AliITSOnlineSPDphysAnalyzer.cxx b/ITS/AliITSOnlineSPDphysAnalyzer.cxx
new file mode 100644 (file)
index 0000000..4f7eaa8
--- /dev/null
@@ -0,0 +1,557 @@
+/**************************************************************************
+ * Copyright(c) 2007-2009, 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.                  *
+ **************************************************************************/
+
+////////////////////////////////////////////////////////////
+// Author: Henrik Tydesjo                                 //
+// This class is used in the detector algorithm framework //
+// to process the data stored in special container files  //
+// (see AliITSOnlineSPDphys).                             //
+////////////////////////////////////////////////////////////
+
+#include "AliITSOnlineSPDphysAnalyzer.h"
+#include "AliITSOnlineSPDphys.h"
+#include "AliITSOnlineCalibrationSPDhandler.h"
+#include "AliITSRawStreamSPD.h"
+#include "AliITSIntMap.h"
+#include <TStyle.h>
+#include <TMath.h>
+#include <TF1.h>
+#include <TGraph.h>
+#include <TH2F.h>
+#include <TError.h>
+#include <iostream>
+#include <fstream>
+
+AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler* handler) :
+  fFileName(fileName),fPhysObj(NULL),fHandler(handler),
+  fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
+  fNrEqHits(0),fbDeadProcessed(kFALSE),
+  fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
+  fMinEventsForNoisy(10000),fMinEventsForDead(10000),
+  fDefinitelyNoisyRatio(0.1),
+  fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
+{
+  // constructor  
+  Init();
+}
+
+AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(AliITSOnlineSPDphys* physObj, AliITSOnlineCalibrationSPDhandler* handler) :
+  fFileName("test.root"),fPhysObj(NULL),fHandler(handler),
+  fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
+  fNrEqHits(0),fbDeadProcessed(kFALSE),
+  fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
+  fMinEventsForNoisy(10000),fMinEventsForDead(10000),
+  fDefinitelyNoisyRatio(0.1),
+  fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
+{
+  // alt constructor
+  fPhysObj = physObj;
+}
+
+AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(const AliITSOnlineSPDphysAnalyzer& handle) :
+  fFileName("test.root"),fPhysObj(NULL),fHandler(NULL),
+  fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
+  fNrEqHits(0),fbDeadProcessed(kFALSE),
+  fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
+  fMinEventsForNoisy(10000),fMinEventsForDead(10000),
+  fDefinitelyNoisyRatio(0.1),
+  fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
+{
+  // copy constructor, only copies the filename and params (not the processed data)
+  fFileName=handle.fFileName;
+  fThreshNoisy = handle.fThreshNoisy;
+  fThreshNoisyExp = handle.fThreshNoisyExp;
+  fThreshDead = handle.fThreshDead;
+  fThreshDeadExp = handle.fThreshDeadExp;
+  fMinEventsForNoisy = handle.fMinEventsForNoisy;
+  fMinEventsForDead = handle.fMinEventsForDead;
+  fDefinitelyNoisyRatio = handle.fDefinitelyNoisyRatio;
+  fMinNrEqHitsForDeadChips = handle.fMinNrEqHitsForDeadChips;
+  fRatioToMeanForInefficientChip = handle.fRatioToMeanForInefficientChip;
+
+  Init();
+}
+
+AliITSOnlineSPDphysAnalyzer::~AliITSOnlineSPDphysAnalyzer() {
+  // destructor
+  if (fPhysObj!=NULL) delete fPhysObj;
+}
+
+AliITSOnlineSPDphysAnalyzer& AliITSOnlineSPDphysAnalyzer::operator=(const AliITSOnlineSPDphysAnalyzer& handle) {
+  // assignment operator, only copies the filename and params (not the processed data)
+  if (this!=&handle) {
+    if (fPhysObj!=NULL) delete fPhysObj;
+    
+    fFileName=handle.fFileName;
+    fThreshNoisy = handle.fThreshNoisy;
+    fThreshNoisyExp = handle.fThreshNoisyExp;
+    fThreshDead = handle.fThreshDead;
+    fThreshDeadExp = handle.fThreshDeadExp;
+    fMinEventsForNoisy = handle.fMinEventsForNoisy;
+    fMinEventsForDead = handle.fMinEventsForDead;
+    fDefinitelyNoisyRatio = handle.fDefinitelyNoisyRatio;
+    fMinNrEqHitsForDeadChips = handle.fMinNrEqHitsForDeadChips;
+    fRatioToMeanForInefficientChip = handle.fRatioToMeanForInefficientChip;
+
+    fPhysObj = NULL;
+    fHandler = NULL;
+    fNrEnoughStatChips = 0;
+    fNrDeadChips = 0;
+    fNrInefficientChips = 0;
+    fNrEqHits = 0;
+    fbDeadProcessed = kFALSE;
+
+    Init();    
+  }
+  return *this;
+}
+
+void AliITSOnlineSPDphysAnalyzer::Init() {
+  // initialize container obj
+  FILE* fp0 = fopen(fFileName.Data(), "r");
+  if (fp0 == NULL) {
+    return;
+  }
+  else {
+    fclose(fp0);
+  }
+  fPhysObj = new AliITSOnlineSPDphys(fFileName.Data());
+}
+
+void AliITSOnlineSPDphysAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
+  // set a parameter
+  TString name = pname;
+  TString val = pval;
+  //  printf("Setting Param %s  to %s\n",name.Data(),val.Data());
+  if (name.CompareTo("MistakeProbabilityNoisy")==0) {
+    Double_t mistakeProbabilityNoisy = val.Atof();
+    fThreshNoisy = mistakeProbabilityNoisy;
+    fThreshNoisyExp = 0;
+    Exponent(fThreshNoisy,fThreshNoisyExp);
+    fThreshNoisy/=(20*6*10*32*256);
+    Exponent(fThreshNoisy,fThreshNoisyExp);
+  }
+  else if (name.CompareTo("MistakeProbabilityDead")==0) {
+    Double_t mistakeProbabilityDead = val.Atof();
+    fThreshDead = mistakeProbabilityDead;
+    fThreshDeadExp = 0;
+    Exponent(fThreshDead,fThreshDeadExp);
+    fThreshDead/=(20*6*10*32*256);
+    Exponent(fThreshDead,fThreshDeadExp);
+  }
+  else if (name.CompareTo("fMinEventsForNoisy")==0) {
+    fMinEventsForNoisy = val.Atoi();
+  }
+  else if (name.CompareTo("fMinEventsForDead")==0) {
+    fMinEventsForDead = val.Atoi();
+  }
+  else if (name.CompareTo("fDefinitelyNoisyRatio")==0) {
+    fDefinitelyNoisyRatio = val.Atof();
+  }
+  else if (name.CompareTo("fMinNrEqHitsForDeadChips")==0) {
+    fMinNrEqHitsForDeadChips = val.Atof();
+  }
+  else if (name.CompareTo("fRatioToMeanForInefficientChip")==0) {
+    fRatioToMeanForInefficientChip = val.Atof();
+  }
+  else {
+    Error("AliITSOnlineSPDphysAnalyzer::SetParam","Parameter %s in configuration file unknown.",name.Data());
+  }
+}
+
+void AliITSOnlineSPDphysAnalyzer::ReadParamsFromLocation(const Char_t *dirName) {
+  // opens file (default name) in dir dirName and reads parameters from it
+  TString paramsFileName = Form("%s/physics_params.txt",dirName);
+  ifstream paramsFile;
+  paramsFile.open(paramsFileName, ifstream::in);
+  if (paramsFile.fail()) {
+    printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName.Data());
+  }
+  else {
+    while(1) {
+      Char_t paramN[50];
+      Char_t paramV[50];
+      paramsFile >> paramN;
+      if (paramsFile.eof()) break;
+      paramsFile >> paramV;
+      SetParam(paramN,paramV);
+      if (paramsFile.eof()) break;
+    }
+    paramsFile.close();
+  }
+}
+
+
+UInt_t AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels() {
+  // process noisy pixel data , returns number of chips with enough statistics
+  if (fPhysObj==NULL) {
+    Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","No data!");
+    return 0;
+  }
+  // do we have enough events to even try the algorithm?
+  if (GetNrEvents() < fMinEventsForNoisy) {
+    Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Nr events (%d) < fMinEventsForNoisy (%d)!",GetNrEvents(),fMinEventsForNoisy);
+    return 0;
+  }
+  // handler should be initialized
+  if (fHandler==NULL) {
+    Error("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
+    return 0;
+  }
+  
+  UInt_t nrEnoughStatChips = 0;
+
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+
+      UInt_t nrPixels = 0;
+      UInt_t nrChipHits = 0;
+      UInt_t nrMostHits = 0;
+      for (UInt_t col=0; col<32; col++) {
+       for (UInt_t row=0; row<256; row++) {
+         UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+         nrChipHits += nrHits;
+         //      if (nrHits>0) nrPixels++; // don't include pixels that might be dead
+         nrPixels++;
+         if (nrHits>fDefinitelyNoisyRatio*GetNrEvents()) {
+           fHandler->SetNoisyPixel(GetEqNr(),hs,chip,col,row);
+           nrPixels--;
+           nrChipHits-=nrHits;
+         }
+         else {
+           if (nrMostHits<nrHits) nrMostHits=nrHits;
+         }
+       }
+      }
+
+      if (nrChipHits>0) { // otherwise there are for sure no noisy
+       // Binomial with n events and probability p for pixel hit
+       UInt_t n = GetNrEvents();
+       if (nrPixels>0 && n>0) {
+
+         Double_t p = (Double_t)nrChipHits/nrPixels/n;
+
+         Double_t bin = 1;
+         Int_t binExp = 0;
+         // Bin(n,k=0):
+         for (UInt_t i=0; i<n; i++) {
+           bin*=(1-p);
+           Exponent(bin,binExp);
+         }
+         // Bin(n,k)
+         UInt_t k=1;
+         while (((binExp>fThreshNoisyExp || (binExp==fThreshNoisyExp && bin>fThreshNoisy)) || k<n*p) && k<=n) {
+           k++;
+           bin = bin*(n-k+1)/k*p/(1-p);
+           Exponent(bin,binExp);
+         }
+         
+         // can we find noisy pixels...?
+         if (k<=n) {
+           //      printf("eq %d , hs %d , chip %d : Noisy level = %d\n",GetEqNr(),hs,chip,k);
+           nrEnoughStatChips++;
+           // add noisy pixels to handler
+           UInt_t noiseLimit=k;
+           if (nrMostHits>=noiseLimit) {
+             for (UInt_t col=0; col<32; col++) {
+               for (UInt_t row=0; row<256; row++) {
+                 UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+                 if (nrHits >= noiseLimit) {
+                   fHandler->SetNoisyPixel(GetEqNr(),hs,chip,col,row);
+                 }
+               }
+             }
+           }
+         }
+       }
+
+      }
+
+    } // for chip
+  } // for hs
+
+  return nrEnoughStatChips;
+}
+
+
+UInt_t AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels() {
+  // process dead pixel data , returns number of chips with enough statistics
+  if (fPhysObj==NULL) {
+    Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","No data!");
+    return 0;
+  }
+  // do we have enough events to even try the algorithm?
+  if (GetNrEvents() < fMinEventsForDead) {
+    Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","Nr events (%d) < fMinEventsForDead (%d)!",GetNrEvents(),fMinEventsForDead);
+    return 0;
+  }
+  // handler should be initialized
+  if (fHandler==NULL) {
+    Error("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","Calibration handler is not initialized!");
+    return 0;
+  }
+
+  AliITSOnlineCalibrationSPDhandler *deadChipHandler = new AliITSOnlineCalibrationSPDhandler();
+  AliITSIntMap* possiblyIneff = new AliITSIntMap();
+
+  fNrEnoughStatChips = 0;
+  fNrDeadChips = 0;
+  fNrInefficientChips = 0;
+  UInt_t nrPossiblyDeadChips = 0;
+  fNrEqHits = 0;
+
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+      Bool_t good=kFALSE;
+
+      AliITSOnlineCalibrationSPDhandler *deadPixelHandler = new AliITSOnlineCalibrationSPDhandler();
+
+      UInt_t nrPossiblyDeadPixels = 0;
+      UInt_t nrPixels = 0;
+      UInt_t nrChipHits = 0;
+      for (UInt_t col=0; col<32; col++) {
+       for (UInt_t row=0; row<256; row++) {
+         UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+         nrChipHits += nrHits;
+         if (!fHandler->IsPixelNoisy(GetEqNr(),hs,chip,col,row)) {
+           // don't include noisy pixels
+           nrPixels++;
+           if (nrHits==0) {
+             nrPossiblyDeadPixels++;
+             deadPixelHandler->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+           }
+         }
+         else {
+           nrChipHits -= nrHits; // this is needed when running offline (online nrHits should be 0 already)
+         }
+       }
+      }
+      fNrEqHits+=nrChipHits;
+
+      // check all pixels that were declared dead from before...
+      UInt_t nrDeadBefore = fHandler->GetNrDeadC(GetEqNr(),hs,chip);
+      UInt_t nrNoisyNow   = fHandler->GetNrNoisyC(GetEqNr(),hs,chip);
+      if (nrDeadBefore+nrNoisyNow==8192) {
+       if (nrChipHits>0) {
+         fHandler->UnSetDeadChip(GetEqNr(),hs,chip);
+       }
+      }
+      else {
+       AliITSOnlineCalibrationSPDhandler *tmpHand = new AliITSOnlineCalibrationSPDhandler();
+       for (UInt_t index=0; index<nrDeadBefore; index++) {
+         UInt_t col = fHandler->GetDeadColAtC(GetEqNr(),hs,chip,index);
+         UInt_t row = fHandler->GetDeadRowAtC(GetEqNr(),hs,chip,index);
+         if (fPhysObj->GetHits(hs,chip,col,row)>0) {
+           //      fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,col,row);
+           tmpHand->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+         }
+       }
+       UInt_t nrToRemove = tmpHand->GetNrDead();
+       for (UInt_t index=0; index<nrToRemove; index++) {
+         fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,tmpHand->GetDeadColAtC(GetEqNr(),hs,chip,index),tmpHand->GetDeadRowAtC(GetEqNr(),hs,chip,index));
+       }
+       delete tmpHand;
+      }
+
+
+
+
+      if (nrPossiblyDeadPixels==0) {
+       // no need to see if we have enough statistics...
+       fNrEnoughStatChips++;
+       good=kTRUE;
+       delete deadPixelHandler;
+       good=kTRUE;
+       printf("%3d",good);
+       if (chip==9) printf("\n");
+       continue;
+      }
+
+      if (nrChipHits==0) {
+       nrPossiblyDeadChips++;
+       deadChipHandler->SetDeadChip(GetEqNr(),hs,chip);
+       delete deadPixelHandler;
+       good=kFALSE;
+       printf("%3d",good);
+       if (chip==9) printf("\n");
+       continue;
+      }
+
+      // Binomial with n events and probability p for pixel hit
+      UInt_t n = GetNrEvents();
+      if (nrPixels>0 && n>0) {
+
+       Double_t p = (Double_t)nrChipHits/nrPixels/n;
+
+       // probability of falsely assigning a dead pixel
+       Double_t falselyDeadProb = 1;
+       Int_t falselyDeadProbExp = 0;
+       for (UInt_t i=0; i<n; i++) {
+         falselyDeadProb*=(1-p);
+         Exponent(falselyDeadProb,falselyDeadProbExp);
+       }
+
+       // can we find dead pixels...?
+       if (falselyDeadProbExp<fThreshDeadExp || (falselyDeadProbExp==fThreshDeadExp && falselyDeadProb<fThreshDead)) {
+         fNrEnoughStatChips++;
+         good=kTRUE;
+         // add dead pixels to handler
+         fHandler->AddDeadFrom(deadPixelHandler);
+       }
+       else {
+         // this might be an inefficient chip
+         possiblyIneff->Insert(hs*10+chip,nrChipHits);
+       }
+
+      }
+      else {
+       if (n>0) {
+         // this is a completely noisy chip... put in category enough stat
+         fNrEnoughStatChips++;
+         good=kTRUE;
+       }
+      }
+
+      delete deadPixelHandler;
+
+      printf("%3d",good);
+      if (chip==9) printf("\n");
+
+    } // for chip
+  } // for hs
+
+
+  // dead chips?
+  if (fNrEqHits>fMinNrEqHitsForDeadChips) {
+    fHandler->AddDeadFrom(deadChipHandler);
+    fNrDeadChips=nrPossiblyDeadChips;
+  }
+  else {
+    fNrDeadChips=0;
+  }
+  delete deadChipHandler;
+
+
+  // inefficient chips?
+  Int_t key,val;
+  while (possiblyIneff->Pop(key,val)) {
+    if (val<fNrEqHits/60*fRatioToMeanForInefficientChip) {
+      fNrInefficientChips++;
+    }
+  }
+  delete possiblyIneff;
+
+
+  fbDeadProcessed = kTRUE;
+
+  return fNrEnoughStatChips;
+}
+
+
+UInt_t AliITSOnlineSPDphysAnalyzer::GetNrEnoughStatChips() {
+  // returns nr of enough stat chips
+  if (!fbDeadProcessed) ProcessDeadPixels();
+  return fNrEnoughStatChips;
+}
+UInt_t AliITSOnlineSPDphysAnalyzer::GetNrDeadChips() {
+  // returns nr of dead chips
+  if (!fbDeadProcessed) ProcessDeadPixels();
+  return fNrDeadChips;
+}
+UInt_t AliITSOnlineSPDphysAnalyzer::GetNrInefficientChips() {
+  // returns nr of inefficient chips
+  if (!fbDeadProcessed) ProcessDeadPixels();
+  return fNrInefficientChips;
+}
+UInt_t AliITSOnlineSPDphysAnalyzer::GetNrNeedsMoreStatChips() {
+  // returns nr of needs more stat chips
+  if (!fbDeadProcessed) ProcessDeadPixels();
+  return 60-fNrEnoughStatChips-fNrDeadChips-fNrInefficientChips;
+}
+
+UInt_t AliITSOnlineSPDphysAnalyzer::GetEqNr() const {
+  // returns the eq nr of phys obj
+  if (fPhysObj!=NULL) return fPhysObj->GetEqNr(); 
+  else return 999;
+}
+
+UInt_t AliITSOnlineSPDphysAnalyzer::GetNrEvents() const {
+  // returns the nr of events of phys obj
+  if (fPhysObj!=NULL) return fPhysObj->GetNrEvents(); 
+  else return 0;
+}
+
+void AliITSOnlineSPDphysAnalyzer::Exponent(Double_t &val, Int_t &valExp) const {
+  // put double in format with val and exp so that 1<val<10 - The actual value is val*10e(valExp)
+  while (val>10) {
+    val/=10;
+    valExp++;
+  }
+  while (val<1) {
+    val*=10;
+    valExp--;
+  }
+}
+
+
+
+TH2F* AliITSOnlineSPDphysAnalyzer::GetHitMapTot() {
+  // creates and returns a pointer to a hitmap histo (half sector style a la spdmood)
+  if (fPhysObj==NULL) {
+    Error("AliITSOnlineSPDphysAnalyzer::GetHitMapTot","No data!");
+    return NULL;
+  }
+  TString histoname = Form("Eq %d",GetEqNr());
+  TH2F* fHitMapTot = new TH2F(histoname.Data(),histoname.Data(),32*10,-0.5,32*10-0.5,256*6,-0.5,256*6-0.5);
+  fHitMapTot->SetNdivisions(-10,"X");
+  fHitMapTot->SetNdivisions(-006,"Y");
+  fHitMapTot->SetTickLength(0,"X");
+  fHitMapTot->SetTickLength(0,"Y");
+  fHitMapTot->GetXaxis()->SetLabelColor(gStyle->GetCanvasColor());
+  fHitMapTot->GetYaxis()->SetLabelColor(gStyle->GetCanvasColor());
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chipNr=0; chipNr<10; chipNr++) {
+      for (UInt_t col=0; col<32; col++) {
+       for (UInt_t row=0; row<256; row++) {
+         fHitMapTot->Fill(chipNr*32+col,(5-hs)*256+row,fPhysObj->GetHits(hs,chipNr,col,row));
+       }
+      }
+    }
+  }
+  return fHitMapTot;
+}
+
+TH2F* AliITSOnlineSPDphysAnalyzer::GetHitMapChip(UInt_t hs, UInt_t chip) {
+  // creates and returns a pointer to a hitmap histo (chip style a la spdmood)
+  if (fPhysObj==NULL) {
+    Error("AliITSOnlineSPDphysAnalyzer::GetHitMapChip","No data!");
+    return NULL;
+  }
+
+  TString histoName;
+  TString histoTitle;
+  histoName = Form("fChipHisto_%d_%d_%d", GetEqNr(), hs, chip);
+  histoTitle = Form("Eq ID %d, Half Stave %d, Chip %d", GetEqNr(), hs, chip);
+
+  TH2F *returnHisto = new TH2F(histoName.Data(), histoTitle.Data(), 32, -0.5, 31.5, 256, -0.5, 255.5);
+  returnHisto->SetMinimum(0);
+  for (UInt_t col=0; col<32; col++) {
+    for (UInt_t row=0; row<256; row++) {
+      returnHisto->Fill(col,row,fPhysObj->GetHits(hs,chip,col,row));
+    }
+  }
+
+  return returnHisto;
+}
diff --git a/ITS/AliITSOnlineSPDphysAnalyzer.h b/ITS/AliITSOnlineSPDphysAnalyzer.h
new file mode 100644 (file)
index 0000000..fd91971
--- /dev/null
@@ -0,0 +1,78 @@
+#ifndef ALIITSONLINESPDPHYSANALYZER_H
+#define ALIITSONLINESPDPHYSANALYZER_H
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+////////////////////////////////////////////////////////////
+// Author: Henrik Tydesjo                                 //
+// This class is used in the detector algorithm framework //
+// to process the data stored in special container files  //
+// (see AliITSOnlineSPDphys).                             //
+////////////////////////////////////////////////////////////
+
+#include <TString.h>
+
+class AliITSOnlineSPDphys;
+class AliITSOnlineCalibrationSPDhandler;
+class TGraph;
+class TH2F;
+
+class AliITSOnlineSPDphysAnalyzer {
+
+ public:
+  AliITSOnlineSPDphysAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler* handler);
+  AliITSOnlineSPDphysAnalyzer(AliITSOnlineSPDphys* physObj, AliITSOnlineCalibrationSPDhandler* handler);
+  AliITSOnlineSPDphysAnalyzer(const AliITSOnlineSPDphysAnalyzer& handle);
+  ~AliITSOnlineSPDphysAnalyzer();
+
+  AliITSOnlineSPDphysAnalyzer& operator=(const AliITSOnlineSPDphysAnalyzer& handle);
+
+  void       SetCalibHandler(AliITSOnlineCalibrationSPDhandler *handler) {fHandler=handler;}
+  void       SetParam(const Char_t *pname, const Char_t *pval);
+  void       ReadParamsFromLocation(const Char_t *dirName);
+
+  UInt_t     ProcessDeadPixels();
+  UInt_t     ProcessNoisyPixels();
+
+  UInt_t     GetNrEnoughStatChips();
+  UInt_t     GetNrDeadChips();
+  UInt_t     GetNrInefficientChips();
+  UInt_t     GetNrNeedsMoreStatChips();
+
+  AliITSOnlineSPDphys* GetOnlinePhys() {return fPhysObj;}
+  UInt_t     GetEqNr() const;
+  UInt_t     GetNrEvents() const;
+
+  TH2F*      GetHitMapTot();
+  TH2F*      GetHitMapChip(UInt_t hs, UInt_t chip);
+
+ private:
+  TString  fFileName; // container file name
+  enum     calibvals{kMINTH,kMEANTH,kDAC,kUNIMA,kNOISE,kDELAY};  // calib types
+  AliITSOnlineSPDphys               *fPhysObj; // container obj
+  AliITSOnlineCalibrationSPDhandler *fHandler; // calib helper obj
+  void     Init();    // initialization
+  void     Exponent(Double_t &val, Int_t &valExp) const;
+
+  UInt_t   fNrEnoughStatChips;    // nr of enough stat chips
+  UInt_t   fNrDeadChips;          // nr of dead chips
+  UInt_t   fNrInefficientChips;   // nr of inefficient chips
+
+  Double_t fNrEqHits;         // total nr of hits for associated eq
+  Bool_t   fbDeadProcessed;   // flag to tell if ProcessDeadPixels has been called
+
+  // dead noisy parameters:
+  Double_t fThreshNoisy;       // at what confidence level do we search for noisy
+  Int_t    fThreshNoisyExp;    // at what confidence level do we search for noisy
+  Double_t fThreshDead;        // at what confidence level do we search for dead
+  Int_t    fThreshDeadExp;     // at what confidence level do we search for dead
+  UInt_t   fMinEventsForNoisy; // min nr of events required to try noisy algorithm
+  UInt_t   fMinEventsForDead;  // min nr of events required to try dead algorithm
+  Float_t  fDefinitelyNoisyRatio; // if a pixel fires more than this ratio of the events, it must be noisy
+  Double_t fMinNrEqHitsForDeadChips; // minimum nr of hits for eq to assign dead chip
+  Double_t fRatioToMeanForInefficientChip; // ratio to mean nr of hits per chip to assign ineff. chip
+  
+
+};
+
+#endif
diff --git a/ITS/AliITSOnlineSPDphysInfo.cxx b/ITS/AliITSOnlineSPDphysInfo.cxx
new file mode 100644 (file)
index 0000000..2c8ea28
--- /dev/null
@@ -0,0 +1,55 @@
+/////////////////////////////////////////////////////////////////
+// Author: Henrik Tydesjo                                      //
+// This class is used as a container online.                   //
+// It holds information needed for a scan.                     //
+// This class should only be used through the interface of the //
+// AliITSOnlineSPDphys class.                                  //
+/////////////////////////////////////////////////////////////////
+
+#include "AliITSOnlineSPDphysInfo.h"
+
+ClassImp(AliITSOnlineSPDphysInfo)
+
+AliITSOnlineSPDphysInfo::AliITSOnlineSPDphysInfo(): 
+  fNrRuns(0),
+  fRunNrs(0),
+  fEqNr(999),
+  fNrEvents(0)
+{}
+
+AliITSOnlineSPDphysInfo::~AliITSOnlineSPDphysInfo() {}
+
+void AliITSOnlineSPDphysInfo::ClearThis() {
+  // reset all values for this object
+  fNrRuns=0;
+  fRunNrs=0;
+  fEqNr=999;
+  fNrEvents=0;
+}
+
+void AliITSOnlineSPDphysInfo::AddRunNr(UInt_t val) {
+  // add a new run nr, allocate space for TArrayI
+  fNrRuns++;
+  fRunNrs.Set(fNrRuns);
+  fRunNrs.AddAt(val, fNrRuns-1);
+}
+
+UInt_t AliITSOnlineSPDphysInfo::GetRunNr(UInt_t posi) const {
+  // get run nr
+  if (posi<fNrRuns) {
+    return fRunNrs.At(posi);
+  }
+  else {
+    return 0;
+  }
+}
+
+void AliITSOnlineSPDphysInfo::AddNrEvents(Int_t val) {
+  // add val nr of events (val could be negative)
+  if (fNrEvents+val>0) {
+    fNrEvents+=val;
+  }
+  else {
+    fNrEvents=0;
+  }
+}
diff --git a/ITS/AliITSOnlineSPDphysInfo.h b/ITS/AliITSOnlineSPDphysInfo.h
new file mode 100644 (file)
index 0000000..4d641e6
--- /dev/null
@@ -0,0 +1,44 @@
+#ifndef ALI_ITS_ONLINESPDPHYSINFO_H
+#define ALI_ITS_ONLINESPDPHYSINFO_H
+
+/////////////////////////////////////////////////////////////////
+// Author: Henrik Tydesjo                                      //
+// This class is used as a container online.                   //
+// It holds information needed for a physics run.              //
+// This class should only be used through the interface of the //
+// AliITSOnlineSPDphys class.                                  //
+/////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+#include <TArrayI.h>
+
+class AliITSOnlineSPDphysInfo :  public TObject {
+
+ public:
+  AliITSOnlineSPDphysInfo();
+  virtual ~AliITSOnlineSPDphysInfo();
+
+  virtual void   ClearThis();
+  // SET METHODS ***********************************
+  void     AddRunNr(UInt_t val);
+  void     SetEqNr(UInt_t val) {fEqNr=val;}
+  void     SetNrEvents(UInt_t val) {fNrEvents=val;}
+  void     AddNrEvents(Int_t val);
+  void     IncrementNrEvents() {fNrEvents++;}
+
+  // GET METHODS ***********************************
+  UInt_t   GetNrRuns() const {return fNrRuns;}
+  UInt_t   GetRunNr(UInt_t posi) const ;
+  UInt_t   GetEqNr() const {return fEqNr;}
+  UInt_t   GetNrEvents() const {return fNrEvents;}
+
+ protected:
+  UInt_t   fNrRuns;               // nr of runs used to fill hitmap
+  TArrayI  fRunNrs;               // list of run nrs for the hitmap
+  UInt_t   fEqNr;                 // eq nr
+  UInt_t   fNrEvents;             // number of events
+
+  ClassDef(AliITSOnlineSPDphysInfo,1)
+    };
+    
+#endif
index a2b84cb..759fc9e 100644 (file)
@@ -22,7 +22,7 @@ class AliITSOnlineSPDHitEvent;
 class AliITSOnlineSPDscan {
 
  public:
-  AliITSOnlineSPDscan():fFile(NULL),fWrite(kFALSE),fCurrentStep(-1),fModified(kFALSE),fInfoModified(kFALSE),fScanInfo(NULL),fFileName("."){}
+  AliITSOnlineSPDscan():fFile(NULL),fWrite(kFALSE),fCurrentStep(-1),fModified(kFALSE),fInfoModified(kFALSE),fScanInfo(NULL),fFileName("./test.root"){}
   AliITSOnlineSPDscan(const Char_t *fileName);
   AliITSOnlineSPDscan(const AliITSOnlineSPDscan& scan);
   virtual ~AliITSOnlineSPDscan();
index 083c2fd..f801c8b 100644 (file)
@@ -20,7 +20,7 @@
 // This class is used in the detector algorithm framework //
 // to process the data stored in special container files  //
 // (see AliITSOnlineSPDscan). For instance, minimum       //
-// threshold values can be calculated.                    //
+// threshold values can be extracted.                     //
 ////////////////////////////////////////////////////////////
 
 #include "AliITSOnlineSPDscanAnalyzer.h"
@@ -36,6 +36,8 @@
 #include <TGraph.h>
 #include <TH2F.h>
 #include <TError.h>
+#include <iostream>
+#include <fstream>
 
 Double_t itsSpdErrorf(Double_t *x, Double_t *par){
   if (par[2]<0) par[2]=0;
@@ -47,10 +49,10 @@ Double_t itsSpdErrorf(Double_t *x, Double_t *par){
 //}
 
 
-AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const Char_t *fileName) :
-  fType(99),fDacId(99),fRouterNr(99),fFileName(fileName),fScanObj(NULL),fTriggers(NULL),
+AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler *handler) :
+  fType(99),fDacId(99),fFileName(fileName),fScanObj(NULL),fHandler(handler),fTriggers(NULL),
   fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
-  fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(2),fMaxBaseLineLevel(10)
+  fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(5),fMaxBaseLineLevel(10)
 {
   // constructor
   for (UInt_t chipNr=0; chipNr<11; chipNr++) {
@@ -59,31 +61,36 @@ AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const Char_t *fileName)
       fHitEventEfficiency[hs][chipNr]=NULL;
     }
   }
-  for (Int_t module=0; module<240; module++) {
-    fHandler[module]=NULL;
+  for (UInt_t mod=0; mod<240; mod++) {
+    fbModuleScanned[mod]=kFALSE;
   }
 
   Init();
 }
 
 AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle) :
-  fType(99),fDacId(99),fRouterNr(99),fFileName("."),fScanObj(NULL),fTriggers(NULL),
+  fType(99),fDacId(99),fFileName("."),fScanObj(NULL),fHandler(NULL),fTriggers(NULL),
   fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
-  fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(2),fMaxBaseLineLevel(10)
+  fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(5),fMaxBaseLineLevel(10)
 {
-  // copy constructor, only copies the filename (not the processed data)
+  // copy constructor, only copies the filename and params (not the processed data)
   fFileName=handle.fFileName;
+  fOverWrite=handle.fOverWrite;
+  fNoiseThreshold=handle.fNoiseThreshold;
+  fNoiseMinimumEvents=handle.fNoiseMinimumEvents;
+  fMinNrStepsBeforeIncrease=handle.fMinNrStepsBeforeIncrease;
+  fMinIncreaseFromBaseLine=handle.fMinIncreaseFromBaseLine;
+  fStepDownDacSafe=handle.fStepDownDacSafe;
+  fMaxBaseLineLevel=handle.fMaxBaseLineLevel;
 
-  fScanObj=NULL;
   for (UInt_t chipNr=0; chipNr<11; chipNr++) {
     for (UInt_t hs=0; hs<6; hs++) {
       fMeanMultiplicity[hs][chipNr]=NULL;
       fHitEventEfficiency[hs][chipNr]=NULL;
     }
   }
-  fTriggers=NULL;
-  for (Int_t module=0; module<240; module++) {
-    fHandler[module]=NULL;
+  for (UInt_t mod=0; mod<240; mod++) {
+    fbModuleScanned[mod]=kFALSE;
   }
 
   Init();
@@ -103,15 +110,10 @@ AliITSOnlineSPDscanAnalyzer::~AliITSOnlineSPDscanAnalyzer() {
   }
   if (fTriggers!=NULL) delete fTriggers;
   if (fScanObj!=NULL) delete fScanObj;
-  for (Int_t module=0; module<240; module++) {
-    if (fHandler[module]!=NULL) {
-      delete fHandler[module];
-    }
-  }
 }
 
 AliITSOnlineSPDscanAnalyzer& AliITSOnlineSPDscanAnalyzer::operator=(const AliITSOnlineSPDscanAnalyzer& handle) {
-  // assignment operator, only copies the filename (not the processed data)
+  // assignment operator, only copies the filename and params (not the processed data)
   if (this!=&handle) {
     for (UInt_t hs=0; hs<6; hs++) {
       for (UInt_t chipNr=0; chipNr<11; chipNr++) {
@@ -125,29 +127,32 @@ AliITSOnlineSPDscanAnalyzer& AliITSOnlineSPDscanAnalyzer::operator=(const AliITS
     }
     if (fTriggers!=NULL) delete fTriggers;
     if (fScanObj!=NULL) delete fScanObj;
-    for (Int_t module=0; module<240; module++) {
-      if (fHandler[module]!=NULL) {
-       delete fHandler[module];
-      }
-    }
    
     fFileName=handle.fFileName;
+    fOverWrite=handle.fOverWrite;
+    fNoiseThreshold=handle.fNoiseThreshold;
+    fNoiseMinimumEvents=handle.fNoiseMinimumEvents;
+    fMinNrStepsBeforeIncrease=handle.fMinNrStepsBeforeIncrease;
+    fMinIncreaseFromBaseLine=handle.fMinIncreaseFromBaseLine;
+    fStepDownDacSafe=handle.fStepDownDacSafe;
+    fMaxBaseLineLevel=handle.fMaxBaseLineLevel;
 
-    fScanObj=NULL;
-    fType=99;
-    fDacId=99;
-    fRouterNr=99;
     for (UInt_t chipNr=0; chipNr<11; chipNr++) {
       for (UInt_t hs=0; hs<6; hs++) {
        fMeanMultiplicity[hs][chipNr]=NULL;
        fHitEventEfficiency[hs][chipNr]=NULL;
       }
     }
-    fTriggers=NULL;
-    for (Int_t module=0; module<240; module++) {
-      fHandler[module]=NULL;
+    for (UInt_t mod=0; mod<240; mod++) {
+      fbModuleScanned[mod]=kFALSE;
     }
+    fTriggers=NULL;
+    fHandler=NULL;
     
+    fScanObj=NULL;
+    fType=99;
+    fDacId=99;
+
     Init();    
   }
   return *this;
@@ -164,7 +169,6 @@ void AliITSOnlineSPDscanAnalyzer::Init() {
   }
   fScanObj = new AliITSOnlineSPDscan(fFileName.Data());
   fType = fScanObj->GetType();
-  fRouterNr = fScanObj->GetRouterNr();
   delete fScanObj;
 
   // init container
@@ -190,15 +194,6 @@ void AliITSOnlineSPDscanAnalyzer::Init() {
     break;
   }
 
-  // set some default values (these should later be read from text file)
-  fOverWrite=kFALSE;
-  fNoiseThreshold=0.01;
-  fNoiseMinimumEvents=100;
-  fMinNrStepsBeforeIncrease=6;
-  fMinIncreaseFromBaseLine=2;
-  fStepDownDacSafe=2;
-  fMaxBaseLineLevel=10;
-
 }
 
 void AliITSOnlineSPDscanAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
@@ -206,9 +201,10 @@ void AliITSOnlineSPDscanAnalyzer::SetParam(const Char_t *pname, const Char_t *pv
   TString name = pname;
   TString val = pval;
   if (name.CompareTo("fOverWrite")==0) {
-    if (val.CompareTo("YES")==0) {
+    if (val.CompareTo("YES")==0 || val.CompareTo("1")==0) {
       fOverWrite = kTRUE;
     }
+    else fOverWrite = kFALSE;
   }
   else if (name.CompareTo("fNoiseThreshold")==0) {
     fNoiseThreshold = val.Atof();
@@ -233,7 +229,37 @@ void AliITSOnlineSPDscanAnalyzer::SetParam(const Char_t *pname, const Char_t *pv
   }
 }
 
-Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(Char_t *oldcalibDir) {
+void AliITSOnlineSPDscanAnalyzer::ReadParamsFromLocation(const Char_t *dirName) {
+  // opens file (default name) in dir dirName and reads parameters from it
+  TString paramsFileName = Form("%s/standal_params.txt",dirName);
+  ifstream paramsFile;
+  paramsFile.open(paramsFileName, ifstream::in);
+  if (paramsFile.fail()) {
+    printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName.Data());
+  }
+  else {
+    while(1) {
+      Char_t paramN[50];
+      Char_t paramV[50];
+      paramsFile >> paramN;
+      if (paramsFile.eof()) break;
+      paramsFile >> paramV;
+      SetParam(paramN,paramV);
+      if (paramsFile.eof()) break;
+    }
+    paramsFile.close();
+  }
+}
+
+Bool_t AliITSOnlineSPDscanAnalyzer::IsModuleScanned(UInt_t module) const {
+  // is this module scanned?
+  if (module<240) {
+    return fbModuleScanned[module];
+  }
+  return kFALSE;
+}
+
+Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(/*Char_t *oldcalibDir*/) {
   // process dead pixel data, for uniformity scan, 
   // NB: This will not be the general way of finding dead pixels.
   if (fScanObj==NULL) {
@@ -245,6 +271,11 @@ Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(Char_t *oldcalibDir) {
     Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Dead pixels only for scan type %d.",kUNIMA);
     return kFALSE;
   }
+  // handler should be initialized
+  if (fHandler==NULL) {
+    Error("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Calibration handler is not initialized!");
+    return kFALSE;
+  }
 
   UInt_t routerNr = fScanObj->GetRouterNr();
   UInt_t rowStart = fScanObj->GetRowStart();
@@ -253,17 +284,17 @@ Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(Char_t *oldcalibDir) {
     for (UInt_t chipNr=0; chipNr<10; chipNr++) {
       if (fScanObj->GetChipPresent(hs,chipNr) && fScanObj->GetAverageMultiplicity(0,hs,chipNr)>0) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        UInt_t module = AliITSRawStreamSPD::GetModuleNumber(routerNr,hs,chipNr);
+       if (!fbModuleScanned[module]) {
+         fbModuleScanned[module]=kTRUE;
+         //      fHandler[module]->SetFileLocation(oldcalibDir);
+         //      fHandler[module]->ReadFromFile(module);
+         if (fOverWrite) {fHandler->ResetDeadForChip(routerNr,hs,chipNr);}
+       }
        for (UInt_t col=0; col<32; col++) {
          for (UInt_t row=rowStart; row<=rowEnd; row++) {
            if (col!=1 && col!=9 && col!=17 && col!=25) { //exclude test columns!!!
              if (fScanObj->GetHits(0,hs,chipNr,col,row)==0) {
-               if (!fHandler[module]) {
-                 fHandler[module] = new AliITSOnlineCalibrationSPDhandler();
-                 fHandler[module]->SetFileLocation(oldcalibDir);
-                 fHandler[module]->ReadFromFile(module);
-                 if (fOverWrite) {fHandler[module]->ResetDeadForChip(routerNr,hs,chipNr);}
-               }
-               fHandler[module]->SetDeadPixel(routerNr,hs,chipNr,col,row);
+               fHandler->SetDeadPixel(routerNr,hs,chipNr,col,row);
              }
            }
          }
@@ -276,7 +307,7 @@ Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(Char_t *oldcalibDir) {
 
 
 
-Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(Char_t *oldcalibDir) {
+Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(/*Char_t *oldcalibDir*/) {
   // process noisy pixel data
   if (fScanObj==NULL) {
     Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","No data!");
@@ -287,26 +318,30 @@ Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(Char_t *oldcalibDir) {
     Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Noisy pixels only for scan type %d.",kNOISE);
     return kFALSE;
   }
-
+  // handler should be initialized
+  if (fHandler==NULL) {
+    Error("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
+    return kFALSE;
+  }
+  // check if enough statistics
   if (fScanObj->GetTriggers(0)<fNoiseMinimumEvents) {
     Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Process noisy: Too few events.");
     return kFALSE;
   }
+
   UInt_t routerNr = fScanObj->GetRouterNr();
   for (UInt_t hs=0; hs<6; hs++) {
     for (UInt_t chipNr=0; chipNr<10; chipNr++) {
       if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        UInt_t module = AliITSRawStreamSPD::GetModuleNumber(routerNr,hs,chipNr);
+       if (!fbModuleScanned[module]) {
+         fbModuleScanned[module]=kTRUE;
+         if (fOverWrite) {fHandler->ResetNoisyForChip(routerNr,hs,chipNr);}
+       }
        for (UInt_t col=0; col<32; col++) {
          for (UInt_t row=0; row<256; row++) {
            if (fScanObj->GetHitsEfficiency(0,hs,chipNr,col,row)>fNoiseThreshold) {
-             if (!fHandler[module]) {
-               fHandler[module] = new AliITSOnlineCalibrationSPDhandler();
-               fHandler[module]->SetFileLocation(oldcalibDir);
-               fHandler[module]->ReadFromFile(module);
-               if (fOverWrite) {fHandler[module]->ResetNoisyForChip(routerNr,hs,chipNr);}
-             }
-             fHandler[module]->SetNoisyPixel(routerNr,hs,chipNr,col,row);
+             fHandler->SetNoisyPixel(routerNr,hs,chipNr,col,row);
            }
          }
        }
@@ -316,17 +351,6 @@ Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(Char_t *oldcalibDir) {
   return kTRUE;
 }
 
-Bool_t AliITSOnlineSPDscanAnalyzer::SaveDeadNoisyPixels(UInt_t module, Char_t *calibDir) {
-  // save dead and noisy pixels to file in dir calibDir
-  if (fHandler[module]!=NULL) {
-    fHandler[module]->SetFileLocation(calibDir);
-    fHandler[module]->WriteToFile(module);
-    return kTRUE;
-  }
-  return kFALSE;
-}
-
-
 Int_t AliITSOnlineSPDscanAnalyzer::GetDelay(UInt_t hs, UInt_t chipNr) {
   // get delay
   if (hs>=6 || chipNr>10) return -1;
@@ -657,12 +681,6 @@ Bool_t AliITSOnlineSPDscanAnalyzer::GetHalfStavePresent(UInt_t hs) {
   return kFALSE;
 }
 
-AliITSOnlineCalibrationSPDhandler* AliITSOnlineSPDscanAnalyzer::GetOnlineCalibrationHandler(UInt_t module) {
-  // returns a pointer to the AliITSOnlineCalibrationSPDhandler
-  if (module<240) return fHandler[module]; 
-  else return NULL;
-}
-
 UInt_t AliITSOnlineSPDscanAnalyzer::GetRouterNr() {
   // returns the router nr of scan obj
   if (fScanObj!=NULL) return fScanObj->GetRouterNr(); 
@@ -700,3 +718,26 @@ TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapTot(UInt_t step) {
   }
   return fHitMapTot;
 }
+
+TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapChip(UInt_t step, UInt_t hs, UInt_t chip) {
+  // creates and returns a pointer to a hitmap histo (chip style a la spdmood)
+  if (fScanObj==NULL) {
+    Error("AliITSOnlineSPDscanAnalyzer::GetHitMapChip","No data!");
+    return NULL;
+  }
+
+  TString histoName;
+  TString histoTitle;
+  histoName = Form("fChipHisto_%d_%d_%d", GetRouterNr(), hs, chip);
+  histoTitle = Form("Eq ID %d, Half Stave %d, Chip %d", GetRouterNr(), hs, chip);
+
+  TH2F *returnHisto = new TH2F(histoName.Data(), histoTitle.Data(), 32, -0.5, 31.5, 256, -0.5, 255.5);
+  returnHisto->SetMinimum(0);
+  for (UInt_t col=0; col<32; col++) {
+    for (UInt_t row=0; row<256; row++) {
+      returnHisto->Fill(col,row,fScanObj->GetHits(step,hs,chip,col,row));
+    }
+  }
+
+  return returnHisto;
+}
index e88d8d8..a03cc72 100644 (file)
@@ -10,7 +10,7 @@
 // This class is used in the detector algorithm framework //
 // to process the data stored in special container files  //
 // (see AliITSOnlineSPDscan). For instance, minimum       //
-// threshold values can be calculated.                    //
+// threshold values can be extracted.                     //
 ////////////////////////////////////////////////////////////
 
 #include <TString.h>
@@ -23,30 +23,31 @@ class TH2F;
 class AliITSOnlineSPDscanAnalyzer {
 
  public:
-  AliITSOnlineSPDscanAnalyzer(const Char_t *fileName);
+  AliITSOnlineSPDscanAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler *handler);
   AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle);
   ~AliITSOnlineSPDscanAnalyzer();
 
   AliITSOnlineSPDscanAnalyzer& operator=(const AliITSOnlineSPDscanAnalyzer& handle);
 
+  Bool_t     IsModuleScanned(UInt_t module) const;
+  Bool_t     IsOverWriteSet() const {return fOverWrite;}
+  void       SetCalibHandler(AliITSOnlineCalibrationSPDhandler *handler) {fHandler=handler;}
   void       SetParam(const Char_t *pname, const Char_t *pval);
+  void       ReadParamsFromLocation(const Char_t *dirName);
 
   UInt_t     GetType() const {return fType;}
   UInt_t     GetDacId() const {return fDacId;}
-  UInt_t     GetRouterNr() const {return fRouterNr;}
 
   Int_t      GetDelay(UInt_t hs, UInt_t chipNr);
   Int_t      GetMinTh(UInt_t hs, UInt_t chipNr);
   
   Int_t      GetNrNoisyUnima(UInt_t hs, UInt_t chipNr);
 
-  Bool_t     ProcessDeadPixels(Char_t *oldCalibDir);
-  Bool_t     ProcessNoisyPixels(Char_t *oldCalibDir);
-  Bool_t     SaveDeadNoisyPixels(UInt_t module, Char_t *calibDir);
+  Bool_t     ProcessDeadPixels();
+  Bool_t     ProcessNoisyPixels();
 
   Bool_t     ProcessNrTriggers();
 
-  AliITSOnlineCalibrationSPDhandler* GetOnlineCalibrationHandler(UInt_t module);
   AliITSOnlineSPDscan* GetOnlineScan() {return fScanObj;}
   UInt_t     GetRouterNr();
   Bool_t     GetHalfStavePresent(UInt_t hs);
@@ -55,17 +56,18 @@ class AliITSOnlineSPDscanAnalyzer {
   TGraph*    GetMeanMultiplicityG(UInt_t hs, UInt_t chipNr);
   TGraph*    GetHitEventEfficiencyG(UInt_t hs, UInt_t chipNr);
   TH2F*      GetHitMapTot(UInt_t step);
+  TH2F*      GetHitMapChip(UInt_t step, UInt_t hs, UInt_t chip);
 
 
  private:
   UInt_t               fType;           // calib type
   UInt_t               fDacId;          // dac id
-  UInt_t               fRouterNr;       // router nr
   TString              fFileName;       // container file name
   enum                 calibvals{kMINTH,kMEANTH,kDAC,kUNIMA,kNOISE,kDELAY};  // calib types
 
-  AliITSOnlineSPDscan               *fScanObj;      // container obj
-  AliITSOnlineCalibrationSPDhandler *fHandler[240]; // calib help objs
+  AliITSOnlineSPDscan               *fScanObj;  // container obj
+  AliITSOnlineCalibrationSPDhandler *fHandler;  // calib helper obj
+  Bool_t     fbModuleScanned[240];        // is module used in scan?
 
   TGraph*    fMeanMultiplicity[6][11];   // mean mult graphs
   TGraph*    fHitEventEfficiency[6][11]; // hit event graphs
index d88bf8d..15e65d9 100644 (file)
@@ -53,8 +53,11 @@ UInt_t AliITSPreprocessorSPD::Process(TMap* /*dcsAliasMap*/)
 
   TString runType = GetRunType();
 
+  UInt_t nrEqForScan  = 0;
+  UInt_t nrEqForPhysN = 0;
+  UInt_t nrEqForPhysD = 0;
 
-
+  // ******************************************************************************************** //
   // *** REFERENCE DATA *** //
 
   // Standalone runs:
@@ -64,15 +67,16 @@ UInt_t AliITSPreprocessorSPD::Process(TMap* /*dcsAliasMap*/)
       runType == "DAQ_NOISY_PIX_SCAN" ||
       runType == "DAQ_PIX_DELAY_SCAN" ||
       runType == "DAQ_FO_UNIF_SCAN") {
-    // Store the scan container files as reference data (one file for each equipment)
+    // Store the scan container files as reference data (0 or 1 file for each equipment)
     for (UInt_t eq=0; eq<20; eq++) {
-      TString id = Form("SPD_reference_%d",eq);
+      TString id = Form("SPD_ref_scan_%d",eq);
       TList* list = GetFileSources(kDAQ,id.Data()); // (the id should be unique, so always 1 file)
       if (list) {
        TObjString* fileNameEntry = (TObjString*) list->First();
        if (fileNameEntry!=NULL) {
+         nrEqForScan++;
          TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
-         TString refCAT = Form("SPDref_eq_%d.root",eq);
+         TString refCAT = Form("SPD_ref_scan_eq_%d",eq);
          if (!StoreReferenceFile(fileName.Data(),refCAT.Data())) {
            Log(Form("Failed to store reference file %s.",fileName.Data()));
            return 1;
@@ -84,78 +88,193 @@ UInt_t AliITSPreprocessorSPD::Process(TMap* /*dcsAliasMap*/)
 
   // Physics runs (online monitoring):
   if (runType == "PHYSICS") {
-    // *** code to be written *** //
+    // Store the phys "per run" container files as reference data (0 or 1 file for each equipment)
+    for (UInt_t eq=0; eq<20; eq++) {
+      TString id = Form("SPD_ref_phys_%d",eq);
+      TList* list = GetFileSources(kDAQ,id.Data()); // (the id should be unique, so always 1 file)
+      if (list) {
+       TObjString* fileNameEntry = (TObjString*) list->First();
+       if (fileNameEntry!=NULL) {
+         nrEqForPhysN++;
+         TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
+         TString refCAT = Form("SPD_ref_phys_eq_%d",eq);
+         if (!StoreReferenceFile(fileName.Data(),refCAT.Data())) {
+           Log(Form("Failed to store reference file %s.",fileName.Data()));
+           return 1;
+         }
+       }
+      }
+    }
+    // Store the phys "dead" container files as reference data (0 or 1 file for each equipment)
+    for (UInt_t eq=0; eq<20; eq++) {
+      TString id = Form("SPD_ref_phys_dead_%d",eq);
+      TList* list = GetFileSources(kDAQ,id.Data()); // (the id should be unique, so always 1 file)
+      if (list) {
+       TObjString* fileNameEntry = (TObjString*) list->First();
+       if (fileNameEntry!=NULL) {
+         nrEqForPhysD++;
+         TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
+         TString refCAT = Form("SPD_ref_phys_dead_eq_%d",eq);
+         if (!StoreReferenceFile(fileName.Data(),refCAT.Data())) {
+           Log(Form("Failed to store reference file %s.",fileName.Data()));
+           return 1;
+         }
+       }
+      }
+    }
   }
 
+  // ******************************************************************************************** //
 
 
   // *** NOISY AND DEAD DATA *** //
 
-  if (runType == "DAQ_NOISY_PIX_SCAN" || runType == "PHYSICS") {
-    // Read old calibration
-    AliCDBEntry* cdbEntry = GetFromOCDB("Calib", "CalibSPD");
-    TObjArray* spdEntry;
+  // Standalone runs:
+  if (runType == "DAQ_NOISY_PIX_SCAN") {
+    // Retrieve and unpack tared calibration files from FXS
+    TList* list = GetFileSources(kDAQ,"SPD_scan_noisy");
+    if (list) {
+      UInt_t index = 0;
+      while (list->At(index)!=NULL) {
+       TObjString* fileNameEntry = (TObjString*) list->At(index);
+       TString fileName = GetFile(kDAQ, "SPD_scan_noisy", fileNameEntry->GetString().Data());
+       TString command = Form("tar -xf %s",fileName.Data());
+       gSystem->Exec(command.Data());
+       index++;
+      }
+    }
+    // Create new database entries
+    TObjArray* spdEntryNoisy = new TObjArray(240);
+    spdEntryNoisy->SetOwner(kTRUE);
+    for(UInt_t module=0; module<240; module++){
+      AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
+      spdEntryNoisy->Add(calObj);
+    }
+    // Add noisy from the copied FXS files
+    AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
+    TString fileLoc = ".";
+    handler->SetFileLocation(fileLoc.Data());
+    handler->ReadNoisyFromFiles();
+    for (Int_t module=0; module<240; module++) {
+      ((AliITSCalibrationSPD*) spdEntryNoisy->At(module)) -> SetNrBad( handler->GetNrNoisy(module) );
+      ((AliITSCalibrationSPD*) spdEntryNoisy->At(module)) -> SetBadList( handler->GetNoisyArray(module) );
+    }
+    delete handler;
+    // Store the new calibration objects in OCDB
+    Log("Noisy lists (scan) will be stored...");
+    AliCDBMetaData metaData;
+    metaData.SetBeamPeriod(0);
+    metaData.SetResponsible("Henrik Tydesjo");
+    metaData.SetComment("Created by SPD PreProcessor");
+    // validity for this run until infinity
+    if (!Store("Calib", "SPDNoisy", spdEntryNoisy, &metaData, 0, kTRUE)) {
+      Log("Failed to store calibration data.");
+      return 1;
+    }
+    Log("Database updated.");
+    delete spdEntryNoisy;
+  }
+
+  // Physics runs (online monitoring):
+  else if (runType == "PHYSICS") {
+
+    // Noisy pixels:
+    // Read noisy from previous calibration
+    AliCDBEntry* cdbEntry = GetFromOCDB("Calib", "SPDNoisy");
+    TObjArray* spdEntryNoisy;
     if(cdbEntry) {
-      spdEntry = (TObjArray*)cdbEntry->GetObject();
-      if(!spdEntry) return 1;
+      spdEntryNoisy = (TObjArray*)cdbEntry->GetObject();
+      if(!spdEntryNoisy) return 1;
     }
     else {
       Log("Old calibration not found in database. This is required for further processing.");
       return 1;
     }
-
-    // Standalone runs:
-    if (runType == "DAQ_NOISY_PIX_SCAN") {
-      UInt_t nrUpdatedMods = 0;
-      // Retrieve and unpack tared calibration files from FXS
-      TList* list = GetFileSources(kDAQ,"SPD_noisy");
-      if (list) {
-       UInt_t index = 0;
-       while (list->At(index)!=NULL) {
-         TObjString* fileNameEntry = (TObjString*) list->At(index);
-         TString fileName = GetFile(kDAQ, "SPD_noisy", fileNameEntry->GetString().Data());
-         TString command = Form("tar -xf %s",fileName.Data());
-         gSystem->Exec(command.Data());
-         index++;
-       }
+    AliITSOnlineCalibrationSPDhandler* handOld = new AliITSOnlineCalibrationSPDhandler();
+    handOld->ReadNoisyFromCalibObj(spdEntryNoisy);
+    // Retrieve and unpack tared calibration files from FXS
+    TList* listN = GetFileSources(kDAQ,"SPD_phys_noisy");
+    if (listN) {
+      UInt_t index = 0;
+      while (listN->At(index)!=NULL) {
+       TObjString* fileNameEntry = (TObjString*) listN->At(index);
+       TString fileName = GetFile(kDAQ, "SPD_phys_noisy", fileNameEntry->GetString().Data());
+       TString command = Form("tar -xf %s",fileName.Data());
+       gSystem->Exec(command.Data());
+       index++;
       }
-      // Update the database entries for the modules that were scanned
-      AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
-      TString fileLoc = ".";
-      handler->SetFileLocation(fileLoc.Data());
+    }
+    AliITSOnlineCalibrationSPDhandler* handNew = new AliITSOnlineCalibrationSPDhandler();
+    handNew->SetFileLocation(".");
+    handNew->ReadNoisyFromFiles();
+    // add the new list to the old one
+    UInt_t nrNewNoisy = handOld->AddNoisyFrom(handNew);
+    // If new noisy pixels were found: Update calibration objects
+    if (nrNewNoisy>0) {
       for (Int_t module=0; module<240; module++) {
-       if (handler->ReadFromFile(module)) {
-         ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrNoisy( handler->GetNrNoisy(module) );
-         ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNoisyList( handler->GetNoisyArray(module) );
-         nrUpdatedMods++;
-       }
+       ((AliITSCalibrationSPD*) spdEntryNoisy->At(module)) -> SetNrBad( handOld->GetNrNoisy(module) );
+       ((AliITSCalibrationSPD*) spdEntryNoisy->At(module)) -> SetBadList( handOld->GetNoisyArray(module) );
       }
-      delete handler;
-      // Store the new calibration objects (if any modifications were made) in OCDB
-      if (nrUpdatedMods>0) {
-       Log(Form("Noisy lists for %d modules will be updated and stored...",nrUpdatedMods));
-       AliCDBMetaData metaData;
-       metaData.SetBeamPeriod(0);
-       metaData.SetResponsible("Henrik Tydesjo");
-       metaData.SetComment("Preprocessor test for SPD.");  
-       if (!Store("Calib", "CalibSPD", spdEntry, &metaData, 0, kTRUE)) {
-         Log("Failed to store calibration data.");
-         return 1;
-       }
-       Log("Database updated.");
+      // Store the new calibration objects in OCDB
+      Log("Noisy lists (phys) will be stored...");
+      AliCDBMetaData metaData;
+      metaData.SetBeamPeriod(0);
+      metaData.SetResponsible("Henrik Tydesjo");
+      metaData.SetComment("Created by SPD PreProcessor");  
+      // validity for this run only
+      if (!Store("Calib", "SPDNoisy", spdEntryNoisy, &metaData, 0, kFALSE)) {
+       Log("Failed to store calibration data.");
+       return 1;
       }
+      Log("Database updated.");
     }
+    delete handNew;
 
-    // Physics runs (online monitoring):
-    if (runType == "PHYSICS") {
-      // *** code to be written *** //
+    // Dead pixels:
+    // Retrieve and unpack tared calibration files from FXS
+    TList* listD = GetFileSources(kDAQ,"SPD_phys_dead");
+    if (listD) {
+      UInt_t index = 0;
+      while (listD->At(index)!=NULL) {
+       TObjString* fileNameEntry = (TObjString*) listD->At(index);
+       TString fileName = GetFile(kDAQ, "SPD_phys_dead", fileNameEntry->GetString().Data());
+       TString command = Form("tar -xf %s",fileName.Data());
+       gSystem->Exec(command.Data());
+       index++;
+      }
     }
-
+    // Create new database entries
+    TObjArray* spdEntryDead = new TObjArray(240);
+    spdEntryDead->SetOwner(kTRUE);
+    for(UInt_t module=0; module<240; module++){
+      AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
+      spdEntryDead->Add(calObj);
+    }
+    // Add dead from the copied FXS files
+    handOld->SetFileLocation(".");
+    handOld->ReadDeadFromFiles();
+    for (Int_t module=0; module<240; module++) {
+      ((AliITSCalibrationSPD*) spdEntryDead->At(module)) -> SetNrBad( handOld->GetNrDead(module) );
+      ((AliITSCalibrationSPD*) spdEntryDead->At(module)) -> SetBadList( handOld->GetDeadArray(module) );
+    }
+    delete handOld;
+    // Store the new calibration objects in OCDB
+    Log("Dead lists (phys) will be stored...");
+    AliCDBMetaData metaData;
+    metaData.SetBeamPeriod(0);
+    metaData.SetResponsible("Henrik Tydesjo");
+    metaData.SetComment("Created by SPD PreProcessor");
+    // validity for this run only
+    if (!Store("Calib", "SPDDead", spdEntryDead, &metaData, 0, kFALSE)) {
+      Log("Failed to store calibration data.");
+      return 1;
+    }
+    Log("Database updated.");
+    delete spdEntryDead;
 
   }
 
 
-
   return 0; // 0 means success
 
 }
index bcf5286..402851e 100644 (file)
@@ -28,7 +28,6 @@
 ClassImp(AliITSRawStreamSPD)
 
 
-  // this map has to change, waiting for the new geometry
 const Int_t AliITSRawStreamSPD::fgkDDLModuleMap[kDDLsNumber][kModulesPerDDL] = {
   { 0, 1, 4, 5, 80, 81, 84, 85, 88, 89, 92, 93},
   { 8, 9,12,13, 96, 97,100,101,104,105,108,109},
@@ -208,8 +207,7 @@ Bool_t AliITSRawStreamSPD::Next()
        fHalfStaveNr=5;
       }
       // translate  ("online") ddl, hs, chip nr  to  ("offline") module id :
-      fModuleID = fgkDDLModuleMap[ddlID][fHalfStaveNr*2+fChipAddr/5];
-      fOffset = 32 * (fChipAddr % 5);
+      fModuleID = GetOfflineModuleFromOnline(ddlID,fHalfStaveNr,fChipAddr);
     } 
     else if ((fData & 0xC000) == 0x0000) {    // trailer
       UShort_t hitCount = fData & 0x1FFF;
@@ -223,15 +221,8 @@ Bool_t AliITSRawStreamSPD::Next()
       fCol = (fData & 0x001F);
       fRow = (fData >> 5) & 0x00FF;
 
-      // translate  ("online") chipcol, chiprow  to  ("offline") col (coord1), row (coord2): 
-      // This will change, waiting for new geometry!!!
-      fCoord1 = fCol;
-      //      if      (fModuleID < 80 && ddlID < 10) fCoord1=31-fCoord1;
-      //      else if (fModuleID >=80 && ddlID >=10) fCoord1=31-fCoord1;
-      fCoord1 += fOffset;
-      //      if (ddlID>=10) fCoord1=159-fCoord1;
-      fCoord2 = fRow;
-      //      if (fModuleID<80) fCoord2=255-fCoord2;
+      fCoord1 = GetOfflineColFromOnline(ddlID,fHalfStaveNr,fChipAddr,fCol);
+      fCoord2 = GetOfflineRowFromOnline(ddlID,fHalfStaveNr,fChipAddr,fRow);
 
       return kTRUE;
     } 
@@ -294,3 +285,103 @@ Bool_t AliITSRawStreamSPD::GetHminTHchipPresent(UInt_t chip) const {
   if (chip<10) return ((( fCalHeadWord[7]>>(16+chip)) & 0x00000001) == 1);
   else return kFALSE;
 }
+
+
+
+
+Int_t AliITSRawStreamSPD::GetModuleNumber(UInt_t iDDL, UInt_t iModule) {
+  if (iDDL<20 && iModule<12) return fgkDDLModuleMap[iDDL][iModule];
+  else return 240;
+}
+
+
+
+
+Bool_t AliITSRawStreamSPD::OfflineToOnline(UInt_t module, UInt_t colM, UInt_t rowM, UInt_t& eq, UInt_t& hs, UInt_t& chip, UInt_t& col, UInt_t& row) {
+  // converts offline coordinates to online
+  eq = GetOnlineEqIdFromOffline(module);
+  hs = GetOnlineHSFromOffline(module);
+  chip = GetOnlineChipFromOffline(module,colM);
+  col = GetOnlineColFromOffline(module,colM);
+  row = GetOnlineRowFromOffline(module,rowM);
+  if (eq>=20 || hs>=6 || chip>=10 || col>=32 || row>=256) return kFALSE;
+  else return kTRUE;
+}
+
+
+Bool_t AliITSRawStreamSPD::OnlineToOffline(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row, UInt_t& module, UInt_t& colM, UInt_t& rowM) {
+  // converts online coordinates to offline
+  module = GetOfflineModuleFromOnline(eq,hs,chip);
+  colM = GetOfflineColFromOnline(eq,hs,chip,col);
+  rowM = GetOfflineRowFromOnline(eq,hs,chip,row);
+  if (module>=240 || colM>=160 || rowM>=256) return kFALSE;
+  else return kTRUE;
+}
+
+
+UInt_t AliITSRawStreamSPD::GetOnlineEqIdFromOffline(UInt_t module) {
+  // offline->online (eq)
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    for (UInt_t iModule=0; iModule<12; iModule++) {
+      if (GetModuleNumber(eqId,iModule)==(Int_t)module) return eqId;
+    }
+  }
+  return 20; // error
+}
+
+UInt_t AliITSRawStreamSPD::GetOnlineHSFromOffline(UInt_t module) {
+  // offline->online (hs)
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    for (UInt_t iModule=0; iModule<12; iModule++) {
+      if (GetModuleNumber(eqId,iModule)==(Int_t)module) return iModule/2;
+    }
+  }
+  return 6; // error
+}
+
+UInt_t AliITSRawStreamSPD::GetOnlineChipFromOffline(UInt_t module, UInt_t colM) {
+  // offline->online (chip)
+  for (UInt_t eq=0; eq<20; eq++) {
+    for (UInt_t iModule=0; iModule<12; iModule++) {
+      if (GetModuleNumber(eq,iModule)==(Int_t)module) {
+       return colM/32 + 5*(iModule%2);
+      }
+    }
+  }
+  return 10; // error
+}
+
+UInt_t AliITSRawStreamSPD::GetOnlineColFromOffline(UInt_t module, UInt_t colM) {
+  // offline->online (col)
+  if (colM<160) return colM%32;
+  else return 32; // error
+}
+
+UInt_t AliITSRawStreamSPD::GetOnlineRowFromOffline(UInt_t module, UInt_t rowM) {
+  // offline->online (row)
+  if (rowM<256) return rowM;
+  else return 256; // error
+}
+
+
+
+
+
+UInt_t AliITSRawStreamSPD::GetOfflineModuleFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip) {
+  // online->offline (module)
+  if (eqId<20 && hs<6 && chip<10) return fgkDDLModuleMap[eqId][hs*2+chip/5];
+  else return 240;
+}
+
+UInt_t AliITSRawStreamSPD::GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col) {
+  // online->offline (col)
+  if (eqId>=20 || hs>=6 || chip>=10 || col>=32) return 160; // error
+  UInt_t offset = 32 * (chip % 5);
+  return col+offset;
+}
+
+UInt_t AliITSRawStreamSPD::GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t row) {
+  // online->offline (row)
+  if (eqId>=20 || hs>=6 || chip>=10 || row>=256) return 256; // error
+  return row;
+}
index 55d3884..babc5ec 100644 (file)
@@ -34,8 +34,24 @@ class AliITSRawStreamSPD: public AliITSRawStream {
     Int_t    GetChipRow() const {return fRow;};
 
     // module mapping
-    static Int_t GetModuleNumber(UInt_t iDDL, UInt_t iModule) {return fgkDDLModuleMap[iDDL][iModule];}
-    static Int_t GetModuleNumber(UInt_t iDDL, UInt_t iHS, UInt_t iChip) {return fgkDDLModuleMap[iDDL][iHS*2+iChip/5];}
+    static Int_t GetModuleNumber(UInt_t iDDL, UInt_t iModule);
+    static Int_t GetModuleNumber(UInt_t iDDL, UInt_t iHS, UInt_t iChip) 
+      {return GetOfflineModuleFromOnline(iDDL,iHS,iChip);}
+
+    // coordinate conversions:
+    static Bool_t OfflineToOnline(UInt_t module, UInt_t colM, UInt_t RowM, UInt_t& eq, UInt_t& hs, UInt_t& chip, UInt_t& col, UInt_t& row);
+    static Bool_t OnlineToOffline(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row, UInt_t& module, UInt_t& colM, UInt_t& rowM);
+    // coordinate conversions - offline->online
+    static UInt_t GetOnlineEqIdFromOffline(UInt_t module);
+    static UInt_t GetOnlineHSFromOffline(UInt_t module);
+    static UInt_t GetOnlineChipFromOffline(UInt_t module, UInt_t colM);
+    static UInt_t GetOnlineColFromOffline(UInt_t module, UInt_t colM);
+    static UInt_t GetOnlineRowFromOffline(UInt_t module, UInt_t rowM);
+    // coordinate conversions - online->offline
+    static UInt_t GetOfflineModuleFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip);
+    static UInt_t GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col);
+    static UInt_t GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t row);
+
 
     Bool_t GetHalfStavePresent(UInt_t hs);
 
diff --git a/ITS/AliITSRawStreamSPD_NEWGEO.cxx b/ITS/AliITSRawStreamSPD_NEWGEO.cxx
new file mode 100644 (file)
index 0000000..16cb686
--- /dev/null
@@ -0,0 +1,433 @@
+/**************************************************************************
+ * Copyright(c) 2007-2009, 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.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This class provides access to ITS SPD digits in raw data.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliITSRawStreamSPD.h"
+#include "AliRawReader.h"
+#include "AliLog.h"
+
+ClassImp(AliITSRawStreamSPD)
+
+
+const Int_t AliITSRawStreamSPD::fgkDDLModuleMap[kDDLsNumber][kModulesPerDDL] = {
+  { 4, 5, 0, 1, 80, 81, 84, 85, 88, 89, 92, 93},
+  {12,13, 8, 9, 96, 97,100,101,104,105,108,109},
+  {20,21,16,17,112,113,116,117,120,121,124,125},
+  {28,29,24,25,128,129,132,133,136,137,140,141},
+  {36,37,32,33,144,145,148,149,152,153,156,157},
+  {44,45,40,41,160,161,164,165,168,169,172,173},
+  {52,53,48,49,176,177,180,181,184,185,188,189},
+  {60,61,56,57,192,193,196,197,200,201,204,205},
+  {68,69,64,65,208,209,212,213,216,217,220,221},
+  {76,77,72,73,224,225,228,229,232,233,236,237},
+  { 7, 6, 3, 2, 83, 82, 87, 86, 91, 90, 95, 94},
+  {15,14,11,10, 99, 98,103,102,107,106,111,110},
+  {23,22,19,18,115,114,119,118,123,122,127,126},
+  {31,30,27,26,131,130,135,134,139,138,143,142},
+  {39,38,35,34,147,146,151,150,155,154,159,158},
+  {47,46,43,42,163,162,167,166,171,170,175,174},
+  {55,54,51,50,179,178,183,182,187,186,191,190},
+  {63,62,59,58,195,194,199,198,203,202,207,206},
+  {71,70,67,66,211,210,215,214,219,218,223,222},
+  {79,78,75,74,227,226,231,230,235,234,239,238}
+};
+
+
+AliITSRawStreamSPD::AliITSRawStreamSPD(AliRawReader* rawReader) :
+  AliITSRawStream(rawReader),
+  fEventNumber(-1),fChipAddr(0),fHalfStaveNr(0),fCol(0),fRow(0),
+  fData(0),fOffset(0),fHitCount(0),
+  fDataChar1(0),fDataChar2(0),fDataChar3(0),fDataChar4(0),
+  fFirstWord(kTRUE),fPrevEventId(0xffffffff)
+{
+  // create an object to read ITS SPD raw digits
+  fRawReader->Select("ITSSPD");
+  // reset calib header words
+  for (UInt_t iword=0; iword<kCalHeadLenMax; iword++) {
+    fCalHeadWord[iword]=0xffffffff;
+  }
+  NewEvent();
+}
+
+Bool_t AliITSRawStreamSPD::ReadNextShort() 
+{
+  // read next 16 bit word into fData
+  if (fFirstWord) {
+    Bool_t b1 = fRawReader->ReadNextChar(fDataChar1);
+    if (!b1) return kFALSE;
+    Bool_t  b2, b3, b4;
+    b2 = fRawReader->ReadNextChar(fDataChar2);
+    b3 = fRawReader->ReadNextChar(fDataChar3);
+    b4 = fRawReader->ReadNextChar(fDataChar4);
+    if (!(b2 && b3 && b4)) {
+      return kFALSE;
+    }
+    fData = fDataChar3+(fDataChar4<<8);
+    if ((*fRawReader->GetEventId())!=fPrevEventId) { // if new event...
+      NewEvent();
+      fPrevEventId=(*fRawReader->GetEventId());
+    }
+    fFirstWord=kFALSE;
+  }
+  else {
+    fFirstWord=kTRUE;
+    fData = fDataChar1+(fDataChar2<<8);
+  }
+
+  return kTRUE;
+}
+
+Bool_t AliITSRawStreamSPD::ReadNextInt() 
+{
+  // reads next 32 bit into fDataChar1..4 
+  // (if first 16 bits read already, just completes the present word)
+  if (fFirstWord) {
+    if (ReadNextShort() && ReadNextShort()) {
+      return kTRUE;
+    }
+  }
+  else {
+    if (ReadNextShort()) {
+      return kTRUE;
+    }
+  }
+  return kFALSE;
+}
+
+void AliITSRawStreamSPD::NewEvent()
+{
+  // call this to reset flags for a new event
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    fCalHeadRead[eqId]=kFALSE;
+  }
+  fEventNumber=-1;
+}
+
+Bool_t AliITSRawStreamSPD::ReadCalibHeader()
+{
+  // read the extra calibration header
+  // returns kTRUE if the header is present and has length > 0
+
+  Int_t ddlID = fRawReader->GetDDLID();
+  if (ddlID==-1) { // we may need to read one word to get the blockAttr
+    if (!ReadNextShort()) return kFALSE;
+    ddlID = fRawReader->GetDDLID();
+  }
+  UChar_t attr = fRawReader->GetBlockAttributes();
+  if (ddlID>=0 && ddlID<20) fCalHeadRead[ddlID]=kTRUE;
+  if ((attr & 0x40) == 0x40) { // is the header present?
+    if (ReadNextInt()) {
+      // length of cal header:
+      UInt_t calLen = fDataChar1+(fDataChar2<<8)+(fDataChar3<<16)+(fDataChar4<<24);
+      if (calLen>kCalHeadLenMax) {
+       fRawReader->AddMajorErrorLog(kCalHeaderLengthErr,Form("Header length %d > max = %d",calLen,kCalHeadLenMax));
+       AliWarning(Form("Header length problem. %d > %d (max)",calLen,kCalHeadLenMax));
+       return kFALSE;
+      }
+      else if (calLen>0) {
+       for (UInt_t iword=0; iword<calLen; iword++) {
+         if (ReadNextInt()) {
+           fCalHeadWord[iword] = fDataChar1+(fDataChar2<<8)+(fDataChar3<<16)+(fDataChar4<<24);
+         }
+         else {
+           fRawReader->AddMajorErrorLog(kCalHeaderLengthErr,"header length problem");
+           AliWarning("header length problem");
+           return kFALSE;
+         }
+       }
+       return kTRUE;
+      }
+    }
+  }
+
+  return kFALSE;
+}
+
+Bool_t AliITSRawStreamSPD::Next()
+{
+// read the next raw digit
+// returns kFALSE if there is no digit left
+
+  Int_t ddlID=-1;
+  fPrevModuleID = fModuleID;
+
+  while (ReadNextShort()) {
+
+    ddlID = fRawReader->GetDDLID();
+    if (ddlID>=0 && ddlID<20) {
+      if (!fCalHeadRead[ddlID]) {
+       ReadCalibHeader();
+      }
+    }
+    else {
+      fRawReader->AddMajorErrorLog(kDDLNumberErr,Form("Wrong DDL number %d",ddlID)); 
+      AliWarning(Form("DDL number error (= %d) , setting it to 19", ddlID));
+      ddlID=19;
+    }
+
+    if ((fData & 0xC000) == 0x4000) {         // header
+      fHitCount = 0;
+      UShort_t eventNumber = (fData >> 4) & 0x007F;
+      if (fEventNumber < 0) {
+       fEventNumber = eventNumber;
+      } 
+      else if (eventNumber != fEventNumber) {
+       fRawReader->AddMajorErrorLog(kEventNumberErr,Form("Reading event number %d instead of %d",eventNumber,fEventNumber));
+       AliWarning(Form("mismatching event numbers: %d != %d",eventNumber, fEventNumber));
+      }
+      fChipAddr = fData & 0x000F;
+      if (fChipAddr>9) {
+       fRawReader->AddMajorErrorLog(kChipAddrErr,Form("Overflow chip address %d - set to 9",fChipAddr));
+       AliWarning(Form("overflow chip addr (= %d) , setting it to 9", fChipAddr));
+       fChipAddr=9;
+      }
+      fHalfStaveNr = (fData & 0x3800)>>11;
+      if (fHalfStaveNr>5 || fRawReader->TestBlockAttribute(fHalfStaveNr)) {
+       fRawReader->AddMajorErrorLog(kStaveNumberErr,Form("Half stave number error %d - set to 5",fHalfStaveNr));
+       AliWarning(Form("half stave number error(=%d) , setting it to 5", fHalfStaveNr));
+       fHalfStaveNr=5;
+      }
+      // translate  ("online") ddl, hs, chip nr  to  ("offline") module id :
+      fModuleID = GetOfflineModuleFromOnline(ddlID,fHalfStaveNr,fChipAddr);
+      //      fOffset = 32 * (fChipAddr % 5);
+    } 
+    else if ((fData & 0xC000) == 0x0000) {    // trailer
+      UShort_t hitCount = fData & 0x1FFF;
+      if (hitCount != fHitCount){
+       fRawReader->AddMajorErrorLog(kNumbHitsErr,Form("Number of hits %d instead of %d",hitCount,fHitCount));
+       AliWarning(Form("wrong number of hits: %d != %d", fHitCount, hitCount));
+      }
+    }
+    else if ((fData & 0xC000) == 0x8000) {    // pixel hit
+      fHitCount++;
+      fCol = (fData & 0x001F);
+      fRow = (fData >> 5) & 0x00FF;
+
+      fCoord1 = GetOfflineColFromOnline(ddlID,fHalfStaveNr,fChipAddr,fCol);
+      fCoord2 = GetOfflineRowFromOnline(ddlID,fHalfStaveNr,fChipAddr,fRow);
+
+      // translate  ("online") chipcol, chiprow  to  ("offline") col (coord1), row (coord2): 
+      // This will change, waiting for new geometry!!!
+      //      fCoord1 = fCol;
+      //      if      (fModuleID < 80 && ddlID < 10) fCoord1=31-fCoord1;
+      //      else if (fModuleID >=80 && ddlID >=10) fCoord1=31-fCoord1;
+      //      fCoord1 += fOffset;
+      //      if (ddlID>=10) fCoord1=159-fCoord1;
+      //      fCoord2 = fRow;
+      //      if (fModuleID<80) fCoord2=255-fCoord2;
+
+      return kTRUE;
+    } 
+    else {                                    // fill word
+      if ((fData & 0xC000) != 0xC000) {
+       fRawReader->AddMajorErrorLog(kWrongWordErr,"Wrong fill word");
+       AliWarning("wrong fill word!");
+      }
+    }
+
+  }
+
+  return kFALSE;
+}
+Bool_t AliITSRawStreamSPD::GetHalfStavePresent(UInt_t hs) {
+  // Reads the half stave present status from the block attributes
+  Int_t ddlID = fRawReader->GetDDLID();
+  if (ddlID==-1) {
+    fRawReader->AddMinorErrorLog(kHalfStaveStatusErr,"DDL ID = -1. Cannot read block attributes.");
+    AliWarning("DDL ID = -1. Cannot read block attributes. Return kFALSE.");
+    return kFALSE;
+  }
+  else {
+    if (hs>=6) {
+      fRawReader->AddMinorErrorLog(kHalfStaveStatusErr,Form( "HS >= 6 requested (%d). Return kFALSE.",hs));
+      AliWarning(Form("HS >= 6 requested (%d). Return kFALSE.",hs));
+      return kFALSE;
+    }
+    UChar_t attr = fRawReader->GetBlockAttributes();
+    if (((attr>>hs) & 0x01) == 0x01) { // bit set means not present
+      return kFALSE;
+    }
+    else {
+      return kTRUE;
+    }
+  }
+}
+
+Bool_t AliITSRawStreamSPD::GetHhalfStaveScanned(UInt_t hs) const {
+  if (hs<6) return (Bool_t)((fCalHeadWord[0]>>(6+hs)) & (0x00000001));
+  else return kFALSE;
+}
+Bool_t AliITSRawStreamSPD::GetHchipPresent(UInt_t hs, UInt_t chip) const {
+  if (hs<6 && chip<10) return ((( fCalHeadWord[hs/3+3]>>((hs%3)*10+chip)) & 0x00000001) == 1);
+  else return kFALSE;
+}
+UInt_t AliITSRawStreamSPD::GetHdacHigh(UInt_t hs) const {
+  if (hs<6) return (fCalHeadWord[hs/2+7]>>(24-16*(hs%2)) & 0x000000ff);
+  else return 0;
+}
+UInt_t AliITSRawStreamSPD::GetHdacLow(UInt_t hs) const {
+  if (hs<6) return (fCalHeadWord[hs/2+7]>>(16-16*(hs%2)) & 0x000000ff);
+  else return 0;
+}
+UInt_t AliITSRawStreamSPD::GetHTPAmp(UInt_t hs) const {
+  if (hs<6) return fCalHeadWord[hs+10];
+  else return 0;
+}
+Bool_t AliITSRawStreamSPD::GetHminTHchipPresent(UInt_t chip) const {
+  if (chip<10) return ((( fCalHeadWord[7]>>(16+chip)) & 0x00000001) == 1);
+  else return kFALSE;
+}
+
+
+
+
+Int_t AliITSRawStreamSPD::GetModuleNumber(UInt_t iDDL, UInt_t iModule) {
+  if (iDDL<20 && iModule<12) return fgkDDLModuleMap[iDDL][iModule];
+  else return 240;
+}
+
+
+
+
+Bool_t AliITSRawStreamSPD::OfflineToOnline(UInt_t module, UInt_t colM, UInt_t rowM, UInt_t& eq, UInt_t& hs, UInt_t& chip, UInt_t& col, UInt_t& row) {
+  // converts offline coordinates to online
+  eq = GetOnlineEqIdFromOffline(module);
+  hs = GetOnlineHSFromOffline(module);
+  chip = GetOnlineChipFromOffline(module,colM);
+  col = GetOnlineColFromOffline(module,colM);
+  row = GetOnlineRowFromOffline(module,rowM);
+  if (eq>=20 || hs>=6 || chip>=10 || col>=32 || row>=256) return kFALSE;
+  else return kTRUE;
+}
+
+
+Bool_t AliITSRawStreamSPD::OnlineToOffline(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row, UInt_t& module, UInt_t& colM, UInt_t& rowM) {
+  // converts online coordinates to offline
+  module = GetOfflineModuleFromOnline(eq,hs,chip);
+  colM = GetOfflineColFromOnline(eq,hs,chip,col);
+  rowM = GetOfflineRowFromOnline(eq,hs,chip,row);
+  if (module>=240 || colM>=160 || rowM>=256) return kFALSE;
+  else return kTRUE;
+}
+
+
+UInt_t AliITSRawStreamSPD::GetOnlineEqIdFromOffline(UInt_t module) {
+  // offline->online (eq)
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    for (UInt_t iModule=0; iModule<12; iModule++) {
+      if (GetModuleNumber(eqId,iModule)==(Int_t)module) return eqId;
+    }
+  }
+  return 20; // error
+}
+
+UInt_t AliITSRawStreamSPD::GetOnlineHSFromOffline(UInt_t module) {
+  // offline->online (hs)
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    for (UInt_t iModule=0; iModule<12; iModule++) {
+      if (GetModuleNumber(eqId,iModule)==(Int_t)module) return iModule/2;
+    }
+  }
+  return 6; // error
+}
+
+UInt_t AliITSRawStreamSPD::GetOnlineChipFromOffline(UInt_t module, UInt_t colM) {
+  // offline->online (chip)
+  for (UInt_t eq=0; eq<20; eq++) {
+    for (UInt_t iModule=0; iModule<12; iModule++) {
+      if (GetModuleNumber(eq,iModule)==(Int_t)module) {
+       if (eq<10) { // side A
+         return (159-colM)/32 + 5*(iModule%2);
+       }
+       else { // side C
+         return colM/32 + 5*(iModule%2);
+       }
+      }
+    }
+  }
+  return 10; // error
+}
+
+UInt_t AliITSRawStreamSPD::GetOnlineColFromOffline(UInt_t module, UInt_t colM) {
+  // offline->online (col)
+  if (module<80) { // inner layer
+    return colM%32;
+  }
+  else if (module<240) { // outer layer
+    return (159-colM)%32;
+  }
+  return 32; // error
+}
+
+UInt_t AliITSRawStreamSPD::GetOnlineRowFromOffline(UInt_t module, UInt_t rowM) {
+  // offline->online (row)
+  if (module<80) { // inner layer
+    return rowM;
+  }
+  else if (module<240) { // outer layer
+    return (255-rowM);
+  }
+  return 256; // error
+}
+
+
+
+
+
+UInt_t AliITSRawStreamSPD::GetOfflineModuleFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip) {
+  // online->offline (module)
+  if (eqId<20 && hs<6 && chip<10) return fgkDDLModuleMap[eqId][hs*2+chip/5];
+  else return 240;
+}
+
+UInt_t AliITSRawStreamSPD::GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col) {
+  // online->offline (col)
+  if (eqId>=20 || hs>=6 || chip>=10 || col>=32) return 160; // error
+  UInt_t offset = 32 * (chip % 5);
+  if (hs<2) {
+    if (eqId<10) {
+      return 159 - (31-col + offset); // inner layer, side A
+    }
+    else {
+      return col + offset; // inner layer, side C
+    }
+  }
+  else {
+    if (eqId<10) {
+      return 159 - (col + offset); // outer layer, side A
+    }
+    else {
+      return 31-col + offset; // outer layer, side C
+    }
+  }
+}
+
+UInt_t AliITSRawStreamSPD::GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t row) {
+  // online->offline (row)
+  if (eqId>=20 || hs>=6 || chip>=10 || row>=256) return 256; // error
+  if (hs<2) {
+    return row;
+  }
+  else {
+    return 255-row;
+  }
+}
index e833ba5..4381468 100644 (file)
@@ -655,11 +655,11 @@ void AliITSsimulationSPD::RemoveDeadPixels(AliITSmodule *mod){
   Int_t moduleNr = mod->GetIndex();
   AliITSCalibrationSPD* calObj = (AliITSCalibrationSPD*) GetCalibrationModel(moduleNr);
 
-  Int_t nrDead = calObj->GetNrDead();
+  Int_t nrDead = calObj->GetNrBad();
 //  cout << "Module --> " << moduleNr << endl; // dom
 //  cout << "nr of dead " << nrDead << endl; // dom
   for (Int_t i=0; i<nrDead; i++) {
-    GetMap()->DeleteHit(calObj->GetDeadColAt(i),calObj->GetDeadRowAt(i));
+    GetMap()->DeleteHit(calObj->GetBadColAt(i),calObj->GetBadRowAt(i));
 //    cout << "dead index " << i << endl; // dom
 //    cout << "col row --> " << calObj->GetDeadColAt(i) << " " << calObj->GetDeadRowAt(i) << endl; // dom
   }
index e735c6b..050926c 100644 (file)
@@ -2675,7 +2675,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
   /////////////////////////////////////////////////////////////
   // Checking overlaps 
   /////////////////////////////////////////////////////////////
-       coolingsystemother->CheckOverlaps(0.01);
+       //coolingsystemother->CheckOverlaps(0.01);
   /////////////////////////////////////////////////////////////
        return coolingsystemother;
 }
@@ -2788,7 +2788,7 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
                                         +                                         fgkSSDFlexHeight[1])); 
     ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
   }
-  ssdflexmother->CheckOverlaps(0.01);
+  //ssdflexmother->CheckOverlaps(0.01);
   return ssdflexmother;
 }
 /////////////////////////////////////////////////////////////////////////////////
@@ -2944,7 +2944,7 @@ for(Int_t i=0; i<karcnumber; i++){
   for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];  
   delete deltatransvector;
   /////////////////////////////////////////////////////////////
-  ssdendflexmother->CheckOverlaps(0.01);
+  //ssdendflexmother->CheckOverlaps(0.01);
   return ssdendflexmother;
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -4208,8 +4208,8 @@ void AliITSv11GeometrySSD::SetEndLadderSegment(){
   fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);                                                                   
   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);                                                                   
   fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);                                                                   
-  fendladdersegment[0]->CheckOverlaps(0.01);
-  fendladdersegment[1]->CheckOverlaps(0.01);
+ // fendladdersegment[0]->CheckOverlaps(0.01);
+ // fendladdersegment[1]->CheckOverlaps(0.01);
 }
 ///////////////////////////////////////////////////////////////////////////////
 void AliITSv11GeometrySSD::SetLadder(){
diff --git a/ITS/Calib/CalibSPD/Run0_9999999_v0_s0.root b/ITS/Calib/CalibSPD/Run0_9999999_v0_s0.root
deleted file mode 100644 (file)
index 296d731..0000000
Binary files a/ITS/Calib/CalibSPD/Run0_9999999_v0_s0.root and /dev/null differ
diff --git a/ITS/Calib/CalibSPD/Run0_9999999_v0_s0.root.pdc06standardDead b/ITS/Calib/CalibSPD/Run0_9999999_v0_s0.root.pdc06standardDead
deleted file mode 100644 (file)
index f7fc3b9..0000000
Binary files a/ITS/Calib/CalibSPD/Run0_9999999_v0_s0.root.pdc06standardDead and /dev/null differ
diff --git a/ITS/Calib/SPDDead/Run0_9999999_v0_s0.root b/ITS/Calib/SPDDead/Run0_9999999_v0_s0.root
new file mode 100644 (file)
index 0000000..4e36f04
Binary files /dev/null and b/ITS/Calib/SPDDead/Run0_9999999_v0_s0.root differ
diff --git a/ITS/Calib/SPDNoisy/Run0_9999999_v0_s0.root b/ITS/Calib/SPDNoisy/Run0_9999999_v0_s0.root
new file mode 100644 (file)
index 0000000..1f5d658
Binary files /dev/null and b/ITS/Calib/SPDNoisy/Run0_9999999_v0_s0.root differ
diff --git a/ITS/ITSSPDPHYSda.cxx b/ITS/ITSSPDPHYSda.cxx
new file mode 100644 (file)
index 0000000..15a4ef2
--- /dev/null
@@ -0,0 +1,514 @@
+/*
+- "Contact:" - henrik.tydesjo@cern.ch
+- "Link:" - 
+- "Run Type:" - PHYSICS
+- "DA Type:" - MON
+- "Number of events needed:"
+- "Input Files:" - daq db config files: spd_physics_params ,  previous dead ref: ./calibResults/DeadReferenceTmp/* , previous dead lists: ./calibResults/DeadToFXS/*
+- "Output Files:" - Ref Data: ./calibResults/NoisyReference/* ,  Ref Data: ./calibResults/DeadReference/* ,  noisy lists: ./calibResults/NoisyToFXS/* ,  persistent files: ./calibResults/DeadReferenceTmp/*,./calibResults/DeadToFXS/*
+- "Trigger types used:" PHYSICS
+*/
+
+////////////////////////////////////////////////////////////////////////////////
+// This program can be compiled in two modes.                                 //
+//                                                                            //
+// 1. Online. With the DAQ DA framework. This is the default operating mode.  //
+//                                                                            //
+// 2. Offline. Without the DAQ DA framework. Define the SPD_DA_OFF            //
+//    environment var. Call this program with the name of the executable      //
+//    followed by the runNr and the data files to process.                    //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+extern "C" {
+#include "daqDA.h"
+}
+#include "event.h"
+#include "monitor.h"
+#include "AliRawReaderDate.h"
+#include "AliITSRawStreamSPD.h"
+#include "AliITSOnlineSPDphys.h"
+#include "AliITSOnlineSPDphysAnalyzer.h"
+#include "AliITSOnlineCalibrationSPDhandler.h"
+#include "AliLog.h"
+#include <iostream>
+#include <fstream>
+#include <TROOT.h>
+#include <TPluginManager.h>
+#include <TObjArray.h>
+#include <TString.h>
+
+int main(int argc, char **argv) {
+  if (argc<2) {
+    printf("Wrong number of arguments\n");
+    return -1;
+  }
+
+  // directory structure, hard coded
+  char *saveDirDeadToFXS     = "./calibResults/DeadToFXS";        // may NOT delete content
+  char *saveDirDeadRef       = "./calibResults/DeadReference";    //     may delete content
+  char *saveDirDeadRefTmp    = "./calibResults/DeadReferenceTmp"; // may NOT delete content
+  char *saveDirNoisyToFXS    = "./calibResults/NoisyToFXS";       //     may delete content
+  char *saveDirNoisyRef      = "./calibResults/NoisyReference";   //     may delete content
+  char *configFilesDir       = "./configFiles";                   //     may delete content
+  // make sure the directory structure is put up correctly:
+  system("mkdir ./calibResults >& /dev/null");
+  system("mkdir ./calibResults/DeadToFXS >& /dev/null");
+  system("mkdir ./calibResults/DeadReference >& /dev/null");
+  system("mkdir ./calibResults/DeadReferenceTmp >& /dev/null");
+  system("mkdir ./calibResults/NoisyToFXS >& /dev/null");
+  system("mkdir ./calibResults/NoisyReference >& /dev/null");
+  system("mkdir ./configFiles >& /dev/null");
+  // parameters config file
+  TString paramsFileName = Form("%s/physics_params.txt",configFilesDir);
+
+  // This line is needed in case of a stand-alone application w/o
+  // $ROOTSYS/etc/system.rootrc file
+  gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
+                                       "*",
+                                       "TStreamerInfo",
+                                       "RIO",
+                                       "TStreamerInfo()");
+
+  // turn off annoying warning messages
+  new AliLog;
+  AliLog::Instance()->SetGlobalDebugLevel(-20);
+
+
+  // ********* STEP 0: Get configuration files from db (if there are any) , then read parameters*********
+  UInt_t nrTuningParams = 0;
+  TObjArray paramNames;  paramNames.SetOwner(kTRUE);
+  TObjArray paramVals;  paramVals.SetOwner(kTRUE);
+  
+  // tuning parameters:
+  Int_t par_status = 0;
+#ifndef SPD_DA_OFF
+  TString idp = "spd_physics_params";
+  par_status=daqDA_DB_getFile(idp.Data(),paramsFileName.Data());
+  if (par_status) {
+    printf("Failed to get config file %s: status=%d. Using default tuning parameters.\n",idp.Data(),par_status);
+  }
+#endif
+  if (par_status==0) {
+    ifstream paramsFile;
+    paramsFile.open(paramsFileName.Data(), ifstream::in);
+    if (paramsFile.fail()) {
+      printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName.Data());
+    }
+    else {
+      while(1) {
+       Char_t paramN[50];
+       Char_t paramV[50];
+       paramsFile >> paramN;
+       if (paramsFile.eof()) break;
+       paramsFile >> paramV;
+       TString* paramNS = new TString(paramN);
+       TString* paramVS = new TString(paramV);
+       paramNames.AddAtAndExpand((TObject*)paramNS,nrTuningParams);
+       paramVals.AddAtAndExpand((TObject*)paramVS,nrTuningParams);
+       nrTuningParams++;
+       if (paramsFile.eof()) break;
+      }
+      paramsFile.close();
+    }
+  }
+  //  for (UInt_t i=0; i<nrTuningParams; i++) {
+  //    printf("Entry %d: N=%s , V=%s\n",i,((TString*)paramNames.At(i))->Data(),((TString*)paramVals.At(i))->Data());
+  //  }
+
+
+
+
+
+  // ********* STEP 1: Produce phys container files (Reference Data). ***********************************
+
+#ifndef SPD_DA_OFF
+  int runNr = atoi(getenv("DATE_RUN_NUMBER"));
+#else
+  int runNr = atoi(argv[1]);
+  int startSeg = 2;
+#endif
+
+
+  // container objects
+  AliITSOnlineSPDphys *physObj[20];
+  Bool_t bPhysInit[20];
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    physObj[eqId]=NULL;
+    bPhysInit[eqId]=kFALSE;
+  }
+
+
+  // loop over run segments in case of offline mode
+#ifdef SPD_DA_OFF
+  for (int segNr=startSeg; segNr<argc; segNr++) {
+#endif
+
+    int status;
+
+    /* define data source : */  
+#ifndef SPD_DA_OFF
+    status=monitorSetDataSource( argv[1] ); // should be "^SPD" in order to get full detector online
+#else
+    status=monitorSetDataSource( argv[segNr] );
+#endif
+    if (status!=0) {
+      printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
+      return -1;
+    }
+    /* declare monitoring program */
+    status=monitorDeclareMp("ITS_SPD_PHYS");
+    if (status!=0) {
+      printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
+      return -1;
+    }
+    /* define wait event timeout - 1s max */
+    monitorSetNowait();
+    monitorSetNoWaitNetworkTimeout(1000);
+
+
+    UInt_t eventNr=0;
+
+    /* main loop (infinite) */
+    for(;;) {
+
+      struct eventHeaderStruct *event;
+      eventTypeType eventT;
+
+      /* check shutdown condition */
+#ifndef SPD_DA_OFF
+      if (daqDA_checkShutdown()) {break;}
+#endif
+
+      /* get next event (blocking call until timeout) */
+      status=monitorGetEventDynamic((void **)&event);
+      if (status==MON_ERR_EOF) {
+       printf ("End of File detected\n");
+       break; /* end of monitoring file has been reached */
+      }
+
+      if (status!=0) {
+       printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
+       break;
+      }
+
+      /* retry if got no event */
+      if (event==NULL) {
+       continue;
+      }
+
+      eventT=event->eventType;
+      if (eventT == PHYSICS_EVENT){
+
+       eventNr++;
+       //      printf("eventNr %d\n",eventNr);
+
+       AliRawReader *reader = new AliRawReaderDate((void*)event);
+       AliITSRawStreamSPD *str = new AliITSRawStreamSPD(reader);
+
+       //      for (UInt_t eqId=0; eqId<20; eqId++) {
+       //        reader->Reset();
+       //        reader->Select("ITSSPD",eqId,eqId);
+
+       while (str->Next()) {
+
+         Int_t eqId = reader->GetDDLID();
+         if (eqId>=0 && eqId<20) {
+           if (!bPhysInit[eqId]) {
+             TString fileName = Form("%s/SPDphys_run_%d_eq_%d.root",saveDirNoisyRef,runNr,eqId);
+             physObj[eqId] = new AliITSOnlineSPDphys(fileName.Data());
+             physObj[eqId]->AddRunNr(runNr);
+             physObj[eqId]->SetEqNr(eqId);
+             bPhysInit[eqId]=kTRUE;
+           }
+           
+           UInt_t hs = str->GetHalfStaveNr();
+           UInt_t chip = str->GetChipAddr();
+           physObj[eqId]->IncrementHits(hs,chip,str->GetChipCol(),str->GetChipRow());
+           
+         }
+       }
+       
+       for (UInt_t eqId=0; eqId<20; eqId++) {
+         if (bPhysInit[eqId]) {
+           physObj[eqId]->IncrementNrEvents();
+         }
+       }
+
+       //      }
+
+       delete str;
+       delete reader;
+
+      }
+
+      /* free resources */
+      free(event);
+
+    }
+    
+
+#ifdef SPD_DA_OFF
+    printf("progress: %d\n",(unsigned int)( ((Float_t)(segNr-startSeg+1))/(argc-startSeg)*50 ));
+  }
+#endif
+  
+  // clean up phys objects (also saves them)
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    if (physObj[eqId]!=NULL) delete physObj[eqId];
+  }
+
+
+
+
+
+  // ********* STEP 2: Analyze phys container files. ************************************************
+
+  // clear noisyToFXS dir:
+  TString command;
+  command = Form("cd %s; rm -f *",saveDirNoisyToFXS);
+  system(command.Data());
+  // delete dead.tar file
+  command = Form("cd %s; rm -f dead.tar",saveDirDeadToFXS);
+  system(command.Data());
+
+
+  // create calibration handler and read dead from previous calibrations
+  AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
+  handler->SetFileLocation(saveDirDeadToFXS);
+  handler->ReadDeadFromFiles();
+
+
+  UInt_t firstRunNrDead = runNr;
+
+
+  UInt_t nrEnoughStatNoisy = 0;
+  UInt_t nrEqActiveNoisy = 0;
+  Bool_t eqActiveNoisy[20];
+
+  // *** *** *** start loop over equipments (eq_id)
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    eqActiveNoisy[eqId] = kFALSE;
+
+    // create analyzer for this eq
+    TString fileName = Form("%s/SPDphys_run_%d_eq_%d.root",saveDirNoisyRef,runNr,eqId);
+    AliITSOnlineSPDphysAnalyzer *noisyAnalyzer = new AliITSOnlineSPDphysAnalyzer(fileName.Data(),handler);
+
+    // check data in container
+    if (noisyAnalyzer->GetEqNr() != eqId) {
+      if (noisyAnalyzer->GetEqNr() != 999) {
+       printf("Error: Mismatching EqId in Container data and filename (%d!=%d). Skipping.\n",
+              noisyAnalyzer->GetEqNr(),eqId);
+      }
+      delete noisyAnalyzer;
+      continue;
+    }
+
+    nrEqActiveNoisy++;
+    eqActiveNoisy[eqId] = kTRUE;
+
+    // configure analyzer with tuning parameters etc:
+    for (UInt_t i=0; i<nrTuningParams; i++) {
+      noisyAnalyzer->SetParam(((TString*)paramNames.At(i))->Data(),((TString*)paramVals.At(i))->Data());
+    }
+
+    printf("SPD phys STEP 2: Noisy search for eq %d\n",eqId);  
+
+    // search for noisy pixels:
+    nrEnoughStatNoisy += noisyAnalyzer->ProcessNoisyPixels();
+
+    // copy this phys obj to temporary dead reference dir to process after noisy search
+    TString fileNameDead = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
+    AliITSOnlineSPDphys* physObj = new AliITSOnlineSPDphys(fileNameDead.Data());
+    physObj->AddPhys(noisyAnalyzer->GetOnlinePhys());
+    if (physObj->GetNrRuns()>0) {
+      UInt_t firstRunNr = physObj->GetRunNr(0);
+      if (firstRunNrDead>firstRunNr) {
+       firstRunNrDead=firstRunNr;
+      }
+    }
+    // remove noisy pixels from dead hitmap
+    for (UInt_t iModule=0; iModule<12; iModule++) {
+      UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,iModule);
+      for (UInt_t ind=0; ind<handler->GetNrNoisy(module); ind++) {
+       UInt_t hs   = handler->GetNoisyHSAt(module,ind);
+       UInt_t chip = handler->GetNoisyChipAt(module,ind);
+       UInt_t col  = handler->GetNoisyColAt(module,ind);
+       UInt_t row  = handler->GetNoisyRowAt(module,ind);
+       physObj->AddHits(hs,chip,col,row,-noisyAnalyzer->GetOnlinePhys()->GetHits(hs,chip,col,row));
+      }
+    }
+
+    delete physObj;
+    delete noisyAnalyzer;
+
+#ifndef SPD_DA_OFF
+    daqDA_progressReport((unsigned int)((eqId+1)*2.5));
+#else
+    printf("progress: %d\n",(unsigned int)(50+(eqId+1)*1.25));
+#endif
+  }
+  // *** *** *** end loop over equipments (eq_id)
+
+  printf("Noisy search finished. %d noisy pixels found. %d chips (%d) had enough statistics.\n",
+        handler->GetNrNoisy(),nrEnoughStatNoisy,nrEqActiveNoisy*60);
+  handler->SetFileLocation(saveDirNoisyToFXS);
+  handler->WriteNoisyToFiles();
+
+
+
+
+
+
+
+
+  UInt_t nrEnoughStatChips = 0;
+  UInt_t nrDeadChips = 0;
+  UInt_t nrInefficientChips = 0;
+  UInt_t nrEqActiveDead = 0;
+  Bool_t eqActiveDead[20];
+
+  // *** *** *** start loop over equipments (eq_id)
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    eqActiveDead[eqId] = kFALSE;
+
+    // setup analyzer for dead search
+    TString fileNameDead = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
+    AliITSOnlineSPDphys* physObj = new AliITSOnlineSPDphys(fileNameDead.Data());
+    AliITSOnlineSPDphysAnalyzer* deadAnalyzer = new AliITSOnlineSPDphysAnalyzer(physObj,handler);
+    // check data in container
+    if (deadAnalyzer->GetEqNr() != eqId) {
+      if (deadAnalyzer->GetEqNr() != 999) {
+       printf("Error: Mismatching EqId in Dead Container data and filename (%d!=%d). Skipping.\n",
+              deadAnalyzer->GetEqNr(),eqId);
+      }
+      delete deadAnalyzer;
+      continue;
+    }
+
+    nrEqActiveDead++;
+    eqActiveDead[eqId] = kTRUE;
+
+    // configure analyzer with tuning parameters etc:
+    for (UInt_t i=0; i<nrTuningParams; i++) {
+      deadAnalyzer->SetParam(((TString*)paramNames.At(i))->Data(),((TString*)paramVals.At(i))->Data());
+    }
+
+    printf("SPD phys STEP 2: Dead search for eq %d\n",eqId);  
+
+    // search for dead pixels:
+    nrEnoughStatChips += deadAnalyzer->ProcessDeadPixels();
+    nrDeadChips += deadAnalyzer->GetNrDeadChips();
+    nrInefficientChips += deadAnalyzer->GetNrInefficientChips();
+
+    delete deadAnalyzer;
+
+#ifndef SPD_DA_OFF
+    daqDA_progressReport((unsigned int)(50+(eqId+1)*2.5));
+#else
+    printf("progress: %d\n",(unsigned int)(75+(eqId+1)*1.25));
+#endif
+  }
+  // *** *** *** end loop over equipments (eq_id)
+
+  
+  printf("Dead search finished. %d dead pixels in total.\n%d chips (%d) had enough statistics. %d chips were dead. %d chips were inefficient.\n",handler->GetNrDead(),nrEnoughStatChips,nrEqActiveDead*60,nrDeadChips,nrInefficientChips);
+  handler->SetFileLocation(saveDirDeadToFXS);
+  handler->WriteDeadToFilesAlways();
+  
+
+
+
+
+
+
+
+  // if there is no chip in category "needsMoreStat"
+  if (nrEnoughStatChips+nrDeadChips+nrInefficientChips == nrEqActiveDead*60) {
+    // calibration is complete
+    printf("Dead calibration is complete.\n");
+    for (UInt_t eqId=0; eqId<20; eqId++) {
+      if (eqActiveDead[eqId]) {
+       TString fileName = Form("%s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
+//!!!  // find out the run span
+//!!!  AliITSOnlineSPDphys* physObj = new AliITSOnlineSPDphys(fileName.Data());
+//!!!  UInt_t nrRuns = physObj->GetNrRuns();
+//!!!  UInt_t firstRun = physObj->GetRunNr(0);
+//!!!  UInt_t lastRun = physObj->GetRunNr(nrRuns-1);
+//!!!  delete physObj;
+       // move file to ref dir
+       TString newFileName = Form("%s/SPDphys_dead_run_%d_%d_eq_%d.root",saveDirDeadRef,firstRunNrDead,runNr,eqId);
+       TString command = Form("mv -f %s %s",fileName.Data(),newFileName.Data());
+       system(command.Data());
+#ifndef SPD_DA_OFF
+       // send ref data to FXS
+       TString id = Form("SPD_ref_phys_dead_%d",eqId);
+       Int_t status = daqDA_FES_storeFile(newFileName.Data(),id.Data());
+       if (status!=0) {
+         printf("Failed to export file %s , status %d\n",newFileName.Data(),status);
+         return -1;
+       }
+#endif
+      }
+      else {
+       TString command = Form("rm -f %s/SPDphys_dead_run_0_0_eq_%d.root",saveDirDeadRefTmp,eqId);
+       system(command.Data());
+      }
+    }
+  }
+
+  // send reference data for this run to FXS
+#ifndef SPD_DA_OFF
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    if (eqActiveNoisy[eqId]) {
+      TString fileName = Form("%s/SPDphys_run_%d_eq_%d.root",saveDirNoisyRef,runNr,eqId);
+      TString id = Form("SPD_ref_phys_%d",eqId);
+      Int_t status = daqDA_FES_storeFile(fileName.Data(),id.Data());
+      if (status!=0) {
+       printf("Failed to export file %s , status %d\n",fileName.Data(),status);
+       return -1;
+      }
+    }
+  }
+#endif
+
+  // send dead files to FXS
+  // send a tared file of all the dead files
+  TString send_command = Form("cd %s; tar -cf dead_phys.tar *",saveDirDeadToFXS);
+  //  printf("\n\n%s\n\n",command.Data());
+  system(send_command.Data());
+#ifndef SPD_DA_OFF
+  TString fileName = Form("%s/dead_phys.tar",saveDirDeadToFXS);
+  TString id = "SPD_phys_dead";
+  Int_t send_status = daqDA_FES_storeFile(fileName.Data(),id.Data());
+  if (send_status!=0) {
+    printf("Failed to export file %s , status %d\n",fileName.Data(),send_status);
+    return -1;
+  }
+#endif
+
+  // send noisy files to FXS
+  if (handler->GetNrNoisy()>0) { // there must be at least one file created
+    // send a tared file of all the noisy files
+    TString command = Form("cd %s; tar -cf noisy_phys.tar *",saveDirNoisyToFXS);
+    //    printf("\n\n%s\n\n",command.Data());
+    system(command.Data());
+#ifndef SPD_DA_OFF
+    TString fileName = Form("%s/noisy_phys.tar",saveDirNoisyToFXS);
+    TString id = "SPD_phys_noisy";
+    Int_t status = daqDA_FES_storeFile(fileName.Data(),id.Data());
+    if (status!=0) {
+      printf("Failed to export file %s , status %d\n",fileName.Data(),status);
+      return -1;
+    }
+#endif
+  }
+
+
+
+
+  delete handler;
+
+
+  return 0;
+}
similarity index 77%
rename from ITS/ITSSPDda.cxx
rename to ITS/ITSSPDSCANda.cxx
index 57ee172..747281e 100644 (file)
@@ -1,5 +1,16 @@
+/*
+- "Contact:" - henrik.tydesjo@cern.ch
+- "Link:" - 
+- "Run Type:" - DAQ_MIN_TH_SCAN,DAQ_MEAN_TH_SCAN,DAQ_UNIFORMITY_SCAN,DAQ_NOISY_PIX_SCAN,DAQ_PIX_DELAY_SCAN,DAQ_FO_UNIF_SCAN
+- "DA Type:" - LDC
+- "Number of events needed:"
+- "Input Files:" - daq db config files: spd_standal_params,spd_perm_noisy ,  previous noisy lists: ./calibResults/ScanNoisy/* ,  raw data
+- "Output Files:" - Ref Data: ./calibResults/ScanReference/* ,  DCS update: ./calibResults/ScanDCSconfigToFXS/* ,  OCDB update: ./calibResults/ScanNoisyToFXS/* ,  persistent files: ./calibResults/ScanNoisy/*
+- "Trigger types used:" 
+*/
+
 ////////////////////////////////////////////////////////////////////////////////
-// This program can be run in two modes.                                      //
+// This program can be compiled in two modes.                                 //
 //                                                                            //
 // 1. With the DAQ DA framework on. This is the default operating mode.       //
 // Call this program with the name of the executable followed by the          //
@@ -38,21 +49,22 @@ int main(int argc, char **argv) {
     return -1;
   }
 
-  // make directory structure (if not here already):
+  // directory structure, hard coded
+  char *saveDirNoisy         = "./calibResults/ScanNoisy";          // may NOT delete content
+  char *saveDirNoisyToFXS    = "./calibResults/ScanNoisyToFXS";     //     may delete content
+  char *saveDirDCSconfigToFXS= "./calibResults/ScanDCSconfigToFXS"; //     may delete content
+  char *saveDirRef           = "./calibResults/ScanReference";      //     may delete content
+  char *configFilesDir       = "./configFiles";                     //     may delete content
+  // make sure the directory structure is correct:
   system("mkdir ./calibResults >& /dev/null");
-  system("mkdir ./calibResults/Noisy >& /dev/null");
-  system("mkdir ./calibResults/NoisyToFXS >& /dev/null");
-  system("mkdir ./calibResults/DCSconfigToFXS >& /dev/null");
-  system("mkdir ./calibResults/Parameters >& /dev/null");
-  system("mkdir ./calibResults/Reference >& /dev/null");
-  char *saveDirNoisy         = "./calibResults/Noisy";
-  char *saveDirNoisyToFXS    = "./calibResults/NoisyToFXS";
-  char *saveDirDCSconfigToFXS= "./calibResults/DCSconfigToFXS";
-  char *saveDirParameters    = "./calibResults/Parameters";
-  char *saveDirRef           = "./calibResults/Reference";
-
-  char *paramsFileName       = "./standal_params.txt";
-  char *permNoisyFileName    = "./perm_noisy.txt";
+  system("mkdir ./calibResults/ScanNoisy >& /dev/null");
+  system("mkdir ./calibResults/ScanNoisyToFXS >& /dev/null");
+  system("mkdir ./calibResults/ScanDCSconfigToFXS >& /dev/null");
+  system("mkdir ./calibResults/ScanReference >& /dev/null");
+  system("mkdir ./configFiles >& /dev/null");
+  // prameters config files
+  TString paramsFileName = Form("%s/standal_params.txt",configFilesDir);
+  TString permNoisyFileName = Form("%s/perm_noisy.txt",configFilesDir);
 
   // This line is needed in case of a stand-alone application w/o
   // $ROOTSYS/etc/system.rootrc file
@@ -79,16 +91,16 @@ int main(int argc, char **argv) {
   Int_t status = 0;
 #ifndef SPD_DA_OFF
   TString idp = "spd_standal_params";
-  status=daqDA_DB_getFile(idp.Data(),paramsFileName);
+  status=daqDA_DB_getFile(idp.Data(),paramsFileName.Data());
   if (status) {
     printf("Failed to get config file %s: status=%d. Using default tuning parameters.\n",idp.Data(),status);
   }
 #endif
   if (status==0) {
     ifstream paramsFile;
-    paramsFile.open(paramsFileName, ifstream::in);
+    paramsFile.open(paramsFileName.Data(), ifstream::in);
     if (paramsFile.fail()) {
-      printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName);
+      printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName.Data());
     }
     else {
       while(1) {
@@ -115,9 +127,9 @@ int main(int argc, char **argv) {
   Int_t permstatus = 0;
 #ifndef SPD_DA_OFF
   TString idn = "spd_perm_noisy";
-  permstatus=daqDA_DB_getFile(idn.Data(),permNoisyFileName);
+  permstatus=daqDA_DB_getFile(idn.Data(),permNoisyFileName.Data());
   if (permstatus) {
-    printf("Failed to get config file %s: status=%d. No additional noisy pixels added.\n",idn.Data(),permstatus);
+    printf("Failed to get config file %s: status=%d. No permanently noisy pixels will be added.\n",idn.Data(),permstatus);
   }
 #endif
 
@@ -167,7 +179,6 @@ int main(int argc, char **argv) {
   // loop over run segments
   for (int segNr=startSeg; segNr<argc; segNr++) {
 
-
     int status;
 
     /* define data source : this is argument 1 */  
@@ -185,16 +196,16 @@ int main(int argc, char **argv) {
     /* define wait event timeout - 1s max */
     monitorSetNowait();
     monitorSetNoWaitNetworkTimeout(1000);
-
-
-    struct eventHeaderStruct *event;
-    eventTypeType eventT;
+    
+    
     UInt_t eventNr=0;
 
-
     /* main loop (infinite) */
     for(;;) {
-
+      
+      struct eventHeaderStruct *event;
+      eventTypeType eventT;
+      
       /* check shutdown condition */
 #ifndef SPD_DA_OFF
       if (daqDA_checkShutdown()) {break;}
@@ -211,26 +222,23 @@ int main(int argc, char **argv) {
       }
       /* retry if got no event */
       if (event==NULL) {
-       printf("event==NULL\n");
        continue;
       }
 
       eventT=event->eventType;
-      if (eventT == PHYSICS_EVENT){
-
-
+      if (eventT == PHYSICS_EVENT) {
+       
        eventNr++;
        //      printf("eventNr %d\n",eventNr);
-
+       
        AliRawReader *reader = new AliRawReaderDate((void*)event);
        AliITSRawStreamSPD *str = new AliITSRawStreamSPD(reader);
-
-
+       
        for (UInt_t eqId=0; eqId<20; eqId++) {
-
+         
          reader->Reset();
          reader->Select("ITSSPD",eqId,eqId);
-
+         
          // Hit Event flags, specific for one event
          Bool_t hitEventHSIncremented[6];
          Bool_t hitEventChipIncremented[6][10];
@@ -240,7 +248,7 @@ int main(int argc, char **argv) {
              hitEventChipIncremented[hs][chip] = kFALSE;
            }
          }
-
+         
          if (str->ReadCalibHeader()) {
            // first check the type:
            if (bScanInit[eqId] && type[eqId]!=str->GetHtype()) {
@@ -384,14 +392,14 @@ int main(int argc, char **argv) {
 #else
              if (type[eqId]!=MINTH || minTHchipPresent[eqId][chip] || runNr<=416900) {
 #endif
-             //*************************************************************************
+               //*************************************************************************
                scanObj[eqId]->IncrementHits(currentStep[eqId],hs,chip,str->GetChipCol(),str->GetChipRow());
-
+               
                if (!hitEventHSIncremented[hs]) {
                  scanObj[eqId]->IncrementHitEventsTot(currentStep[eqId],hs);
                  hitEventHSIncremented[hs]=kTRUE;
                }
-           
+               
                if (!hitEventChipIncremented[hs][chip]) {
                  scanObj[eqId]->IncrementHitEvents(currentStep[eqId],hs,chip);
                  hitEventChipIncremented[hs][chip]=kTRUE;
@@ -418,12 +426,6 @@ int main(int argc, char **argv) {
 
     }
 
-    status = monitorLogout();
-    if (status != 0) {
-      printf("monitorLogout() failed : %s\n",monitorDecodeError(status));
-      return -1;
-    }
-    
 #ifndef SPD_DA_OFF
     daqDA_progressReport((unsigned int)( ((Float_t)(segNr-startSeg+1))/(argc-startSeg)*50 ));
 #else
@@ -432,7 +434,8 @@ int main(int argc, char **argv) {
 
   }
 
-  // clean up scan objects
+  
+  // clean up scan objects (which also saves them)
   for (UInt_t eqId=0; eqId<20; eqId++) {
     if (scanObj[eqId]!=NULL) delete scanObj[eqId];
   }
@@ -451,14 +454,25 @@ int main(int argc, char **argv) {
   UInt_t nrNoisyFilesProduced=0;
   UInt_t nrDCSconfigFilesProduced=0;
 
-  AliITSOnlineSPDscanAnalyzer *analyzer;
+  AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
+  AliITSOnlineSPDscanAnalyzer *analyzer = NULL;
+  AliITSOnlineCalibrationSPDhandler* handlerPermNoisy = NULL;
+  // fill permanent noisy list to add later...
+  if (permstatus==0) { 
+    handlerPermNoisy = new AliITSOnlineCalibrationSPDhandler();
+    UInt_t permNoisy = handlerPermNoisy->ReadNoisyFromText(permNoisyFileName.Data(),240); // 240 = read for all modules
+    if (permNoisy>0) {
+      printf("%d noisy pixels read from permanent list.\n",permNoisy);
+    }
+  }
+
 
   // *** *** *** start loop over equipments (eq_id)
   for (int eqId=0; eqId<20; eqId++) {
 
     // create analyzer for this eq
     TString fileName = Form("%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
-    analyzer = new AliITSOnlineSPDscanAnalyzer(fileName.Data());
+    analyzer = new AliITSOnlineSPDscanAnalyzer(fileName.Data(),handler);
 
     // configure analyzer with tuning parameters etc:
     for (UInt_t i=0; i<nrTuningParams; i++) {
@@ -470,9 +484,9 @@ int main(int argc, char **argv) {
     UInt_t routerNr = analyzer->GetRouterNr();
     if (type!=99) {
       if (type==DAC) {
-       printf("SPD calibrator Step2: eqId %d, type %d, dacId %d\n",eqId,type,dacId);
+       printf("SPD scan calibrator Step2: eqId %d, type %d, dacId %d\n",eqId,type,dacId);
       }
-      else printf("SPD calibrator Step2: eqId %d type %d\n",eqId,type);  
+      else printf("SPD scan calibrator Step2: eqId %d type %d\n",eqId,type);  
     }
 
 
@@ -484,7 +498,13 @@ int main(int argc, char **argv) {
     }
 
     else if (type==NOISE) {
-      if (analyzer->ProcessNoisyPixels(saveDirNoisy)) {
+      // read previous noisy list
+      handler->SetFileLocation(saveDirNoisy);
+      handler->ReadFromFiles();
+      if (analyzer->ProcessNoisyPixels(/*saveDirNoisy*/)) {
+       if (permstatus==0) {
+         handler->AddNoisyFrom(handlerPermNoisy);
+       }
        // init dcs config text file
        TString dcsConfigFileName = Form("%s/dcsConfig_run_%d_eq_%d.txt",saveDirDCSconfigToFXS,runNr,eqId);
        ofstream dcsfile;
@@ -493,34 +513,30 @@ int main(int argc, char **argv) {
        dcsfile << "RunNumber=" << runNr << "\n";
        dcsfile << "Type=" << type << "\n";
        dcsfile << "Router=" << routerNr << "\n";
-       dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values for now
+       dcsfile << "ActualDetConfiguration=" << "0,-1,-1\n"; // dummy values for now
        dcsfile << "[NOISY]\n";
        nrDCSconfigFilesProduced++;
        for (UInt_t iModule=0; iModule<12; iModule++) {
          UInt_t module = AliITSRawStreamSPD::GetModuleNumber(eqId,iModule);      
-         AliITSOnlineCalibrationSPDhandler *handler = analyzer->GetOnlineCalibrationHandler(module);
-         if (permstatus==0) { // add permanent noisy list
-           UInt_t newNoisy = handler->ReadNoisyFromText(permNoisyFileName);
-           if (newNoisy>0) {
-             printf("%d additional noisy pixels added from permanent list.\n",newNoisy);
-           }
-         }
-         if (analyzer->SaveDeadNoisyPixels(module,saveDirNoisy)) {
-           UInt_t nrNoisy = handler->GetNrNoisy(module);
+         UInt_t nrNoisy = handler->GetNrNoisy(module);
+         if (analyzer->IsModuleScanned(module) || analyzer->IsOverWriteSet()) {
            UInt_t headkey=20*10*6;
            for (UInt_t ind=0; ind<nrNoisy; ind++) {
-             UInt_t newkey = handler->GetNoisyEqIdAt(module,ind)*10*6 +
-               handler->GetNoisyHSAt(module,ind)*10 +
-               handler->GetNoisyChipAt(module,ind);
+             UInt_t nEqId = handler->GetNoisyEqIdAt(module,ind);
+             UInt_t nHs = handler->GetNoisyHSAt(module,ind);
+             UInt_t nChip = handler->GetNoisyChipAt(module,ind);
+             UInt_t newkey = nEqId*10*6 + nHs*10 + nChip;
              if (newkey!=headkey) { // print eqId,hs,chip_header
                headkey = newkey;
-               dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
+               dcsfile << "-" << nEqId << "," << nHs << "," << nChip << "\n";
              }
              dcsfile << handler->GetNoisyColAt(module,ind) << "," << handler->GetNoisyRowAt(module,ind) << "\n";
            }
+           handler->SetFileLocation(saveDirNoisy);
+           handler->WriteNoisyToFile(module);
+           handler->SetFileLocation(saveDirNoisyToFXS);
+           handler->WriteNoisyToFile(module);
            nrNoisyFilesProduced++;
-           TString command = Form("cp %s/SPD_DeadNoisy_%d.root %s/.",saveDirNoisy,module,saveDirNoisyToFXS);
-           system(command.Data());
          }
        }
        dcsfile.close();
@@ -539,9 +555,9 @@ int main(int argc, char **argv) {
       dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values for now
       dcsfile << "[DACvalues]\n";
       nrDCSconfigFilesProduced++;
-      TString ofileName = Form("%s/minth_eq_%d.txt",saveDirParameters,eqId);
-      ofstream ofile;
-      ofile.open (ofileName.Data());
+      //      TString ofileName = Form("%s/minth_eq_%d.txt",saveDirParameters,eqId);
+      //      ofstream ofile;
+      //      ofile.open (ofileName.Data());
       for (UInt_t hs=0; hs<6; hs++) {
        for (UInt_t chipNr=0; chipNr<10; chipNr++) {
          Int_t minTh = -1;
@@ -554,12 +570,12 @@ int main(int argc, char **argv) {
              printf("MinTh failed for Eq %d , HS %d , Chip %d\n",eqId,hs,chipNr);
            }
          }
-         ofile << minTh;
-         ofile << "\t";
+         //      ofile << minTh;
+         //      ofile << "\t";
        }
-       ofile << "\n";
+       //      ofile << "\n";
       }
-      ofile.close();
+      //      ofile.close();
       dcsfile.close();
     }
 
@@ -575,9 +591,9 @@ int main(int argc, char **argv) {
       dcsfile << "ActualDetCoonfiguration=" << "0,-1,-1\n"; // dummy values for now
       dcsfile << "[DACvalues]\n";
       nrDCSconfigFilesProduced++;
-      TString ofileName = Form("%s/delay_eq_%d.txt",saveDirParameters,eqId);
-      ofstream ofile;
-      ofile.open (ofileName.Data());
+//      TString ofileName = Form("%s/delay_eq_%d.txt",saveDirParameters,eqId);
+//      ofstream ofile;
+//      ofile.open (ofileName.Data());
       for (UInt_t hs=0; hs<6; hs++) {
        for (UInt_t chipNr=0; chipNr<10; chipNr++) {
          Int_t clockCycle = -1;
@@ -596,12 +612,12 @@ int main(int argc, char **argv) {
              printf("Delay failed for Eq %d , HS %d , Chip %d\n",eqId,hs,chipNr);
            }
          }
-         ofile << delayCtrl << "/" << miscCtrl;
-         ofile << "\t";
+         //      ofile << delayCtrl << "/" << miscCtrl;
+         //      ofile << "\t";
        }
-       ofile << "\n";
+       //      ofile << "\n";
       }
-      ofile.close();
+      //      ofile.close();
       dcsfile.close();
     }
 
@@ -616,15 +632,23 @@ int main(int argc, char **argv) {
   }
   // *** *** *** end loop over equipments (eq_id)
 
+  delete handler;
+  if (handlerPermNoisy!=NULL) {
+    delete handlerPermNoisy;
+  }
+
+
 
+
+  // send noisy data to FXS
   if (nrNoisyFilesProduced>0) {
     // send a tared file of all new noisy maps
-    TString command = Form("cd %s; tar -cf noisy.tar *",saveDirNoisyToFXS);
-    printf("\n\n%s\n\n",command.Data());
+    TString command = Form("cd %s; tar -cf noisy_scan.tar *",saveDirNoisyToFXS);
+    //    printf("\n\n%s\n\n",command.Data());
     system(command.Data());
 #ifndef SPD_DA_OFF
-    TString fileName = Form("%s/noisy.tar",saveDirNoisyToFXS);
-    TString id = "SPD_noisy";
+    TString fileName = Form("%s/noisy_scan.tar",saveDirNoisyToFXS);
+    TString id = "SPD_scan_noisy";
     Int_t status = daqDA_FES_storeFile(fileName.Data(),id.Data());
     if (status!=0) {
       printf("Failed to export file %s , status %d\n",fileName.Data(),status);
@@ -633,6 +657,7 @@ int main(int argc, char **argv) {
 #endif
   }
 
+  // send dcs config files to FXS
   if (nrDCSconfigFilesProduced>0) {
     // send a tared file of all the dcsConfig text files
     TString command = Form("cd %s; tar -cf dcsConfig.tar *",saveDirDCSconfigToFXS);
@@ -649,6 +674,23 @@ int main(int argc, char **argv) {
 #endif
   }
 
+  // send reference data to FXS
+#ifndef SPD_DA_OFF
+  for (UInt_t eqId=0; eqId<20; eqId++) {
+    if (bScanInit[eqId]) {
+      TString fileName = Form("%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
+      TString id = Form("SPD_ref_scan_%d",eqId);
+      Int_t status = daqDA_FES_storeFile(fileName.Data(),id.Data());
+      if (status!=0) {
+       printf("Failed to export file %s , status %d\n",fileName.Data(),status);
+       return -1;
+      }
+    }
+  }
+#endif
+
+
+
 
 
   return 0;
index 0672c7c..34d567f 100644 (file)
 #pragma link C++ class AliITSOnlineSPDscanMeanTh+;
 #pragma link C++ class AliITSOnlineSPDscanMultiple+;
 #pragma link C++ class AliITSOnlineSPDscanSingle+;
+#pragma link C++ class AliITSOnlineSPDphys+;
+#pragma link C++ class AliITSOnlineSPDphysAnalyzer+;
+#pragma link C++ class AliITSOnlineSPDphysInfo+;
 #pragma link C++ class AliITSPreprocessorSDD+;
 #pragma link C++ class AliITSOnlineSDD+;
 #pragma link C++ class AliITSOnlineSDDBase+;
index 2f27733..c37a652 100644 (file)
@@ -67,6 +67,9 @@ SRCS =        AliITSDetTypeRec.cxx \
                AliITSOnlineSPDscanMeanTh.cxx \
                AliITSOnlineSPDscanMultiple.cxx \
                AliITSOnlineSPDscanSingle.cxx \
+               AliITSOnlineSPDphys.cxx \
+               AliITSOnlineSPDphysAnalyzer.cxx \
+               AliITSOnlineSPDphysInfo.cxx \
                AliITSBadChannelsAuxSPD.cxx \
                AliITSBadChannelsSPD.cxx  \
                AliITSChannelSPD.cxx  \