1. Improved implementation of AliITSIntMap and AliITSOnlineCalibrationSPDhandler...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 21 Aug 2007 10:26:47 +0000 (10:26 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 21 Aug 2007 10:26:47 +0000 (10:26 +0000)
2. ITSSPDda: Implementation for producing output to DCS. Reading of configuration files (tuning params and permanently noisy list).
3. Addition of field "DCSversion" to the scan container classes. (Version changed to 2 for the AliITSOnlineSPDscanInfo classes.)
4. Change of Char_t arrays --> TString inside several classes.

24 files changed:
ITS/AliITSIntMap.cxx
ITS/AliITSIntMap.h
ITS/AliITSIntMapNode.cxx
ITS/AliITSIntMapNode.h
ITS/AliITSOnlineCalibrationSPDhandler.cxx
ITS/AliITSOnlineCalibrationSPDhandler.h
ITS/AliITSOnlineSPDscan.cxx
ITS/AliITSOnlineSPDscan.h
ITS/AliITSOnlineSPDscanAnalyzer.cxx
ITS/AliITSOnlineSPDscanAnalyzer.h
ITS/AliITSOnlineSPDscanInfo.cxx
ITS/AliITSOnlineSPDscanInfo.h
ITS/AliITSOnlineSPDscanInfoMeanTh.h
ITS/AliITSOnlineSPDscanInfoMultiple.h
ITS/AliITSOnlineSPDscanMeanTh.cxx
ITS/AliITSOnlineSPDscanMeanTh.h
ITS/AliITSOnlineSPDscanMultiple.cxx
ITS/AliITSOnlineSPDscanMultiple.h
ITS/AliITSOnlineSPDscanSingle.cxx
ITS/AliITSOnlineSPDscanSingle.h
ITS/AliITSPreprocessorSPD.cxx
ITS/AliITSRawStreamSPD.h
ITS/AliITSVertexerZTest.C
ITS/ITSSPDda.cxx

index ba04a25..fc91cb1 100644 (file)
 //////////////////////////////////////////////////////////////////////
 // Author: Henrik Tydesjo                                           //
 // This class implements the use of a map of integers.              //
-// For simplicity, this version is just a sorted linked list,       //
-// but it may be rewritten later for better performance if required.//
+// The values are kept in a binary tree, which is automatically     //
+// reordered to be more balanced when the tree height gets too large//
 //////////////////////////////////////////////////////////////////////  
 
 #include "AliITSIntMap.h"
 #include "AliITSIntMapNode.h"
+#include <TMath.h>
+#include <TError.h>
 
 AliITSIntMap::AliITSIntMap():
   fNrEntries(0),
-  fFirst(0)
+  fRoot(NULL),
+  fFastAccess(kFALSE),
+  fFastAccessSerialize(kFALSE),
+  fFastAccessArray(NULL),
+  fDummyIndex(0)
+{}
+
+AliITSIntMap::AliITSIntMap(AliITSIntMapNode* root, UInt_t nrEntries):
+  fNrEntries(nrEntries),
+  fRoot(root),
+  fFastAccess(kFALSE),
+  fFastAccessSerialize(kFALSE),
+  fFastAccessArray(NULL),
+  fDummyIndex(0)
 {}
 
 AliITSIntMap::AliITSIntMap(const AliITSIntMap& imap):
   fNrEntries(0),
-  fFirst(0)
+  fRoot(NULL),
+  fFastAccess(kFALSE),
+  fFastAccessSerialize(kFALSE),
+  fFastAccessArray(NULL),
+  fDummyIndex(0)
 {
   // copy constructor
-  for (UInt_t index=0; index<imap.fNrEntries; index++) {
-    this->Insert(imap.GetKey(index),imap.GetVal(index));
-  }
+  *this = imap;
 }
 
-AliITSIntMap::~AliITSIntMap() 
-{}
+AliITSIntMap::~AliITSIntMap() {
+  Clear();
+}
 
 AliITSIntMap& AliITSIntMap::operator=(const AliITSIntMap& imap) {
   // assignment operator
   if (this!=&imap) {
     this->Clear();
-    for (UInt_t index=0; index<imap.fNrEntries; index++) {
-      this->Insert(imap.GetKey(index),imap.GetVal(index));
-    }
+    fRoot = CloneNode(imap.fRoot);
+    fFastAccess=kFALSE;
+    fFastAccessSerialize=kFALSE;
+    fFastAccessArray=NULL;
+    fDummyIndex=0;
   }
   return *this;
 }
 
 void AliITSIntMap::Clear() {
   // clear the whole map
-  while (fNrEntries>0) {
-    Remove(fFirst->GetKey());
-  }
+  ClearFastAccess();
+  ClearNode(fRoot);
+}
+
+void AliITSIntMap::ClearNode(AliITSIntMapNode* &node) {
+  // clear this node and all children nodes
+  if (node==NULL) return;
+  ClearNode(node->Left());
+  ClearNode(node->Right());
+  delete node;
+  fNrEntries--;
+  node = NULL;
+  fFastAccess=kFALSE;
+  fFastAccessSerialize=kFALSE;
+}
+
+AliITSIntMap* AliITSIntMap::Clone() const {
+  // returns a clone of the map
+  AliITSIntMapNode* newRoot;
+  newRoot = CloneNode(fRoot);
+  AliITSIntMap* newMap = new AliITSIntMap(newRoot,fNrEntries);
+  return newMap;
+}
+
+AliITSIntMapNode* AliITSIntMap::CloneNode(AliITSIntMapNode* node) const {
+  if (node==NULL) return NULL;
+  else return new AliITSIntMapNode(node->Key(),node->Val(),CloneNode(node->Left()),CloneNode(node->Right()));
 }
 
 Bool_t AliITSIntMap::Insert(Int_t key, Int_t val) {
   // insert a new node into the map (returns true if the node was not present before)
-  if (fNrEntries==0) {
-    fFirst = new AliITSIntMapNode(key, val, NULL);
+  UInt_t entriesBefore = fNrEntries;
+  InsertNode(key,val,fRoot,0);
+  if (fNrEntries>entriesBefore) return kTRUE;
+  else return kFALSE;
+}
+
+void AliITSIntMap::InsertNode(Int_t key, Int_t val, AliITSIntMapNode* &node, UInt_t height) {
+  // method to insert a node in the tree (used recursively)
+  height++;
+  if (node==NULL) {
+    node = new AliITSIntMapNode(key,val,NULL,NULL);
     fNrEntries++;
-    return kTRUE;
-  }
-  else {
-    AliITSIntMapNode* it1 = fFirst;
-    AliITSIntMapNode* it2 = fFirst->GetNext();
-    while (it2!=NULL && key > it2->GetKey()) {
-      it1 = it2;
-      it2 = it1->GetNext();
-    }
-    if (key < it1->GetKey()) {
-      fFirst = new AliITSIntMapNode(key, val, it1);
-      fNrEntries++;
-      return kTRUE;
-    }
-    else if (key > it1->GetKey() && 
-            ( (it2!=NULL && key < it2->GetKey()) || (it2==NULL) )
-            ) {
-      it1->SetNext(new AliITSIntMapNode(key, val, it2));
-      fNrEntries++;
-      return kTRUE;
+    fFastAccess=kFALSE;
+    fFastAccessSerialize=kFALSE;
+    UInt_t balanceHeight = (UInt_t) (log(fNrEntries+1)/log(2)+1);
+    if ( (height-balanceHeight)*(height-balanceHeight) > fNrEntries ) {
+      Balance();
     }
   }
-  return kFALSE;
+  else if (key < node->Key()) {
+    InsertNode(key,val,node->Left(),height);
+  }
+  else if (key > node->Key()) {
+    InsertNode(key,val,node->Right(),height);
+  }
+  else { // (key==node->Key()): do nothing (avoid duplicates)
+    Warning("AliITSIntMap::InsertNode","Node with key %d already in map. Not inserted.",key);
+  }
 }
 
 Bool_t AliITSIntMap::Remove(Int_t key) {
   // remove a node from the map (returns true if the node was found)
-  if (fNrEntries>0) {
-    AliITSIntMapNode* it1 = fFirst;
-    AliITSIntMapNode* it2 = fFirst->GetNext();
-    while (it2!=NULL && key > it2->GetKey()) {
-      it1 = it2;
-      it2 = it1->GetNext();
-    }
-    if (key == it1->GetKey()) {
-      fFirst = it1->GetNext();
-      delete it1;
-      fNrEntries--;
-      return kTRUE;
+  UInt_t entriesBefore = fNrEntries;
+  RemoveNode(key,fRoot);
+  if (fNrEntries<entriesBefore) return kTRUE;
+  else return kFALSE;
+}
+
+void AliITSIntMap::RemoveNode(Int_t key, AliITSIntMapNode* &node) {
+  // method to remove a node in the tree (used recursively)
+  if (node == NULL) return;   // node not found; do nothing
+  if (key < node->Key()) {
+    RemoveNode(key,node->Left());
+  }
+  else if (key > node->Key()) {
+    RemoveNode(key,node->Right());
+  }
+  else if (node->Left()!=NULL && node->Right()!=NULL) { // Two children
+    if (fNrEntries%2==0) { // for better balance, remove from left or right sub tree
+      AliITSIntMapNode* moveNode = FindMinNode(node->Right());
+      node->SetKey(moveNode->Key());
+      node->SetVal(moveNode->Val());
+      RemoveNode(moveNode->Key(),node->Right());
     }
-    else if (it2 != NULL && key == it2->GetKey()) {
-      it1->SetNext(it2->GetNext());
-      delete it2;
-      fNrEntries--;
-      return kTRUE;
+    else {
+      AliITSIntMapNode* moveNode = FindMaxNode(node->Left());
+      node->SetKey(moveNode->Key());
+      node->SetVal(moveNode->Val());
+      RemoveNode(moveNode->Key(),node->Left());
     }
   }
-  return kFALSE; 
+  else {
+    AliITSIntMapNode* oldNode = node;
+    node = (node->Left()!=NULL) ? node->Left() : node->Right();
+    fNrEntries--;
+    delete oldNode;
+    fFastAccess=kFALSE;
+    fFastAccessSerialize=kFALSE;
+  }
+}
+
+Bool_t AliITSIntMap::Pop(Int_t& key, Int_t& val) {
+  // removes one entry (root) from tree, giving its key,val pair
+  if (fRoot!=NULL) {
+    key = fRoot->Key();
+    val = fRoot->Val();
+    return Remove(key);
+  }
+  else return kFALSE;
+}
+
+AliITSIntMapNode* AliITSIntMap::FindMinNode(AliITSIntMapNode* node) const {
+  // returns the node with smallest key in the sub tree starting from node
+  if (node==NULL) return NULL;
+  else if (node->Left()==NULL) return node;
+  else return FindMinNode(node->Left());
+}
+
+AliITSIntMapNode* AliITSIntMap::FindMaxNode(AliITSIntMapNode* node) const {
+  // returns the node with largest key in the sub tree starting from node
+  if (node==NULL) return NULL;
+  else if (node->Right()==NULL) return node;
+  else return FindMaxNode(node->Right());
 }
 
 AliITSIntMapNode* AliITSIntMap::Find(Int_t key) const {
   // finds a node and returns it (returns NULL if not found)
+  return FindNode(key,fRoot,0);
+}
+
+AliITSIntMapNode*  AliITSIntMap::FindNode(Int_t key, AliITSIntMapNode* node, UInt_t height) const {
+  // method to find a node in the tree (used recursively)
+  if (node==NULL) return NULL;
+  height++;
+  if (key<node->Key()) return FindNode(key,node->Left(),height);
+  else if (key>node->Key()) return FindNode(key,node->Right(),height);
+  else { // Match
+//    //*** balance if height too high. const above have to be removed if this is needed ***
+//    UInt_t balanceHeight = (UInt_t) (log(fNrEntries+1)/log(2)+1);
+//    if ( (height-balanceHeight)*(height-balanceHeight) > fNrEntries ) {
+//      Balance();
+//    }
+    return node;
+  }
+}
+
+Int_t AliITSIntMap::GetVal(Int_t key) const {
+  // returns the value for the node with key
+  AliITSIntMapNode* node = Find(key);
+  if (node!=NULL) {
+    return node->Val();
+  }
+  else {
+    Warning("AliITSIntMap::GetVal","Node with key %d not found in map. Returning -999.",key);
+    return -999;
+  }
+}
+
+void AliITSIntMap::Balance() {
+  // method to balance the tree
+  //  printf("balance H=%d --> ",GetTreeHeight());
+  if (fNrEntries==0) return;
+  if (!fFastAccess) InitFastAccess();
+  fRoot = BalanceNode(0,fNrEntries-1);
+  //  printf("H=%d\n",GetTreeHeight());
+}
+
+AliITSIntMapNode* AliITSIntMap::BalanceNode(Int_t lowInd, Int_t highInd) {
+  // balances the tree by selecting the center of an index range 
+  // (used recursively)
+  if (lowInd>highInd) return NULL;
+  Int_t thisInd = lowInd+(highInd-lowInd)/2;
+  fFastAccessArray[thisInd]->Left() = BalanceNode(lowInd,thisInd-1);
+  fFastAccessArray[thisInd]->Right() = BalanceNode(thisInd+1,highInd);
+  return fFastAccessArray[thisInd];
+}
+
+void AliITSIntMap::ClearFastAccess(){
+  // clears the fast access array of pointers
+  if (fFastAccessArray!=NULL) {
+    delete [] fFastAccessArray;
+    fFastAccessArray=NULL;
+  }
+  fFastAccess=kFALSE;
+  fFastAccessSerialize=kFALSE;
+}
+
+void AliITSIntMap::InitFastAccess(){
+  // initializes the fast access array
+  ClearFastAccess();
   if (fNrEntries>0) {
-    AliITSIntMapNode* it1 = fFirst;
-    AliITSIntMapNode* it2 = fFirst->GetNext();
-    while (it2!=NULL && key > it2->GetKey()) {
-      it1 = it2;
-      it2 = it1->GetNext();
-    }
-    if (key == it1->GetKey()) {
-      return it1;
-    }
-    else if (it2 != NULL && key == it2->GetKey()) {
-      return it2;
-    }
+    fFastAccessArray = new AliITSIntMapNode*[fNrEntries];
+    fDummyIndex=0;
+    InitFastAccessNode(fRoot);
+    fFastAccess=kTRUE;
+  }
+}
+
+void AliITSIntMap::InitFastAccessNode(AliITSIntMapNode* node) {
+  // initializes the fast access array starting from node (used recursively)
+  if (node==NULL) return;
+  InitFastAccessNode(node->Left());
+  fFastAccessArray[fDummyIndex++] = node;
+  InitFastAccessNode(node->Right());
+}
+
+void AliITSIntMap::InitFastAccessSerialize(){
+  // initializes the fast access array
+  ClearFastAccess();
+  if (fNrEntries>0) {
+    fFastAccessArray = new AliITSIntMapNode*[fNrEntries];
+    fDummyIndex=0;
+    InitFastAccessSerializeNode(fRoot);
+    fFastAccessSerialize=kTRUE;
   }
-  return NULL; 
 }
 
-Int_t AliITSIntMap::GetKey(UInt_t index) const {
+void AliITSIntMap::InitFastAccessSerializeNode(AliITSIntMapNode* node) {
+  // initializes the fast access array for tree ordering starting from node (used recursively)
+  if (node==NULL) return;
+  fFastAccessArray[fDummyIndex++] = node;
+  InitFastAccessSerializeNode(node->Left());
+  InitFastAccessSerializeNode(node->Right());
+}
+
+Int_t AliITSIntMap::GetKeyIndex(UInt_t index) {
   // returns the key of the node at position 'index' in the map
   // returns -1 if out of bounds
-  if (index < fNrEntries) {
-    AliITSIntMapNode* it1 = fFirst;
-    for (UInt_t i=0; i<index; i++) {
-      it1 = it1->GetNext();
-    }
-    return it1->GetKey();
-  }
-  else {
-    return -1;
+  if (index<fNrEntries) {
+    if (!fFastAccess && !fFastAccessSerialize) InitFastAccess();
+    return fFastAccessArray[index]->Key();
   }
+  return -1;
 }
 
-Int_t AliITSIntMap::GetVal(UInt_t index) const {
+Int_t AliITSIntMap::GetValIndex(UInt_t index) {
   // returns the value of the node at position 'index' in the map
   // returns -1 if out of bounds
-  if (index < fNrEntries) {
-    AliITSIntMapNode* it1 = fFirst;
-    for (UInt_t i=0; i<index; i++) {
-      it1 = it1->GetNext();
+  if (index<fNrEntries) {
+    if (!fFastAccess && !fFastAccessSerialize) InitFastAccess();
+    return fFastAccessArray[index]->Val();
+  }
+  return -1;
+}
+
+AliITSIntMapNode* AliITSIntMap::FindNodeIndex(UInt_t index, AliITSIntMapNode* node) const {
+  // method to find the index:th node in the tree (used recursively)
+  // this method should not be needed anymore, since GetKeyIndex/GetValIndex is faster
+  static UInt_t fTmpInd;
+  if (node==fRoot) fTmpInd=0;
+  if (node->Left()!=NULL) {
+    AliITSIntMapNode* tmpResult = FindNodeIndex(index,node->Left());
+    if (tmpResult != NULL) {
+      return tmpResult;
     }
-    return it1->GetVal();
   }
-  else {
-    return -1;
+  if (fTmpInd==index) return node;
+  fTmpInd++;
+  if (node->Right()!=NULL) {
+    AliITSIntMapNode* tmpResult = FindNodeIndex(index,node->Right());
+    if (tmpResult != NULL) {
+      return tmpResult;
+    }
   }
+  return NULL;
 }
 
 void AliITSIntMap::PrintEntries() const {
   // prints all the entries (key,value pairs) of the map
   printf("*** Map Entries: (key , value)***\n");
-  AliITSIntMapNode* it1 = fFirst;  
-  for (UInt_t i=0; i<fNrEntries; i++) {
-    printf("%d , %d\n",it1->GetKey(),it1->GetVal());
-    it1 = it1->GetNext();
-  }
+  PrintNode(fRoot);
   printf("*********************************\n");
 }
+
+void AliITSIntMap::PrintNode(AliITSIntMapNode* node) const {
+  // method to print node entry (key,value) (used recursively)
+  if (node==NULL) return;
+  if (node->Left()!=NULL) PrintNode(node->Left());
+  printf("%d , %d\n",node->Key(),node->Val());
+  if (node->Right()!=NULL) PrintNode(node->Right());
+}
+
+UInt_t AliITSIntMap::GetTreeHeight() const {
+  // returns the height of the tree
+  return GetTreeHeightNode(fRoot);
+}
+
+UInt_t AliITSIntMap::GetTreeHeightNode(AliITSIntMapNode* node) const {
+  // returns tree height for the sub tree starting from node (used recursively)
+  if (node==NULL) return 0;
+  UInt_t leftH = GetTreeHeightNode(node->Left());
+  UInt_t rightH = GetTreeHeightNode(node->Right());
+  if (leftH>=rightH) return leftH+1;
+  else               return rightH+1;
+}
index d7f7ccc..9a8f9f8 100644 (file)
@@ -4,8 +4,7 @@
 //////////////////////////////////////////////////////////////////////
 // Author: Henrik Tydesjo                                           //
 // This class implements the use of a map of integers.              //
-// For simplicity, this version is just a sorted linked list,       //
-// but it may be rewritten later for better performance if required.//
+//                                                                  //
 //////////////////////////////////////////////////////////////////////  
 
 #include <Rtypes.h>
@@ -16,22 +15,53 @@ class AliITSIntMap {
 
  public:
   AliITSIntMap();
+  AliITSIntMap(AliITSIntMapNode* root, UInt_t nrEntries);
   AliITSIntMap(const AliITSIntMap& imap);
   virtual ~AliITSIntMap();
   AliITSIntMap& operator=(const AliITSIntMap& imap);
 
   void               Clear();
+  AliITSIntMap*      Clone() const;
   Bool_t             Insert(Int_t key, Int_t val);
   Bool_t             Remove(Int_t key);
+  Bool_t             Pop(Int_t& key, Int_t& val);
   AliITSIntMapNode*  Find(Int_t key) const;
-  Int_t              GetKey(UInt_t index) const;
-  Int_t              GetVal(UInt_t index) const;
+  Int_t              GetVal(Int_t key) const;
+
   UInt_t             GetNrEntries() const {return fNrEntries;}
+  Int_t              GetKeyIndex(UInt_t index);
+  Int_t              GetValIndex(UInt_t index);
+
   void               PrintEntries() const;
+  void               Balance();
+  void               PrepareSerialize() {InitFastAccessSerialize();}
+  UInt_t             GetTreeHeight() const;
 
  private:
-  UInt_t             fNrEntries;   // nr of entries in map
-  AliITSIntMapNode*  fFirst;       // link to first node of map
+  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             fFastAccessSerialize;// is fast access array initialized (tree ordered)?
+  AliITSIntMapNode** fFastAccessArray;    // array of pointers to nodes
+  UInt_t             fDummyIndex;         // dummy index used when traversing tree
+
+  void               ClearNode(AliITSIntMapNode* &node); // delete this node and all below
+  AliITSIntMapNode*  CloneNode(AliITSIntMapNode* node) const;
+  void               InsertNode(Int_t key, Int_t val, AliITSIntMapNode* &node, UInt_t height);
+  void               RemoveNode(Int_t key, AliITSIntMapNode* &node);
+  AliITSIntMapNode*  FindNode(Int_t key, AliITSIntMapNode* node, UInt_t height) const;
+  AliITSIntMapNode*  FindNodeIndex(UInt_t index, AliITSIntMapNode* node) const;
+  AliITSIntMapNode*  FindMinNode(AliITSIntMapNode* node) const;
+  AliITSIntMapNode*  FindMaxNode(AliITSIntMapNode* node) const;
+  void               PrintNode(AliITSIntMapNode* node) const;
+  UInt_t             GetTreeHeightNode(AliITSIntMapNode* node) const;
+
+  AliITSIntMapNode*  BalanceNode(Int_t lowInd, Int_t highInd);
+  void               ClearFastAccess();
+  void               InitFastAccess();
+  void               InitFastAccessNode(AliITSIntMapNode* node);
+  void               InitFastAccessSerialize();
+  void               InitFastAccessSerializeNode(AliITSIntMapNode* node);
 
 };
 
index 9863a1f..20a0078 100644 (file)
@@ -9,19 +9,22 @@
 AliITSIntMapNode::AliITSIntMapNode():
   fKey(0),
   fVal(0),
-  fNext(0)
+  fLeft(NULL),
+  fRight(NULL)
 {}
 
-AliITSIntMapNode::AliITSIntMapNode(Int_t key, Int_t val, AliITSIntMapNode* next):
+AliITSIntMapNode::AliITSIntMapNode(Int_t key, Int_t val, AliITSIntMapNode* left, AliITSIntMapNode* right):
   fKey(key),
   fVal(val),
-  fNext(next)
+  fLeft(left),
+  fRight(right)
 {}
 
 AliITSIntMapNode::AliITSIntMapNode(const AliITSIntMapNode& obj):
   fKey(obj.fKey),
   fVal(obj.fVal),
-  fNext(obj.fNext)
+  fLeft(obj.fLeft),
+  fRight(obj.fRight)
 {
   // copy constructor
 }
@@ -35,7 +38,8 @@ AliITSIntMapNode& AliITSIntMapNode::operator=(const AliITSIntMapNode& obj)
   if (this!=&obj) {
     fKey = obj.fKey;
     fVal = obj.fVal;
-    fNext = obj.fNext;
+    fLeft = obj.fLeft;
+    fRight = obj.fRight;
   }
   return *this;
 }
index 745f459..b39db5b 100644 (file)
@@ -13,22 +13,26 @@ class AliITSIntMapNode {
 
  public:
   AliITSIntMapNode();
-  AliITSIntMapNode(Int_t key, Int_t val, AliITSIntMapNode* next);
+  AliITSIntMapNode(Int_t key, Int_t val, AliITSIntMapNode* left, AliITSIntMapNode* right);
   AliITSIntMapNode(const AliITSIntMapNode& obj);
   virtual ~AliITSIntMapNode();
   AliITSIntMapNode& operator=(const AliITSIntMapNode& obj);
 
-  Int_t             GetKey() const {return fKey;}
-  Int_t             GetVal() const {return fVal;}
-  AliITSIntMapNode* GetNext() {return fNext;}
+  Int_t             Key() const {return fKey;}
+  Int_t             Val() const {return fVal;}
+  AliITSIntMapNode*& Left() {return fLeft;}
+  AliITSIntMapNode*& Right() {return fRight;}
+
   void              SetKey(Int_t key) {fKey=key;}
   void              SetVal(Int_t val) {fVal=val;}
-  void              SetNext(AliITSIntMapNode* obj) {fNext = obj;}
+  void              SetLeft(AliITSIntMapNode* obj) {fLeft = obj;}
+  void              SetRight(AliITSIntMapNode* obj) {fRight = obj;}
 
  private:
   Int_t fKey;               // key (for sorting)
   Int_t fVal;               // value
-  AliITSIntMapNode* fNext;  // pointer to next object in list
+  AliITSIntMapNode* fLeft;  // pointer to left object in bin tree
+  AliITSIntMapNode* fRight; // pointer to right object in bin tree
 
 };
 
index 22ff881..23f8a77 100644 (file)
@@ -9,36 +9,44 @@
 
 #include "AliITSOnlineCalibrationSPDhandler.h"
 #include "AliITSOnlineCalibrationSPD.h"
+#include "AliITSIntMap.h"
+#include <TObjArray.h>
 #include <TArrayI.h>
 #include <TFile.h>
+#include <TError.h>
+#include <fstream>
 
-AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
-  fModuleNr(0),
-  fDeadPixelMap(AliITSIntMap()),
-  fNoisyPixelMap(AliITSIntMap())
-{}
+#ifndef SPD_DA_OFF // you may want to exclude cdb classes, if using this class outside aliroot
+#include "AliITSCalibrationSPD.h"
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+#endif
 
-AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(UInt_t module):
-  fModuleNr(module),
-  fDeadPixelMap(AliITSIntMap()),
-  fNoisyPixelMap(AliITSIntMap())
-{}
+AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler():
+  fFileLocation("."),
+  fModuleMapInited(kFALSE)
+{
+  // constructor
+  for (UInt_t module=0; module<240; module++) {
+    fNrDead[module]=0;
+    fNrNoisy[module]=0;
+    fDeadPixelMap[module] = new AliITSIntMap();
+    fNoisyPixelMap[module] = new AliITSIntMap();
+  }
+}
 
 AliITSOnlineCalibrationSPDhandler::AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle): 
-  fModuleNr(handle.fModuleNr),
-  fDeadPixelMap(AliITSIntMap()),
-  fNoisyPixelMap(AliITSIntMap())
+  fFileLocation("."),
+  fModuleMapInited(kFALSE)
 {
   // copy constructor
-  UInt_t nrDead = handle.GetNrDead();
-  for (UInt_t index=0; index<nrDead; index++) {
-    this->SetDeadPixel(handle.GetDeadColAt(index),handle.GetDeadRowAt(index));
-  }
-  UInt_t nrNoisy = handle.GetNrNoisy();
-  for (UInt_t index=0; index<nrNoisy; index++) {
-    this->SetNoisyPixel(handle.GetNoisyColAt(index),handle.GetNoisyRowAt(index));
+  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();
   }
-  sprintf(fFileLocation,"%s",handle.fFileLocation);
+  fFileLocation = handle.fFileLocation;
 }
 
 AliITSOnlineCalibrationSPDhandler::~AliITSOnlineCalibrationSPDhandler() {
@@ -49,16 +57,13 @@ AliITSOnlineCalibrationSPDhandler& AliITSOnlineCalibrationSPDhandler::operator=(
   // assignment operator
   if (this!=&handle) {
     this->ClearMaps();
-    fModuleNr = handle.fModuleNr;
-    UInt_t nrDead = handle.GetNrDead();
-    for (UInt_t index=0; index<nrDead; index++) {
-      this->SetDeadPixel(handle.GetDeadColAt(index),handle.GetDeadRowAt(index));
+    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();
     }
-    UInt_t nrNoisy = handle.GetNrNoisy();
-    for (UInt_t index=0; index<nrNoisy; index++) {
-      this->SetNoisyPixel(handle.GetNoisyColAt(index),handle.GetNoisyRowAt(index));
-    }
-    sprintf(fFileLocation,"%s",handle.fFileLocation);
+    fFileLocation = handle.fFileLocation;
   }
   return *this;
 }
@@ -69,51 +74,23 @@ void AliITSOnlineCalibrationSPDhandler::ClearMaps() {
   ResetNoisy();
 }
 
-void AliITSOnlineCalibrationSPDhandler::WriteToFile() {
-  // write the lists of dead and noisy to default file
-  Char_t fileName[200];
-  sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
-  WriteToFile(fileName);
-}
-
-void AliITSOnlineCalibrationSPDhandler::WriteToFile(Char_t* fileName) {
-  // write the lists of dead and noisy to file fileName
-  AliITSOnlineCalibrationSPD* calib = new AliITSOnlineCalibrationSPD();
-  calib->SetModuleNr(GetModuleNr());
-  calib->SetDeadList(GetDeadArray());
-  calib->SetNoisyList(GetNoisyArray());
-  calib->SetNrDead(GetNrDead());
-  calib->SetNrNoisy(GetNrNoisy());
-
-  TFile file(fileName, "RECREATE");
-  file.WriteTObject(calib, "AliITSOnlineCalibrationSPD");
-  file.Close();
-
-  delete calib;
-}
-
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile() {
-  // read dead and noisy from default file
-  Char_t fileName[200];
-  sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
-  return ReadFromFile(fileName);
-}
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile() {
-  // read dead from default file
-  Char_t fileName[200];
-  sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
-  return ReadDeadFromFile(fileName);
+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;
+    }
+  }
+  return returnval;
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile() {
-  // read noisy from default file
-  Char_t fileName[200];
-  sprintf(fileName,"%s/SPD_DeadNoisy_%d.root",fFileLocation,fModuleNr);
-  return ReadNoisyFromFile(fileName);
+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());
 }
-
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile(Char_t* fileName) {
-  // read dead and noisy from file fileName (clear the previous list of dead and noisy pixels)
-  ClearMaps();
+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;}
@@ -124,27 +101,41 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromFile(Char_t* fileName) {
       file.GetObject("AliITSOnlineCalibrationSPD", calib);
       file.Close();
       if (calib!=NULL) {
-       SetModuleNr(calib->GetModuleNr());
+       UInt_t module = calib->GetModuleNr();
        Int_t nrDead=calib->GetNrDead();
        for (Int_t index=0; index<nrDead; index++) {
-         Int_t col=calib->GetDeadColAt(index);
-         Int_t row=calib->GetDeadRowAt(index);
-         SetDeadPixel(col,row);
+         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++) {
-         Int_t col=calib->GetNoisyColAt(index);
-         Int_t row=calib->GetNoisyRowAt(index);
-         SetNoisyPixel(col,row);
+         UInt_t colM=calib->GetNoisyColAt(index);
+         UInt_t row=calib->GetNoisyRowAt(index);
+         SetNoisyPixelM(module,colM,row);
        }
       }
     }
   }
   return kTRUE;
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(Char_t* fileName) {
-  // read dead from file fileName (clear the previous list of dead pixels)
-  ResetDead();
+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)) {
+      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);
+  return ReadDeadFromFileName(fileName.Data());
+}
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFileName(const char *fileName) {
+  // read dead from file fileName
   AliITSOnlineCalibrationSPD* calib;
   FILE* fp0 = fopen(fileName, "r");
   if (fp0 == NULL) {return kFALSE;}
@@ -155,21 +146,35 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadDeadFromFile(Char_t* fileName) {
       file.GetObject("AliITSOnlineCalibrationSPD", calib);
       file.Close();
       if (calib!=NULL) {
-       SetModuleNr(calib->GetModuleNr());
+       UInt_t module = calib->GetModuleNr();
        Int_t nrDead=calib->GetNrDead();
        for (Int_t index=0; index<nrDead; index++) {
-         Int_t col=calib->GetDeadColAt(index);
-         Int_t row=calib->GetDeadRowAt(index);
-         SetDeadPixel(col,row);
+         UInt_t colM=calib->GetDeadColAt(index);
+         UInt_t row=calib->GetDeadRowAt(index);
+         SetDeadPixelM(module,colM,row);
        }
       }
     }
   }
   return kTRUE;
 }
-Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(Char_t* fileName) {
-  // read noisy from file fileName (clear the previous list of noisy pixels)
-  ResetNoisy();
+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;
   FILE* fp0 = fopen(fileName, "r");
   if (fp0 == NULL) {return kFALSE;}
@@ -180,12 +185,12 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(Char_t* fileName) {
       file.GetObject("AliITSOnlineCalibrationSPD", calib);
       file.Close();
       if (calib!=NULL) {
-       SetModuleNr(calib->GetModuleNr());
+       UInt_t module = calib->GetModuleNr();
        Int_t nrNoisy=calib->GetNrNoisy();
        for (Int_t index=0; index<nrNoisy; index++) {
-         Int_t col=calib->GetNoisyColAt(index);
-         Int_t row=calib->GetNoisyRowAt(index);
-         SetNoisyPixel(col,row);
+         UInt_t colM=calib->GetNoisyColAt(index);
+         UInt_t row=calib->GetNoisyRowAt(index);
+         SetNoisyPixelM(module,colM,row);
        }
       }
     }
@@ -193,69 +198,322 @@ Bool_t AliITSOnlineCalibrationSPDhandler::ReadNoisyFromFile(Char_t* fileName) {
   return kTRUE;
 }
 
-TArrayI AliITSOnlineCalibrationSPDhandler::GetDeadArray() {
+
+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 newNrDead=0;
+  ifstream textFile;
+  textFile.open(fileName, ifstream::in);
+  if (textFile.fail()) {
+    Error("AliITSOnlineCalibrationSPDhandler::ReadDeadFromText","No noisy text file (%s) present.",fileName);
+  }
+  else {
+    while(1) {
+      UInt_t eqId,hs,chip,col,row;
+      textFile >> eqId; 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 (textFile.eof()) break;
+    }
+    textFile.close();
+  }
+  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 newNrNoisy=0;
+  ifstream textFile;
+  textFile.open(fileName, ifstream::in);
+  if (textFile.fail()) {
+    Error("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;
+      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 (textFile.eof()) break;
+    }
+    textFile.close();
+  }
+  return newNrNoisy;
+}
+
+
+#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
+  AliCDBManager* man = AliCDBManager::Instance();
+  if(!man->IsDefaultStorageSet()) {
+    man->SetDefaultStorage("local://$ALICE_ROOT");
+  }
+  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", 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);
+    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);
+  }
+  spdEntry->SetOwner(kTRUE);
+  spdEntry->Clear();
+  return kTRUE;
+}
+
+Bool_t AliITSOnlineCalibrationSPDhandler::ReadFromDB(Int_t runNr) {
+  // 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
+  AliCDBManager* man = AliCDBManager::Instance();
+  if(!man->IsDefaultStorageSet()) {
+    man->SetDefaultStorage("local://$ALICE_ROOT");
+  }
+  AliCDBEntry *cdbEntry = man->Get("ITS/Calib/CalibSPD", 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);
+    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 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::WriteToDB(Int_t runNrStart, Int_t runNrEnd) {
+  // writes dead and noisy pixels to DB for given runNr
+  // overwrites any previous entries
+  AliCDBManager* man = AliCDBManager::Instance();
+  if(!man->IsDefaultStorageSet()) {
+    man->SetDefaultStorage("local://$ALICE_ROOT");
+  }
+  AliCDBMetaData* metaData = new AliCDBMetaData();
+  metaData->SetResponsible("Henrik Tydesjo");
+  metaData->SetComment("Created by AliITSOnlineCalibrationSPDhandler.");
+  AliCDBId idCalSPD("ITS/Calib/CalibSPD",runNrStart,runNrEnd);
+  TObjArray* spdEntry = new TObjArray(240);
+  spdEntry->SetOwner(kTRUE);
+  for(UInt_t module=0; module<240; module++){
+    AliITSCalibrationSPD* calObj = new AliITSCalibrationSPD();
+    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) );
+  }
+  AliCDBEntry* cdbEntry = new AliCDBEntry((TObject*)spdEntry,idCalSPD,metaData);
+  man->Put(cdbEntry);
+  delete spdEntry;
+  delete cdbEntry;
+  delete metaData;
+  return kTRUE;
+}
+#endif
+
+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);
+    }
+  }
+}
+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);
+    }
+  }
+}
+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::WriteNoisyToFiles() {
+  // write the lists of noisy to files (only if there are >0 dead pixels)
+  for (UInt_t module=0; module<240; module++) {
+    if (fNrNoisy[module] > 0) {
+      printf("writing noisy to file for module %d\n",module);
+      WriteNoisyToFile(module);
+    }
+  }
+}
+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) {
   // get a TArrayI of the dead pixels (format for the AliITSCalibrationSPD object)
   TArrayI returnArray;
-  returnArray.Set(GetNrDead()*2);
-  for (UInt_t index=0; index<fDeadPixelMap.GetNrEntries(); index++) {
-    Int_t key = fDeadPixelMap.GetKey(index);
-    Int_t col = GetColFromKey(key);
+  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(col,index*2);
+    returnArray.AddAt(colM,index*2);
     returnArray.AddAt(row,index*2+1);
   }
   return returnArray;
 }
