treelensinversiongenomebase.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_TREELENSINVERSIONGENOMEBASE_H

#define GRALE_TREELENSINVERSIONGENOMEBASE_H

#include "graleconfig.h"
#include "lensinversiongenomebase.h"
#include "vector2d.h"
#include <vector>
#include <string>

#define TREELENSINVERSIONGENOMEBASE_MAXFITNESSCOMP 16

namespace grale
{
        
class BackProjectTreeBase;
class TreeLensInversionGAFactoryBase;
class GravitationalLens;        
class GridNodeBase;
class GridTreeNode;
class MultiplePlummerLensParams;

class GRALE_IMPORTEXPORT TreeLensInversionGenomeBase : public LensInversionGenomeBase
{
protected:
        TreeLensInversionGenomeBase(TreeLensInversionGAFactoryBase *pFactory, BackProjectTreeBase *m, int firstLevelSubdiv);
        TreeLensInversionGenomeBase(TreeLensInversionGAFactoryBase *pFactory, BackProjectTreeBase *m, GridNodeBase *pRootNode);
public:
        ~TreeLensInversionGenomeBase();
        
        void setActiveFitnessComponent(int i)                                                           { m_activeFitnessComponent = i; }
        bool calculateFitness();
        bool isFitterThan(const mogal::Genome *g) const                                                 { const TreeLensInversionGenomeBase *g2 = (const TreeLensInversionGenomeBase *)g; if (m_fitnessValues[m_activeFitnessComponent] < g2->getFitnessValues()[m_activeFitnessComponent]) return true; return false; }
        mogal::Genome *reproduce(const mogal::Genome *g) const;
        mogal::Genome *clone() const;
        void mutate();
        std::string getFitnessDescription() const;
                
        const float *getFitnessValues() const                                                           { return m_fitnessValues; }
        float getScaleFactor() const                                                                    { return m_scaleFactor; }
        void setFitnessValues(const float *pValues)                                                     { for (int i = 0 ; i < TREELENSINVERSIONGENOMEBASE_MAXFITNESSCOMP ; i++) m_fitnessValues[i] = pValues[i]; }
        void setScaleFactor(float s)                                                                    { m_scaleFactor = s; }
        
        const GridNodeBase *getRootNode() const                                                         { return m_pRootNode; }

        GravitationalLens *createLens(double *totalmass, std::string &errstr) const;
protected:
        virtual TreeLensInversionGenomeBase *allocateNewInstance(TreeLensInversionGAFactoryBase *f, BackProjectTreeBase *m, GridNodeBase *pRootNode) const = 0;
        virtual void initializeNewCalculation() = 0;
        virtual float calculateMassScaleFitness(float scalefactor) = 0;
        virtual void calculateTotalFitness(float scalefactor, float *fitnessvalues) = 0;
        virtual void getCalculationParameters(float &startfactor, float &stopfactor, int &numiterationsteps, int &numiterations) const
        { 
                startfactor = 0.2;
                stopfactor = 5.0;
                numiterationsteps = 20;
                numiterations = 5;
        }
        
        TreeLensInversionGAFactoryBase *getFactory() const                                              { return m_pFactory; }
        BackProjectTreeBase *getBackProjectTree()                                                       { return m_pBackProjectTree; }
private:
        void rescale();
        void addBasisFunction(const GridNodeBase *pNode, int level, MultiplePlummerLensParams *pLensParams, Vector2D<double> center, double areaSize, double widthScaleFactor, double massScale) const;
        static float findMaxWeight(const GridNodeBase *pNode);
        static float sumWeights(const GridNodeBase *pNode, int level, bool useWeights);
        static void scaleWeights(GridNodeBase *pNode, float scaleFactor);
        GridNodeBase *reproduce(const GridNodeBase *pNode1, const GridNodeBase *pNode2, float scaleFactor1, float scaleFactor2) const;
        void findAllWeightNodes(GridNodeBase *pNode, std::vector<GridNodeBase *> &allNodes);
        static int countAllWeightNodes(GridNodeBase *pNode, std::vector<GridTreeNode *> &parentNodes);
        GridNodeBase *prune(GridNodeBase *pNode, int maxBasisFunctions) const;
        static void scaleAllWeightNodes(GridNodeBase *pNode, float factor);
        
        int m_activeFitnessComponent;
        float m_fitnessValues[TREELENSINVERSIONGENOMEBASE_MAXFITNESSCOMP];      
        float m_scaleFactor;
        GridNodeBase *m_pRootNode;
        bool m_useWeights;
        
        TreeLensInversionGAFactoryBase *m_pFactory;
        BackProjectTreeBase *m_pBackProjectTree;
};

} // end namespace

#endif // GRALE_TREELENSINVERSIONGENOMEBASE_H