cmdlenses.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 CMDLENSES_H

#define CMDLENSES_H

#include <shellp/shellcommand.h>
#include <shellp/shellcmdrealarg.h>
#include <shellp/shellcmdstringarg.h>
#include <shellp/shellcmdboolarg.h>
#include <shellp/shellcmdintarg.h>
#include <vector>

class CmdLens : public shellp::ShellCommand
{
protected:
        CmdLens(const std::string &cmdname);
public:
        ~CmdLens();
protected:
        double GetD_d() const                                                   { return distarg->getValue(); }
private:
        shellp::ShellCmdRealArg *distarg;
};

class CmdLensPointmass : public CmdLens
{
public:
        CmdLensPointmass(const std::string &cmdname);
        ~CmdLensPointmass();
        bool execute();
private:
        shellp::ShellCmdRealArg *massarg;
};

class CmdLensPlummer : public CmdLens
{
public:
        CmdLensPlummer(const std::string &cmdname);
        ~CmdLensPlummer();
        bool execute();
private:
        shellp::ShellCmdRealArg *massarg;
        shellp::ShellCmdRealArg *widtharg;
};

class CmdLensGauss : public CmdLens
{
public:
        CmdLensGauss(const std::string &cmdname);
        ~CmdLensGauss();
        bool execute();
private:
        shellp::ShellCmdRealArg *massarg;
        shellp::ShellCmdRealArg *widtharg;
};

class CmdLensMultiplePlummers : public CmdLens
{
public:
        CmdLensMultiplePlummers(const std::string &cmdname);
        ~CmdLensMultiplePlummers();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        std::vector<shellp::ShellCmdArg *> plumargs;
        shellp::ShellCmdRealArg *massarg,*widtharg,*xposarg,*yposarg;
};

class CmdLensNSIE : public CmdLens
{
public:
        CmdLensNSIE(const std::string &cmdname);
        ~CmdLensNSIE();
        bool execute();
private:
        shellp::ShellCmdRealArg *Varg,*Farg,*corearg;
};

class CmdLensNSIS : public CmdLens
{
public:
        CmdLensNSIS(const std::string &cmdname);
        ~CmdLensNSIS();
        bool execute();
private:
        shellp::ShellCmdRealArg *Varg,*corearg;
};

class CmdLensSIE : public CmdLens
{
public:
        CmdLensSIE(const std::string &cmdname);
        ~CmdLensSIE();
        bool execute();
private:
        shellp::ShellCmdRealArg *Varg,*Farg;
};

class CmdLensSIS : public CmdLens
{
public:
        CmdLensSIS(const std::string &cmdname);
        ~CmdLensSIS();
        bool execute();
private:
        shellp::ShellCmdRealArg *Varg;
};

class CmdLensMassSheetDegeneracy : public shellp::ShellCommand
{
public:
        CmdLensMassSheetDegeneracy(const std::string &cmdName);
        ~CmdLensMassSheetDegeneracy();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pDsArg;
        shellp::ShellCmdRealArg *m_pDdsArg;
        shellp::ShellCmdRealArg *m_pLambdaArg;
};

class CmdLensMassDiskDegeneracy : public shellp::ShellCommand
{
public:
        CmdLensMassDiskDegeneracy(const std::string &cmdName);
        ~CmdLensMassDiskDegeneracy();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pDsArg;
        shellp::ShellCmdRealArg *m_pDdsArg;
        shellp::ShellCmdRealArg *m_pLambdaArg;
        shellp::ShellCmdRealArg *m_pCenterXArg;
        shellp::ShellCmdRealArg *m_pCenterYArg;
        shellp::ShellCmdRealArg *m_pAngularRadiusArg;
};

class CmdLensMassSheet : public CmdLens
{
public:
        CmdLensMassSheet(const std::string &cmdName);
        ~CmdLensMassSheet();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pDsArg;
        shellp::ShellCmdRealArg *m_pDdsArg;
};

class CmdLensMassDisk : public CmdLens
{
public:
        CmdLensMassDisk(const std::string &cmdName);
        ~CmdLensMassDisk();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pDsArg;
        shellp::ShellCmdRealArg *m_pDdsArg;
        shellp::ShellCmdRealArg *m_pAngularRadiusArg;
};