-
-TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray() {
+TArrayI AliITSOnlineCalibrationSPDhandler::GetNoisyArray(UInt_t module) {
   // get a TArrayI of the noisy pixels (format for the AliITSCalibrationSPD object)
   TArrayI returnArray;
-  returnArray.Set(GetNrNoisy()*2);
-  for (UInt_t index=0; index<fNoisyPixelMap.GetNrEntries(); index++) {
-    Int_t key = fNoisyPixelMap.GetKey(index);
-    Int_t col = GetColFromKey(key);
+  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(col,index*2);
+    returnArray.AddAt(colM,index*2);
     returnArray.AddAt(row,index*2+1);
   }
   return returnArray;
 }
 
 void AliITSOnlineCalibrationSPDhandler::ResetDead() {
-  fDeadPixelMap.Clear();
+  // reset the dead pixel map
+  for (UInt_t module=0; module<240; module++) {
+    fNrDead[module]=0;
+    fDeadPixelMap[module]->Clear();
+  }
 }
 
-
-Bool_t AliITSOnlineCalibrationSPDhandler::SetDeadPixel(Int_t col, Int_t row) {
-  // set a dead pixel, returns false if pixel is already dead or noisy
-  Int_t key = GetKey(col,row);
-  // if noisy we dont want to add it...
-  if (fNoisyPixelMap.Find(key) != NULL) return kFALSE;
-  return fDeadPixelMap.Insert(key,col);
+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]--;
+      }
+    }
+  }
 }
 
