cmdinvert.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 CMDINVERT_H

#define CMDINVERT_H

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

namespace mogal
{
        class GeneticAlgorithm;
        class GAFactoryParams;
        class GAFactory;
}

class CmdInvertBase : public shellp::ShellCommand
{
public:
        CmdInvertBase(const std::string &cmdname);
        ~CmdInvertBase();
protected:
        bool GetModuleDirectory(std::string &moduledir);
        bool ProcessSolution(mogal::GeneticAlgorithm &ga);
        mogal::GeneticAlgorithm *GetGeneticAlgorithm();
};

class CmdInvertGridBase : public CmdInvertBase
{
public:
        CmdInvertGridBase(const std::string &cmdname);
        ~CmdInvertGridBase();
protected:
        void AddDefaultArguments();
        mogal::GAFactoryParams *GetFactoryParameters();
        bool GetModuleName(std::string &modulename);
        int GetPopulationSize()                                                         { return popsizearg->getValue(); }
private:
        shellp::ShellCmdRealArg *Ddarg;
        shellp::ShellCmdRealArg *m_pZArg;
        shellp::ShellCmdStringArg *invtypearg;
        shellp::ShellCmdIntArg *popsizearg;
        shellp::ShellCmdIntArg *maxgenarg;
        shellp::ShellCmdRealArg *plumwidtharg;
        shellp::ShellCmdBoolArg *adjustweights;
        shellp::ShellCmdStringArg *basisarg;
        shellp::ShellCmdBoolArg *m_pAllowNegativeArg;
        shellp::ShellCmdBoolArg *m_pUseBaseLensArg;
        shellp::ShellCmdRealArg *m_pMassScaleArg;
        shellp::ShellCmdStringArg *m_pSearchSheetArg;
};

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

class CmdInvertGridRemote : public CmdInvertGridBase
{
public:
        CmdInvertGridRemote(const std::string &cmdname);
        ~CmdInvertGridRemote();
        bool execute();
private:
        shellp::ShellCmdStringArg *ipstrarg;
        shellp::ShellCmdIntArg *portarg;
};

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

class CmdInvertGAParamsSet : public shellp::ShellCommand
{
public:
        CmdInvertGAParamsSet(const std::string &cmdname);
        ~CmdInvertGAParamsSet();
        bool execute();
private:
        shellp::ShellCmdRealArg *betaarg;
        shellp::ShellCmdBoolArg *elitarg;
        shellp::ShellCmdBoolArg *bestarg;
        shellp::ShellCmdRealArg *crossarg;
        shellp::ShellCmdBoolArg *saveintarg;
        shellp::ShellCmdStringArg *prefarg;
        shellp::ShellCmdBoolArg *saveallarg;
        shellp::ShellCmdStringArg *saveprefarg;
};

class CmdInvertAreaBase : public CmdInvertBase
{
public:
        CmdInvertAreaBase(const std::string &cmdname);
        ~CmdInvertAreaBase();
protected:
        void AddDefaultArguments();
        int GetPopulationSize()                                                         { return popsizearg->getValue(); }
        bool GetModuleName(std::string &modulename);
        mogal::GAFactoryParams *GetFactoryParameters(mogal::GAFactory &factory);
private:
        shellp::ShellCmdRealArg *Ddarg;
        shellp::ShellCmdRealArg *sizearg;
        shellp::ShellCmdRealArg *xarg;
        shellp::ShellCmdRealArg *yarg;
        shellp::ShellCmdStringArg *invtypearg;
        shellp::ShellCmdIntArg *popsizearg;
        shellp::ShellCmdIntArg *maxgenarg;
        shellp::ShellCmdStringArg *filearg;
};

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

class CmdInvertAreaRemote : public CmdInvertAreaBase
{
public:
        CmdInvertAreaRemote(const std::string &cmdname);
        ~CmdInvertAreaRemote();
        bool execute();
private:
        shellp::ShellCmdStringArg *ipstrarg;
        shellp::ShellCmdIntArg *portarg;
};

class CmdInvertTreeBase : public CmdInvertBase
{
public:
        CmdInvertTreeBase(const std::string &cmdName);
        ~CmdInvertTreeBase();
protected:
        void AddDefaultArguments();
        int GetPopulationSize()                                                         { return m_pPopulationSizeArg->getValue(); }
        bool GetModuleName(std::string &moduleName);
        mogal::GAFactoryParams *GetFactoryParameters();
private:
        shellp::ShellCmdRealArg *m_pDdArg;
        shellp::ShellCmdRealArg *m_pSizeArg;
        shellp::ShellCmdRealArg *m_pCenterXArg;
        shellp::ShellCmdRealArg *m_pCenterYArg;
        shellp::ShellCmdStringArg *m_pInversionModuleArg;
        shellp::ShellCmdIntArg *m_pMaxDepthArg;
        shellp::ShellCmdIntArg *m_pMaxBasisArg;
        shellp::ShellCmdIntArg *m_pFirstSubdivArg;
        shellp::ShellCmdIntArg *m_pPopulationSizeArg;
        shellp::ShellCmdIntArg *m_pMaxGenArg;
        shellp::ShellCmdBoolArg *m_pUseWeightsArg;
};

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

class CmdInvertTreeRemote : public CmdInvertTreeBase
{
public:
        CmdInvertTreeRemote(const std::string &cmdname);
        ~CmdInvertTreeRemote();
        bool execute();
private:
        shellp::ShellCmdStringArg *m_pIPArg;
        shellp::ShellCmdIntArg *m_pPortArg;
};

class CmdInvertGridNewBase : public CmdInvertBase
{
public:
        CmdInvertGridNewBase(const std::string &cmdName);
        ~CmdInvertGridNewBase();
protected:
        void AddDefaultArguments();
        mogal::GAFactoryParams *GetFactoryParameters();
        bool GetModuleName(std::string &modulename);
        int GetPopulationSize()                                                         { return popsizearg->getValue(); }
private:
        shellp::ShellCmdRealArg *Ddarg;
        shellp::ShellCmdRealArg *m_pZArg;
        shellp::ShellCmdStringArg *invtypearg;
        shellp::ShellCmdIntArg *popsizearg;
        shellp::ShellCmdIntArg *maxgenarg;
        shellp::ShellCmdRealArg *plumwidtharg;
        shellp::ShellCmdStringArg *basisarg;
        shellp::ShellCmdBoolArg *m_pAllowNegativeArg;
        shellp::ShellCmdBoolArg *m_pUseBaseLensArg;
        shellp::ShellCmdRealArg *m_pMassScaleArg;
        shellp::ShellCmdBoolArg *m_pSearchSheetArg;
        shellp::ShellCmdBoolArg *m_pShowEvolutionArg;
        shellp::ShellCmdBoolArg *m_pSaveFirstGenomeArg;
};

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

class CmdInvertGridNewRemote : public CmdInvertGridNewBase
{
public:
        CmdInvertGridNewRemote(const std::string &cmdname);
        ~CmdInvertGridNewRemote();
        bool execute();
private:
        shellp::ShellCmdStringArg *ipstrarg;
        shellp::ShellCmdIntArg *portarg;
};


#endif // CMDINVERT_H