class CmdLensComposite : public shellp::ShellCommand
{
public:
        CmdLensComposite(const std::string &cmdName);
        ~CmdLensComposite();
        bool execute();
private:
        std::vector<shellp::ShellCmdArg *> m_lensArgs;
        shellp::ShellCmdRealArg *m_pCenterXArg;
        shellp::ShellCmdRealArg *m_pCenterYArg;
        shellp::ShellCmdRealArg *m_pAngleArg;
        shellp::ShellCmdRealArg *m_pScaleArg;
        shellp::ShellCmdStringArg *m_pFileNameArg;
};

class CmdLensLoadSave : public shellp::ShellCommand
{
protected:
        CmdLensLoadSave(const std::string &cmdname);
public:
        ~CmdLensLoadSave();
protected:
        std::string GetFileName() const                                                 { return fnamearg->getValue(); }
private:
        shellp::ShellCmdStringArg *fnamearg;
};

class CmdLensLoad : public CmdLensLoadSave
{
public:
        CmdLensLoad(const std::string &cmdname);
        ~CmdLensLoad();
        bool execute();
};

class CmdLensSave : public CmdLensLoadSave
{
public:
        CmdLensSave(const std::string &cmdname);
        ~CmdLensSave();
        bool execute();
};

class CmdLensPlot : public shellp::ShellCommand
{
public:
        CmdLensPlot(const std::string &cmdname);
        ~CmdLensPlot();
protected:
        std::string GetFileName() const                                         { return fnamearg->getValue(); }
        double GetX1() const                                                    { return x1arg->getValue(); }
        double GetY1() const                                                    { return y1arg->getValue(); }
        double GetX2() const                                                    { return x2arg->getValue(); }
        double GetY2() const                                                    { return y2arg->getValue(); }
        int GetNumX() const                                                     { return numxarg->getValue(); }
        int GetNumY() const                                                     { return numyarg->getValue(); }
        
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdRealArg *x1arg,*y1arg,*x2arg,*y2arg;
        shellp::ShellCmdIntArg *numxarg,*numyarg;
};

class CmdLensPlotGnuplot : public CmdLensPlot
{
public:
        CmdLensPlotGnuplot(const std::string &cmdname);
        ~CmdLensPlotGnuplot();
        bool execute();
private:
        shellp::ShellCmdBoolArg *arg3d,*colorarg;
        shellp::ShellCmdStringArg *xlabelarg,*ylabelarg;
};

class CmdLensPlotFITS : public CmdLensPlot
{
public:
        CmdLensPlotFITS(const std::string &cmdname);
        ~CmdLensPlotFITS();
        bool execute();
};

class CmdLensPlotProfile : public shellp::ShellCommand
{
public:
        CmdLensPlotProfile(const std::string &cmdname);
        ~CmdLensPlotProfile();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdRealArg *xarg;
        shellp::ShellCmdRealArg *yarg;
        shellp::ShellCmdRealArg *radiusarg;
        shellp::ShellCmdIntArg *rsteparg;
        shellp::ShellCmdIntArg *asteparg;
        shellp::ShellCmdBoolArg *flagarg;
};

class CmdLensAverage : public shellp::ShellCommand
{
public:
        CmdLensAverage(const std::string &cmdname);
        ~CmdLensAverage();
        bool execute();
private:
        shellp::ShellCmdBoolArg *checkdistarg;
        std::vector<shellp::ShellCmdArg *> fileargs;
        shellp::ShellCmdStringArg *fnamearg;
};

class CmdLensSquare : public CmdLens
{
public:
        CmdLensSquare(const std::string &cmdname);
        ~CmdLensSquare();
        bool execute();
private:
        shellp::ShellCmdRealArg *massarg;
        shellp::ShellCmdRealArg *widtharg;
};

class CmdLensMultipleSquares : public CmdLens
{
public:
        CmdLensMultipleSquares(const std::string &cmdname);
        ~CmdLensMultipleSquares();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        std::vector<shellp::ShellCmdArg *> squareargs;
        shellp::ShellCmdRealArg *massarg,*widtharg,*xposarg,*yposarg;
};

class CmdLensMultipleSquaresFits : public CmdLens
{
public:
        CmdLensMultipleSquaresFits(const std::string &cmdname);
        ~CmdLensMultipleSquaresFits();
        bool execute();
private:
        shellp::ShellCmdStringArg *m_pFileArg;
        shellp::ShellCmdRealArg *m_pWidthArg;
        shellp::ShellCmdRealArg *m_pTotalMassArg;
};

