Changeset 7353

Timestamp:

09/16/05 11:58:09 (19 years ago)

Author:

tbretz

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars

Files:

• Changelog (modified) (1 diff)
• mbadpixels/MBadPixelsTreat.cc (modified) (9 diffs)
• mcalib/MCalibrateData.cc (modified) (2 diffs)
• mcalib/MCalibrateRelTimes.cc (modified) (4 diffs)
• msignal/MArrivalTimePix.h (modified) (1 diff)

trunk/MagicSoft/Mars/Changelog

@@ -18 +18 @@
 
                                                  -*-*- END OF LINE -*-*-
+ 2005/09/16 Thomas Bretz
+
+   * mbadpixels/MBadPixelsTreat.cc:
+     - removed obsolete artificial add of missing (zero supressed)
+       pixels
+     - removed obsolete MArrayD which stored the result of the
+       interpolation but was never used
+
+   * mcalib/MCalibrateData.cc:
+     - removed an obsolete calibConv=-1 in case the pixel is unsuitable
+       (UpdateConversionFactors)
+     - improved warning output in case the conv factor is out-of-range
+
+   * mcalib/MCalibrateRelTimes.cc:
+     - reordered the algorithm for the time calibration to make it faster
+     - replaced if(IsLoGainUsed()) by the new function GetArrivalTime in
+       MArrivalTimePix
+
+   * msignal/MArrivalTimePix.h:
+     - new getter function GetArrivalTime returning the arrival time
+       depending on the flag IsLoGainUsed()
+
+
+
  2005/09/16 Daniela Dorner
 

trunk/MagicSoft/Mars/mbadpixels/MBadPixelsTreat.cc

@@ -69 +69 @@
 #include <TObjString.h>
 
-#include "MArrayD.h" // Used instead of TArrayD because operator[] has no range check
+//#include "MArrayD.h" // Used instead of TArrayD because operator[] has no range check
 
 #include "MLog.h"
@@ -218 +218 @@
 
     //
-    // Create arrays (FIXME: Check if its possible to create it only once)
+    // Loop over all pixels
     //
