Changeset 3925 for trunk/MagicSoft/Mars/msignal

Timestamp:

05/01/04 12:34:15 (21 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars/msignal

Files:

• MExtractFixedWindowPeakSearch.cc (modified) (11 diffs)
• MExtractFixedWindowPeakSearch.h (modified) (3 diffs)
• MExtractPINDiode.cc (modified) (1 diff)
• MExtractSlidingWindow.cc (modified) (4 diffs)

trunk/MagicSoft/Mars/msignal/MExtractFixedWindowPeakSearch.cc

@@ -16 +16 @@
    !
    !
-   !   Author(s): Abelardo Moralejo, 4/2004 <mailto:moralejo@pd.infn.it>
-   !              Markus Gaug      , 4/2004 <mailto:markus@ifae.es>
+   !   Author(s): Abelardo Moralejo,04/2004 <mailto:moralejo@pd.infn.it>
+   !              Markus Gaug      ,04/2004 <mailto:markus@ifae.es>
    !   Copyright: MAGIC Software Development, 2000-2004
    !
@@ -75 +75 @@
 using namespace std;
 
-const Byte_t MExtractFixedWindowPeakSearch::fgHiGainWindowSize     = 6;
-const Byte_t MExtractFixedWindowPeakSearch::fgLoGainWindowSize     = 6;
-const Byte_t MExtractFixedWindowPeakSearch::fgPeakSearchWindowSize = 4;
 const Byte_t MExtractFixedWindowPeakSearch::fgHiGainFirst          = 0;
 const Byte_t MExtractFixedWindowPeakSearch::fgHiGainLast           = 14;
 const Byte_t MExtractFixedWindowPeakSearch::fgLoGainFirst          = 3;
 const Byte_t MExtractFixedWindowPeakSearch::fgLoGainLast           = 14;
+const Byte_t MExtractFixedWindowPeakSearch::fgHiGainWindowSize     = 6;
+const Byte_t MExtractFixedWindowPeakSearch::fgLoGainWindowSize     = 6;
+const Byte_t MExtractFixedWindowPeakSearch::fgPeakSearchWindowSize = 4;
+const Byte_t MExtractFixedWindowPeakSearch::fgOffsetFromPeak       = 2;
 // --------------------------------------------------------------------------
 //
@@ -92 +93 @@
 //
 // Calls: 
+// - SetOffsetFromPeak()
 // - SetRange(fgHiGainFirst, fgHiGainLast, fgLoGainFirst, fgLoGainLast)
 //
@@ -103 +105 @@
   fTitle = title ? title : "Task to extract the signal from the FADC slices";
 
+  SetOffsetFromPeak();
   SetRange(fgHiGainFirst, fgHiGainLast, fgLoGainFirst, fgLoGainLast);
 }
@@ -171 +174 @@
     }
   
+  
   if (fWindowSizeLoGain > availlorange)
     {
@@ -200 +204 @@
     }
 
-
   fNumHiGainSamples = (Float_t)fWindowSizeHiGain;
   fNumLoGainSamples = (Float_t)fWindowSizeLoGain;
@@ -271 +274 @@
 // - If *ptr is greater than fSaturationLimit, raise sat by 1
 // 