-Int_t AliITSOnlineCalibrationSPDhandler::GetDeadColAt(UInt_t index) const {
-  // get column for the dead pixel at position index in list of dead
-  if (index<fDeadPixelMap.GetNrEntries()) {
-    Int_t key = fDeadPixelMap.GetKey(index);
-    return GetColFromKey(key);
+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;
   }
-  else return 0;
+  return kFALSE;
 }
 
-Int_t AliITSOnlineCalibrationSPDhandler::GetDeadRowAt(UInt_t index) const {
-  // get row for the dead pixel at position index in list of dead
-  if (index<fDeadPixelMap.GetNrEntries()) {
-    Int_t key = fDeadPixelMap.GetKey(index);
-    return 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;
   }
-  else return 0;
+  return kFALSE;
 }
 
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(Int_t col, Int_t row) const {
-  // is the pixel dead?
-  Int_t key = GetKey(col,row);
-  if ( fDeadPixelMap.Find(key) != NULL) {
+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;
   }
   else {
@@ -263,41 +521,165 @@ Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelDead(Int_t col, Int_t row) cons
   }
 }
 
+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);
+  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 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;
+}
+
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNrDead(UInt_t module) const {
+  // returns the number of dead pixels for a certain module
+  if (module<240) {
+    return fNrDead[module];
+  }
+  else {
+    return 0;
+  }
+}
+
+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);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetDeadEqIdAt", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+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;
+  }
+}
+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;
+  }
+}
+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::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;
+  }
+}
+
 void AliITSOnlineCalibrationSPDhandler::ResetNoisy() {
   // clear the list of noisy pixels
-  fNoisyPixelMap.Clear();
+  for (UInt_t module=0; module<240; module++) {
+    fNrNoisy[module]=0;
+    fNoisyPixelMap[module]->Clear();
+  }
 }
+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);
+  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]--;
+      }
+    }
+  }
+}
+
 
-Bool_t AliITSOnlineCalibrationSPDhandler::SetNoisyPixel(Int_t col, Int_t row) {
+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
-  Int_t key = GetKey(col,row);
-  // if dead before - remove from the dead list 
-  fDeadPixelMap.Remove(key);
-  return fNoisyPixelMap.Insert(key,col);
+  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;
+  }
+  return kFALSE;
 }
 
-Int_t AliITSOnlineCalibrationSPDhandler::GetNoisyColAt(UInt_t index) const {
-  // get column for the noisy pixel at position index in list of noisy
-  if (index<fNoisyPixelMap.GetNrEntries()) {
-    Int_t key = fNoisyPixelMap.GetKey(index);
-    return GetColFromKey(key);
+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]++;
+    return kTRUE;
   }
-  else return 0;
+  return kFALSE;
 }
 
