Changeset 4649 for trunk/MagicSoft/Mars/mcalib

Timestamp:

08/17/04 13:37:28 (20 years ago)

Author:

gaug

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars/mcalib

Files:

• CalibLinkDef.h (modified) (1 diff)
• MCalibrationTestCalc.cc (modified) (23 diffs)
• MCalibrationTestCalc.h (modified) (5 diffs)
• MCalibrationTestCam.cc (added)
• MCalibrationTestCam.h (added)
• MCalibrationTestPix.cc (added)
• MCalibrationTestPix.h (added)
• Makefile (modified) (1 diff)

trunk/MagicSoft/Mars/mcalib/CalibLinkDef.h

@@ -18 +18 @@
 #pragma link C++ class MCalibrationQEPix+;
 #pragma link C++ class MCalibrationTestCalc+;
+#pragma link C++ class MCalibrationTestCam+;
+#pragma link C++ class MCalibrationTestPix+;
 #pragma link C++ class MCalibrationChargeCalc+;
 #pragma link C++ class MCalibrationChargeCam+;

trunk/MagicSoft/Mars/mcalib/MCalibrationTestCalc.cc

@@ -64 +64 @@
 #include "MHCalibrationTestPix.h"
 
+#include "MCalibrationTestCam.h"
+#include "MCalibrationTestPix.h"
+
 #include "MBadPixelsCam.h"
 #include "MBadPixelsPix.h"
@@ -85 +88 @@
 //
 MCalibrationTestCalc::MCalibrationTestCalc(const char *name, const char *title)