-void MExtractFixedWindowPeakSearch::FindSignalHiGain(Byte_t *ptr, Int_t &sum, Byte_t &sat) const
-{
+void MExtractFixedWindowPeakSearch::FindSignalHiGain(Byte_t *ptr, Byte_t *logain, Int_t &sum, Byte_t &sat) const
+{
+
+  Byte_t *end = ptr + fWindowSizeHiGain-fHiLoLast;
+
   //
   // Calculate the sum of the "window" slices starting in ptr
   //
-  sum = 0;
-  sat = 0;
-  Byte_t *p = ptr;
-
-  while (p<ptr+fWindowSizeHiGain)
-    {
+  while (ptr<end)
+    {
+      sum += *ptr;
+      if (*ptr++ >= fSaturationLimit)
+        sat++;
+    }
+
+  //
+  // If part of the "low-Gain" slices are used, 
+  // repeat steps one and two for the logain part until fHiLoLast
+  //
+  Byte_t *p = logain;
+  end = logain + fHiLoLast;
+  while (p<end)
+    {
+  
       sum += *p;
       if (*p++ >= fSaturationLimit)
-        sat++;
+        sat++;
     }
 
@@ -323 +339 @@
 // "startslice" will mark the slice at which the highest sum begins for that pixel.
 // Then define the beginning of the integration window for ALL pixels as the slice
-// before that: startslice-1 (this is somehow arbitrary), unless of course startslice=0,
+// before that: startslice-fOffsetFraomPeak, unless of course startslice-fOffsetFromPeak<=0,
 // in which case we start at 0. We will also check that the integration window does not 
 // go beyond the FADC limits.
@@ -348 +364 @@
         {
           maxsumhi = sumhi;
-          if (startslice > 0)
-            hiGainFirst = fHiGainFirst + startslice - 1;
+          if ((startslice-fOffsetFromPeak) > 0)
+            hiGainFirst = fHiGainFirst + startslice - fOffsetFromPeak;
           else
             hiGainFirst = fHiGainFirst;
@@ -360 +376 @@
   // Make sure we will not integrate beyond the hi gain limit:
   if (hiGainFirst+fWindowSizeHiGain > pixel.GetNumHiGainSamples())
-    hiGainFirst = pixel.GetNumHiGainSamples()-fWindowSizeHiGain;
+    fHiLoLast = hiGainFirst+fWindowSizeHiGain - pixel.GetNumHiGainSamples();
+  //    hiGainFirst = pixel.GetNumHiGainSamples()-fWindowSizeHiGain;
 
   // Make sure we will not integrate beyond the lo gain limit:
@@ -375 +392 @@
       // Find signal in hi- and lo-gain
       //
-      Int_t sumhi;
-      Byte_t sathi;
-
-      FindSignalHiGain(pixel.GetHiGainSamples()+hiGainFirst, sumhi, sathi);
+      Int_t sumhi=0;
+      Byte_t sathi=0;
+
+      FindSignalHiGain(pixel.GetHiGainSamples()+hiGainFirst, pixel.GetLoGainSamples(), sumhi, sathi);
 
       Int_t sumlo=0;

trunk/MagicSoft/Mars/msignal/MExtractFixedWindowPeakSearch.h

@@ -14 +14 @@
   static const Byte_t fgLoGainFirst;
   static const Byte_t fgLoGainLast;
-  static const Byte_t fgHiGainWindowSize;     // The extraction window Hi-Gain
-  static const Byte_t fgLoGainWindowSize;     // The extraction window Lo-Gain
-  static const Byte_t fgPeakSearchWindowSize; // The window in which the global peak is searched for
-
+  static const Byte_t fgHiGainWindowSize;     // Default for fWindowSizeHiGain (now set to: 6)
+  static const Byte_t fgLoGainWindowSize;     // Default for fWindowSizeLoGain (now set to: 6)
+  static const Byte_t fgPeakSearchWindowSize; // Default for fPeakSearchWindowSize (now set to: 4)
+  static const Byte_t fgOffsetFromPeak;       // Default for fOffsetFromPeak   (now set to: 2)
+  
   Byte_t  fWindowSizeHiGain;     // Number of Hi Gain slices in window
   Byte_t  fWindowSizeLoGain;     // Number of Lo Gain slices in window
   Byte_t  fPeakSearchWindowSize; // Size of FADC window in the search for the highest peak of all pixels.
+  Byte_t  fOffsetFromPeak;       // Number of slices to start extraction from global peak
 
-
-  void   FindSignalHiGain(Byte_t *ptr, Int_t &sum, Byte_t &sat) const;
+  void   FindSignalHiGain(Byte_t *ptr, Byte_t *logain, Int_t &sum, Byte_t &sat) const;
   void   FindSignalLoGain(Byte_t *ptr, Int_t &sum, Byte_t &sat) const;  
 
@@ -29 +30 @@
 
   Int_t  Process();
-
+  
 public:
 
@@ -37 +38 @@
     void SetWindows(Byte_t windowh=fgHiGainWindowSize, Byte_t windowl=fgLoGainWindowSize, 
                     Byte_t peaksearchwindow=fgPeakSearchWindowSize);
-
+    void SetOffsetFromPeak(Byte_t offset=fgOffsetFromPeak)    {  fOffsetFromPeak = offset; }
+    
     ClassDef(MExtractFixedWindowPeakSearch, 0) // Signal Extractor for fixed size trigger-corrected extraction window 
 };

trunk/MagicSoft/Mars/msignal/MExtractPINDiode.cc

@@ -129 +129 @@
   MExtractor::SetRange(hifirst,hilast,lofirst,lolast);
 
+
+  fNumHiGainSamples = (Float_t)(fHiGainLast-fHiGainFirst+1);
+  fNumLoGainSamples = (Float_t)(fLoGainLast-fLoGainFirst+1);  
+
+  fSqrtHiGainSamples = TMath::Sqrt(fNumHiGainSamples);
+  fSqrtLoGainSamples = TMath::Sqrt(fNumLoGainSamples);  
+  
   fNumSamples = fHiGainLast-fHiGainFirst+1+fLoGainLast-fLoGainFirst+1;
   fSqrtSamples = TMath::Sqrt((Float_t)fNumSamples);

trunk/MagicSoft/Mars/msignal/MExtractSlidingWindow.cc

@@ -194 +194 @@
 // - Check if the sum has become bigger and store it in case yes.
 // 
-void MExtractSlidingWindow::FindSignalHiGain(Byte_t *ptr, Int_t &max, Byte_t &sat) const
+void MExtractSlidingWindow::FindSignalHiGain(Byte_t *ptr, Byte_t *logain, Int_t &max, Byte_t &sat) const
 {
     const Byte_t *end = ptr + fHiGainLast - fHiGainFirst + 1;
@@ -205 +205 @@
     sat = 0;
     Byte_t *p = ptr;
-    while (p<ptr+fWindowSizeHiGain)
+    
+    while (p<ptr+fWindowSizeHiGain-fHiLoLast)
     {
         sum += *p;
@@ -218 +219 @@
         if (*p++ >= fSaturationLimit)
             sat++;
+
+    //
+    // If part of the "low-Gain" slices are used, 
+    // repeat steps one and two for the logain part until fHiLoLast
+    //
+    Byte_t *l = logain;
+    while (l<logain+fHiLoLast)
+      {
+        sum += *l;
+        if (*l++ >= fSaturationLimit)
+            sat++;
+      }
+
 
     //
@@ -225 +239 @@
     //
     max=sum;
-    for (p=ptr; p+fWindowSizeHiGain<end; p++)
-    {
-        sum += *(p+fWindowSizeHiGain) - *p;
+    for (p=ptr; p+fWindowSizeHiGain-fHiLoLast<end; p++)
+    {
+        sum += *(p+fWindowSizeHiGain-fHiLoLast) - *p;
         if (sum>max)
             max = sum;
     }
+
+    for (l=logain; l<logain+fHiLoLast; l++)
+    {
+        sum += *l - *p++;
+        if (sum>max)
+            max = sum;
+    }
+
 }