-Int_t AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt(UInt_t index) const {
-  // get row for the noisy pixel at position index in list of noisy
-  if (index<fNoisyPixelMap.GetNrEntries()) {
-    Int_t key = fNoisyPixelMap.GetKey(index);
-    return GetRowFromKey(key);
-  }
-  else return 0;
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyKey(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 IsPixelNoisyMKey(module,key);
 }
 
-Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(Int_t col, Int_t row) const {
+Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisyMKey(UInt_t module, Int_t key) const {
   // is this pixel noisy?
-  Int_t key = GetKey(col,row);
-  if ( fNoisyPixelMap.Find(key) != NULL ) {
+  if ( fNoisyPixelMap[module]->Find(key) != NULL ) {
     return kTRUE;
   }
   else {
@@ -305,28 +687,297 @@ Bool_t AliITSOnlineCalibrationSPDhandler::IsPixelNoisy(Int_t col, Int_t row) con
   }
 }
 
+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];
+  }
+  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 {
+    return 0;
+  }
+}
+
+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 0;
+  }
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt(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);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyHSAt", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+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);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyChipAt", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+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);
+  }
+  else {
+    Warning("AliITSOnlineCalibrationSPDhandler::GetNoisyColAt", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+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);
+  }
+  else {
+    Error("AliITSOnlineCalibrationSPDhandler::GetNoisyRowAt", "Index %d out of bounds.", index);
+    return 0;
+  }
+}
+
 void AliITSOnlineCalibrationSPDhandler::PrintDead() const {
   // print the dead pixels to screen
-  printf("-----------------------\n");
-  printf("Dead Pixels Module %d:\n",fModuleNr);
-  printf("-----------------------\n");
-  for (UInt_t index=0; index<fDeadPixelMap.GetNrEntries(); index++) {
-    Int_t key = fDeadPixelMap.GetKey(index);
-    Int_t col = GetColFromKey(key);
-    Int_t row = GetRowFromKey(key);
-    printf("%d,%d\n",col,row);
+  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);
+    }
   }
 }
 
 void AliITSOnlineCalibrationSPDhandler::PrintNoisy() const {
-  // print the noisy pixels to screen
-  printf("-----------------------\n");
-  printf("Noisy Pixels Module %d:\n",fModuleNr);
-  printf("-----------------------\n");
-  for (UInt_t index=0; index<fNoisyPixelMap.GetNrEntries(); index++) {
-    Int_t key = fNoisyPixelMap.GetKey(index);
-    Int_t col = GetColFromKey(key);
-    Int_t row = GetRowFromKey(key);
-    printf("%d,%d\n",col,row);
+  // 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::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);
+      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))) {
+       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);
+      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))) {
+       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);
+      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);
+      }
+    }
+    for (UInt_t ind2=0; ind2<fNrNoisy[module]; ind2++) {
+      Int_t key = fNoisyPixelMap[module]->GetKeyIndex(ind2);
+      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);
+      if (!(other->IsPixelNoisy(eqId,hs,chip,col,row))) {
+       newHandler->SetNoisyPixel(eqId,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);
+      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);
+      }
+    }
+  }
+  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);
+      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);
+      }
+    }
+  }
+  return newHandler;
+}
+
+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;
+    }
+  }
+}
+
+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 << "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";
+      }
+      dcsfile << GetNoisyColAt(module,ind) << "," << GetNoisyRowAt(module,ind) << "\n";
+    }
+  }
+  dcsfile.close();
+}
+
+UInt_t AliITSOnlineCalibrationSPDhandler::GetEqIdFromOffline(UInt_t module) {
+  // module to eqId mapping
+  if (!fModuleMapInited) InitModuleMaps();
+  return fiDDL[module];
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetHSFromOffline(UInt_t module) {
+  // module to hs mapping
+  if (!fModuleMapInited) InitModuleMaps();
+  return fiModule[module]/2;
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetChipFromOffline(UInt_t module, UInt_t colM) {
+  // module,colM to chip mapping
+  if (!fModuleMapInited) InitModuleMaps();
+  return colM/32 + 5*(fiModule[module]%2);
+}
+UInt_t AliITSOnlineCalibrationSPDhandler::GetColFromOffline(UInt_t colM) const {
+  // colM to col mapping
+  return colM%32;
 }
index b68572d..8f0b079 100644 (file)
 #ifndef ALI_ITS_ONLINECALIBRATIONSPDHANDLER_H
 #define ALI_ITS_ONLINECALIBRATIONSPDHANDLER_H
 
-//////////////////////////////////////////////////////////////////////
-// Author: Henrik Tydesjo                                           //
-// Class that  simplifies the managing of dead and noisy pixels.    //
-// Interface to the AliITSOnlineCalibrationSPD container object     //
-// through reading and writing to TFile.                            //
-//////////////////////////////////////////////////////////////////////  
+//////////////////////////////////////////////////////////////////////////
+// Author: Henrik Tydesjo                                               //
+// Class that  simplifies the managing of dead and noisy pixels.        //
+// Has interface to the AliITSOnlineCalibrationSPD container objects    //
+// through reading and writing to TFile.                                //
+//////////////////////////////////////////////////////////////////////////
 
 
-#include "AliITSIntMap.h"
+#include "AliITSRawStreamSPD.h"
+#include <TString.h>
 
 class TArrayI;
+class AliITSIntMap;
 
 class AliITSOnlineCalibrationSPDhandler {
 
  public:
   AliITSOnlineCalibrationSPDhandler();
-  AliITSOnlineCalibrationSPDhandler(UInt_t module);
   AliITSOnlineCalibrationSPDhandler(const AliITSOnlineCalibrationSPDhandler& handle);
   virtual ~AliITSOnlineCalibrationSPDhandler();
   AliITSOnlineCalibrationSPDhandler& operator=(const AliITSOnlineCalibrationSPDhandler& handle);
+
+  void    SetFileLocation(const Char_t* loc) {fFileLocation = loc;}
+  TString GetFileLocation() const {return fFileLocation;}
+
   void    ClearMaps();
 
-  void    WriteToFile();
-  void    WriteToFile(Char_t* fileName);
-  Bool_t  ReadFromFile();
-  Bool_t  ReadDeadFromFile();
-  Bool_t  ReadNoisyFromFile();
-  Bool_t  ReadFromFile(Char_t* fileName);
-  Bool_t  ReadDeadFromFile(Char_t* fileName);
-  Bool_t  ReadNoisyFromFile(Char_t* fileName);
-  void    SetModuleNr(UInt_t mod) {fModuleNr=mod;}
-  UInt_t  GetModuleNr() const {return fModuleNr;}
-  void    SetFileLocation(Char_t* loc) {sprintf(fFileLocation,"%s",loc);}
-  UInt_t  GetNrDead() const {return fDeadPixelMap.GetNrEntries();}
-  UInt_t  GetNrNoisy() const {return fNoisyPixelMap.GetNrEntries();}
-  TArrayI GetDeadArray();
-  TArrayI GetNoisyArray();
+  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  ReadDeadFromFileName(const char *fileName);
+  Bool_t  ReadNoisyFromFileName(const char *fileName);
+
+  void    WriteToFiles();
+  void    WriteDeadToFiles();
+  void    WriteNoisyToFiles();
+  void    WriteToFile(UInt_t module);  
+  void    WriteDeadToFile(UInt_t module);
+  void    WriteNoisyToFile(UInt_t module);
+
+#ifndef SPD_DA_OFF
+  Bool_t  ReadModuleFromDB(UInt_t module, Int_t runNr);
+  Bool_t  ReadFromDB(Int_t runNr);
+  Bool_t  WriteToDB(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    ResetDead();
-  Bool_t  SetDeadPixel(Int_t col, Int_t row);
-  Int_t   GetDeadColAt(UInt_t index) const;
-  Int_t   GetDeadRowAt(UInt_t index) const;
-  Bool_t  IsPixelDead(Int_t col, Int_t row) const;
+  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  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);
+
+  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    ResetNoisy();
-  Bool_t  SetNoisyPixel(Int_t col, Int_t row);
-  Int_t   GetNoisyColAt(UInt_t index) const;
-  Int_t   GetNoisyRowAt(UInt_t index) const;
-  Bool_t  IsPixelNoisy(Int_t col, Int_t row) const;
+  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  SetNoisyPixelM(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  GetNrNoisy(UInt_t module) const;
+  UInt_t  GetNoisyEqIdAt(UInt_t module, UInt_t index);
+  UInt_t  GetNoisyHSAt(UInt_t module, UInt_t index);
+  UInt_t  GetNoisyChipAt(UInt_t module, UInt_t index);
+  UInt_t  GetNoisyColAt(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  GetNrDiff(AliITSOnlineCalibrationSPDhandler* other) const;
+  UInt_t  GetNrDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const;
+  UInt_t  GetNrNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const;
+  AliITSOnlineCalibrationSPDhandler* GetDiff(AliITSOnlineCalibrationSPDhandler* other) const;
+  AliITSOnlineCalibrationSPDhandler* GetDeadDiff(AliITSOnlineCalibrationSPDhandler* other) const;
+  AliITSOnlineCalibrationSPDhandler* GetNoisyDiff(AliITSOnlineCalibrationSPDhandler* other) const;
+
+
  private:
-  UInt_t fModuleNr;                 // module nr
-  AliITSIntMap fDeadPixelMap;       // list of dead pixels
-  AliITSIntMap fNoisyPixelMap;      // list of noisy pixels
-  Char_t  fFileLocation[200];       // location (dir) of file to read and write from
-
-  Int_t   GetKey(Int_t col, Int_t row) const {return col*256 + row;}
-  Int_t   GetColFromKey(Int_t key) const {return key/256;}
-  Int_t   GetRowFromKey(Int_t key) const {return key%256;}
+  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
+                                    
+  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;}
+
+  UInt_t   GetEqIdFromKey(Int_t key) const 
+    {return key/(6*10*32*256);}
+  UInt_t   GetHSFromKey(Int_t key) const 
+    {return (key%(6*10*32*256))/(10*32*256);}
+  UInt_t   GetChipFromKey(Int_t key) const 
+    {return ((key%(6*10*32*256))%(10*32*256))/(32*256);}
+  UInt_t   GetColFromKey(Int_t key) const 
+    {return (((key%(6*10*32*256))%(10*32*256))%(32*256))/256;}
+  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));}
+  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;
 
 };
 
index ecb2c66..02d501d 100644 (file)
 #include "AliITSOnlineSPDHitArray.h"
 #include "AliITSOnlineSPDHitEvent.h"
 
-ClassImp(AliITSOnlineSPDscan)
-
-AliITSOnlineSPDscan::AliITSOnlineSPDscan(Char_t *fileName) :
+AliITSOnlineSPDscan::AliITSOnlineSPDscan(const Char_t *fileName) :
   fFile(NULL),
   fWrite(kFALSE),
   fCurrentStep(-1),
   fModified(kFALSE),
   fInfoModified(kFALSE),