-    : fMaxNumBadPixelsCluster(-1), 
-      fBadPixels(NULL), fTestCam(NULL), fGeom(NULL)
+    : fBadPixels(NULL), fTestCam(NULL), fCam(NULL), fGeom(NULL)
 {
         
@@ -112 +114 @@
   // Containers that are created in case that they are not there.
   //
-  fBadPixels = (MBadPixelsCam*)pList->FindCreateObj("MBadPixelsCam");
+  fBadPixels = (MBadPixelsCam*)pList->FindCreateObj(AddSerialNumber("MBadPixelsCam"));
   if (!fBadPixels)
     {
       *fLog << err << "Could not find or create MBadPixelsCam ... aborting." << endl;
+      return kFALSE;
+    }
+  
+  fCam = (MCalibrationTestCam*)pList->FindCreateObj(AddSerialNumber("MCalibrationTestCam"));
+  if (!fCam)
+    {
+      *fLog << err << "Could not find or create MCalibrationTestCam ... aborting." << endl;
       return kFALSE;
     }
@@ -170 +179 @@
 {
 
-  //  if (GetNumExecutions()==0)
-  //    return kFALSE;
+  if (GetNumExecutions()==0)
+    return kFALSE;
 
   //
@@ -184 +193 @@
   FinalizeCalibratedPhotons();
   FinalizeNotInterpolated();
-  CalcMaxNumBadPixelsCluster();
+  const Int_t maxbad = CalcMaxNumBadPixelsCluster();
 
 
@@ -193 +202 @@
     {
       *fLog << " " << setw(7) << "Not interpolateable Pixels: " 
-            << Form("%s%3i%s%3i","Inner: ",fNumUninterpolateable[0],
-                    " Outer: ",fNumUninterpolateable[1]) << endl;
+            << Form("%s%3i%s%3i","Inner: ",fCam->GetNumUninterpolated(0),
+                    " Outer: ",fCam->GetNumUninterpolated(1)) << endl;
       *fLog << " " << setw(7) << "Biggest not-interpolateable cluster: " 
-            << fMaxNumBadPixelsCluster << endl;
-    }
-  
+            << maxbad << endl;
+    }
+  
+  fCam->SetNumUninterpolatedInMaxCluster(maxbad);
+
   *fLog << endl;  
   SetLogStream(&gLog);
@@ -251 +262 @@
     {
       
-      MHCalibrationTestPix &pix = (MHCalibrationTestPix&)(*fTestCam)[i];
+      MHCalibrationTestPix &hist = (MHCalibrationTestPix&)(*fTestCam)[i];
+      MCalibrationTestPix  &pix =                         (*fCam)[i];
       //
       // We assume that the pixels have been interpolated so far. 
       // The MBadPixelsCam does not give any more information
       //
-      if (pix.IsEmpty())
-          continue;
-
-      const Double_t nphot = pix.GetMean();
-      const Int_t    aidx  = (*fGeom)[i].GetAidx();
+      if (hist.IsEmpty())
+        {
+          pix.SetExcluded();
+          continue;
+        }
+      
+
+      const Double_t nphot    = hist.GetMean();
+      const Double_t nphoterr = hist.GetMeanErr();
+      const Int_t    aidx     = (*fGeom)[i].GetAidx();
 
       camphotons.Fill(i,nphot);
       camphotons.SetUsed(i);
+
+      pix.SetNumPhotons   ( nphot    );
+      pix.SetNumPhotonsErr( nphoterr );
 
       areaphotons [aidx] += nphot;
@@ -299 +319 @@
           continue;
         }
-      
-      lowlim [aidx] = areaphotons[aidx] - fPhotErrLimit*TMath::Sqrt(areavars[aidx]);
-      upplim [aidx] = areaphotons[aidx] + fPhotErrLimit*TMath::Sqrt(areavars[aidx]);
+
+      const Float_t areamean = areaphotons[aidx];
+      const Float_t areaerr  = TMath::Sqrt(areavars[aidx]);
+      
+      MCalibrationTestPix &avpix = fCam->GetAverageArea(aidx);
+      avpix.SetNumPhotons   (areamean);
+      avpix.SetNumPhotonsErr(areaerr );
+
+      lowlim [aidx] = areamean - fPhotErrLimit*areaerr;
+      upplim [aidx] = areamean + fPhotErrLimit*areaerr;
 
       TArrayI area(1);
@@ -338 +365 @@
       fittedsigma[aidx] = sigma;
       
+      avpix.SetNumPhotons   (mean );
+      avpix.SetNumPhotonsErr(sigma);
+
       lowlim  [aidx] = mean  - fPhotErrLimit*sigma;
       upplim  [aidx] = mean  + fPhotErrLimit*sigma;
@@ -361 +391 @@
     {
       
-      MHCalibrationTestPix &pix = (MHCalibrationTestPix&)(*fTestCam)[i];
-
-      const Int_t    aidx   = (*fGeom)[i].GetAidx();
-      const Int_t    sector = (*fGeom)[i].GetSector();
-      const Float_t  area   = (*fGeom)[i].GetA();
-      const Double_t nphot  = pix.GetMean();
+      MHCalibrationTestPix &hist = (MHCalibrationTestPix&)(*fTestCam)[i];
+      MCalibrationTestPix  &pix =                         (*fCam)[i];
+
+      const Int_t    aidx         = (*fGeom)[i].GetAidx();
+      const Int_t    sector       = (*fGeom)[i].GetSector();
+      const Double_t nphot        = hist.GetMean();
+      const Double_t nphotpera    = nphot            / (*fGeom)[i].GetA();
+      const Double_t nphotperaerr = hist.GetMeanErr()/ (*fGeom)[i].GetA();
+
+      pix.SetNumPhotonsPerArea   ( nphotpera    );
+      pix.SetNumPhotonsPerAreaErr( nphotperaerr );
 
       if ( nphot < lowlim[aidx] || nphot > upplim[aidx] )
@@ -376 +411 @@
           bad.SetUncalibrated( MBadPixelsPix::kDeviatingNumPhots );
           bad.SetUnsuitable  ( MBadPixelsPix::kUnsuitableRun     );
-          continue;
-        }
-      
-      areavars     [aidx] += nphot*nphot/area/area;
-      areaphotons  [aidx] += nphot/area;
+          pix.SetExcluded();
+          continue;
+        }
+      
+      areavars     [aidx] += nphotpera*nphotpera;
+      areaphotons  [aidx] += nphotpera;
       numareavalid [aidx] ++;
 
