source: trunk/MagicSoft/Mars/mgeom/MGeomCam.cc@ 7360

/* ======================================================================== *\
!
! *
! * This file is part of MARS, the MAGIC Analysis and Reconstruction
! * Software. It is distributed to you in the hope that it can be a useful
! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
! * It is distributed WITHOUT ANY WARRANTY.
! *
! * Permission to use, copy, modify and distribute this software and its
! * documentation for any purpose is hereby granted without fee,
! * provided that the above copyright notice appear in all copies and
! * that both that copyright notice and this permission notice appear
! * in supporting documentation. It is provided "as is" without express
! * or implied warranty.
! *
!
!
!   Author(s): Thomas Bretz     12/2000 <mailto:tbretz@uni-sw.gwdg.de>
!              Harald Kornmayer 01/2001
!              Markus Gaug      03/2004 <mailto:markus@ifae.es>
!
!   Copyright: MAGIC Software Development, 2000-2004
!
\* ======================================================================== */

/////////////////////////////////////////////////////////////////////////////
//
// MGeomCam
//
// This is the base class of different camera geometries. It creates
// a pixel object for a given number of pixels and defines the
// interface of how to acccess the geometry information.
//
// We use a TObjArray for possible future usage (it is much more flexible
// than a TClonesArray so that it can store more types of pixels (eg
// fake pixels which are not really existing)
//
// Version 1:
// ----------
//  - first implementation
//
// Version 2:
// ----------
//  - added fPixRatio
//  - added fPixRatioSqrt
//
// Version 3:
// ----------
//  - added fNumAreas
//
/////////////////////////////////////////////////////////////////////////////
#include "MGeomCam.h"

#include <TClass.h>     // IsA()->New()
#include <TArrayI.h>    // TArrayI
#include <TVector2.h>   // TVector2

#include "MLog.h"
#include "MLogManip.h"

#include "MGeomPix.h"

ClassImp(MGeomCam);

using namespace std;

// --------------------------------------------------------------------------
//
// Default Constructor. Initializes a Camera Geometry with npix pixels. All
// pixels are deleted when the corresponding array is deleted.
//
MGeomCam::MGeomCam(UInt_t npix, Float_t dist, const char *name, const char *title)
    : fNumPixels(npix), fCamDist(dist), fConvMm2Deg(kRad2Deg/(dist*1000)), 
      fPixels(npix), fMaxRadius(1), fMinRadius(1), fPixRatio(npix), fPixRatioSqrt(npix)
{
    fName  = name  ? name  : "MGeomCam";
    fTitle = title ? title : "Storage container for a camera geometry";

    //
    // make sure that the destructor delete all contained objects
    //
    fPixels.SetOwner();

    for (UInt_t i=0; i<npix; i++)
        fPixels[i] = new MGeomPix;
}

// --------------------------------------------------------------------------
//
// Returns a reference of the i-th entry (the pixel with the software idx i)
// The access is unchecked (for speed reasons!) accesing non existing
// entries may crash the program!
//
MGeomPix &MGeomCam::operator[](Int_t i)
{
    return *static_cast<MGeomPix*>(fPixels.UncheckedAt(i));
}

// --------------------------------------------------------------------------
//
// Returns a reference of the i-th entry (the pixel with the software idx i)
// The access is unchecked (for speed reasons!) accesing non existing
// entries may crash the program!
//
MGeomPix &MGeomCam::operator[](Int_t i) const
{
    return *static_cast<MGeomPix*>(fPixels.UncheckedAt(i));
}

// --------------------------------------------------------------------------
//
// Calculate and fill the arrays storing the ratio of the area of a pixel
// i to the pixel 0 and its square root.
// The precalculation is done for speed reasons. Having an event the
// ratio would be calculated at least once for each pixel which is
// an enormous amount of numerical calculations, which are time
// consuming and which can be avoided doing the precalculation.
//
void MGeomCam::CalcPixRatio()
{
    const Double_t a0 = (*this)[0].GetA();

    for (UInt_t i=0; i<fNumPixels; i++)
    {
        fPixRatio[i] = a0/(*this)[i].GetA();
        fPixRatioSqrt[i] = TMath::Sqrt(fPixRatio[i]);
    }
}

// --------------------------------------------------------------------------
//
//  Set the kIsOuterRing flag for all pixels which have a outermost pixel
//  as Next Neighbor and don't have the kIsOutermostRing flag itself.
//
void MGeomCam::InitOuterRing()
{
    fPixels.ForEach(MGeomPix, CheckOuterRing)(*this);
}

// --------------------------------------------------------------------------
//
// Calculate the highest sector index+1 of all pixels, please make sure
// the the sector numbers are continous.
//
void MGeomCam::CalcNumSectors()
{
    fNumSectors = 0;

    for (UInt_t i=0; i<fNumPixels; i++)
    {
        const Int_t s = (*this)[i].GetSector();

        if (s>fNumSectors)
            fNumSectors = s;
    }

    fNumSectors++;
}

