gridlensinversiongenomenew.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_GRIDLENSINVERSIONGENOMENEW_H

#define GRALE_GRIDLENSINVERSIONGENOMENEW_H

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

#define GRIDLENSINVERSIONGENOMENEW_MAXFITNESSCOMP 16

namespace grale
{
        
class GridLensInversionGAFactoryNew;
class GravitationalLens;        

class GRALE_IMPORTEXPORT GridLensInversionGenomeNew : public LensInversionGenomeBase
{
public:
        GridLensInversionGenomeNew(GridLensInversionGAFactoryNew *pFactory, int numMasses, bool useSheet);
        GridLensInversionGenomeNew(GridLensInversionGAFactoryNew *pFactory, const std::vector<float> &masses, float sheetValue);
        ~GridLensInversionGenomeNew();
        
        void setActiveFitnessComponent(int i)                                                           { m_activeFitnessComponent = i; }
        bool calculateFitness();
        bool isFitterThan(const mogal::Genome *pGenome) const;
        mogal::Genome *reproduce(const mogal::Genome *pGenome) const;
        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);
        void setScaleFactor(float s)                                                                    { m_scaleFactor = s; }
        
        const std::vector<float> &getMasses() const                                                     { return m_masses; }
        float getSheetValue() const                                                                     { return m_sheetValue; }

        GravitationalLens *createLens(double *totalmass, std::string &errstr) const;

        void copyFitnessValuesTo(float *pDestination, int amount) const                                 { memcpy(pDestination, m_fitnessValues, sizeof(float)*amount); }
protected:
        GridLensInversionGAFactoryNew *getFactory() const                                               { return m_pFactory; }
private:
        void initGenome();

        void initializeNewCalculation();
        float calculateMassScaleFitness(float scalefactor, float sheetScale);
        void calculateTotalFitness(float scalefactor, float sheetScale, float *fitnessvalues);
        
        int m_activeFitnessComponent;
        float m_fitnessValues[GRIDLENSINVERSIONGENOMENEW_MAXFITNESSCOMP];       
        float m_scaleFactor;
        std::vector<float> m_masses;
        float m_sheetValue;

        GridLensInversionGAFactoryNew *m_pFactory;
};

inline bool GridLensInversionGenomeNew::isFitterThan(const mogal::Genome *pGenome) const
{
        const GridLensInversionGenomeNew *pGenome2 = (const GridLensInversionGenomeNew *)pGenome; 
        
        if (m_fitnessValues[m_activeFitnessComponent] < pGenome2->m_fitnessValues[m_activeFitnessComponent]) 
                return true; 
        return false; 
}

inline void GridLensInversionGenomeNew::setFitnessValues(const float *pValues)
{ 
        memcpy(m_fitnessValues, pValues, sizeof(float)*GRIDLENSINVERSIONGENOMENEW_MAXFITNESSCOMP);
}

} // end namespace

#endif // GRALE_GRIDLENSINVERSIONGENOMENEW_H