-      sectorvars    [sector] += nphot*nphot/area/area;
-      sectorphotons [sector] += nphot/area;
+      sectorvars    [sector] += nphotpera*nphotpera;
+      sectorphotons [sector] += nphotpera;
       numsectorvalid[sector] ++;
     } 
@@ -392 +428 @@
   for (UInt_t aidx=0; aidx<nareas; aidx++)
     {
-
+      
       if (numareavalid[aidx] == 1)
         areavars[aidx] = 0.;
@@ -407 +443 @@
         }
       
+
+      MCalibrationTestPix &avpix = fCam->GetAverageArea(aidx);
+
       if (areavars[aidx] < 0. || areaphotons[aidx] <= 0.)
         {
@@ -413 +452 @@
                 << aidx << " could not be calculated! Mean: " << areaphotons[aidx] 
                 << " Variance: " << areavars[aidx] << endl;
-          continue;
-        }
-      
+          avpix.SetExcluded();
+          continue;
+        }
+
+      const Float_t areaerr = TMath::Sqrt(areavars[aidx]);
+      
+      avpix.SetNumPhotonsPerArea   (areaphotons[aidx]);
+      avpix.SetNumPhotonsPerAreaErr(areaerr );
+
       *fLog << inf << GetDescriptor() << ": Mean number of equiv. Cher. photons "
             << "per area in area idx " << aidx << ": "  
-            << Form("%5.3f+-%5.4f  [ph/mm^2]",areaphotons[aidx],TMath::Sqrt(areavars[aidx])) << endl;
+            << Form("%5.3f+-%5.4f  [ph/mm^2]",areaphotons[aidx],areaerr) << endl;
     }
 
@@ -442 +487 @@
         }
       
+      MCalibrationTestPix &avpix = fCam->GetAverageSector(sector);
+
       if (sectorvars[sector] < 0. || sectorphotons[sector] <= 0.)
         {
@@ -448 +495 @@
                 << sector << " could not be calculated! Mean: " << sectorphotons[sector] 
                 << " Variance: " << sectorvars[sector] << endl;
-          continue;
-        }
-      
-  
+          avpix.SetExcluded();
+          continue;
+        }
+      
+  
+      const Float_t sectorerr = TMath::Sqrt(sectorvars[sector]);
+
+      avpix.SetNumPhotonsPerArea   (sectorphotons[sector]);
+      avpix.SetNumPhotonsPerAreaErr(sectorerr );
+
       *fLog << inf << GetDescriptor() << ": Mean number of equiv. Cher. photons "
             << "per area in sector " << sector << ":   "  
-            << Form("%5.3f+-%5.4f  [ph/mm^2]",sectorphotons[sector],TMath::Sqrt(sectorvars[sector])) << endl;
+            << Form("%5.3f+-%5.4f  [ph/mm^2]",sectorphotons[sector],sectorerr) << endl;
     }
 
@@ -468 +521 @@
 {
   
-  const TArrayI &arr = fTestCam->GetNotInterpolateablePixels();
   const Int_t areas  = fGeom->GetNumAreas();
-
   TArrayI *newarr[areas];
 
@@ -476 +527 @@
     newarr[aidx] = new TArrayI(0);
 
-  fNumUninterpolateable.Set(areas);
-
-  for (Int_t i=0; i<arr.GetSize(); i++)
-    {
-      const Int_t id   = arr[i];
-      const Int_t aidx = (*fGeom)[id].GetAidx();
-      const Int_t size = newarr[aidx]->GetSize();
-      newarr[aidx]->Set(size+1);
-      newarr[aidx]->AddAt(id,size);
-      fNumUninterpolateable[aidx]++;
+  for (Int_t i=0; i<fCam->GetSize(); i++)
+    {
+      const Int_t aidx = (*fGeom)[i].GetAidx();
+      if ((*fCam)[i].IsExcluded())
+        {
+          const Int_t size = newarr[aidx]->GetSize();
+          newarr[aidx]->Set(size+1);
+          newarr[aidx]->AddAt(i,size);
+        }
     }
 
@@ -500 +550 @@
           num++;
         }
+      fCam->SetNumUninterpolated(newarr[aidx]->GetSize(),aidx);
       *fLog << endl;
     }
