Changeset 8489 for trunk/MagicSoft/Mars/msignal

Timestamp:

05/10/07 16:33:01 (18 years ago)

Author:

tbretz

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars/msignal

Files:

• MSignalCam.cc (modified) (24 diffs)
• MSignalCam.h (modified) (3 diffs)

trunk/MagicSoft/Mars/msignal/MSignalCam.cc

@@ -18 +18 @@
 !   Author(s): Thomas Bretz, 03/2005 <mailto:tbretz@astro.uni-wuerzburg.de>
 !
-!   Copyright: MAGIC Software Development, 2000-2005
+!   Copyright: MAGIC Software Development, 2000-2007
 !
 !
@@ -38 +38 @@
 #include <fstream>
 
+#include <TArrayI.h>
 #include <TArrayD.h>
-#include <TCanvas.h>
 
 #include "MLog.h"
@@ -68 +68 @@
 // --------------------------------------------------------------------------
 //
-// This is not yet implemented like it should.
-//
-/*
-void MSignalCam::Draw(Option_t* option) 
-{
-    //
-    //   FIXME!!! Here the Draw function of the CamDisplay
-    //   should be called to add the CamDisplay to the Pad.
-    //   The drawing should be done in MCamDisplay::Paint
-    //
-
-    //    MGeomCam *geom = fType ? new MGeomCamMagic : new MGeomCamCT1;
-    //    MCamDisplay *disp = new MCamDisplay(geom);
-    //    delete geom;
-    //    disp->DrawPhotNum(this);
-}
-*/
-
-// --------------------------------------------------------------------------
-//
 // reset counter and delete netries in list.
 //
 void MSignalCam::Reset()
 {
-    //fNumPixels        =  0;
     fNumSinglePixels  =  0;
     fSizeSinglePixels =  0;
     fSizeSubIslands   =  0;
     fSizeMainIsland   =  0;
-    //fMaxIndex         = -1;
     fNumIslands       = -1;
-    //fLut.Set(0);
 
     fNumPixelsSaturatedHiGain = -1;
@@ -106 +83 @@
     fPixels->R__FOR_EACH(TObject, Clear)();
 }
-/*
-void MSignalCam::FixSize()
-{
-    fLut.Set(fMaxIndex+1);
-
-    if (fPixels->GetEntriesFast() == (Int_t)fNumPixels)
-        return;
-
-    fPixels->ExpandCreateFast(fNumPixels);
-}*/
 
 // --------------------------------------------------------------------------
@@ -134 +101 @@
 // --------------------------------------------------------------------------
 //
-// Checks if in the pixel list is an entry with pixel id
-//
-Bool_t MSignalCam::IsPixelExisting(Int_t id) const
-{
-    return GetPixById(id) ? kTRUE : kFALSE;
-} 
-
-// --------------------------------------------------------------------------
-//
-//   Checks if in the pixel list is an entry with pixel id
-//
-Bool_t MSignalCam::IsPixelUsed(Int_t id) const
-{
-    const MSignalPix *pix = GetPixById(id);
-    return pix ? pix->IsPixelUsed() : kFALSE;
-} 
-
-// --------------------------------------------------------------------------
-//
-//   Checks if in the pixel list is an entry with pixel id
-//
-Bool_t MSignalCam::IsPixelCore(Int_t id) const
-{
-    const MSignalPix *pix = GetPixById(id);
-    return pix ? pix->IsPixelCore() : kFALSE;
-} 
+//   Count and return the number of unmapped pixels
+//
+Int_t MSignalCam::GetNumPixelsUnmapped() const
+{
+    const UInt_t n = GetNumPixels();
+
+    if (n <= 0)
+        return -1;
+
+    Int_t cnt=0;
+    for (UInt_t i=0; i<n; i++)
+    {
+        if ((*this)[i].IsPixelUnmapped())
+            cnt++;
+    }
+
+    return cnt;
+}
 
 // --------------------------------------------------------------------------
