Changeset 4342 for trunk/MagicSoft

Timestamp:

06/23/04 02:31:43 (20 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars

Files:

• Changelog (modified) (1 diff)
• mbadpixels/MBadPixelsCam.cc (modified) (1 diff)
• msignal/MExtractBlindPixel.cc (modified) (12 diffs)
• msignal/MExtractBlindPixel.h (modified) (1 diff)

trunk/MagicSoft/Mars/Changelog

@@ -51 +51 @@
     - adapted for various blind pixels
     - adapted Draw for the datacheck
+
+  * msignal/MExtractor.[h,cc]
+  * msignal/MExtractFixedWindow.[h,cc]
+  * msignal/MExtractSlidingWindow.[h,cc]
+  * msignal/MExtractFixedWindowPeakSearch.[h,cc]
+  * msignal/MExtractFixedWindowSpline.[h,cc]
+    - made sum in FindSignal() float which is now the variable used by 
+      the majority of the extractors.
+
+  * msignal/MExtractAmplitudeSpline.[h,cc]
+    - new extractor calculating the amplitude using a spline. 
+
+  * mcalib/MCalibrationPix.[h,cc]
+  * mcalib/MCalibrationChargePix.[h,cc]
+  * mcalib/MCalibrationChargeCalc.[h,cc]
+    - added debug flags and output on debug
+
+  * mbadpixels/MBadPixelsCam.cc
+    - enlarged the Print-function
 
 

trunk/MagicSoft/Mars/mbadpixels/MBadPixelsCam.cc

@@ -171 +171 @@
 void MBadPixelsCam::Print(Option_t *o) const
 {
-    *fLog << all << GetDescriptor() << ":" << endl;
+  *fLog << all << GetDescriptor() << ":" << endl;
+  
+  *fLog << "Pixels without problems:" << endl;
+  *fLog << endl;
     
-    *fLog << "Pixels without problems:" << endl;
-    *fLog << endl;
-
-    Int_t count = 0;
-
-    for (Int_t i=0; i<GetSize(); i++)
-    {
-        if (!(*this)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
-        {
-            *fLog << i << " ";
-            count ++;
-        }
-
-        if (count == 0)
-            continue;
-
-        if (!(count % 25))
-            *fLog << endl;
-    }
-    *fLog << endl;
-    *fLog << count << " normal pixels :-))" << endl;
-    *fLog << endl;
-    count = 0;
-
-
-    *fLog << "Pixels unsuited for the whole run:" << endl;
-    *fLog << endl;
-
-    for (Int_t i=0; i<GetSize(); i++)
-    {
-        if ((*this)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
-        {
-            *fLog << i << " ";
-            count ++;
-        }
-
-        if (count == 0)
-            continue;
-
-        if (!(count % 25))
-            *fLog << endl;
-    }
-    *fLog << endl;
-    *fLog << count << " unsuited pixels :-(" << endl;
-    *fLog << endl;
-
-    count = 0;
-
-    *fLog << all << "Pixels unreliable for the whole run:" << endl;
-    *fLog << all << endl;
-
-    for (Int_t i=0; i<GetSize(); i++)
-    {
-        if ((*this)[i].IsUnsuitable(MBadPixelsPix::kUnreliableRun))
-        {
-            *fLog << i << " ";
-            count ++;
-        }
-
-        if (count == 0)
-            continue;
-
-        if (!(count % 25))
-          *fLog << endl;
-    }
-
-    *fLog << endl;
-    *fLog << count << " unreliable pixels :-(" << endl;
-    *fLog << endl;
+  Int_t count = 0;
+  
+  for (Int_t i=0; i<GetSize(); i++)
+    {
+      if (!(*this)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
+        {
+          *fLog << i << " ";
+          count ++;
+        }
+      
+      if (count == 0)
+        continue;
+      
+      if (!(count % 25))
+        *fLog << endl;
+    }
+  *fLog << endl;
+  *fLog << count << " normal pixels :-))" << endl;
+  *fLog << endl;
+  count = 0;
+  
+  
+  *fLog << "Pixels unsuited for the whole run:" << endl;
+  *fLog << endl;
+  
+  for (Int_t i=0; i<GetSize(); i++)
+    {
+      if ((*this)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
+        {
+          *fLog << i << " ";
+          count ++;
+        }
+      
+      if (count == 0)
+        continue;
+      
+      if (!(count % 25))
+        *fLog << endl;
+    }
+  *fLog << endl;
+  *fLog << count << " unsuited pixels :-(" << endl;
+  *fLog << endl;
+  
+  count = 0;
+  
+  *fLog << all << "Pixels unreliable for the whole run:" << endl;
+  *fLog << all << endl;
+  
+  for (Int_t i=0; i<GetSize(); i++)
+    {
+      if ((*this)[i].IsUnsuitable(MBadPixelsPix::kUnreliableRun))
+        {
+          *fLog << i << " ";
+          count ++;
+        }
+      
+      if (count == 0)
+        continue;
+      
+      if (!(count % 25))
+        *fLog << endl;
+    }
+  
+  *fLog << endl;
+  *fLog << count << " unreliable pixels :-(" << endl;
+  *fLog << endl;
+
+  count = 0;
+  
+  *fLog << all << "Charge is Pedestal:" << endl;
+  *fLog << all << endl;
+  
+  for (Int_t i=0; i<GetSize(); i++)
+    {
+      if ((*this)[i].IsUncalibrated(MBadPixelsPix::kChargeIsPedestal))
+        {
+          *fLog << i << " ";
+          count ++;
+        }
+      
+      if (count == 0)
+        continue;
+      
+      if (!(count % 25))
+        *fLog << endl;
+    }
+  
+  *fLog << endl;
+  *fLog << count << " ChargeIsPedestal :-(" << endl;
+  *fLog << endl;
+
+  count = 0;
+  
+  *fLog << all << "Charge Sigma not valid:" << endl;
+  *fLog << all << endl;
+  
+  for (Int_t i=0; i<GetSize(); i++)
+    {
+      if ((*this)[i].IsUncalibrated(MBadPixelsPix::kChargeSigmaNotValid))
+        {
+          *fLog << i << " ";
+          count ++;
+        }
+      
+      if (count == 0)
+        continue;
+      
+      if (!(count % 25))
+        *fLog << endl;
+    }
+  
+  *fLog << endl;
+  *fLog << count << " ChargeSigmaNotValid :-(" << endl;
+  *fLog << endl;
+
+  count = 0;
+  
+  *fLog << all << "Rel. Error Charge not valid:" << endl;
+  *fLog << all << endl;
+  
+  for (Int_t i=0; i<GetSize(); i++)
+    {
+      if ((*this)[i].IsUncalibrated(MBadPixelsPix::kChargeRelErrNotValid))
+        {
+          *fLog << i << " ";
+          count ++;
+        }
+      
+      if (count == 0)
+        continue;
+      
+      if (!(count % 25))
+        *fLog << endl;
+    }
+  
+  *fLog << endl;
+  *fLog << count << " ChargeRelErrNotValid :-(" << endl;
+  *fLog << endl;
+
+
+  count = 0;
+  
+  *fLog << all << " Deviating number photo-electrons:" << endl;
+  *fLog << all << endl;
+  
+  for (Int_t i=0; i<GetSize(); i++)
+    {
+      if ((*this)[i].IsUncalibrated(MBadPixelsPix::kDeviatingNumPhes))
+        {
+          *fLog << i << " ";
+          count ++;
+        }
+      
+      if (count == 0)
+        continue;
+      
+      if (!(count % 25))
+        *fLog << endl;
+    }
+  
+  *fLog << endl;
+  *fLog << count << " DeviatingNumPhes :-(" << endl;
+  *fLog << endl;
+
+  count = 0;
+  
+  *fLog << all << " Deviating F-Factor:" << endl;
+  *fLog << all << endl;
+  
+  for (Int_t i=0; i<GetSize(); i++)
+    {
+      if ((*this)[i].IsUncalibrated(MBadPixelsPix::kDeviatingFFactor))
+        {
+          *fLog << i << " ";
+          count ++;
+        }
+      
+      if (count == 0)
+        continue;
+      
+      if (!(count % 25))
+        *fLog << endl;
+    }
+  
+  *fLog << endl;
+  *fLog << count << " DeviatingFFactor :-(" << endl;
+  *fLog << endl;
+
 }
 

trunk/MagicSoft/Mars/msignal/MExtractBlindPixel.cc

@@ -43 +43 @@
 #include "MExtractBlindPixel.h"
 
-#include <fstream>
-
 #include "MLog.h"
 #include "MLogManip.h"
@@ -51 +49 @@
 
 #include "MRawEvtData.h"
+#include "MRawRunHeader.h"
 #include "MRawEvtPixelIter.h"
 
@@ -62 +61 @@
 using namespace std;
 
-const Int_t  MExtractBlindPixel::fgBlindPixelIdx  = 559;
-const Int_t  MExtractBlindPixel::fgNSBFilterLimit = 100;
-const Byte_t MExtractBlindPixel::fgHiGainFirst    =  10;
-const Byte_t MExtractBlindPixel::fgHiGainLast     =  29;
-const Byte_t MExtractBlindPixel::fgLoGainFirst    =  0;
-const Byte_t MExtractBlindPixel::fgLoGainLast     =  7;
+const Int_t   MExtractBlindPixel::fgBlindPixelIdx  = 559;
+const Int_t   MExtractBlindPixel::fgNSBFilterLimit =  70;
+const Byte_t  MExtractBlindPixel::fgHiGainFirst    =  10;
+const Byte_t  MExtractBlindPixel::fgHiGainLast     =  29;
+const Byte_t  MExtractBlindPixel::fgLoGainFirst    =   0;
+const Byte_t  MExtractBlindPixel::fgLoGainLast     =   6;
+const Float_t MExtractBlindPixel::fgResolution    = 0.003;
 // --------------------------------------------------------------------------
 //
@@ -75 +75 @@
 // - fBlindPixelIdx to fgBlindPixelIdx
 // - fNSBFilterLimit to fgNSBFilterLimit
+// - fResolution to fgResolution
 //
 // Calls:
@@ -80 +81 @@
 //
 MExtractBlindPixel::MExtractBlindPixel(const char *name, const char *title)
+    : fHiGainSignal(NULL),
+      fHiGainFirstDeriv(NULL), 
+      fHiGainSecondDeriv(NULL)
 {
   
@@ -86 +90 @@
   
   AddToBranchList("MRawEvtData.*");
+
+  fBlindPixelIdx.Set(1);
   
   SetBlindPixelIdx();
+  SetResolution();
   SetNSBFilterLimit();
   SetRange(fgHiGainFirst, fgHiGainLast, fgLoGainFirst, fgLoGainLast);
@@ -93 +100 @@
 }
 
+MExtractBlindPixel::~MExtractBlindPixel()
+{
+
+  if (fHiGainSignal)
+    delete fHiGainSignal;
+  if (fHiGainFirstDeriv)
+    delete fHiGainFirstDeriv;
+  if (fHiGainSecondDeriv)
+    delete fHiGainSecondDeriv;
+
+}
+
 void MExtractBlindPixel::SetRange(Byte_t hifirst, Byte_t hilast, Byte_t lofirst, Byte_t lolast)
 {
@@ -104 +123 @@
   fSqrtLoGainSamples = TMath::Sqrt(fNumLoGainSamples);  
   
+  fHiLoFirst = 0;
+  fHiLoLast  = 0;
 }
 
@@ -126 +147 @@
     return kFALSE;
 
-  fBlindPixel->SetBlindPixelIdx(fBlindPixelIdx);
+  fBlindPixel->SetBlindPixelIdx(fBlindPixelIdx.At(0));
   fBlindPixel->SetUsedFADCSlices(fHiGainFirst, fHiGainLast);
   
-  MPedestalPix &pedpix  = (*fPedestals)[fBlindPixelIdx];    
+  MPedestalPix &pedpix  = (*fPedestals)[fBlindPixelIdx.At(0)];    
   
   if (&pedpix)
@@ -141 +162 @@
   
   return kTRUE;
+}
+
+// -------------------------------------------------------------------------- //
+//
+// The ReInit searches for:
+// -  MRawRunHeader::GetNumSamplesHiGain()
+// -  MRawRunHeader::GetNumSamplesLoGain()
+//
+// In case that the variables fHiGainLast and fLoGainLast are smaller than 
+// the even part of the number of samples obtained from the run header, a
+// warning is given an the range is set back accordingly. A call to:  
+// - SetRange(fHiGainFirst, fHiGainLast-diff, fLoGainFirst, fLoGainLast) or 
+// - SetRange(fHiGainFirst, fHiGainLast, fLoGainFirst, fLoGainLast-diff) 
+// is performed in that case. The variable diff means here the difference 
+// between the requested range (fHiGainLast) and the available one. Note that 
+// the functions SetRange() are mostly overloaded and perform more checks, 
+// modifying the ranges again, if necessary.
+//
+Bool_t MExtractBlindPixel::ReInit(MParList *pList)
+{
+  
+  if (fHiGainSignal)
+    delete fHiGainSignal;
+  if (fHiGainFirstDeriv)
+    delete fHiGainFirstDeriv;
+  if (fHiGainSecondDeriv)
+    delete fHiGainSecondDeriv;
+
+  const Int_t firstdesired   = (Int_t)fHiGainFirst;
+  Int_t lastavailable  = (Int_t)fRunHeader->GetNumSamplesHiGain()-1;
+  
+  if (firstdesired > lastavailable)
+    {
+      const Int_t diff = firstdesired - lastavailable;
+      *fLog << endl;
+      *fLog << warn << GetDescriptor()
+            << Form("%s%2i%s%2i%s",": Selected First Hi Gain FADC slice ",
+                    (int)fHiGainFirst,
+                    " ranges out of the available limits: [0,",lastavailable,"].") << endl;
+      *fLog << warn << GetDescriptor() 
+            << Form("%s%2i%s",": Will start with slice ",diff," of the Low-Gain for the High-Gain extraction")
+            << endl;
+      
+      fHiLoFirst   = diff;
+    }
+
+  Int_t lastdesired   = (Int_t)fHiGainLast;
+  lastavailable = (Int_t)fRunHeader->GetNumSamplesHiGain()-1;
+  
+  if (lastdesired > lastavailable)
+    {
+      Int_t diff = lastdesired - lastavailable;
+      lastavailable += (Int_t)fRunHeader->GetNumSamplesLoGain()-1;
+      
+      if (lastdesired > lastavailable)
+        {
+          *fLog << endl;
+          *fLog << warn << GetDescriptor()
+                << Form("%s%2i%s%2i%s",": Selected Last Hi Gain FADC slice ",
+                        (int)fHiGainLast,
+                        " ranges out of the available limits: [0,",lastavailable,"].") << endl;
+          *fLog << warn << GetDescriptor() 
+                << Form("%s%2i",": Will reduce upper limit by ",diff)
+                << endl;
+          fHiGainLast = (Int_t)fRunHeader->GetNumSamplesLoGain() - 1;
+          diff        = (Int_t)fRunHeader->GetNumSamplesLoGain() - 1;
+        }
+
+      fHiLoLast = diff;
+    }
+
+  const Int_t range = fHiLoFirst ? fHiLoLast - fHiLoFirst + 1 : fHiGainLast - fHiGainFirst + fHiLoLast + 1;
+
+  fHiGainSignal = new Float_t[range];
+  memset(fHiGainSignal,0,range*sizeof(Float_t));
+  fHiGainFirstDeriv = new Float_t[range];
+  memset(fHiGainFirstDeriv,0,range*sizeof(Float_t));
+  fHiGainSecondDeriv = new Float_t[range];
+  memset(fHiGainSecondDeriv,0,range*sizeof(Float_t));
+
+
+  *fLog << endl;
+  *fLog << inf << GetDescriptor() << ": Taking " << range
+        << " FADC samples from " 
+        << Form("%s%2i",fHiLoFirst ? "Low Gain slice " : " High Gain slice ",
+                fHiLoFirst ? (Int_t)fHiLoFirst : (Int_t)fHiGainFirst) 
+        << " to (including)  " 
+        << Form("%s%2i",fHiLoLast ? "Low Gain slice " : " High Gain slice ",
+                fHiLoLast ?  (Int_t)fHiLoLast : (Int_t)fHiGainLast ) 
+        << endl;
+
+  return kTRUE;
+
 }
 
@@ -153 +267 @@
 // - Add contents of *logain to sum
 // 
-void MExtractBlindPixel::FindSignalHiGain(Byte_t *ptr, Byte_t *logain, Int_t &sum, Byte_t &sat) const
-{
-
+void MExtractBlindPixel::FindSignalHiGain(Byte_t *ptr, Byte_t *logain, Float_t &sum, Byte_t &sat) const
+{
+
+  Int_t summ = 0;
+  Byte_t *p     = ptr;
   Byte_t *end = ptr + fHiGainLast - fHiGainFirst + 1;
-  
-  while (ptr<end)
-    {
-      sum += *ptr;
-      
-      if (*ptr++ >= fSaturationLimit)
-        sat++;
-    }
-
-  if (fHiLoLast == 0)
+
+  if (fHiLoFirst == 0)
+    {
+
+      while (p<end)
+        {
+          summ += *ptr;
+          
+          if (*p++ >= fSaturationLimit)
+            sat++;
+        }
+      
+    }
+  
+  p   = logain + fHiLoFirst;  
+  end = logain + fHiLoLast;
+  while (p<end)
+    {
+      summ += *p;
+
+      if (*p++ >= fSaturationLimit)
+            sat++;
+    }
+  sum = (Float_t)summ;
+}
+
+// --------------------------------------------------------------------------
+//
+// FindSignalPhe:
+//
+// - Loop from ptr to (ptr+fHiGainLast-fHiGainFirst)
+// - Sum up contents of *ptr
+// - If *ptr is greater than fSaturationLimit, raise sat by 1
+// - If fHiLoLast is set, loop from logain to (logain+fHiLoLast)
+// - Add contents of *logain to sum
+// 
+void MExtractBlindPixel::FindAmplitude(Byte_t *ptr, Byte_t *logain, Float_t &sum, Byte_t &sat) const
+{
+
+  Int_t range   = 0;
+  Int_t count   = 0;
+  Float_t abmaxpos = 0.;
+  Byte_t *p     = ptr;
+  Byte_t *end;
+  Byte_t max    = 0;
+  Byte_t maxpos = 0;
+  Int_t summ   = 0;
+
+  if (fHiLoFirst == 0)
+    {
+
+      range = fHiGainLast - fHiGainFirst + 1;
+      end   = ptr + range;
+      //
+      // Check for saturation in all other slices
+      //
+      while (++p<end)
+        {
+          
+          fHiGainSignal[count] = (Float_t)*p;
+          summ += *p;
+
+          if (*p > max)
+            {
+              max    = *p;
+              maxpos =  count;
+            }
+          
+          range++;
+          count++;
+
+          if (*p >= fSaturationLimit)
+            {
+              sat++;
+              break;
+            }
+        }
+    }
+  
+  if (fHiLoLast != 0)
+    {
+      
+      p    = logain + fHiLoFirst;
+      end  = logain + fHiLoLast + 1;
+      
+      while (p<end)
+        {
+          
+          fHiGainSignal[count] = (Float_t)*p;
+          summ += *p;
+
+          if (*p > max)
+            {
+              max    = *p;
+              maxpos =  count;
+            }
+          
+          range++;
+          count++;
+
+          if (*p++ >= fSaturationLimit)
+            {
+              sat++;
+              break;
+            }
+        }
+    }
+
+  //  sum = (Float_t)summ;
+  //  return;
+  
+  //
+  // allow one saturated slice 
+  //
+  if (sat > 1)
     return;
 
-  
-  end = logain + fHiLoLast;
-  while (logain<end)
-    {
-      sum += *logain;
-
-      if (*logain++ >= fSaturationLimit)
-            sat++;
-    }
-
+  //
+  // Don't start if the maxpos is too close to the left limit.
+  //
+  if (maxpos < 2)
+    return;
+
+  Float_t pp;
+  fHiGainSecondDeriv[0] = 0.;
+  fHiGainFirstDeriv[0]  = 0.;
+
+  for (Int_t i=1;i<range-1;i++)
+    {
+      pp = fHiGainSecondDeriv[i-1] + 4.;
+      fHiGainSecondDeriv[i] = -1.0/pp;
+      fHiGainFirstDeriv [i] = fHiGainSignal[i+1] - fHiGainSignal[i] - fHiGainSignal[i] + fHiGainSignal[i-1];
+      fHiGainFirstDeriv [i] = (6.0*fHiGainFirstDeriv[i]-fHiGainFirstDeriv[i-1])/pp;
+      p++;
+    }
+
+  fHiGainSecondDeriv[range-1] = 0.;
+  for (Int_t k=range-2;k>=0;k--)
+    fHiGainSecondDeriv[k] = (fHiGainSecondDeriv[k]*fHiGainSecondDeriv[k+1] + fHiGainFirstDeriv[k])/6.;
+  
+  //
+  // Now find the maximum  
+  //
+  Float_t step  = 0.2; // start with step size of 1ns and loop again with the smaller one
+  Float_t lower = (Float_t)maxpos-1.;
+  Float_t upper = (Float_t)maxpos;
+  Float_t x     = lower;
+  Float_t y     = 0.;
+  Float_t a     = 1.;
+  Float_t b     = 0.;
+  Int_t   klo = maxpos-1;
+  Int_t   khi = maxpos;
+  Float_t klocont = fHiGainSignal[klo];
+  Float_t khicont = fHiGainSignal[khi];
+  sum       = (Float_t)khicont;
+  abmaxpos  = lower;
+
+  //
+  // Search for the maximum, starting in interval maxpos-1. If no maximum is found, go to 
+  // interval maxpos+1.
+  //
+  while (x<upper-0.3)
+    {
+
+      x += step;
+      a -= step;
+      b += step;
+
+      y = a*klocont
+        + b*khicont
+        + (a*a*a-a)*fHiGainSecondDeriv[klo] 
+        + (b*b*b-b)*fHiGainSecondDeriv[khi];
+
+      if (y > sum)
+        {
+          sum      = y;
+          abmaxpos = x;
+        }
+    }
+
+  if (abmaxpos > upper-0.1)
+    {
+      
+      upper = (Float_t)maxpos+1;
+      lower = (Float_t)maxpos;
+      x     = lower;
+      a     = 1.;
+      b     = 0.;
+      khi   = maxpos+1;
+      klo   = maxpos;
+      klocont = fHiGainSignal[klo];
+      khicont = fHiGainSignal[khi];
+
+      while (x<upper-0.3)
+        {
+
+          x += step;
+          a -= step;
+          b += step;
+          
+          y = a* klocont
+            + b* khicont
+            + (a*a*a-a)*fHiGainSecondDeriv[klo] 
+            + (b*b*b-b)*fHiGainSecondDeriv[khi];
+          
+          if (y > sum)
+            {
+              sum    = y;
+              abmaxpos = x;
+            }
+        }
+    }
+
+ const Float_t up = abmaxpos+step-0.055;
+ const Float_t lo = abmaxpos-step+0.055;
+ const Float_t maxpossave = abmaxpos;
+ 
+ x     = abmaxpos;
+ a     = upper - x;
+ b     = x - lower;
+
+  step  = 0.04; // step size of 83 ps 
+
+  while (x<up)
+    {
+
+      x += step;
+      a -= step;
+      b += step;
+      
+      y = a* klocont
+        + b* khicont
+        + (a*a*a-a)*fHiGainSecondDeriv[klo] 
+        + (b*b*b-b)*fHiGainSecondDeriv[khi];
+      
+      if (y > sum)
+        {
+          sum    = y;
+          abmaxpos = x;
+        }
+    }
+
+ if (abmaxpos < klo + 0.02)
+    {
+      klo--;
+      khi--;
+      klocont = fHiGainSignal[klo];
+      khicont = fHiGainSignal[khi];
+      upper--;
+      lower--;
+    }
+ 
+  x     = maxpossave;
+  a     = upper - x;
+  b     = x - lower;
+
+  while (x>lo)
+    {
+
+      x -= step;
+      a += step;
+      b -= step;
+      
+      y = a* klocont
+        + b* khicont
+        + (a*a*a-a)*fHiGainSecondDeriv[klo] 
+        + (b*b*b-b)*fHiGainSecondDeriv[khi];
+      
+      if (y > sum)
+        {
+          sum    = y;
+          abmaxpos = x;
+        }
+    }
 }
 
@@ -215 +583 @@
   fBlindPixel->Clear();
   
-  pixel.Jump(fBlindPixelIdx);
-  
-  Int_t sum   = 0;
-  Byte_t sat  = 0;
-
-  FindSignalFilter(pixel.GetHiGainSamples()+fLoGainFirst, sum, sat);
-
-  if (sum > fNSBFilterLimit)
-    {
-      sum = -1;
-      fBlindPixel->SetExtractedSignal(sum);
-      fBlindPixel->SetNumSaturated(sat);
-      fBlindPixel->SetReadyToSave();
-      return kTRUE;
-    }
-
-  sum = 0;
-  sat = 0;
-
-  FindSignalHiGain(pixel.GetHiGainSamples()+fHiGainFirst, pixel.GetLoGainSamples(), sum, sat);
-  
-  fBlindPixel->SetExtractedSignal(sum);
-  fBlindPixel->SetNumSaturated(sat);
+  for (Int_t id=0;id<fBlindPixelIdx.GetSize();id++)
+    {
+  
+      pixel.Jump(fBlindPixelIdx.At(id));
+      
+      Int_t sum   = 0;
+      Byte_t sat  = 0;
+
+      FindSignalFilter(pixel.GetHiGainSamples()+fLoGainFirst, sum, sat);
+
+      if (sum > fNSBFilterLimit)
+        {
+          fBlindPixel->SetExtractedSignal(-1.);
+          fBlindPixel->SetNumSaturated(sat);
+          fBlindPixel->SetReadyToSave();
+          continue;
+        }
+      
+      Float_t newsum = 0.;
+      sat = 0;
+      
+      FindSignalHiGain(pixel.GetHiGainSamples()+fHiGainFirst, pixel.GetLoGainSamples(), newsum, sat);
+  
+      fBlindPixel->SetExtractedSignal(newsum,id);
+      fBlindPixel->SetNumSaturated(sat,id);
+    }
+  
   fBlindPixel->SetReadyToSave();
-  
   return kTRUE;
 }

trunk/MagicSoft/Mars/msignal/MExtractBlindPixel.h

@@ -43 +43 @@
   Int_t   fNSBFilterLimit;  
 
-  void FindSignalPhe(Byte_t *firstused, Byte_t *lowgain, Float_t &sum, Byte_t &sat) const;
+  void FindAmplitude(Byte_t *firstused, Byte_t *lowgain, Float_t &sum, Byte_t &sat) const;
+  void FindSignalHiGain(Byte_t *firstused, Byte_t *lowgain, Float_t &sum, Byte_t &sat) const;
   void FindSignalFilter(Byte_t *ptr, Int_t &sum, Byte_t &sat) const;