class CmdLensMultipleGaussians : public CmdLens
{
public:
        CmdLensMultipleGaussians(const std::string &cmdname);
        ~CmdLensMultipleGaussians();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        std::vector<shellp::ShellCmdArg *> squareargs;
        shellp::ShellCmdRealArg *massarg,*widtharg,*xposarg,*yposarg;
};

class CmdLensMultipleWendland : public CmdLens
{
public:
        CmdLensMultipleWendland(const std::string &cmdName);
        ~CmdLensMultipleWendland();
        bool execute();
private:
        shellp::ShellCmdStringArg *m_pFileNameArg;
        std::vector<shellp::ShellCmdArg *> m_params;
        shellp::ShellCmdBoolArg *m_pFlagArg;
        shellp::ShellCmdRealArg *m_pHeightArg, *m_pAngularScaleArg, *m_pXArg, *m_pYArg;
};

class CmdLensScaleDegeneracy : public CmdLens
{
public:
        CmdLensScaleDegeneracy(const std::string &cmdName);
        ~CmdLensScaleDegeneracy();
        bool execute();
private:
        static void Interpolate(std::vector<double> &points, int refIndex, int stopIndex);
        
        shellp::ShellCmdRealArg *m_pCenterXArg;
        shellp::ShellCmdRealArg *m_pCenterYArg;
};

class CmdLensGetLensPlane : public shellp::ShellCommand
{
public:
        CmdLensGetLensPlane(const std::string &cmdName);
        ~CmdLensGetLensPlane();
        bool execute();
};

class CmdLensGetImagePlane : public shellp::ShellCommand
{
public:
        CmdLensGetImagePlane(const std::string &cmdName);
        ~CmdLensGetImagePlane();
        bool execute();
};

class CmdLensGetLensPlaneGrid : public shellp::ShellCommand
{
public:
        CmdLensGetLensPlaneGrid(const std::string &cmdName);
        ~CmdLensGetLensPlaneGrid();
        bool execute();
};

class CmdLensTimeDelayAdjust : public CmdLens
{
public:
        CmdLensTimeDelayAdjust(const std::string &cmdName);
        ~CmdLensTimeDelayAdjust();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pTimeDiffArg;
        shellp::ShellCmdRealArg *m_pLensZArg;
        shellp::ShellCmdRealArg *m_pThetaStopArg;
        shellp::ShellCmdRealArg *m_pThetaStartArg;
};

class CmdLensMagnificationAdjust : public shellp::ShellCommand
{
public:
        CmdLensMagnificationAdjust(const std::string &cmdName);
        ~CmdLensMagnificationAdjust();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pXArg;
        shellp::ShellCmdRealArg *m_pYArg;
        shellp::ShellCmdRealArg *m_pTargetMagnificationArg;
        shellp::ShellCmdRealArg *m_pMaxWidthArg;
        shellp::ShellCmdRealArg *m_pPotentialScaleArg;
        shellp::ShellCmdBoolArg *m_pConstantTimeDelayArg;

};

class CmdLensTestLens : public CmdLens
{
public:
        CmdLensTestLens(const std::string &cmdName);
        ~CmdLensTestLens();
        bool execute();
};

class CmdLensNFW : public CmdLens
{
public:
        CmdLensNFW(const std::string &cmdname);
        ~CmdLensNFW();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pDensScale;
        shellp::ShellCmdRealArg *m_pAngularRadiusScale;
};

class CmdLensEllipticNFW : public CmdLens
{
public:
        CmdLensEllipticNFW(const std::string &cmdname);
        ~CmdLensEllipticNFW();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pDensScale;
        shellp::ShellCmdRealArg *m_pAngularRadiusScale;
        shellp::ShellCmdRealArg *m_pEllipticityArg;
};

class CmdLensSersic : public CmdLens
{
public:
        CmdLensSersic(const std::string &cmdname);
        ~CmdLensSersic();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pDensScaleArg;
        shellp::ShellCmdRealArg *m_pAngularScaleArg;
        shellp::ShellCmdRealArg *m_pSersicIndexArg;
};

class CmdLensEllipticSersic : public CmdLens
{
public:
        CmdLensEllipticSersic(const std::string &cmdname);
        ~CmdLensEllipticSersic();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pDensScaleArg;
        shellp::ShellCmdRealArg *m_pAngularScaleArg;
        shellp::ShellCmdRealArg *m_pSersicIndexArg;
        shellp::ShellCmdRealArg *m_pEllipticityArg;
};

#endif // CMDLENSES_H