@@ -169 +128 @@
 Float_t MSignalCam::GetNumPhotonsMin(const MGeomCam *geom) const
 {
-    if (GetNumPixels() <= 0)
+    const UInt_t n = GetNumPixels();
+
+    if (n <= 0)
         return -5.;
 
-    const UInt_t n = GetNumPixels();
-
     Float_t minval = FLT_MAX;
 
@@ -181 +140 @@
         if (!pix.IsPixelUsed())
             continue;
-
-        //const UInt_t id = pix.GetPixId();
-        //if (id<0 || id>=n)
-        //    continue;
 
         Float_t testval = pix.GetNumPhotons();
@@ -206 +161 @@
 Float_t MSignalCam::GetNumPhotonsMax(const MGeomCam *geom) const
 {
-    if (GetNumPixels() <= 0)
+    const UInt_t n = GetNumPixels();
+
+    if (n <= 0)
         return 50.;
 
-    const UInt_t n = GetNumPixels();
-
     Float_t maxval = -FLT_MAX;
 
@@ -218 +173 @@
         if (!pix.IsPixelUsed())
             continue;
-
-        //const UInt_t id = pix.GetPixId();
-        //if (id<0 || id>=n)
-        //    continue;
 
         Float_t testval = pix.GetNumPhotons();
@@ -239 +190 @@
 Float_t MSignalCam::GetRatioMin(const MGeomCam *geom) const
 {
-    if (GetNumPixels() <= 0)
+    const UInt_t n = GetNumPixels();
+
+    if (n <= 0)
         return -5.;
 
     Float_t minval = FLT_MAX;
 
-    for (UInt_t i=0; i<GetNumPixels(); i++)
+    for (UInt_t i=0; i<n; i++)
     {
         const MSignalPix &pix = (*this)[i];
@@ -252 +205 @@
         Float_t testval = pix.GetNumPhotons()/pix.GetErrorPhot();
         if (geom)
-            testval *= geom->GetPixRatioSqrt(i/*pix.GetPixId()*/);
+            testval *= geom->GetPixRatioSqrt(i);
 
         if (testval < minval)
@@ -267 +220 @@
 Float_t MSignalCam::GetRatioMax(const MGeomCam *geom) const
 {
-    if (GetNumPixels() <= 0)
+    const UInt_t n = GetNumPixels();
+
+    if (n <= 0)
         return -5.;
 
     Float_t maxval = -FLT_MAX;
 
-    for (UInt_t i=0; i<GetNumPixels(); i++)
+    for (UInt_t i=0; i<n; i++)
     {
         const MSignalPix &pix = (*this)[i];
@@ -280 +235 @@
         Float_t testval = pix.GetNumPhotons()/pix.GetErrorPhot();
         if (geom)
-            testval *= geom->GetPixRatioSqrt(i/*pix.GetPixId()*/);
+            testval *= geom->GetPixRatioSqrt(i);
 
         if (testval > maxval)
@@ -297 +252 @@
 Float_t MSignalCam::GetErrorPhotMin(const MGeomCam *geom) const
 {
-    if (GetNumPixels() <= 0)
+    const UInt_t n = GetNumPixels();
+
+    if (n <= 0)
         return 50.;
 
     Float_t minval = FLT_MAX;
 
-    for (UInt_t i=0; i<GetNumPixels(); i++)
+    for (UInt_t i=0; i<n; i++)
     {
         const MSignalPix &pix = (*this)[i];
@@ -311 +268 @@
 
         if (geom)
-            testval *= geom->GetPixRatio(i/*pix.GetPixId()*/);
+            testval *= geom->GetPixRatio(i);
 
         if (testval < minval)
@@ -327 +284 @@
 Float_t MSignalCam::GetErrorPhotMax(const MGeomCam *geom) const
 {
-    if (GetNumPixels() <= 0)
+    const UInt_t n = GetNumPixels();
+
+    if (n <= 0)
         return 50.;
 
     Float_t maxval = -FLT_MAX;
 
-    for (UInt_t i=0; i<GetNumPixels(); i++)
+    for (UInt_t i=0; i<n; i++)
     {
         const MSignalPix &pix = (*this)[i];
@@ -341 +300 @@
 
         if (geom)
-            testval *= geom->GetPixRatio(i/*pix.GetPixId()*/);
+            testval *= geom->GetPixRatio(i);
 
         if (testval > maxval)
@@ -348 +307 @@
     return maxval;
 }
-/*
-void MSignalCam::RemoveUnusedPixels()
-{
-    // Create iterator
-    TIter Next(fPixels);
-    MSignalPix *pix = NULL;
-
-    fMaxIndex = -1;
-
-    // Remove all unused pixels from list, calculate new fMaxIndex
-    while ((pix=(MSignalPix*)Next()))
-    {
-        if (!pix->IsPixelUsed())
-            fPixels->Remove(pix);
-        else
-            fMaxIndex = TMath::Max(fMaxIndex, pix->GetPixId());
-    }
-
-    // Crompress array
-    fPixels->Compress();
-
-    // Get new number of entries in array
-    fNumPixels=fPixels->GetEntriesFast();
-
-    // Rebuild lookup table
-    RebuildLut();
-}
-*/
-// --------------------------------------------------------------------------
-//
-// Return a pointer to the pixel with the requested idx. NULL if it doesn't
-// exist. The Look-up-table fLut is used. If its size is zero (according
-// to Rene this will happen if an old class object is loaded) we still
-// try to search in the array.
-//
-MSignalPix *MSignalCam::GetPixById(Int_t idx) const
-{
-    return (MSignalPix*)(fPixels->UncheckedAt(idx));
-    /*
-    if (idx<0)
-        return 0;
-
-    if (fLut.GetSize()>0)
-    {
-        if (idx>=fLut.GetSize())
-            return 0;
-        return fLut[idx]<0 ? 0 : (MSignalPix*)(fPixels->UncheckedAt(fLut[idx]));
-    }
-
-    TIter Next(fPixels);
-    MSignalPix *pix = NULL;
-
-    while ((pix=(MSignalPix*)Next()))
-        if (pix->GetPixId()==idx)
-            return pix;
-
-    return NULL;*/
-}
 
 MSignalPix *MSignalCam::AddPixel(Int_t idx, Float_t nph, Float_t er)
 {
-    /*
-    //
-    // If this is too slow or takes to much space we might use
-    // MGeomApply and an InitSize member function instead.
-    //
-    if (idx>=fLut.GetSize())
-    {
-        const Int_t n = fLut.GetSize();
-        fLut.Set(idx*2+1); //idx+1 is slower than idx*2+1
-        for (int i=n; i<idx*2+1; i++)
-            fLut[i] = -1;
-    }
-
-    fLut[idx] = fNumPixels;
-    if (idx>fMaxIndex)
-        fMaxIndex=idx;
-
-    return new ((*fPixels)[fNumPixels++]) MSignalPix(idx, nph, er);
-    */
-    //return new ((*fPixels)[idx]) MSignalPix(nph, er);
-
     MSignalPix *pix = static_cast<MSignalPix*>((*fPixels)[idx]);
     pix->Set(nph, er);
@@ -452 +332 @@
 Double_t MSignalCam::CalcIsland(const MGeomCam &geom, Int_t idx, Int_t num)
 {
-    // Try to get the pixel information of a pixel with this index
-    MSignalPix *pix = GetPixById(idx);
-
-    // If a pixel with this index is not existing... do nothing.
-    if (!pix)
+    // Get the pixel information of a pixel with this index
+    MSignalPix &pix = (*this)[idx];
+
+    // If an island number was already assigned to this pixel... do nothing.
+    if (pix.GetIdxIsland()>=0)
         return 0;
 
-    // If an island number was already assigned to this pixel... do nothing.
-    if (pix->GetIdxIsland()>=0)
+    // If the pixel is an unused pixel... do nothing.
+    if (!pix.IsPixelUsed())
         return 0;
 
-    // If the pixel is an unused pixel... do nothing.
-    if (!pix->IsPixelUsed())
-        return 0;
-
     // Assign the new island number num to this used pixel
-    pix->SetIdxIsland(num);
+    pix.SetIdxIsland(num);
 
     // Get the geometry information (neighbors) of this pixel
@@ -474 +350 @@
 
     // Get the size of this pixel
-    Double_t size = pix->GetNumPhotons();
+    Double_t size = pix.GetNumPhotons();
 
     // Now do the same with all its neighbors and sum the
@@ -603 +479 @@
 Bool_t MSignalCam::GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type) const
 {
-    MSignalPix *pix = GetPixById(idx);
-    if (!pix)
+    if (idx<0 || (UInt_t)idx>GetNumPixels())
         return kFALSE;
 
+    const MSignalPix &pix = (*this)[idx];
+
     // Used inlcudes status unampped
-    if (!pix->IsPixelUsed() && (type<6 || type==8))
+    if (!pix.IsPixelUsed() && (type<6 || type==8))
         return kFALSE;
 
@@ -616 +493 @@
     {
     case 1: // scaled error of phtoons
-        val = pix->GetErrorPhot()*TMath::Sqrt(ratio);
+        val = pix.GetErrorPhot()*TMath::Sqrt(ratio);
         return kTRUE;
 
     case 2: // significance of number of photons
-        if (pix->GetErrorPhot()<=0)
+        if (pix.GetErrorPhot()<=0)
             return kFALSE;
-        val = pix->GetNumPhotons()*TMath::Sqrt(ratio)/pix->GetErrorPhot();
+        val = pix.GetNumPhotons()*TMath::Sqrt(ratio)/pix.GetErrorPhot();
         return kTRUE;
 
     case 3: // number of photo electrons
-        val = pix->GetNumPhotons();
+        val = pix.GetNumPhotons();
         break;
 
     case 4: // error of signal
-        val = pix->GetErrorPhot();
+        val = pix.GetErrorPhot();
         break;
 
     case 5: // index of island
-        val = pix->GetIdxIsland();
+        val = pix.GetIdxIsland();
         break;
 
     case 6: // arrival time of mapped pixels only
-        if (pix->IsPixelUnmapped())
+        if (pix.IsPixelUnmapped())
             return kFALSE;
-        val = pix->GetArrivalTime();
+        val = pix.GetArrivalTime();
         break;
 
@@ -647 +524 @@
         // otherwise to many large pixels survive (maybe because the
         // fluctuations scale different than expected)
-        if (pix->IsPixelUnmapped() || pix->GetNumPhotons()<50)
+        if (pix.IsPixelUnmapped() || pix.GetNumPhotons()<50)
             return kFALSE;
-        val = pix->GetArrivalTime();
+        val = pix.GetArrivalTime();
         break;
 
     case 8: // arrival time
-        val = pix->GetArrivalTime();
+        val = pix.GetArrivalTime();
         break;
 
         /*
     case 10: // lo gain time
-        if (pix->IsPixelUnmapped() || !pix->IsLoGainUsed() ||
-            pix->GetNumPhotons()<320)
+        if (pix.IsPixelUnmapped() || !pix.IsLoGainUsed() ||
+            pix.GetNumPhotons()<320)
             return kFALSE;
-        val = pix->GetArrivalTime();
+        val = pix.GetArrivalTime();
         return kTRUE;
 
@@ -668 +545 @@
         // otherwise to many large pixels survive (maybe because the
         // fluctuations scale different than expected)
-        if (pix->IsPixelUnmapped() || pix->IsLoGainUsed() ||
-            pix->GetNumPhotons()<50)
+        if (pix.IsPixelUnmapped() || pix.IsLoGainUsed() ||
+            pix.GetNumPhotons()<50)
             return kFALSE;
-        val = pix->GetArrivalTime();
+        val = pix.GetArrivalTime();
         return kTRUE;
         */
 
     default:
-        val = pix->GetNumPhotons()*ratio;
+        val = pix.GetNumPhotons()*ratio;
         return kTRUE;
     }

trunk/MagicSoft/Mars/msignal/MSignalCam.h

@@ -4 +4 @@
 #ifndef ROOT_TClonesArray
 #include <TClonesArray.h>
-#endif
-#ifndef ROOT_TArrayI
-#include <TArrayI.h>
 #endif
 #ifndef MARS_MCamEvent
@@ -60 +57 @@
     Int_t   GetNumPixelsSaturatedLoGain() const { return fNumPixelsSaturatedLoGain; }
 
-    Bool_t  IsPixelExisting(Int_t id) const;
-    Bool_t  IsPixelUsed    (Int_t id) const;
-    Bool_t  IsPixelCore    (Int_t id) const;
+    Int_t   GetNumPixelsUnmapped() const;
 
     Float_t GetNumPhotonsMin(const MGeomCam *geom=NULL) const;
@@ -77 +72 @@
     MSignalPix &operator[](int i) const { return *(MSignalPix*)(fPixels->UncheckedAt(i)); }
 
-    MSignalPix *GetPixById(Int_t idx) const;
-
     // Functions to change the contained data
-    //void Scale(Double_t f) { fPixels->ForEach(MSignalPix, Scale)(f); }
     Int_t CalcIslands(const MGeomCam &geom);