// --------------------------------------------------------------------------
//
// Calculate the highest area index+1 of all pixels, please make sure
// the the area indices are continous.
//
void MGeomCam::CalcNumAreas()
{
    fNumAreas = 0;

    for (UInt_t i=0; i<fNumPixels; i++)
    {
        const Int_t s = (*this)[i].GetAidx();

        if (s>fNumAreas)
            fNumAreas = s;
    }

    fNumAreas++;
}

// --------------------------------------------------------------------------
//
// Calculate the maximum radius of the camera. This is ment for GUI layout.
//
void MGeomCam::CalcMaxRadius()
{
    fMaxRadius.Set(fNumAreas+1);
    fMinRadius.Set(fNumAreas+1);

    for (Int_t i=0; i<fNumAreas+1; i++)
    {
        fMaxRadius[i] = 0.;
        fMinRadius[i] = FLT_MAX;
    }

    for (UInt_t i=0; i<fNumPixels; i++)
    {
        const MGeomPix &pix = (*this)[i];

        const UInt_t  s = pix.GetAidx();
        const Float_t x = pix.GetX();
        const Float_t y = pix.GetY();
        const Float_t d = pix.GetD();

        const Float_t r = TMath::Hypot(x, y);

        const Float_t maxr = r + d;
        const Float_t minr = r>d ? r-d : 0;

        if (maxr>fMaxRadius[s+1])
            fMaxRadius[s+1] = maxr;

        if (minr<fMinRadius[s+1])
            fMinRadius[s+1] = minr;

        if (minr<fMinRadius[0])
            fMinRadius[0] = minr;

        if (maxr>fMaxRadius[0])
            fMaxRadius[0] = maxr;
    }
}

// --------------------------------------------------------------------------
//
// sort neighbours from angle of -180 degree to -180 degree
//
// where right side of main pixel contains negative degrees
// and left side positive degrees
//
// angle measured from top (0 degree) to bottom (180 degree)
//             ^  -     |     +         //
//             |      _ | _             //
//             |     / \|/ \            //
//  30 degree -+-   |   |   |           //
//             |   / \ / \ / \          //
//  90 degree -+- |   | X |   |         //
//             |   \ / \ / \ /          //
// 150 degree -+-   |   |   |           //
//             |     \_/|\_/            //
//             |        |               //
//             |  -     |     +         //
//             ------------------>      //
//                                      //
void MGeomCam::SortNeighbors()
{
    for (unsigned int i=0; i<fNumPixels; i++)
    {
        MGeomPix &gpix = (*this)[i];

        Double_t phi[6];
        Int_t    idx[7] = { 0, 0, 0, 0, 0, 0, -1 };

        const Int_t n2 = gpix.GetNumNeighbors();
        for (int j=0; j<n2; j++)
        {
            idx[j] = gpix.GetNeighbor(j);
            phi[j] = (*this)[idx[j]].GetAngle(gpix);
        }

        Int_t sort[6] = { 6, 6, 6, 6, 6, 6 };

        TMath::Sort(n2, phi, sort, kFALSE);

        gpix.SetNeighbors(idx[sort[0]], idx[sort[1]], idx[sort[2]],
                          idx[sort[3]], idx[sort[4]], idx[sort[5]]);
    }
}

// --------------------------------------------------------------------------
//
// Returns the distance between the pixels i and j. -1 if an index
// doesn't exist. The default for j is 0. Assuming that 0 is the index
// for a central pixel you can get the distance to the camera center.
//
Float_t MGeomCam::GetDist(UShort_t i, UShort_t j) const
{
    if (i>=fNumPixels || j>=fNumPixels)
        return -1;

    return (*this)[i].GetDist((*this)[j]);
}

// --------------------------------------------------------------------------
//
// Returns the angle between of pixels i wrt pixel j (default=0). The angle
// is returned in the range between -pi and pi (atan2) and 2*pi if i or j
// is out of range.
//
Float_t MGeomCam::GetAngle(UShort_t i, UShort_t j) const
{
    if (i>=fNumPixels || j>=fNumPixels)
        return TMath::TwoPi();

    return (*this)[i].GetAngle((*this)[j]);
}

// --------------------------------------------------------------------------
//
// Have to call the radii of the subcameras starting to count from 1
//
Float_t MGeomCam::GetMaxRadius(const Int_t i) const
{
    return i<-1 || i>fNumAreas ? -1 : fMaxRadius[i+1];
}

// --------------------------------------------------------------------------
//
// Have to call the radii of the subcameras starting to count from 1
//
Float_t MGeomCam::GetMinRadius(const Int_t i) const
{
    return i<-1 || i>fNumAreas ? -1 : fMinRadius[i+1];
}


