graleshellinstance.h

/*

  This file is a part of GRALESHELL, a program to facilitate the simulation
  and inversion of gravitational lenses, based on the GRALE library.

  Copyright (C) 2008-2012 Jori Liesenborgs

  Contact: jori.liesenborgs@gmail.com
  
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  
*/

#ifndef GRALESHELLINSTANCE_H

#define GRALESHELLINSTANCE_H

#include "unittypes.h"
#include <shellp/shellinstance.h>
#include <stdint.h>
#include <string>
#include <list>
#include <map>

namespace grale
{
        class GravitationalLens;
        class ImagePlane;
        class LensPlane;
        class SourcePlane;
        class SourceImage;
        class ImagesDataExtended;
        class Grid;
        class Cosmology;
        class OpenCLKernel;
        class RandomNumberGenerator;
}

class GraleShellGAParams;

class GraleShellInstance : public shellp::ShellInstance
{
public:
        GraleShellInstance();
        ~GraleShellInstance();

        double GetAngularUnit() const                                           { return getUnitMultiplier(UNIT_ANGULAR); }
        double GetMassUnit() const                                              { return getUnitMultiplier(UNIT_MASS); }
        double GetDistanceUnit() const                                          { return getUnitMultiplier(UNIT_DISTANCE); }
        void SetAngularUnit(double u)                                           { setUnitMultiplier(UNIT_ANGULAR, u); }
        void SetMassUnit(double u)                                              { setUnitMultiplier(UNIT_MASS, u); }
        void SetDistanceUnit(double u)                                          { setUnitMultiplier(UNIT_DISTANCE, u); }

        grale::GravitationalLens *GetLens()                                     { return lens; }
        grale::ImagePlane *GetImagePlane()                                      { return imgplane; }
        grale::LensPlane *GetLensPlane()                                        { return lensplane; }
        grale::SourcePlane *GetSourcePlane()                                    { return srcplane; }
        grale::SourceImage *GetSource(uint16_t i)                               { std::map<uint16_t, grale::SourceImage *>::iterator it = sources.find(i); if (it == sources.end()) return 0; return (*it).second; }
        grale::ImagesDataExtended *GetImagesData()                              { return imagesdata; }
        void GetImagesDataList(std::list<grale::ImagesDataExtended *> &imgslist){ imgslist = imagesdatalist; }
        grale::Grid *GetGrid()                                                  { return grid; }
        GraleShellGAParams *GetGAParams() const                                 { return gaparams; }
        grale::Cosmology *GetCosmology()                                        { return m_pCosmology; }
        grale::OpenCLKernel *GetOpenCLKernel()                                  { return m_pOpenCLKernel; }
        
        void SetLens(grale::GravitationalLens *l);
        void SetSourcePlane(grale::SourcePlane *s, bool deletesources = true);
        void SetImagePlane(grale::ImagePlane *i);
        void SetLensPlane(grale::LensPlane *lp);
        void SetSource(uint16_t i, grale::SourceImage *s);
        void SetImagesData(grale::ImagesDataExtended *imgsdata);
        void AddToImagesDataList(grale::ImagesDataExtended *imgsdata);
        void ClearSources();
        void ClearImagesDataList();
        void SetGrid(grale::Grid *g);
        void SetGAParams(GraleShellGAParams *p);
        void SetCosmology(grale::Cosmology *pCosmology);
        void SetOpenCLKernel(grale::OpenCLKernel *pCLKernel);

        const grale::RandomNumberGenerator *GetRandomNumberGenerator() const    { return m_pRndGen; }
private:
        bool FindSource(grale::SourceImage *s);
        bool FindImagesData(grale::ImagesDataExtended *i);
        
        grale::GravitationalLens *lens;
        grale::ImagePlane *imgplane;
        grale::LensPlane *lensplane;
        grale::SourcePlane *srcplane;
        std::map<uint16_t, grale::SourceImage *> sources;
        grale::ImagesDataExtended *imagesdata;
        std::list<grale::ImagesDataExtended *> imagesdatalist;
        grale::Grid *grid;
        GraleShellGAParams *gaparams;
        grale::Cosmology *m_pCosmology;
        grale::OpenCLKernel *m_pOpenCLKernel;
        grale::RandomNumberGenerator *m_pRndGen;
};

#endif // GRALESHELLINSTANCE_H