modifications for online SPD monitoring (Annalisa)
authorprino <prino@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 25 Sep 2009 07:29:19 +0000 (07:29 +0000)
committerprino <prino@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 25 Sep 2009 07:29:19 +0000 (07:29 +0000)
ITS/AliITSOnlineCalibrationSPDhandler.cxx
ITS/AliITSOnlineCalibrationSPDhandler.h
ITS/AliITSOnlineSPDphys.h
ITS/AliITSOnlineSPDphysAnalyzer.cxx
ITS/AliITSOnlineSPDphysAnalyzer.h

index 870dcbd..3b06d49 100644 (file)
@@ -2902,3 +2902,28 @@ Bool_t AliITSOnlineCalibrationSPDhandler::IsSilentChip(UInt_t eq, UInt_t hs, UIn
   }
   return (!IsActiveEq(eq) || IsDeadEq(eq) || !IsActiveHS(eq,hs) || IsDeadHS(eq,hs) || !IsActiveChip(eq,hs,chip) || IsDeadChip(eq,hs,chip));
 }
+//____________________________________________________________________________________________
+Bool_t AliITSOnlineCalibrationSPDhandler::IsNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) const {
+  // returns true if there is at least a noisy pixel in the chip
+
+  if (eq>=20 || hs>=6 || chip>=10) {
+    Error("AliITSOnlineCalibrationSPDhandler::IsNoisyChip", "eq,hs,chip (%d,%d,%d) out of bounds.",eq,hs,chip);
+    return kFALSE;
+  }
+  Bool_t isNoisy = kFALSE;
+
+  UInt_t nrNoisy = GetNrNoisy();
+  for (UInt_t i=0; i<nrNoisy; i++) {
+    if(eq  == GetNoisyEqIdAt(i)){
+      if(hs  == GetNoisyHSAt(i)){
+        if(chip == GetNoisyChipAt(i)) {
+            UInt_t col  = GetNoisyColAt(i);
+            UInt_t row  = GetNoisyRowAt(i);
+            if (IsPixelNoisy(eq,hs,chip,col,row)) isNoisy = kTRUE;
+        }
+      }
+    }
+  }
+  return isNoisy;
+}
+
index 47b1296..f08582d 100644 (file)
@@ -202,6 +202,7 @@ class AliITSOnlineCalibrationSPDhandler {
   Bool_t  IsSilentHS(UInt_t eq, UInt_t hs) const;
   Bool_t  IsSilentChip(UInt_t eq, UInt_t hs, UInt_t chip) const;
 
+  Bool_t  IsNoisyChip(UInt_t eq, UInt_t hs, UInt_t chip) const; 
 
   UInt_t  AddSilentFrom(AliITSOnlineCalibrationSPDhandler* other);
   UInt_t  AddDeadFrom(AliITSOnlineCalibrationSPDhandler* other);
index bcf6fb9..3ea5017 100644 (file)
@@ -29,6 +29,7 @@ class AliITSOnlineSPDphys {
 
   virtual void       AddPhys(AliITSOnlineSPDphys* phys2);
   virtual void       ClearThis();
+  void               InitializeHitMap() {InitHitmap();} // online monitoring
   // SET METHODS ***********************************
   void     AddRunNr(UInt_t val);
   void     SetEqNr(UInt_t val);
index 234343e..9d2d47c 100644 (file)
@@ -269,6 +269,91 @@ UInt_t AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels() {
   return nrEnoughStatChips;
 }
 
+UInt_t AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels(UInt_t eq, UInt_t nrEvts) {
+  // process noisy pixel data , returns number of chips with enough statistics
+  if (fPhysObj==NULL) {
+    Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","No data!");
+    return 0;
+  }
+  // do we have enough events to even try the algorithm?
+  if (nrEvts < fMinEventsForNoisy) {
+    Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Nr events (%d) < fMinEventsForNoisy (%d)!",nrEvts,fMinEventsForNoisy);
+    return 0;
+  }
+  // handler should be initialized
+  if (fHandler==NULL) {
+    Error("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
+    return 0;
+  }
+  
+  UInt_t nrEnoughStatChips = 0;
+
+  for (UInt_t hs=0; hs<6; hs++) {
+    for (UInt_t chip=0; chip<10; chip++) {
+
+      UInt_t nrPixels = 0;
+      UInt_t nrChipHits = 0;
+      UInt_t nrMostHits = 0;
+      for (UInt_t col=0; col<32; col++) {
+       for (UInt_t row=0; row<256; row++) {
+         UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+         nrChipHits += nrHits;
+         //      if (nrHits>0) nrPixels++; // don't include pixels that might be dead
+         nrPixels++;
+         if (nrHits>fDefinitelyNoisyRatio*nrEvts) {
+           fHandler->SetNoisyPixel(eq,hs,chip,col,row);
+           nrPixels--;
+           nrChipHits-=nrHits;
+         }
+         else {
+           if (nrMostHits<nrHits) nrMostHits=nrHits;
+         }
+       }
+      }
+
+      if (nrChipHits>0) { // otherwise there are for sure no noisy
+       // Binomial with n events and probability p for pixel hit
+       UInt_t n = nrEvts;
+       if (nrPixels>0 && n>0) {
+
+         Double_t p = (Double_t)nrChipHits/nrPixels/n;
+
+         // Bin(n,k=0):
+         Double_t bin = pow((Double_t)(1-p),(Double_t)n);
+         // Bin(n,k)
+         UInt_t k=1;
+         while ((bin>fThreshNoisy || k<n*p) && k<=n) {
+           k++;
+           bin = bin*(n-k+1)/k*p/(1-p);
+         }
+         
+         // can we find noisy pixels...?
+         if (k<=n) {
+           //      printf("eq %d , hs %d , chip %d : Noisy level = %d\n",GetEqNr(),hs,chip,k);
+           nrEnoughStatChips++;
+           // add noisy pixels to handler
+           UInt_t noiseLimit=k;
+           if (nrMostHits>=noiseLimit) {
+             for (UInt_t col=0; col<32; col++) {
+               for (UInt_t row=0; row<256; row++) {
+                 UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+                 if (nrHits >= noiseLimit) {
+                   fHandler->SetNoisyPixel(eq,hs,chip,col,row);
+                 }
+               }
+             }
+           }
+         }
+       }
+
+      }
+
+    } // for chip
+  } // for hs
+
+  return nrEnoughStatChips;
+}
+
 
 UInt_t AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels() {
   // process dead pixel data , returns number of chips with enough statistics
index d83ab5b..0589028 100644 (file)
@@ -33,6 +33,7 @@ class AliITSOnlineSPDphysAnalyzer {
 
   UInt_t     ProcessDeadPixels();
   UInt_t     ProcessNoisyPixels();
+  UInt_t     ProcessNoisyPixels(UInt_t eq, UInt_t nrEvts);
 
   UInt_t     GetNrEnoughStatChips();
   UInt_t     GetNrDeadChips();