-  fScanInfo(NULL)
+  fScanInfo(NULL),
+  fFileName(fileName)
 {
   // constructor, open file for reading or writing
-  sprintf(fFileName,"%s",fileName);
   // look for a previously saved info object 
   // (if file not found create a new one and return, else read)
-  FILE* fp0 = fopen(fFileName, "r");
+  FILE* fp0 = fopen(fFileName.Data(), "r");
   if (fp0 == NULL) {
     fScanInfo = new AliITSOnlineSPDscanInfo();
-    fFile = new TFile(fFileName, "RECREATE");
+    fFile = new TFile(fFileName.Data(), "RECREATE");
     fWrite=kTRUE;
   }
   else {
     fclose(fp0);
-    fFile = new TFile(fFileName, "READ");
+    fFile = new TFile(fFileName.Data(), "READ");
     fWrite=kFALSE;
     fFile->GetObject("AliITSOnlineSPDscanInfo", fScanInfo);
   }
@@ -56,7 +54,8 @@ AliITSOnlineSPDscan::AliITSOnlineSPDscan(const AliITSOnlineSPDscan& /*scan*/) :
   fCurrentStep(-1),
   fModified(kFALSE),
   fInfoModified(kFALSE),
-  fScanInfo(NULL)
+  fScanInfo(NULL),
+  fFileName(".")
 {
   printf("This object should not be copied!");
 }
@@ -80,7 +79,7 @@ AliITSOnlineSPDscan::~AliITSOnlineSPDscan() {
     if (!fWrite) {
       fFile->Close();
       delete fFile;
-      fFile = new TFile(fFileName, "UPDATE");
+      fFile = new TFile(fFileName.Data(), "UPDATE");
       fWrite=kTRUE;
     }
     fFile->Delete("AliITSOnlineSPDscanInfo;*");
@@ -99,49 +98,6 @@ AliITSOnlineSPDscan& AliITSOnlineSPDscan::operator=(const AliITSOnlineSPDscan& s
   return *this;
 }
 
-
-//TObjArray* AliITSOnlineSPDscan::GetAsTObjArray() {
-//  TObjArray *arr = new TObjArray();
-//  arr->Add(fScanInfo);
-//  for (UInt_t step=0; step<GetNSteps(); step++) {
-//    SwitchToStep(step);
-//    for (UInt_t hs=0; hs<6; hs++) {
-//      arr->Add(fCurrentHitArray[hs]->CloneThis());
-//      arr->Add(fCurrentHitEvent[hs]->CloneThis());
-//    }
-//  }
-//  return arr;
-//}
-//
-//void AliITSOnlineSPDscan::ReadFromTObjArray(TObjArray *arr) {
-//  ClearThis();
-//  Int_t nrEntries = arr->GetEntriesFast();
-//  if (nrEntries>0 && nrEntries%2==1) {
-//    fScanInfo = (AliITSOnlineSPDscanInfo*) arr->At(0);
-//    fInfoModified=kTRUE;
-//    FillFromTObjArray(arr,nrEntries);
-//  }
-//}
-//
-//void AliITSOnlineSPDscan::FillFromTObjArray(TObjArray *arr, UInt_t nrEntries) {
-//  UInt_t index=1;
-//  UInt_t hs=0;
-//  while (index<nrEntries) {
-//    UInt_t step=(index-1)/12;
-//    SwitchToStep(step);
-//    if (index%2==1) {
-//      fCurrentHitArray[hs] = (AliITSOnlineSPDHitArray*) arr->At(index);
-//    }
-//    else {
-//      fCurrentHitEvent[hs] = (AliITSOnlineSPDHitEvent*) arr->At(index);
-//      hs++;
-//      if (hs>5) hs=0;
-//    }
-//    fModified=kTRUE;
-//    index++;
-//  }
-//}
-
 void AliITSOnlineSPDscan::ClearThis() {
   // clear this scan, close file and open new
   for (UInt_t hs=0; hs<6; hs++) {
@@ -157,7 +113,7 @@ void AliITSOnlineSPDscan::ClearThis() {
   fScanInfo->ClearThis();
   fFile->Close();
   delete fFile;
-  fFile = new TFile(fFileName, "RECREATE");
+  fFile = new TFile(fFileName.Data(), "RECREATE");
   fWrite=kTRUE;
   fFile->WriteTObject(fScanInfo, "AliITSOnlineSPDscanInfo");
   fInfoModified=kTRUE;
@@ -236,11 +192,9 @@ void AliITSOnlineSPDscan::FillGap(UInt_t nsi) {
 void AliITSOnlineSPDscan::ReadCurrentStep() {
   // read current step index into memory
   for (UInt_t hs=0; hs<6; hs++) {
-    Char_t stepName[40];
-    sprintf(stepName,"HitArray_HS%d_Step%d",hs,fCurrentStep);
-    fFile->GetObject(stepName, fCurrentHitArray[hs]);
-    Char_t stepName2[40];
-    sprintf(stepName2,"HitEvent_HS%d_Step%d",hs,fCurrentStep);
+    TString stepName = Form("HitArray_HS%d_Step%d",hs,fCurrentStep);
+    fFile->GetObject(stepName.Data(), fCurrentHitArray[hs]);
+    TString stepName2 = Form("HitEvent_HS%d_Step%d",hs,fCurrentStep);
     fFile->GetObject(stepName2, fCurrentHitEvent[hs]);
   }
 }
@@ -250,22 +204,18 @@ void AliITSOnlineSPDscan::SaveCurrentStep() {
   if (!fWrite) {
     fFile->Close();
     delete fFile;
-    fFile = new TFile(fFileName, "UPDATE");
+    fFile = new TFile(fFileName.Data(), "UPDATE");
     fWrite=kTRUE;
   }
   for (UInt_t hs=0; hs<6; hs++) {
-    Char_t stepName[40];
-    sprintf(stepName,"HitArray_HS%d_Step%d",hs,fCurrentStep);
-    Char_t stepDelete[40];
-    sprintf(stepDelete,"%s;*",stepName);
-    fFile->Delete(stepDelete);
-    fFile->WriteTObject(fCurrentHitArray[hs], stepName);
-    Char_t stepName2[40];
-    sprintf(stepName2,"HitEvent_HS%d_Step%d",hs,fCurrentStep);
-    Char_t stepDelete2[40];
-    sprintf(stepDelete2,"%s;*",stepName2);
-    fFile->Delete(stepDelete2);
-    fFile->WriteTObject(fCurrentHitEvent[hs], stepName2);
+    TString stepName = Form("HitArray_HS%d_Step%d",hs,fCurrentStep);
+    TString stepDelete = Form("%s;*",stepName.Data());
+    fFile->Delete(stepDelete.Data());
+    fFile->WriteTObject(fCurrentHitArray[hs], stepName.Data());
+    TString stepName2 = Form("HitEvent_HS%d_Step%d",hs,fCurrentStep);
+    TString stepDelete2 = Form("%s;*",stepName2.Data());
+    fFile->Delete(stepDelete2.Data());
+    fFile->WriteTObject(fCurrentHitEvent[hs], stepName2.Data());
   }
   fModified=kFALSE;
 }
@@ -455,6 +405,11 @@ void AliITSOnlineSPDscan::SetDacStep(UInt_t val){
   fScanInfo->SetDacStep(val); 
   fInfoModified=kTRUE;
 }
+void AliITSOnlineSPDscan::SetDCSVersion(UInt_t val){
+  // set dcs db version
+  fScanInfo->SetDCSVersion(val); 
+  fInfoModified=kTRUE;
+}
 void AliITSOnlineSPDscan::IncrementTriggers(UInt_t nsi) {
   // increment nr of triggers
   SwitchToStep(nsi);
@@ -503,3 +458,6 @@ UInt_t AliITSOnlineSPDscan::GetDacEnd() const {
 UInt_t AliITSOnlineSPDscan::GetDacStep() const {
   return fScanInfo->GetDacStep();
 }
+UInt_t AliITSOnlineSPDscan::GetDCSVersion() const {
+  return fScanInfo->GetDCSVersion();
+}
index 3f02591..a2b84cb 100644 (file)
@@ -12,7 +12,7 @@
 // information is stored (AliITSOnlineSPDscanInfo).       //
 ////////////////////////////////////////////////////////////
 
-#include <Rtypes.h> 
+#include <TString.h>
 
 class TFile;
 class AliITSOnlineSPDscanInfo;
@@ -22,8 +22,8 @@ class AliITSOnlineSPDHitEvent;
 class AliITSOnlineSPDscan {
 
  public:
-  AliITSOnlineSPDscan():fFile(NULL),fWrite(kFALSE),fCurrentStep(-1),fModified(kFALSE),fInfoModified(kFALSE),fScanInfo(NULL){}
-  AliITSOnlineSPDscan(Char_t *fileName);
+  AliITSOnlineSPDscan():fFile(NULL),fWrite(kFALSE),fCurrentStep(-1),fModified(kFALSE),fInfoModified(kFALSE),fScanInfo(NULL),fFileName("."){}
+  AliITSOnlineSPDscan(const Char_t *fileName);
   AliITSOnlineSPDscan(const AliITSOnlineSPDscan& scan);
   virtual ~AliITSOnlineSPDscan();
   AliITSOnlineSPDscan& operator=(const AliITSOnlineSPDscan& scan);
@@ -43,6 +43,7 @@ class AliITSOnlineSPDscan {
   void     SetDacStart(UInt_t val);
   void     SetDacEnd(UInt_t val);
   void     SetDacStep(UInt_t val);
+  void     SetDCSVersion(UInt_t val);
 
   void     SetHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi, UInt_t val);
   void     IncrementTriggers(UInt_t nsi);
@@ -65,6 +66,7 @@ class AliITSOnlineSPDscan {
   UInt_t   GetDacStart() const;
   UInt_t   GetDacEnd() const;
   UInt_t   GetDacStep() const;
+  UInt_t   GetDCSVersion() const;
 
   UInt_t   GetHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi);
   Float_t  GetHitsEfficiency(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi);
@@ -87,7 +89,7 @@ class AliITSOnlineSPDscan {
   AliITSOnlineSPDscanInfo *fScanInfo;           // overall scan information
   AliITSOnlineSPDHitArray *fCurrentHitArray[6]; // hit array, one for each halfstave
   AliITSOnlineSPDHitEvent *fCurrentHitEvent[6]; // hit events, one for each halfstave
-  Char_t   fFileName[200];                      // filename of file to read write
+  TString  fFileName;                           // filename of file to read write
 
   void     Init();
   void     CreateNewStep();
index 4fb1780..10cca0e 100644 (file)
@@ -1,20 +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                                 //
 // This class is used in the detector algorithm framework //
@@ -35,6 +18,7 @@
 #include <TF1.h>
 #include <TGraph.h>
 #include <TH2F.h>
+#include <TError.h>
 
 Double_t itsSpdErrorf(Double_t *x, Double_t *par){
   if (par[2]<0) par[2]=0;
@@ -46,13 +30,12 @@ Double_t itsSpdErrorf(Double_t *x, Double_t *par){
 //}
 
 
-AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(Char_t *fileName) :
-  fType(99),fDacId(99),fScanObj(NULL),fTriggers(NULL),
+AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const Char_t *fileName) :
+  fType(99),fDacId(99),fFileName(fileName),fScanObj(NULL),fTriggers(NULL),
   fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
   fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(2),fMaxBaseLineLevel(10)
 {
   // constructor
-  sprintf(fFileName,"%s",fileName);
   for (UInt_t chipNr=0; chipNr<11; chipNr++) {
     for (UInt_t hs=0; hs<6; hs++) {
       fMeanMultiplicity[hs][chipNr]=NULL;
@@ -67,12 +50,12 @@ AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(Char_t *fileName) :
 }
 
 AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle) :
-  fType(99),fDacId(99),fScanObj(NULL),fTriggers(NULL),
+  fType(99),fDacId(99),fFileName("."),fScanObj(NULL),fTriggers(NULL),
   fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
   fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(2),fMaxBaseLineLevel(10)
 {
   // copy constructor, only copies the filename (not the processed data)
-  sprintf(fFileName,"%s",handle.fFileName);
+  fFileName=handle.fFileName;
 
   fScanObj=NULL;
   fType=99;
@@ -133,7 +116,7 @@ AliITSOnlineSPDscanAnalyzer& AliITSOnlineSPDscanAnalyzer::operator=(const AliITS
       }
     }
    
-    sprintf(fFileName,"%s",handle.fFileName);
+    fFileName=handle.fFileName;
 
     fScanObj=NULL;
     fType=99;
@@ -156,14 +139,14 @@ AliITSOnlineSPDscanAnalyzer& AliITSOnlineSPDscanAnalyzer::operator=(const AliITS
 
 void AliITSOnlineSPDscanAnalyzer::Init() {
   // first checks type of container and then initializes container obj
-  FILE* fp0 = fopen(fFileName, "r");
+  FILE* fp0 = fopen(fFileName.Data(), "r");
   if (fp0 == NULL) {
     return;
   }
   else {
     fclose(fp0);
   }
-  fScanObj = new AliITSOnlineSPDscan(fFileName);
+  fScanObj = new AliITSOnlineSPDscan(fFileName.Data());
   fType = fScanObj->GetType();
   delete fScanObj;
 
@@ -171,20 +154,20 @@ void AliITSOnlineSPDscanAnalyzer::Init() {
   switch(fType) {
   case kUNIMA:
   case kNOISE:
-    fScanObj = new AliITSOnlineSPDscanSingle(fFileName);
+    fScanObj = new AliITSOnlineSPDscanSingle(fFileName.Data());
     break;
   case kMINTH:
   case kDAC:
   case kDELAY:
-    fScanObj = new AliITSOnlineSPDscanMultiple(fFileName);
+    fScanObj = new AliITSOnlineSPDscanMultiple(fFileName.Data());
     fDacId = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacId();
     break;
   case kMEANTH:
-    fScanObj = new AliITSOnlineSPDscanMeanTh(fFileName);
+    fScanObj = new AliITSOnlineSPDscanMeanTh(fFileName.Data());
     fDacId = ((AliITSOnlineSPDscanMeanTh*)fScanObj)->GetDacId();
     break;
   default:
-    printf("Type %d not defined!\n",fType);
+    Error("AliITSOnlineSPDscanAnalyzer::Init","Type %d not defined!",fType);
     fScanObj=NULL;
     return;
     break;
@@ -201,44 +184,69 @@ void AliITSOnlineSPDscanAnalyzer::Init() {
 
 }
 
+void AliITSOnlineSPDscanAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
+  // set a parameter
+  TString name = pname;
+  TString val = pval;
+  if (name.CompareTo("fOverWrite")==0) {
+    if (val.CompareTo("YES")==0) {
+      fOverWrite = kTRUE;
+    }
+  }
+  else if (name.CompareTo("fNoiseThreshold")==0) {
+    fNoiseThreshold = val.Atof();
+  }
+  else if (name.CompareTo("fNoiseMinimumEvents")==0) {
+    fNoiseMinimumEvents = val.Atoi();
+  }
+  else if (name.CompareTo("fMinNrStepsBeforeIncrease")==0) {
+    fMinNrStepsBeforeIncrease = val.Atoi();
+  }
+  else if (name.CompareTo("fMinIncreaseFromBaseLine")==0) {
+    fMinIncreaseFromBaseLine = val.Atof();
+  }
+  else if (name.CompareTo("fStepDownDacSafe")==0) {
+    fStepDownDacSafe = val.Atoi();
+  }
+  else if (name.CompareTo("fMaxBaseLineLevel")==0) {
+    fMaxBaseLineLevel = val.Atof();
+  }
+  else {
+    Error("AliITSOnlineSPDscanAnalyzer::SetParam","Parameter %s in configuration file unknown.",name.Data());
+  }
+}
 
 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(Char_t *oldcalibDir) {
-  // process dead pixel data
+  // process dead pixel data, for uniformity scan, 
+  // NB: This will not be the general way of finding dead pixels.
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","No data!");
     return kFALSE;
   }
   // should be type kUNIMA
   if (fType!=kUNIMA) {
-    printf("Dead pixels only for scan type %d\n",kUNIMA);
+    Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Dead pixels only for scan type %d.",kUNIMA);
     return kFALSE;
   }
 
-  Int_t nrDead[240];
-  for (Int_t i=0; i<240; i++) {
-    nrDead[i]=0;
-  }
   UInt_t routerNr = fScanObj->GetRouterNr();
   UInt_t rowStart = fScanObj->GetRowStart();
   UInt_t rowEnd   = fScanObj->GetRowEnd();
   for (UInt_t hs=0; hs<6; hs++) {
     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*2+chipNr/5);
-       if (!fHandler[module]) {
-         fHandler[module] = new AliITSOnlineCalibrationSPDhandler(module);
-       }
-       fHandler[module]->SetFileLocation(oldcalibDir);
-       fHandler[module]->ReadFromFile();
-       if (fOverWrite) {fHandler[module]->ResetDead();}
+       UInt_t module = AliITSRawStreamSPD::GetModuleNumber(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) {
-               Int_t newCol = 32*(chipNr%5) + col;
-               if (fHandler[module]->SetDeadPixel(newCol,row)) {
-                 nrDead[module]++;
+               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);
              }
            }
          }
@@ -254,41 +262,34 @@ Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(Char_t *oldcalibDir) {
 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(Char_t *oldcalibDir) {
   // process noisy pixel data
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","No data!");
     return kFALSE;
   }
   // should be type kNOISE
   if (fType != kNOISE) {
-    printf("Noisy pixels only for scan type %d\n",kNOISE);
+    Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Noisy pixels only for scan type %d.",kNOISE);
     return kFALSE;
   }
 
-  Int_t nrNoisy[240];
-  for (Int_t i=0; i<240; i++) {
-    nrNoisy[i]=0;
-  }
   if (fScanObj->GetTriggers(0)<fNoiseMinimumEvents) {
-    printf("Error: Process noisy: Too few events.\n"); 
+    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*2+chipNr/5);
+       UInt_t module = AliITSRawStreamSPD::GetModuleNumber(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(module);
-             }
-             fHandler[module]->SetFileLocation(oldcalibDir);
-             fHandler[module]->ReadFromFile();
-             if (fOverWrite) {fHandler[module]->ResetNoisy();}
-             Int_t newCol = 32*(chipNr%5) + col;
-             if (fHandler[module]->SetNoisyPixel(newCol,row)) {
-               nrNoisy[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);
            }
          }
        }
@@ -302,25 +303,23 @@ Bool_t AliITSOnlineSPDscanAnalyzer::SaveDeadNoisyPixels(UInt_t module, Char_t *c
   // save dead and noisy pixels to file in dir calibDir
   if (fHandler[module]!=NULL) {
     fHandler[module]->SetFileLocation(calibDir);
-    fHandler[module]->WriteToFile();
+    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;
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","No data!");
     return -1;
   }
   // should be type kDELAY or kDAC with id 42 (delay_ctrl)
   if (fType!=kDELAY && (fType!=kDAC || fDacId!=42)) {
-    printf("Delay only for scan type %d or %d and dac_id 42\n",kDELAY,kDAC);
+    Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","Delay only for scan type %d or %d and dac_id 42.",kDELAY,kDAC);
     return -1;
   }
   if (fMeanMultiplicity[hs][chipNr]==NULL) {
@@ -351,56 +350,20 @@ Int_t AliITSOnlineSPDscanAnalyzer::GetDelay(UInt_t hs, UInt_t chipNr) {
 }
 
 
-// ********** old version of "GetDelay", which fits a gaussian to the meanmult graph
-//Int_t AliITSOnlineSPDscanAnalyzer::GetDelay(UInt_t hs, UInt_t chipNr) {
-//  // get delay
-//  if (hs>=6 || chipNr>10) return -1;
-//  if (fScanObj==NULL) {
-//    printf("No data!\n");
-//    return -1;
-//  }
-//  // should be type kDELAY or kDAC with id 42 (delay_ctrl)
-//  if (fType!=kDELAY && (fType!=kDAC || fDacId!=42)) {
-//    printf("Delay only for scan type %d or %d and dac_id 42\n",kDELAY,kDAC);
-//    return -1;
-//  }
-//  if (fMeanMultiplicity[hs][chipNr]==NULL) {
-//    if (!ProcessMeanMultiplicity()) {
-//      return -1;
-//    }
-//  }
-//
-//  Char_t funcName[30];
-//  sprintf(funcName,"Fit delay func HS%d CHIP%d",hs,chipNr);
-//  Int_t minDac = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(0);
-//  Int_t maxDac = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(fScanObj->GetNSteps()-1);
-//  TF1* delayFunc = new TF1(funcName,"gaus",minDac,maxDac);
-//  fMeanMultiplicity[hs][chipNr]->Fit(funcName,"Q0");
-//  Double_t mean = delayFunc->GetParameter(1);
-//  //  Double_t sigma = fDelayFunc[hs][chipNr]->GetParameter(2);
-//  delete delayFunc;
-//  if (mean>minDac && mean<maxDac) {
-//    return (Int_t) (mean+0.5);
-//  }
-//  else {
-//    return -1;
-//  }
-//}
-
 Int_t AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima(UInt_t hs, UInt_t chipNr) {
   // in case of a uniformity scan, returns the nr of noisy pixels, (here > 200 hits)
   if (hs>=6 || chipNr>10) return -1;
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","No data!");
     return kFALSE;
   }
   // should be type kUNIMA
   if (fType != kUNIMA) {
-    printf("Noisy pixels Unima only for scan type %d\n",kUNIMA);
+    Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Noisy pixels Unima only for scan type %d.",kUNIMA);
     return kFALSE;
   }
   if (fScanObj->GetTriggers(0)!=25600) {
-    printf("Error: Process noisy unima: Incorrect number of events (!=25600.\n"); 
+    Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Process noisy unima: Incorrect number of events (!=25600.");
     return kFALSE;
   }
 
@@ -477,12 +440,12 @@ Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
   // calculates and returns the minimum threshold
   if (hs>=6 || chipNr>10) return -1;
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","No data!");
     return -1;
   }
   // should be type  kMINTH  or  kDAC with id 39 (pre_vth)
   if (fType!=kMINTH && (fType!=kDAC || fDacId!=39)) {
-    printf("MinTh only for scan type %d OR %d with dac_id 39\n",kMINTH,kDAC);
+    Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","MinTh only for scan type %d OR %d with dac_id 39.",kMINTH,kDAC);
     return -1;
   }
   if (fMeanMultiplicity[hs][chipNr]==NULL) {
@@ -493,14 +456,13 @@ Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
 
   Int_t lastDac = FindLastMinThDac(hs,chipNr);
   if (lastDac==-1) {
-    printf("GetMinTh: HS%d, Chip%d: Increase of Mean Multiplicity by %1.2f never reached.\n",hs,chipNr,fMinIncreaseFromBaseLine);
+    Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Increase of Mean Multiplicity by %1.2f never reached.",hs,chipNr,fMinIncreaseFromBaseLine);
     return -1;
   }
 
   Int_t minDac = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(0);
-  Char_t funcName[30];
-  sprintf(funcName,"Fit minth func HS%d CHIP%d",hs,chipNr);
-  TF1 *minThFunc = new TF1(funcName,itsSpdErrorf,100,500,3);
+  TString funcName = Form("Fit minth func HS%d CHIP%d",hs,chipNr);
+  TF1 *minThFunc = new TF1(funcName.Data(),itsSpdErrorf,100,500,3);
   minThFunc->SetParameter(0,lastDac+10);
   minThFunc->SetParameter(1,2);
   minThFunc->SetParameter(2,0);
@@ -521,13 +483,13 @@ Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
   delete minThFunc;
 
   if (baseLine>fMaxBaseLineLevel) {
-    printf("GetMinTh: HS%d, Chip%d: BaseLine too large (%1.2f>%1.2f)\n",hs,chipNr,baseLine,fMaxBaseLineLevel);
+    Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: BaseLine too large (%1.2f>%1.2f).",hs,chipNr,baseLine,fMaxBaseLineLevel);
     return -1;
   }
   UInt_t step=FindClosestLowerStep(lastDac);
   Float_t compareLine = GetCompareLine(step,hs,chipNr,baseLine);
   if (compareLine==-1) {
-    printf("GetMinTh: HS%d, Chip%d: Not enough steps (%d<%d) before increase to get a compare line.\n",hs,chipNr,step,fMinNrStepsBeforeIncrease);
+    Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Not enough steps (%d<%d) before increase to get a compare line.",hs,chipNr,step,fMinNrStepsBeforeIncrease);
     return -1;
   }
 
@@ -543,7 +505,7 @@ Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
     return minth;
   }
   else {
-    printf("GetMinTh: HS%d, Chip%d: Did not find a point below the compare line (%f).\n",hs,chipNr,compareLine);
+    Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Did not find a point below the compare line (%f).",hs,chipNr,compareLine);
     return -1;
   }
 }
@@ -553,7 +515,7 @@ Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity() {
   // process mean multiplicity data
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Error("AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity","No data!");
     return kFALSE;
   }
   for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
@@ -594,7 +556,7 @@ TGraph* AliITSOnlineSPDscanAnalyzer::GetMeanMultiplicityG(UInt_t hs, UInt_t chip
 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency() {
   // process hit event efficiency
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Error("AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency","No data!");
     return kFALSE;
   }
   for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
@@ -636,7 +598,7 @@ TGraph* AliITSOnlineSPDscanAnalyzer::GetHitEventEfficiencyG(UInt_t hs, UInt_t ch
 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers() {
   // process nr of triggers data
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Error("AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers","No data!");
     return kFALSE;
   }
   for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
@@ -693,17 +655,17 @@ UInt_t AliITSOnlineSPDscanAnalyzer::GetRouterNr() {
 TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapTot(UInt_t step) {
   // creates and returns a pointer to a hitmap histo (half sector style a la spdmood)
   if (fScanObj==NULL) {
-    printf("No data!\n");
+    Error("AliITSOnlineSPDscanAnalyzer::GetHitMapTot","No data!");
     return NULL;
   }
-  Char_t histoname[50];
+  TString histoname;
   if (fType==kMINTH || fType==kMEANTH || fType==kDAC) {
-    sprintf(histoname,"Router %d , DAC %d",GetRouterNr(),((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step));
+    histoname = Form("Router %d , DAC %d",GetRouterNr(),((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step));
   }
   else {
-    sprintf(histoname,"Router %d ",GetRouterNr());
+    histoname = Form("Router %d ",GetRouterNr());
   }
-  TH2F* fHitMapTot = new TH2F(histoname,histoname,32*10,-0.5,32*10-0.5,256*6,-0.5,256*6-0.5);
+  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");
index c22a4fd..8a8ef7e 100644 (file)
@@ -9,7 +9,7 @@
 // threshold values can be calculated.                    //
 ////////////////////////////////////////////////////////////
 
-#include <Rtypes.h>
+#include <TString.h>
 
 class AliITSOnlineSPDscan;
 class AliITSOnlineCalibrationSPDhandler;
@@ -19,12 +19,14 @@ class TH2F;
 class AliITSOnlineSPDscanAnalyzer {
 
  public:
-  AliITSOnlineSPDscanAnalyzer(Char_t *fileName);
+  AliITSOnlineSPDscanAnalyzer(const Char_t *fileName);
   AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle);
   ~AliITSOnlineSPDscanAnalyzer();
 
   AliITSOnlineSPDscanAnalyzer& operator=(const AliITSOnlineSPDscanAnalyzer& handle);
 
+  void       SetParam(const Char_t *pname, const Char_t *pval);
+
   UInt_t     GetType() const {return fType;}
   UInt_t     GetDacId() const {return fDacId;}
 
@@ -53,7 +55,7 @@ class AliITSOnlineSPDscanAnalyzer {
  private:
   UInt_t               fType;           // calib type
   UInt_t               fDacId;          // dac id
-  Char_t               fFileName[100];  // container file name
+  TString              fFileName;       // container file name
   enum                 calibvals{kMINTH,kMEANTH,kDAC,kUNIMA,kNOISE,kDELAY};  // calib types
 
   AliITSOnlineSPDscan               *fScanObj;      // container obj
index 6d1abf9..528306d 100644 (file)
@@ -12,6 +12,7 @@ ClassImp(AliITSOnlineSPDscanInfo)
 
 AliITSOnlineSPDscanInfo::AliITSOnlineSPDscanInfo(): 
   fType(999),
+  fDataFormat(999),
   fRunNr(0),
   fRouterNr(999),
   fNSteps(0),
@@ -20,7 +21,8 @@ AliITSOnlineSPDscanInfo::AliITSOnlineSPDscanInfo():
   fRowEnd(255),
   fDacStep(1),
   fDacStart(0),
-  fDacEnd(255)
+  fDacEnd(255),
+  fDCSVersion(0)
 {
   ClearThis();
 }
index b2dce57..0c1fe28 100644 (file)
@@ -33,6 +33,7 @@ class AliITSOnlineSPDscanInfo :  public TObject {
   void     SetDacStart(UInt_t val){fDacStart=val;}
   void     SetDacEnd(UInt_t val){fDacEnd=val;}  
   void     SetDacStep(UInt_t val){fDacStep=val;}
+  void     SetDCSVersion(UInt_t val){fDCSVersion=val;}
 
   void     IncrementTriggers(UInt_t nsi);
 
@@ -50,6 +51,7 @@ class AliITSOnlineSPDscanInfo :  public TObject {
   UInt_t   GetDacStart() const {return fDacStart;}
   UInt_t   GetDacEnd() const {return fDacEnd;}
   UInt_t   GetDacStep() const {return fDacStep;}
+  UInt_t   GetDCSVersion() const {return fDCSVersion;}
 
  protected:
   UInt_t   fType;                 // type of calibration scan
@@ -65,8 +67,9 @@ class AliITSOnlineSPDscanInfo :  public TObject {
   UInt_t   fDacStep;              // dac step
   UInt_t   fDacStart;             // dac start
   UInt_t   fDacEnd;               // dac end
+  UInt_t   fDCSVersion;           // ConfigDB version
 
-  ClassDef(AliITSOnlineSPDscanInfo,1)
+  ClassDef(AliITSOnlineSPDscanInfo,2)
     };
     
 #endif
index a33e7ae..1311723 100644 (file)
@@ -33,7 +33,7 @@ class AliITSOnlineSPDscanInfoMeanTh :  public AliITSOnlineSPDscanInfoMultiple {
   TArrayI   fDacHigh[6];       // DAC high values for each step
   TArrayI   fTPAmps[6];        // test pulse amplitudes, one for each step
 
-  ClassDef(AliITSOnlineSPDscanInfoMeanTh,1)
+  ClassDef(AliITSOnlineSPDscanInfoMeanTh,2)
     };
     
 #endif
index 6528692..619b104 100644 (file)
@@ -33,7 +33,7 @@ class AliITSOnlineSPDscanInfoMultiple :  public AliITSOnlineSPDscanInfo {
   TArrayI   fDacValues;     // DAC values for each step
 
 
-  ClassDef(AliITSOnlineSPDscanInfoMultiple,1)
+  ClassDef(AliITSOnlineSPDscanInfoMultiple,2)
     };
 
 #endif
index 4b80f4a..bcf6fee 100644 (file)
@@ -8,22 +8,20 @@
 #include "AliITSOnlineSPDscanMeanTh.h"
 #include "AliITSOnlineSPDscanInfoMeanTh.h"
 
-ClassImp(AliITSOnlineSPDscanMeanTh)
-
-AliITSOnlineSPDscanMeanTh::AliITSOnlineSPDscanMeanTh(Char_t *fileName) {
+AliITSOnlineSPDscanMeanTh::AliITSOnlineSPDscanMeanTh(const Char_t *fileName) {
   // constructor
-  sprintf(fFileName,"%s",fileName);
+  fFileName=fileName;
   // look for a previously saved info object 
   // (if file not found create a new one and return, else read)
-  FILE* fp0 = fopen(fFileName, "r");
+  FILE* fp0 = fopen(fFileName.Data(), "r");
   if (fp0 == NULL) {
     fScanInfo = new AliITSOnlineSPDscanInfoMeanTh();
-    fFile = new TFile(fFileName, "RECREATE");
+    fFile = new TFile(fFileName.Data(), "RECREATE");
     fWrite=kTRUE;
   }
   else {
     fclose(fp0);
-    fFile = new TFile(fFileName, "READ");
+    fFile = new TFile(fFileName.Data(), "READ");
     fWrite=kFALSE;
     fFile->GetObject("AliITSOnlineSPDscanInfo", fScanInfo);
   }
@@ -45,16 +43,6 @@ AliITSOnlineSPDscanMeanTh& AliITSOnlineSPDscanMeanTh::operator=(const AliITSOnli
   return *this;
 }
 
-//void AliITSOnlineSPDscanMeanTh::ReadFromTObjArray(TObjArray *arr) {
-//  ClearThis();
-//  Int_t nrEntries = arr->GetEntriesFast();
-//  if (nrEntries>0 && nrEntries%2==1) {
-//    fScanInfo = (AliITSOnlineSPDscanInfoMeanTh*) arr->At(0);
-//    fInfoModified=kTRUE;
-//    FillFromTObjArray(arr,nrEntries);
-//  }
-//}
-
 UInt_t AliITSOnlineSPDscanMeanTh::AddScanStep() {
   CreateNewStep();
   return ((AliITSOnlineSPDscanInfoMeanTh*)fScanInfo)->AddScanStep();
index b467da7..09db7b5 100644 (file)
@@ -13,12 +13,11 @@ class AliITSOnlineSPDscanMeanTh :  public AliITSOnlineSPDscanMultiple {
 
  public:
   AliITSOnlineSPDscanMeanTh(){}
-  AliITSOnlineSPDscanMeanTh(Char_t *fileName);
+  AliITSOnlineSPDscanMeanTh(const Char_t *fileName);
   AliITSOnlineSPDscanMeanTh(const AliITSOnlineSPDscanMeanTh& scan);
   virtual ~AliITSOnlineSPDscanMeanTh();
   AliITSOnlineSPDscanMeanTh& operator=(const AliITSOnlineSPDscanMeanTh& scan);
 
-  //  virtual void   ReadFromTObjArray(TObjArray *arr);
   virtual UInt_t AddScanStep();
 
   void     SetDacLow(UInt_t nsi, UInt_t hs, Int_t val);
@@ -29,9 +28,6 @@ class AliITSOnlineSPDscanMeanTh :  public AliITSOnlineSPDscanMultiple {
   Int_t    GetDacHigh(UInt_t nsi, UInt_t hs);
   Int_t    GetTPAmp(UInt_t nsi, UInt_t hs);
 
- protected:
-  
-  ClassDef(AliITSOnlineSPDscanMeanTh,1)
-    };
+};
     
 #endif
index d36b608..a9ecb94 100644 (file)
@@ -8,25 +8,23 @@
 #include "AliITSOnlineSPDscanMultiple.h"
 #include "AliITSOnlineSPDscanInfoMultiple.h"
 
-ClassImp(AliITSOnlineSPDscanMultiple)
-
 AliITSOnlineSPDscanMultiple::AliITSOnlineSPDscanMultiple():AliITSOnlineSPDscan(){
 // Default constructor
 }
-AliITSOnlineSPDscanMultiple::AliITSOnlineSPDscanMultiple(Char_t *fileName) {
+AliITSOnlineSPDscanMultiple::AliITSOnlineSPDscanMultiple(const Char_t *fileName) {
   // constructor
-  sprintf(fFileName,"%s",fileName);
+  fFileName=fileName;
   // look for a previously saved info object 
   // (if file not found create a new one and return, else read)
-  FILE* fp0 = fopen(fFileName, "r");
+  FILE* fp0 = fopen(fFileName.Data(), "r");
   if (fp0 == NULL) {
     fScanInfo = new AliITSOnlineSPDscanInfoMultiple();
-    fFile = new TFile(fFileName, "RECREATE");
+    fFile = new TFile(fFileName.Data(), "RECREATE");
     fWrite=kTRUE;
   }
   else {
     fclose(fp0);
-    fFile = new TFile(fFileName, "READ");
+    fFile = new TFile(fFileName.Data(), "READ");
     fWrite=kFALSE;
     fFile->GetObject("AliITSOnlineSPDscanInfo", fScanInfo);
   }
@@ -48,16 +46,6 @@ AliITSOnlineSPDscanMultiple& AliITSOnlineSPDscanMultiple::operator=(const AliITS
   return *this;
 }
 
-//void AliITSOnlineSPDscanMultiple::ReadFromTObjArray(TObjArray *arr) {
-//  ClearThis();
-//  Int_t nrEntries = arr->GetEntriesFast();
-//  if (nrEntries>0 && nrEntries%2==1) {
-//    fScanInfo = (AliITSOnlineSPDscanInfoMultiple*) arr->At(0);
-//    fInfoModified=kTRUE;
-//    FillFromTObjArray(arr,nrEntries);
-//  }
-//}
-
 UInt_t AliITSOnlineSPDscanMultiple::AddScanStep() {
   CreateNewStep();
   return ((AliITSOnlineSPDscanInfoMultiple*)fScanInfo)->AddScanStep();
index d471f24..235948c 100644 (file)
@@ -13,12 +13,11 @@ class AliITSOnlineSPDscanMultiple :  public AliITSOnlineSPDscan {
 
  public:
   AliITSOnlineSPDscanMultiple();
-  AliITSOnlineSPDscanMultiple(Char_t *fileName);
+  AliITSOnlineSPDscanMultiple(const Char_t *fileName);
   AliITSOnlineSPDscanMultiple(const AliITSOnlineSPDscanMultiple& scan);
   virtual ~AliITSOnlineSPDscanMultiple();
   AliITSOnlineSPDscanMultiple& operator=(const AliITSOnlineSPDscanMultiple& scan);
 
-  //  virtual void   ReadFromTObjArray(TObjArray *arr);
   virtual UInt_t AddScanStep();
 
   void    SetDacId(Int_t val);
@@ -28,9 +27,6 @@ class AliITSOnlineSPDscanMultiple :  public AliITSOnlineSPDscan {
   Int_t   GetDacValue(UInt_t nsi);
 
 
- protected:
-
-  ClassDef(AliITSOnlineSPDscanMultiple,1)
-    };
+};
 
 #endif
index d937f72..9a36015 100644 (file)
@@ -8,22 +8,20 @@
 #include "AliITSOnlineSPDscanSingle.h"
 #include "AliITSOnlineSPDscanInfo.h"
 
-ClassImp(AliITSOnlineSPDscanSingle)
-
-AliITSOnlineSPDscanSingle::AliITSOnlineSPDscanSingle(Char_t *fileName) {
+AliITSOnlineSPDscanSingle::AliITSOnlineSPDscanSingle(const Char_t *fileName) {
   // constructor
-  sprintf(fFileName,"%s",fileName);
+  fFileName=fileName;
   // look for a previously saved info object 
   // (if file not found create a new one and return, else read)
-  FILE* fp0 = fopen(fFileName, "r");
+  FILE* fp0 = fopen(fFileName.Data(), "r");
   if (fp0 == NULL) {
     fScanInfo = new AliITSOnlineSPDscanInfo();
-    fFile = new TFile(fFileName, "RECREATE");
+    fFile = new TFile(fFileName.Data(), "RECREATE");
     fWrite=kTRUE;
   }
   else {
     fclose(fp0);
-    fFile = new TFile(fFileName, "READ");
+    fFile = new TFile(fFileName.Data(), "READ");
     fWrite=kFALSE;
     fFile->GetObject("AliITSOnlineSPDscanInfo", fScanInfo);
   }
index ec14e87..4da5d24 100644 (file)
@@ -13,7 +13,7 @@ class AliITSOnlineSPDscanSingle :  public AliITSOnlineSPDscan {
 
  public:
   AliITSOnlineSPDscanSingle() {}
-  AliITSOnlineSPDscanSingle(Char_t *fileName);
+  AliITSOnlineSPDscanSingle(const Char_t *fileName);
   virtual ~AliITSOnlineSPDscanSingle();
   
   //  virtual void Clear() {AliITSOnlineSPDscan::Clear(); AddScanStep();}
index c1bec5c..d88bf8d 100644 (file)
@@ -6,10 +6,7 @@
 
 #include "AliITSPreprocessorSPD.h"
 #include "AliITSCalibrationSPD.h"
-#include "AliITSOnlineCalibrationSPD.h"
 #include "AliITSOnlineCalibrationSPDhandler.h"
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
 #include "AliCDBMetaData.h"
 #include "AliShuttleInterface.h"
@@ -17,6 +14,7 @@
 #include <TTimeStamp.h>
 #include <TObjString.h>
 #include <TSystem.h>
+#include <TList.h>
 
 ClassImp(AliITSPreprocessorSPD)
 
@@ -51,102 +49,114 @@ UInt_t AliITSPreprocessorSPD::Process(TMap* /*dcsAliasMap*/)
   // Do the actual preprocessing
 
 
-  // *** CHECK RUN TYPE ***
+  // *** GET RUN TYPE ***
 
   TString runType = GetRunType();
-  if(runType != "SPD_STANDALONE_CALIBRATION") {
-    Log("Nothing to do");
-    return 0;
-  }
 
 
-  // *** REFERENCE DATA ***
-
-  // Store the container files as reference data (one file for each equipment)
-  for (UInt_t eq=0; eq<20; eq++) {
-    Char_t id[20];
-    sprintf(id,"SPD_reference_%d",eq);
-    TList* list = GetFileSources(kDAQ,id); // (the id should be unique, so always 1 file)
-    if (list) {
-      TObjString* fileNameEntry = (TObjString*) list->First();
-      if (fileNameEntry!=NULL) {
-       TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
-       Char_t refCAT[10];
-       sprintf(refCAT,"SPDref_eq_%d.root",eq);
-       if (!StoreReferenceFile(fileName.Data(),refCAT)) {
-         return 1;
+
+  // *** REFERENCE DATA *** //
+
+  // Standalone runs:
+  if (runType == "DAQ_MIN_TH_SCAN" ||
+      runType == "DAQ_MEAN_TH_SCAN" ||
+      runType == "DAQ_UNIFORMITY_SCAN" ||
+      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)
+    for (UInt_t eq=0; eq<20; eq++) {
+      TString id = Form("SPD_reference_%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) {
+         TString fileName = GetFile(kDAQ, id, fileNameEntry->GetString().Data());
+         TString refCAT = Form("SPDref_eq_%d.root",eq);
+         if (!StoreReferenceFile(fileName.Data(),refCAT.Data())) {
+           Log(Form("Failed to store reference file %s.",fileName.Data()));
+           return 1;
+         }
        }
       }
     }
   }
 
+  // Physics runs (online monitoring):
+  if (runType == "PHYSICS") {
+    // *** code to be written *** //
+  }
 
-  // *** NOISY DATA ***
 
-  // Read old calibration
-  AliCDBEntry* cdbEntry = GetFromOCDB("Calib", "CalibSPD");
-  TObjArray* spdEntry;
-  if(cdbEntry) {
-    spdEntry = (TObjArray*)cdbEntry->GetObject();
-    if(!spdEntry) return 1;
-  }
-  else {
-    Log("Old calibration not found in database. This is required for further processing.");
-    return 1;
-  }
 
-  TString pwd = gSystem->pwd();  // remember the working directory, to cd back later
-  TString tempDir = Form("%s",AliShuttleInterface::GetShuttleTempDir());
-
-  // 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());
-      gSystem->cd(tempDir.Data());
-      Char_t command[100];
-      sprintf(command,"tar -xf %s",fileName.Data());
-      gSystem->Exec(command);
-      index++;
-    }
-  }
+  // *** NOISY AND DEAD DATA *** //
 
-  gSystem->cd(pwd.Data());
-
-  // Update the database entries if needed
-  UInt_t nrUpdatedMods = 0;
-  AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
-  Char_t fileLoc[100];
-  sprintf(fileLoc,"%s",AliShuttleInterface::GetShuttleTempDir());
-  handler->SetFileLocation(fileLoc);
-  for (Int_t module=0; module<240; module++) {
-    handler->SetModuleNr(module);
-    if (handler->ReadFromFile()) {
-      ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNrNoisy( handler->GetNrNoisy() );
-      ((AliITSCalibrationSPD*) spdEntry->At(module)) -> SetNoisyList( handler->GetNoisyArray() );
-      nrUpdatedMods++;
+  if (runType == "DAQ_NOISY_PIX_SCAN" || runType == "PHYSICS") {
+    // Read old calibration
+    AliCDBEntry* cdbEntry = GetFromOCDB("Calib", "CalibSPD");
+    TObjArray* spdEntry;
+    if(cdbEntry) {
+      spdEntry = (TObjArray*)cdbEntry->GetObject();
+      if(!spdEntry) return 1;
     }
-  }
-  delete handler;
-  if (nrUpdatedMods>0) {
-    Log(Form("Noisy lists for %d modules will be updated and stored...",nrUpdatedMods));
-    // Store the cdb entry
-    AliCDBMetaData metaData;
-    metaData.SetBeamPeriod(0);
-    metaData.SetResponsible("Henrik Tydesjo");
-    metaData.SetComment("Preprocessor test for SPD.");  
-    if (!Store("Calib", "CalibSPD", spdEntry, &metaData, 0, kTRUE)) {
+    else {
+      Log("Old calibration not found in database. This is required for further processing.");
       return 1;
     }
-    //    delete spdEntry;
-    Log("Database updated.");
+
+    // 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++;
+       }
+      }
+      // Update the database entries for the modules that were scanned
+      AliITSOnlineCalibrationSPDhandler* handler = new AliITSOnlineCalibrationSPDhandler();
+      TString fileLoc = ".";
+      handler->SetFileLocation(fileLoc.Data());
+      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++;
+       }
+      }
+      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.");
+      }
+    }
+
+    // Physics runs (online monitoring):
+    if (runType == "PHYSICS") {
+      // *** code to be written *** //
+    }
+
+
   }
 
-  return 0; // 0 means success
 
 
+  return 0; // 0 means success
 
 }
 
index 24a6e62..55d3884 100644 (file)
@@ -33,9 +33,10 @@ class AliITSRawStreamSPD: public AliITSRawStream {
     Int_t    GetChipCol() const {return fCol;};
     Int_t    GetChipRow() const {return fRow;};
 
-    // module mapping, iModule = halfStaveNr*2+chipAddr/5
+    // 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];}
+
     Bool_t GetHalfStavePresent(UInt_t hs);
 
     // use the methods below to extract the information from the calibration header
index f9068e4..9e0d2d0 100644 (file)
@@ -8,6 +8,7 @@
 #include <AliRun.h>
 #include <AliHeader.h>
 #include <AliGenEventHeader.h>
+#include <AliGeomManager.h>
 #include <AliITSVertexerZ.h>
 #include <AliRunLoader.h>
 #include <AliITSLoader.h>
index c7b5cb2..3785287 100644 (file)
@@ -23,12 +23,14 @@ extern "C" {
 #include "AliITSOnlineSPDscanMultiple.h"
 #include "AliITSOnlineSPDscanMeanTh.h"
 #include "AliITSOnlineSPDscanAnalyzer.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) {
@@ -40,15 +42,18 @@ int main(int argc, char **argv) {
   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";
-#ifndef SPD_DA_OFF
   char *saveDirNoisyToFXS    = "./calibResults/NoisyToFXS";
-#endif
+  char *saveDirDCSconfigToFXS= "./calibResults/DCSconfigToFXS";
   char *saveDirParameters    = "./calibResults/Parameters";
   char *saveDirRef           = "./calibResults/Reference";
 
+  char *paramsFileName       = "./standal_params.txt";
+  char *permNoisyFileName    = "./perm_noisy.txt";
+
   // This line is needed in case of a stand-alone application w/o
   // $ROOTSYS/etc/system.rootrc file
   gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
@@ -65,7 +70,61 @@ int main(int argc, char **argv) {
   enum calib_types{MINTH,MEANTH,DAC,UNIMA,NOISE,DELAY};
 
 
-  // ********* STEP 1: Produce scan container files. ***********************************
+  // ********* STEP 0: Get configuration files from db (if there are any) *******************************
+  UInt_t nrTuningParams = 0;
+  TObjArray paramNames;  paramNames.SetOwner(kTRUE);
+  TObjArray paramVals;  paramVals.SetOwner(kTRUE);
+  
+  // tuning parameters:
+  Int_t status = 0;
+#ifndef SPD_DA_OFF
+  TString idp = "spd_standal_params";
+  status=daqDA_DB_getFile(idp.Data(),paramsFileName);
+  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);
+    if (paramsFile.fail()) {
+      printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName);
+    }
+    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());
+  //  }
+
+  // perm noisy list:
+  Int_t permstatus = 0;
+#ifndef SPD_DA_OFF
+  TString idn = "spd_perm_noisy";
+  permstatus=daqDA_DB_getFile(idn.Data(),permNoisyFileName);
+  if (permstatus) {
+    printf("Failed to get config file %s: status=%d. No additional noisy pixels added.\n",idn.Data(),permstatus);
+  }
+#endif
+
+
+
+
+  // ********* STEP 1: Produce scan container files (Reference Data). ***********************************
   int startSeg = 1;
 
 #ifndef SPD_DA_OFF
@@ -75,10 +134,6 @@ int main(int argc, char **argv) {
   startSeg = 2;
 #endif
 
-#ifndef SPD_DA_OFF
-  UInt_t nrNoisyFilesProduced=0;
-#endif
-
   // container objects
   AliITSOnlineSPDscan *scanObj[20];
   Bool_t bScanInit[20];
@@ -235,24 +290,23 @@ int main(int argc, char **argv) {
 
            if (!bScanInit[eqId]) {
              // initialize container object
-             Char_t fileName[200];
-             sprintf(fileName,"%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
+             TString fileName = Form("%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
              switch (type[eqId]) {
              case NOISE:
              case UNIMA:
-               scanObj[eqId] = new AliITSOnlineSPDscanSingle(fileName); 
+               scanObj[eqId] = new AliITSOnlineSPDscanSingle(fileName.Data());
                ((AliITSOnlineSPDscanSingle*)scanObj[eqId])->ClearThis();
                bScanInit[eqId]=kTRUE;
                break;
              case MINTH:
              case DAC:
              case DELAY:
-               scanObj[eqId] = new AliITSOnlineSPDscanMultiple(fileName);
+               scanObj[eqId] = new AliITSOnlineSPDscanMultiple(fileName.Data());
                scanObj[eqId]->ClearThis();
                bScanInit[eqId]=kTRUE;
                break;
              case MEANTH: 
-               scanObj[eqId] = new AliITSOnlineSPDscanMeanTh(fileName);
+               scanObj[eqId] = new AliITSOnlineSPDscanMeanTh(fileName.Data());
                scanObj[eqId]->ClearThis();
                bScanInit[eqId]=kTRUE;
                break;
@@ -319,18 +373,20 @@ int main(int argc, char **argv) {
 
 
          }
-       
+
          if (bScanInit[eqId]) {
            while (str->Next()) {
              UInt_t hs = str->GetHalfStaveNr();
              UInt_t chip = str->GetChipAddr();
+             //***remove last condition when minthpresent put correctly in calib header?
 #ifndef SPD_DA_OFF
-             if (type[eqId]!=MINTH || minTHchipPresent[eqId][chip]) { 
+             if (type[eqId]!=MINTH || minTHchipPresent[eqId][chip] || runNr<=416900) {
 #else
-               if (type[eqId]!=MINTH || minTHchipPresent[eqId][chip] || runNr<=416900) { 
+             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;
@@ -385,22 +441,29 @@ int main(int argc, char **argv) {
 
 
 
-  // ********* STEP 2: Analyze scan container files. ***********************************
-#ifndef SPD_DA_OFF
-  // clear noisyToFXS dir:
-  Char_t command[200];
-  sprintf(command,"cd %s; rm -f *",saveDirNoisyToFXS);
-  system(command);
-#endif
+  // ********* STEP 2: Analyze scan container files. ************************************************
+
+  // clear noisyToFXS and DCSconfigToFXS dirs:
+  TString command = Form("cd %s; rm -f *",saveDirNoisyToFXS);
+  system(command.Data());
+  TString command2 = Form("cd %s; rm -f *",saveDirDCSconfigToFXS);
+  system(command2.Data());
+  UInt_t nrNoisyFilesProduced=0;
+  UInt_t nrDCSconfigFilesProduced=0;
 
   AliITSOnlineSPDscanAnalyzer *analyzer;
 
   // *** *** *** start loop over equipments (eq_id)
   for (int eqId=0; eqId<20; eqId++) {
 
-    Char_t fileName[200];
-    sprintf(fileName,"%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
-    analyzer = new AliITSOnlineSPDscanAnalyzer(fileName);
+    // create analyzer for this eq
+    TString fileName = Form("%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
+    analyzer = new AliITSOnlineSPDscanAnalyzer(fileName.Data());
+
+    // configure analyzer with tuning parameters etc:
+    for (UInt_t i=0; i<nrTuningParams; i++) {
+      analyzer->SetParam(((TString*)paramNames.At(i))->Data(),((TString*)paramVals.At(i))->Data());
+    }
 
     Int_t type  = analyzer->GetType();
     Int_t dacId = analyzer->GetDacId();
@@ -410,98 +473,133 @@ int main(int argc, char **argv) {
       }
       else printf("SPD calibrator Step2: eqId %d type %d\n",eqId,type);  
     }
+    
 
-
-
+    // algorithms for the different types of scans:
 
     if (type==UNIMA) {
+
     }
+
     else if (type==NOISE) {
       if (analyzer->ProcessNoisyPixels(saveDirNoisy)) {
-       for (UInt_t module=0; module<240; module++) {
+       // init dcs config text file
+       TString dcsConfigFileName = Form("%s/dcsConfig_run_%d_eq_%d.txt",saveDirDCSconfigToFXS,runNr,eqId);
+       ofstream dcsfile;
+       dcsfile.open(dcsConfigFileName.Data());
+       dcsfile << "[SPD SCAN]\n";
+       dcsfile << "RunNumber=" << runNr << "\n";
+       dcsfile << "Type=" << type << "\n";
+       dcsfile << "ActualDetCoonfiguration=" << "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)) {
-#ifndef SPD_DA_OFF
+           UInt_t nrNoisy = handler->GetNrNoisy(module);
+           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);
+             if (newkey!=headkey) { // print eqId,hs,chip_header
+               headkey = newkey;
+               dcsfile << "-" << newkey/(6*10) << "," << (newkey%(6*10))/10 << "," << (newkey%(6*10))%10 << "\n";
+             }
+             dcsfile << handler->GetNoisyColAt(module,ind) << "," << handler->GetNoisyRowAt(module,ind) << "\n";
+           }
            nrNoisyFilesProduced++;
-           Char_t command[100];
-           sprintf(command,"cp %s/SPD_DeadNoisy_%d.root %s/.",saveDirNoisy,module,saveDirNoisyToFXS);
-           system(command);
-#endif
+           TString command = Form("cp %s/SPD_DeadNoisy_%d.root %s/.",saveDirNoisy,module,saveDirNoisyToFXS);
+           system(command.Data());
          }
        }
+       dcsfile.close();
       }
     }
-//    else if (type==DAC && dacId==42) {
-//      Char_t ofileName[100];
-//      sprintf(ofileName,"%s/delay_eq_%d.txt",saveDirParameters,eqId);
-//      ofstream ofile;
-//      ofile.open (ofileName);
-//      for (UInt_t hs=0; hs<6; hs++) {
-//     for (UInt_t chipNr=0; chipNr<10; chipNr++) {
-//       ofile << analyzer->GetDelay(hs,chipNr);
-//       ofile << "\t";
-//     }
-//     ofile << "\n";
-//      }
-//      ofile.close();
-//#ifndef SPD_DA_OFF
-//      Char_t id[20];
-//      sprintf(id,"SPD_delay_%d",eqId);
-//      Int_t status = daqDA_FES_storeFile(ofileName,id);
-//      if (status) {
-//     printf("Failed to export file %s , status %d\n",ofileName,status);
-//      }
-//#endif
-//    }
+
     else if (type==MINTH || (type==DAC && dacId==39)) {
-      Char_t ofileName[100];
-      sprintf(ofileName,"%s/minth_eq_%d.txt",saveDirParameters,eqId);
+      // init dcs config text file
+      TString dcsConfigFileName = Form("%s/dcsConfig_run_%d_eq_%d.txt",saveDirDCSconfigToFXS,runNr,eqId);
+      ofstream dcsfile;
+      dcsfile.open(dcsConfigFileName.Data());
+      dcsfile << "[SPD SCAN]\n";
+      dcsfile << "RunNumber=" << runNr << "\n";
+      dcsfile << "Type=" << type << "\n";
+      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);
+      ofile.open (ofileName.Data());
       for (UInt_t hs=0; hs<6; hs++) {
        for (UInt_t chipNr=0; chipNr<10; chipNr++) {
-         ofile << analyzer->GetMinTh(hs,chipNr);
+         Int_t minTh = -1;
+         if (analyzer->GetOnlineScan()->GetChipPresent(hs,chipNr)) {
+           minTh = analyzer->GetMinTh(hs,chipNr);
+           if (minTh!=-1) {
+             dcsfile << "39," << eqId << "," << hs << "," << chipNr << "=" << minTh << "\n";
+           }
+           else {
+             printf("MinTh failed for Eq %d , HS %d , Chip %d\n",eqId,hs,chipNr);
+           }
+         }
+         ofile << minTh;
          ofile << "\t";
        }
        ofile << "\n";
       }
       ofile.close();
-#ifndef SPD_DA_OFF
-      Char_t id[20];
-      sprintf(id,"SPD_minth_%d",eqId);
-      Int_t status = daqDA_FES_storeFile(ofileName,id);
-      if (status) {
-       printf("Failed to export file %s , status %d\n",ofileName,status);
-      }
-#endif
+      dcsfile.close();
     }
+
     else if (type==DELAY) {
-      Char_t ofileName[100];
-      sprintf(ofileName,"%s/delay_eq_%d.txt",saveDirParameters,eqId);
+      // init dcs config text file
+      TString dcsConfigFileName = Form("%s/dcsConfig_run_%d_eq_%d.txt",saveDirDCSconfigToFXS,runNr,eqId);
+      ofstream dcsfile;
+      dcsfile.open(dcsConfigFileName.Data());
+      dcsfile << "[SPD SCAN]\n";
+      dcsfile << "RunNumber=" << runNr << "\n";
+      dcsfile << "Type=" << type << "\n";
+      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);
+      ofile.open (ofileName.Data());
       for (UInt_t hs=0; hs<6; hs++) {
        for (UInt_t chipNr=0; chipNr<10; chipNr++) {
-         UInt_t clockCycle = analyzer->GetDelay(hs,chipNr);
-         UInt_t delayCtrl = clockCycle/2;
-         UInt_t miscCtrl = 192;
-         if (clockCycle%2==1) miscCtrl = 128;
+         Int_t clockCycle = -1;
+         Int_t delayCtrl = -1;
+         Int_t miscCtrl = -1;
+         if (analyzer->GetOnlineScan()->GetChipPresent(hs,chipNr)) {
+           clockCycle = analyzer->GetDelay(hs,chipNr);
+           delayCtrl = clockCycle/2;
+           miscCtrl = 192;
+           if (clockCycle!=-1) {
+             if (clockCycle%2==1) miscCtrl = 128;
+             dcsfile << "42," << eqId << "," << hs << "," << chipNr << "=" << delayCtrl << "\n";
+             dcsfile << "43," << eqId << "," << hs << "," << chipNr << "=" << miscCtrl << "\n";
+           }
+           else {
+             printf("Delay failed for Eq %d , HS %d , Chip %d\n",eqId,hs,chipNr);
+           }
+         }
          ofile << delayCtrl << "/" << miscCtrl;
          ofile << "\t";
        }
        ofile << "\n";
       }
       ofile.close();
-#ifndef SPD_DA_OFF
-      Char_t id[20];
-      sprintf(id,"SPD_delay_%d",eqId);
-      Int_t status = daqDA_FES_storeFile(ofileName,id);
-      if (status) {
-       printf("Failed to export file %s , status %d\n",ofileName,status);
-      }
-#endif
+      dcsfile.close();
     }
 
-
     delete analyzer;
 
 #ifndef SPD_DA_OFF
@@ -514,23 +612,38 @@ int main(int argc, char **argv) {
   // *** *** *** end loop over equipments (eq_id)
 
 
-#ifndef SPD_DA_OFF
   if (nrNoisyFilesProduced>0) {
     // send a tared file of all new noisy maps
-    sprintf(command,"cd %s; tar -cf noisy.tar *",saveDirNoisyToFXS);
-    printf("\n\n%s\n\n",command);
-    system(command);
-    Char_t fileName[200];
-    sprintf(fileName,"%s/noisy.tar",saveDirNoisyToFXS);
-    Char_t id[20];
-    sprintf(id,"SPD_noisy");
-    Int_t status = daqDA_FES_storeFile(fileName,id);
+    TString command = Form("cd %s; tar -cf noisy.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";
+    Int_t status = daqDA_FES_storeFile(fileName.Data(),id.Data());
     if (status!=0) {
-      printf("Failed to export file %s , status %d\n",fileName,status);
+      printf("Failed to export file %s , status %d\n",fileName.Data(),status);
       return -1;
     }
+#endif
   }
+
+  if (nrDCSconfigFilesProduced>0) {
+    // send a tared file of all the dcsConfig text files
+    TString command = Form("cd %s; tar -cf dcsConfig.tar *",saveDirDCSconfigToFXS);
+    //    printf("\n\n%s\n\n",command.Data());
+    system(command.Data());
+#ifndef SPD_DA_OFF
+    TString fileName = Form("%s/dcsConfig.tar",saveDirDCSconfigToFXS);
+    TString id = "SPD_dcsConfig";
+    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;