-
-
   
   *fLog << " " << setw(7) << num << " total not interpolateable pixels " << endl;
@@ -509 +558 @@
 }
 
-void MCalibrationTestCalc::CalcMaxNumBadPixelsCluster()
+Int_t MCalibrationTestCalc::CalcMaxNumBadPixelsCluster()
 {
 
@@ -516 +565 @@
   
   if (size == 0)
-    {
-      fMaxNumBadPixelsCluster = 0; 
-      return;
-    }
+    return 0;
   
   if (size == 1)
-    {
-      fMaxNumBadPixelsCluster = 1; 
-      return;
-    }
+    return 1;
 
   TArrayI knownpixels(0);
@@ -546 +589 @@
     }
 
-  fMaxNumBadPixelsCluster = oldclustersize; 
+  return oldclustersize; 
 
 }
@@ -619 +662 @@
 }
 
-const Int_t MCalibrationTestCalc::GetNumUninterpolateable(const Int_t aidx) const
-{
-  if (aidx < 0)
-    return -1;
-
-  return aidx > fNumUninterpolateable.GetSize() ? -1 : fNumUninterpolateable[aidx]; 
-}

trunk/MagicSoft/Mars/mcalib/MCalibrationTestCalc.h

@@ -20 +20 @@
 
 class MHCalibrationTestCam;
+class MCalibrationTestCam;
 class MBadPixelsCam;
 class MGeomCam;
@@ -30 +31 @@
   // Variables
   Float_t fPhotErrLimit;               // Limit acceptance nr. cal. phots w.r.t. area idx mean (in sigmas)
-  Int_t   fMaxNumBadPixelsCluster;     // Number of not interpolateable pixels in biggest cluster
-
-  TArrayI fNumUninterpolateable;       // Number uninterpolated Pixels per area index 
 
   TString fOutputPath;                 // Path to the output file
@@ -40 +38 @@
   MBadPixelsCam         *fBadPixels;   //! Bad Pixels 
   MHCalibrationTestCam  *fTestCam;     //! Calibrated Photons in the camera
+  MCalibrationTestCam   *fCam;         //! Storage Calibrated Photons in the camera
   MGeomCam              *fGeom;        //! Camera geometry
 
@@ -47 +46 @@
   void   FinalizeNotInterpolated();
   void   FinalizeCalibratedPhotons() const;
-  void   CalcMaxNumBadPixelsCluster();
+  Int_t  CalcMaxNumBadPixelsCluster();
   void   LoopNeighbours( const TArrayI &arr, TArrayI &known, Int_t &clustersize, const Int_t idx );
   
@@ -59 +58 @@
   MCalibrationTestCalc(const char *name=NULL, const char *title=NULL);
 
-  const Int_t GetMaxNumBadPixelsCluster () const  { return fMaxNumBadPixelsCluster; }
-  const Int_t GetNumUninterpolateable   ( const Int_t aidx ) const;
-
   void SetOutputFile  ( TString file="TestCalibStat.txt" );
   void SetOutputPath  ( TString path="."                 );

trunk/MagicSoft/Mars/mcalib/Makefile

@@ -43 +43 @@
            MCalibrationPedCam.cc \
            MCalibrationTestCalc.cc \
+           MCalibrationTestCam.cc \
+           MCalibrationTestPix.cc \
            MCalibrationChargeCalc.cc \
            MCalibrationChargeCam.cc \