lensplane.h

/*

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

  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 GRALE_LENSPLANE_H

#define GRALE_LENSPLANE_H

#include "graleconfig.h"
#include "vector2d.h"
#include <enut/networklayeraddress.h>
#include <serut/serializationinterface.h>
#include <stdint.h>
#include <stdio.h>
#include <list>
#include <string>
#include <vector>

namespace grale
{

class GravitationalLens;
class OpenCLKernel;

class GRALE_IMPORTEXPORT LensPlane : public errut::ErrorBase
{
public:
        LensPlane(const GravitationalLens *pLens);
        virtual ~LensPlane();
        bool init(Vector2D<double> bottomleft,Vector2D<double> topright,int xpoints,int ypoints, OpenCLKernel *pCLKernel = 0);
        bool init(Vector2D<double> bottomleft,Vector2D<double> topright,int xpoints,int ypoints,
                  const nut::NetworkLayerAddress &serverAddress, uint16_t serverport);
        bool isInit() const                                                                     { return m_init; }
        const GravitationalLens *getLens() const                                                { return m_pLens; }

        GravitationalLens *createDeflectionGridLens() const;
        
        bool scaleDeflections(double factor);
        int getNumXPoints() const                                                               { return numx; }
        int getNumYPoints() const                                                               { return numy; }
        Vector2D<double> getBottomLeft() const                                                  { return bottomleft; }
        Vector2D<double> getTopRight() const                                                    { return topright; }
        double getXStep() const                                                                 { return xstep; }
        double getYStep() const                                                                 { return ystep; }
        
        Vector2D<double> getAlpha(int xpos, int ypos) const                                     { return alphas[xpos+ypos*numx]; }
        void getAlphaDerivatives(int xpos, int ypos, double &axx, double &ayy, double &axy) const { axx = alphaxx[xpos+ypos*numx]; ayy = alphayy[xpos+ypos*numx]; axy = alphaxy[xpos+ypos*numx]; }
        
        Vector2D<double> getIndexCoordinate(int xpos,int ypos) const;
        bool getIndices(Vector2D<double> v,int *xpos,int *ypos) const;

        bool write(serut::SerializationInterface &si) const;
        static bool read(serut::SerializationInterface &si,LensPlane **ip,std::string &errstr);
        static bool load(const std::string &fname,LensPlane **ip,std::string &errstr);
        bool save(const std::string &fname) const;

        const std::vector<Vector2D<double> > &getAlphas() const                                 { return alphas; }
        const std::vector<double> &getAlphaXXs() const                                          { return alphaxx; }
        const std::vector<double> &getAlphaXYs() const                                          { return alphaxy; }
        const std::vector<double> &getAlphaYYs() const                                          { return alphayy; }
protected:
        virtual void setFeedbackStatus(const std::string &msg)                                  { }
        virtual void setFeedbackPercentage(int pct)                                             { }
private:
        LensPlane()                                                                             { }
        static double getTime();

        bool initUsingGPU(OpenCLKernel *pCLKernel, bool lilePerLine, int numSubLenses, bool &renderError);
        bool renderRemote(const nut::NetworkLayerAddress &serverAddress, uint16_t serverport);
        
        GravitationalLens *m_pLens;
        
        std::vector<Vector2D<double> > alphas;
        std::vector<double> alphaxx, alphayy, alphaxy;
        
        Vector2D<double> bottomleft;
        Vector2D<double> topright;
        double xstep,ystep;
        int numx,numy;
        bool m_init;
};

inline Vector2D<double> LensPlane::getIndexCoordinate(int xpos,int ypos) const
{ 
        return Vector2D<double>((((double)xpos))*xstep+bottomleft.getX(),(((double)ypos))*ystep+bottomleft.getY());
}

inline bool LensPlane::getIndices(Vector2D<double> v,int *xpos,int *ypos) const
{
        int x,y;

        x = (int)(((v.getX()-bottomleft.getX())/xstep)+0.5);
        y = (int)(((v.getY()-bottomleft.getY())/ystep)+0.5);

        if (x < 0 || y < 0 || x >= numx || y >= numy)
                return false;
        *xpos = x;
        *ypos = y;
        return true;
}

} // end namespace

#endif // GRALE_LENSPLANE_H