// --------------------------------------------------------------------------
//
//  returns the ratio of the area of the pixel with index 0 to the pixel
//  with the specified index i. 0 Is returned if the index argument is
//  out of range.
//
Float_t MGeomCam::GetPixRatio(UInt_t i) const
{
    // Former: (*this)[0].GetA()/(*this)[i].GetA();
    // The const_cast is necessary to support older root version
    return i<fNumPixels ? const_cast<TArrayF&>(fPixRatio)[i] : 0;
}

// --------------------------------------------------------------------------
//
//  returns the square root of the ratio of the area of the pixel with
//  index 0 to the pixel with the specified index i. 0 Is returned if
//  the index argument is out of range.
//
Float_t MGeomCam::GetPixRatioSqrt(UInt_t i) const
{
    // The const_cast is necessary to support older root version
    return i<fNumPixels ? const_cast<TArrayF&>(fPixRatioSqrt)[i] : 0;
}

// --------------------------------------------------------------------------
//
//  Prints the Geometry information of all pixels in the camera
//
void MGeomCam::Print(Option_t *) const
{
    //
    //   Print Information about the Geometry of the camera
    //
    *fLog << all << " Number of Pixels (" << GetTitle() << "): " << fNumPixels << endl;
    *fLog << " Number of Sectors: " << GetNumSectors() << "  Area-Indices: " << GetNumAreas() << endl;
    *fLog << " Min.Radius: " << GetMinRadius() << "  Max.Radius: " << GetMaxRadius() << endl;

    fPixels.Print();
} 

// --------------------------------------------------------------------------
//
//  Create a clone of this container. This is very easy, because we
//  simply have to create a new object of the same type.
//
TObject *MGeomCam::Clone(const char *newname) const
{
    if (IsA()==MGeomCam::Class())
    {
        MGeomCam *cam = new MGeomCam(fNumPixels, fCamDist);
        for (UInt_t i=0; i<fNumPixels; i++)
        {
            //if (fPixels.UncheckedAt(i))
                (*this)[i].Copy((*cam)[i]);
        }
        cam->InitGeometry();
        return cam;
    }

    return (TObject*)IsA()->New();
}

// --------------------------------------------------------------------------
//
//  Return the pixel index corresponding to the coordinates given in x, y.
//  The coordinates are given in pixel units (millimeters)
//  If no pixel exists return -1;
//
Int_t MGeomCam::GetPixelIdxXY(Float_t x, Float_t y) const
{
    for (unsigned int i=0; i<fNumPixels; i++)
        if ((*this)[i].IsInside(x, y))
            return i;

    return -1;
}

Int_t MGeomCam::GetPixelIdx(const TVector2 &v) const
{
    return GetPixelIdxXY(v.X(), v.Y());
}

Int_t MGeomCam::GetPixelIdxDeg(const TVector2 &v) const
{
    return GetPixelIdxXYdeg(v.X(), v.Y());
}

// --------------------------------------------------------------------------
//
// Add all indices to arr of all neighbors around pix in a radius r.
// The center pixel is also returned.
//
void MGeomCam::GetNeighbors(TArrayI &arr, const MGeomPix &pix, Float_t r) const
{
    arr.Set(GetNumPixels());

    Int_t n = 0;

    for (unsigned int i=0; i<GetNumPixels(); i++)
    {
        if (r>TMath::Hypot(pix.GetX()-(*this)[i].GetX(), pix.GetY()-(*this)[i].GetY()))
            arr[n++] = i;
    }

    arr.Set(n);
}

// --------------------------------------------------------------------------
//
// Add all indices to arr of all neighbors around idx in a radius r.
// The center pixel is also returned.
//
void MGeomCam::GetNeighbors(TArrayI &arr, UInt_t idx, Float_t r) const
{
    if (idx>=GetNumPixels())
    {
        arr.Set(0);
        return;
    }


    const MGeomPix &pix = (*this)[idx];
    GetNeighbors(arr, pix, r);
}

// --------------------------------------------------------------------------
//
// Add all pixels to list of all neighbors around pix in a radius r.
// The center pixel is also returned.
//
void MGeomCam::GetNeighbors(TList &arr, const MGeomPix &pix, Float_t r) const
{
    for (unsigned int i=0; i<GetNumPixels(); i++)
    {
        if (r>TMath::Hypot(pix.GetX()-(*this)[i].GetX(), pix.GetY()-(*this)[i].GetY()))
            arr.Add(fPixels.UncheckedAt(i));
    }
}

// --------------------------------------------------------------------------
//
// Add all pixels to list of all neighbors around idx in a radius r.
// The center pixel is also returned.
//
void MGeomCam::GetNeighbors(TList &arr, UInt_t idx, Float_t r) const
{
    if (idx>=GetNumPixels())
        return;

    const MGeomPix &pix = (*this)[idx];
    GetNeighbors(arr, pix, r);
}