gridlensinversiongenomebase.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_GRIDLENSINVERSIONGENOMEBASE_H

#define GRALE_GRIDLENSINVERSIONGENOMEBASE_H

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

#define GRIDLENSINVERSIONGENOMEBASE_MAXFITNESSCOMP 16

namespace grale
{
        
class GridLensInversionGAFactoryBase;
class GravitationalLens;        

class GRALE_IMPORTEXPORT GridLensInversionGenomeBase : public LensInversionGenomeBase
{
public:
        GridLensInversionGenomeBase(GridLensInversionGAFactoryBase *f, int nummasses, bool useGenomeSheet);
#ifdef AUTODISTFRAC
        GridLensInversionGenomeBase(GridLensInversionGAFactoryBase *f, const std::vector<float> &masses, const std::vector<float> &fractions, float sheetValue);
#else
        GridLensInversionGenomeBase(GridLensInversionGAFactoryBase *f, const std::vector<float> &masses, float sheetValue);
#endif // AUTODISTFRAC
        ~GridLensInversionGenomeBase();
        
        void setActiveFitnessComponent(int i)                                                           { m_fitnessComp = i; }
        bool calculateFitness();
        bool isFitterThan(const mogal::Genome *g) const                                                 { const GridLensInversionGenomeBase *g2 = (const GridLensInversionGenomeBase *)g; if (fitnessvalues[m_fitnessComp] < g2->getFitnessValues()[m_fitnessComp]) return true; return false; }
        mogal::Genome *reproduce(const mogal::Genome *g) const;
        Genome *clone() const;
        void mutate();
        std::string getFitnessDescription() const;
                
        const float *getFitnessValues() const                                                           { return fitnessvalues; }
        float getScaleFactor() const                                                                    { return scalefactor; }
        float getSheetFactor() const                                                                    { return m_sheetFactor; }
        void setFitnessValues(const float *f)                                                           { for (int i = 0 ; i < GRIDLENSINVERSIONGENOMEBASE_MAXFITNESSCOMP ; i++) fitnessvalues[i] = f[i]; }
        void setScaleFactor(float s)                                                                    { scalefactor = s; }
        void setSheetFactor(float s)                                                                    { m_sheetFactor = s; }
        
        const std::vector<float> &getMasses() const                                                     { return m_masses; }
        float getSheetValue() const                                                                     { return m_sheetValue; }
#ifdef AUTODISTFRAC
        const std::vector<float> &getDistanceFractions() const                                          { return m_distanceFractions; }
#endif // AUTODISTFRAC

        GravitationalLens *createLens(double *totalmass, std::string &errstr) const;
        void copyFitnessValuesTo(float *pDestination, int amount) const                                 { memcpy(pDestination, fitnessvalues, sizeof(float)*amount); }
protected:
        virtual void getCalculationParameters(float &startfactor, float &stopfactor, int &numiterationsteps, int &numiterations) const
        { 
                startfactor = 0.2;
                stopfactor = 5.0;
                numiterationsteps = 20;
                numiterations = 5;
        }
        virtual void getSheetCalculationParameters(float &startfactor, float &stopfactor) const
        { 
                startfactor = 0;
                stopfactor = 2.0;
        }
        
        GridLensInversionGAFactoryBase *getFactory() const                                              { return factory; }
private:
        void initializeNewCalculation();
        float calculateMassScaleFitness(float scalefactor, float sheetScale);
        void calculateTotalFitness(float scalefactor, float sheetScale, float *fitnessvalues);
        void rescale();
        
        int m_fitnessComp;
        float fitnessvalues[GRIDLENSINVERSIONGENOMEBASE_MAXFITNESSCOMP];        
        float scalefactor;
        std::vector<float> m_masses;
#ifdef AUTODISTFRAC
        std::vector<float> m_distanceFractions;
#endif // AUTODISTFRAC
        float m_sheetValue;
        float m_sheetFactor;

        GridLensInversionGAFactoryBase *factory;
};

} // end namespace

#endif // GRALE_GRIDLENSINVERSIONGENOMEBASE_H