IllumTable.hxx

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// CVS: $Revision: 4785 $, $Date: 2008-05-20 14:19:36 +0100 (Tue, 20 May 2008) $, $Author: RossCollins $
//-----------------------------------------------------------------------------
#ifndef ILLUMTABLE_H
#define ILLUMTABLE_H

#include <exception> // for std::bad_alloc
#include <map>
#include <string>
//-----------------------------------------------------------------------------
typedef struct {
  unsigned x1;
  unsigned x2;
  double val1;
  double val2;
} Intervall;
//-----------------------------------------------------------------------------
class IllumTable
{
public:
  IllumTable(unsigned aNumXi, unsigned aNumEta, std::string aFilterName)
    : mNumXi(aNumXi),
      mNumEta(aNumEta),
      mFilterName(aFilterName),
      mDelMagAry(0)
    {
      mDelMagAry = new double*[mNumXi];
      for (unsigned ii = 0; ii < mNumXi; ++ii)
      {
        mDelMagAry[ii] = new double[mNumEta];
        for (unsigned jj = 0; jj < mNumEta; ++jj)
        {
          mDelMagAry[ii][jj] = 0.0;
        }
      }
    }
  //---------------------------------------------------------------------------
  ~IllumTable()
  {
    for (unsigned ii = 0; ii < mNumXi; ++ii)
    {
      delete[] mDelMagAry[ii];
    }
    delete[] mDelMagAry;
  }
  //---------------------------------------------------------------------------
  // Query properties of illum table

  unsigned getNumEtas() const { return mNumEta; }

  unsigned getNumXis() const { return mNumXi; }

  std::string getFilterName() const { return mFilterName; }
  //---------------------------------------------------------------------------
  // Assign a value to the given entry location.
  void assignMag(unsigned aCol, unsigned aRow, double aValue)
  {
    writeToMag(aCol, aRow, aValue);
  }
  //---------------------------------------------------------------------------
  // Assign value to Xi maps.
  void assignXi(unsigned aIdx, double aValue)
  {
    writeToXi(aIdx, aValue);
  }
  //---------------------------------------------------------------------------
  // Assign value to Eta maps.
  void assignEta(unsigned aIdx, double aValue)
  {
    writeToEta(aIdx, aValue);
  }
  //---------------------------------------------------------------------------
  void setXiIntervall(double aXiVal)
  {
    writeXiIntervall(aXiVal);
  }
  //---------------------------------------------------------------------------
  void setEtaIntervall(double aEtaVal)
  {
    writeEtaIntervall(aEtaVal);
  }
  //---------------------------------------------------------------------------
  Intervall& getXiIntervall()
  {
    return readXiIntervall();
  }
  //---------------------------------------------------------------------------
  Intervall& getEtaIntervall()
  {
    return readEtaIntervall();
  }
  //---------------------------------------------------------------------------
  const double& getMag(unsigned aCol, unsigned aRow) const
  {
    return readMag(aCol, aRow);
  }
  //---------------------------------------------------------------------------
  double& getXi(unsigned aIdx)
  {
    return readXi(aIdx);
  }
  //---------------------------------------------------------------------------
  double& getEta(unsigned aIdx)
  {
    return readEta(aIdx);
  }

  //---------------------------------------------------------------------------

private:
  typedef std::map<double, unsigned> DoubleUintMap;
  typedef std::map<unsigned, double> UintDoubleMap;
  unsigned mNumXi;
  unsigned mNumEta;
  std::string mFilterName;
  DoubleUintMap mXi;
  UintDoubleMap mXiInv;
  DoubleUintMap mEta;
  UintDoubleMap mEtaInv;
  Intervall mXiIvall, mEtaIvall;

  double **mDelMagAry;

  //---------------------------------------------------------------------------
  void writeToMag(unsigned aCol, unsigned aRow, double aValue)
  {
    //checkIsInRange(aCol, aRow);
    mDelMagAry[aCol][aRow] = aValue;
  }
  //---------------------------------------------------------------------------
  void writeToXi(unsigned aIdx, double aValue)
  {
    mXi[aValue] = aIdx;
    mXiInv[aIdx] = aValue;
  }
  //---------------------------------------------------------------------------
  void writeToEta(unsigned aIdx, double aValue)
  {
    mEta[aValue] = aIdx;
    mEtaInv[aIdx] = aValue;
  }
  //---------------------------------------------------------------------------
  void writeXiIntervall(double aXiVal)
  {
    mXiIvall.x2 = mXi.lower_bound(aXiVal)->second;
    mXiIvall.val2 = mXi.lower_bound(aXiVal)->first;
    if (mXiIvall.x2 > 0) 
    { 
      mXiIvall.x1 = mXiIvall.x2 - 1; 
    } else {
      mXiIvall.x1 = 0;
    }
    mXiIvall.val1 = mXiInv[mXiIvall.x1];
  }
  //---------------------------------------------------------------------------
  void writeEtaIntervall(double aEtaVal)
  {
    mEtaIvall.x2 = mEta.lower_bound(aEtaVal)->second;
    mEtaIvall.val2 = mEta.lower_bound(aEtaVal)->first;
    if (mEtaIvall.x2 > 0)
    {
      mEtaIvall.x1 = mEtaIvall.x2 - 1;
    } else {
      mEtaIvall.x1 = 0;
    }
    mEtaIvall.val1 = mEtaInv[mEtaIvall.x1];
  }
  //---------------------------------------------------------------------------
  const double& readMag(unsigned aCol, unsigned aRow) const
  {
    //checkIsInRange(aCol, aRow);
    return mDelMagAry[aCol][aRow];
  }
  //---------------------------------------------------------------------------
  double& readXi(unsigned aIdx)
  {
    //checkIsInRange(aCol, aRow);
    return mXiInv[aIdx];
  }
  //---------------------------------------------------------------------------
  double& readEta(unsigned aIdx)
  {
    //checkIsInRange(aCol, aRow);
    return mEtaInv[aIdx];
  }
  //---------------------------------------------------------------------------
  Intervall& readXiIntervall()
  {
    return mXiIvall;
  }
  //---------------------------------------------------------------------------
  Intervall& readEtaIntervall()
  {
    return mEtaIvall;
  }
};
//-----------------------------------------------------------------------------
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Change log:
//
//  17-Apr-2008, ETWS: First version.

---