-    MArrayD nphot(entries);
-    MArrayD perr(entries);
+    for (UShort_t i=0; i<entries; i++)
+    {
+        //
+        // Check whether pixel with idx i is blind
+        //
+        if (!IsPixelBad(i))
+            continue;
+
+        //
+        // Get the corresponding geometry and pedestal
+        //
+        MSignalPix     &pix  = (*fEvt)[i];
+        const MGeomPix &gpix = (*fGeomCam)[i];
+
+        // Do Not-Use-Central-Pixel
+        const Bool_t nucp = !TESTBIT(fFlags, kUseCentralPixel);
+
+        Int_t num = nucp ? 0 : 1;
+
+        Double_t nphot  = nucp ? 0 : pix.GetNumPhotons();
+        Double_t perr   = nucp ? 0 : Pow2(pix.GetErrorPhot());
+
+        //
+        // The values are rescaled to the small pixels area for the right comparison
+        //
+        const Double_t ratio = fGeomCam->GetPixRatio(i);
+
+        nphot *= ratio;
+        perr  *= ratio;
+
+        //
+        // Loop over all its neighbors
+        //
+        const Int_t n = gpix.GetNumNeighbors();
+        for (int j=0; j<n; j++)
+        {
+            const UShort_t nidx = gpix.GetNeighbor(j);
+
+            //
+            // Do not use blind neighbors
+            //
+            if (IsPixelBad(nidx))
+                continue;
+
+            //
+            // Get the geometry for the neighbor
+            //
+            const Double_t nratio = fGeomCam->GetPixRatio(nidx);
+
+            //
+            //The error is calculated as the quadratic sum of the errors
+            //
+            const MSignalPix &evtpix = (*fEvt)[nidx];
+
+            nphot += nratio*evtpix.GetNumPhotons();
+            perr  += nratio*Pow2(evtpix.GetErrorPhot());
+
+            num++;
+        }
+
+        // Check if there are enough neighbors to calculate the mean
+        // If not, unmap the pixel. The maximum number of blind neighbors
+        // should be 2
+        if (num<fNumMinNeighbors)
+        {
+            pix.SetPixelUnmapped();
+            continue;
+        }
+
+        //
+        // Now the mean is calculated and the values rescaled back
+        // to the pixel area
+        //
+        nphot /= num*ratio;
+        perr   = TMath::Sqrt(perr/(num*ratio));
  
+        pix.Set(nphot, perr);
+    }
+}
+
+// --------------------------------------------------------------------------
+//
+void MBadPixelsTreat::InterpolatePedestals(MPedPhotCam &pedphot) const
+{
+    const Int_t entries = pedphot.GetSize();
+
     //
     // Loop over all pixels
@@ -237 +320 @@
         // Get the corresponding geometry and pedestal
         //
-        MSignalPix     &pix  = (*fEvt)[i];
-        const MGeomPix &gpix = (*fGeomCam)[i];
+        const MGeomPix    &gpix = (*fGeomCam)[i];
+        const MPedPhotPix &ppix = pedphot[i];
 
         // Do Not-Use-Central-Pixel
@@ -245 +328 @@
         Int_t num = nucp ? 0 : 1;
 
-        nphot[i]  = nucp ? 0 : pix.GetNumPhotons();
-        perr[i]   = nucp ? 0 : Pow2(pix.GetErrorPhot());
-
-        //
-        // The values are rescaled to the small pixels area for the right comparison
+        Double_t ped = nucp ? 0 : ppix.GetMean();
+        Double_t rms = nucp ? 0 : Pow2(ppix.GetRms());
+
+        //
+        // The values are rescaled to the small pixels area for the right comparison
         //
         const Double_t ratio = fGeomCam->GetPixRatio(i);
 
-        nphot[i] *= ratio;
-        perr[i]  *= ratio;
+        ped *= ratio;
+        rms *= ratio;
 
         //
@@ -273 +356 @@
             // Get the geometry for the neighbor
             //
-            const Double_t nratio = fGeomCam->GetPixRatio(nidx);
-
-            //
-            //The error is calculated as the quadratic sum of the errors
-            //
-            const MSignalPix &evtpix = (*fEvt)[nidx];
-
-            nphot[i] += nratio*evtpix.GetNumPhotons();
-            perr[i]  += nratio*Pow2(evtpix.GetErrorPhot());
-
-            num++;
-        }
-
-        // Check if there are enough neighbors to calculate the mean
-        // If not, unmap the pixel. The maximum number of blind neighbors
-        // should be 2
-        if (num<fNumMinNeighbors)
-        {
-            pix.SetPixelUnmapped();
-            continue;
-        }
-
-        //
-        // Now the mean is calculated and the values rescaled back
-        // to the pixel area
-        //
-        nphot[i] /= (num*ratio);
-        perr[i]   = TMath::Sqrt(perr[i]/(num*ratio));
- 
-        pix.Set(nphot[i], perr[i]);
-    }
-}
-
-// --------------------------------------------------------------------------
-//
-void MBadPixelsTreat::InterpolatePedestals(MPedPhotCam &pedphot) const
-{
-    const Int_t entries = pedphot.GetSize();
-
-    // Create arrays (FIXME: Check if its possible to create it only once)
-    MArrayD ped(entries);
-    MArrayD rms(entries);
-
-    //
-    // Loop over all pixels
-    //
-    for (UShort_t i=0; i<entries; i++)
-    {
-        //
-        // Check whether pixel with idx i is blind
-        //
-        if (!IsPixelBad(i))
-            continue;
-
-        //
-        // Get the corresponding geometry and pedestal
-        //
-        const MGeomPix    &gpix = (*fGeomCam)[i];
-        const MPedPhotPix &ppix = pedphot[i];
-
-        // Do Not-Use-Central-Pixel
-        const Bool_t nucp = !TESTBIT(fFlags, kUseCentralPixel);
-
-        Int_t num = nucp ? 0 : 1;
-
-        ped[i] = nucp ? 0 : ppix.GetMean();
-        rms[i] = nucp ? 0 : Pow2(ppix.GetRms());
-
-        //
-        // The values are rescaled to the small pixels area for the right comparison
-        //
-        const Double_t ratio = fGeomCam->GetPixRatio(i);
-
-        ped[i] *= ratio;
-        rms[i] *= ratio;
-
-        //
-        // Loop over all its neighbors
-        //
-        const Int_t n = gpix.GetNumNeighbors();
-        for (int j=0; j<n; j++)
-        {
-            const UShort_t nidx = gpix.GetNeighbor(j);
-
-            //
-            // Do not use blind neighbors
-            //
-            if (IsPixelBad(nidx))
-                continue;
-
-            //
-            // Get the geometry for the neighbor
-            //
             const Double_t    nratio = fGeomCam->GetPixRatio(nidx);
             const MPedPhotPix &nppix = pedphot[nidx];
@@ -372 +362 @@
             //The error is calculated as the quadratic sum of the errors
             //
-            ped[i] += nratio*nppix.GetMean();
-            rms[i] += nratio*Pow2(nppix.GetRms());
+            ped += nratio*nppix.GetMean();
+            rms += nratio*Pow2(nppix.GetRms());
 
             num++;
@@ -381 +371 @@
         // If not, unmap the pixel. The minimum number of good neighbors
         // should be fNumMinNeighbors
-        if (num < fNumMinNeighbors)
-        {
-            MSignalPix *pix =fEvt->GetPixById(i);
-            if (!pix)
-                pix = fEvt->AddPixel(i, 0, 0);
-            pix->SetPixelUnmapped();
+        if (num<fNumMinNeighbors)
+        {
+            (*fEvt)[i].SetPixelUnmapped();
             continue;
         }
@@ -394 +381 @@
         // to the pixel area
         //
-        ped[i] /=  (num*ratio);
-        rms[i]  = TMath::Sqrt(rms[i]/(num*ratio));
-
-        pedphot[i].Set(ped[i], rms[i]);
+        ped /= num*ratio;
+        rms  = TMath::Sqrt(rms/(num*ratio));
+
+        pedphot[i].Set(ped, rms);
     }
     pedphot.SetReadyToSave();
@@ -436 +423 @@
         const MGeomPix &gpix = (*fGeomCam)[i];
 
-        MArrayD time(gpix.GetNumNeighbors());
+        const UInt_t n2 = gpix.GetNumNeighbors();
+
+        Double_t time[n2];
 
         Int_t n0 = 0;
-        for (unsigned int j=0; j<time.GetSize(); j++)
-        {
-            const Int_t nn = gpix.GetNeighbor(j);
-
-            const Double_t t = (*fEvt)[nn].GetArrivalTime();
-            if (t>=0 && !IsPixelBad(nn))
+        for (unsigned int j=0; j<n2; j++)
+        {
+            const Double_t t = (*fEvt)[j].GetArrivalTime();
+            if (t>=0)
                 time[n0++] = t;
         }

trunk/MagicSoft/Mars/mcalib/MCalibrateData.cc

@@ -542 +542 @@
               {
                 skip++;
-                calibConv = -1.;
-                continue;
+                continue; // calibConv will remain 0
              }
             
@@ -679 +678 @@
             calibConv    = -1.;
             calibFFactor = -1.;
-            *fLog << warn << "Conversion factor of Pixel " << pixidx << " out of range " << endl;
+            *fLog << warn << GetDescriptor()
+                << ": WARNING - Conversion factor of Pixel " << pixidx << " out of range... set to 0. " << endl;
           }
         cpix.SetCalibConst(calibConv);

trunk/MagicSoft/Mars/mcalib/MCalibrateRelTimes.cc

@@ -86 +86 @@
 Int_t MCalibrateRelTimes::PreProcess(MParList *pList)
 {
-
     fSignals = (MArrivalTimeCam*)pList->FindObject(AddSerialNumber("MArrivalTimeCam"));
 
     if (!fSignals)
     {
-      *fLog << err << AddSerialNumber("MArrivalTimeCam") << " not found ... aborting" << endl;
+        *fLog << err << AddSerialNumber("MArrivalTimeCam") << " not found ... aborting" << endl;
         return kFALSE;
     }
@@ -97 +96 @@
     fBadPixels = (MBadPixelsCam*)pList->FindObject(AddSerialNumber("MBadPixelsCam"));
     if (!fBadPixels)
-      *fLog << warn << AddSerialNumber("MBadPixelsCam") << " not found ... no action" << endl;
-    
+        *fLog << warn << AddSerialNumber("MBadPixelsCam") << " not found ... ignoring." << endl;
 
     fCalibrations = (MCalibrationRelTimeCam*)pList->FindObject(AddSerialNumber("MCalibrationRelTimeCam"));
@@ -106 +104 @@
         return kFALSE;
       }
-
 
     fArrivalTime = (MSignalCam*)pList->FindCreateObj(AddSerialNumber("MSignalCam"));
@@ -124 +121 @@
     const UInt_t npix = fSignals->GetSize();
 
-    for (UInt_t pixidx=0; pixidx<npix; pixidx++)
+    for (UInt_t idx=0; idx<npix; idx++)
     {
-        MCalibrationRelTimePix &pix = (MCalibrationRelTimePix&)(*fCalibrations)[pixidx];
-
-        if (fBadPixels && (*fBadPixels)[pixidx].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
+        if (fBadPixels && (*fBadPixels)[idx].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
             continue;
 
-        const Float_t offset    = pix.GetTimeOffset();
+        const MCalibrationRelTimePix &pix = (MCalibrationRelTimePix&)(*fCalibrations)[idx];
+        const MArrivalTimePix        &sig = (*fSignals)[idx];
 
-        MArrivalTimePix &sig = (*fSignals)[pixidx];
+        const Float_t signal = sig.GetArrivalTime();
+        const Float_t offset = pix.GetTimeOffset();
 
-        Float_t signal;
-
-        if (sig.IsLoGainUsed())
-          signal = sig.GetArrivalTimeLoGain();
-        else
-          signal = sig.GetArrivalTimeHiGain();
-
-        const Float_t time = signal - offset;
-
-        (*fArrivalTime)[pixidx].SetArrivalTime(time);
-
-    } /* for (UInt_t pixidx=0; pixidx<npix; pixidx++) */
+        (*fArrivalTime)[idx].SetArrivalTime(signal - offset);
+    }
 
     fArrivalTime->SetReadyToSave();

trunk/MagicSoft/Mars/msignal/MArrivalTimePix.h

@@ -35 +35 @@
     Float_t GetArrivalTimeLoGainError() const { return fArrivalTimeLoGainError; }
 
+    Float_t GetArrivalTime()            const { return IsLoGainUsed() ? fArrivalTimeLoGain : fArrivalTimeHiGain; }
+
     Byte_t GetNumHiGainSaturated()      const { return fNumHiGainSaturated; }
     Byte_t GetNumLoGainSaturated()      const { return fNumLoGainSaturated; }