#include "DerevyankoReport.h"
#include "individual/Trait.h"
#include "individual/Phenotype.h"
//#include "population/BreedingStrategies/PopulationBreedingStrategy.h"
#include "population/BreedingStrategies/NeutralEvolutionBreedStrat.h"

#include <list>
#include <fstream>


using std::string;

string DerevyankoReport::initMtDNA;
string DerevyankoReport::initMtDNA_G;
std::vector<std::string> DerevyankoReport::initMtDNAgui;
std::vector<std::string> DerevyankoReport::initMtDNA_Ggui;

BisexualPopulation* DerevyankoReport::pop_f;
BisexualPopulation* DerevyankoReport::pop_G;
BisexualPopulation* DerevyankoReport::pop_e;
BisexualPopulation* DerevyankoReport::pop_F;
BisexualPopulation* DerevyankoReport::pop_d;
BisexualPopulation* DerevyankoReport::pop_E;
BisexualPopulation* DerevyankoReport::pop_c;
BisexualPopulation* DerevyankoReport::pop_D;
BisexualPopulation* DerevyankoReport::pop_b;
BisexualPopulation* DerevyankoReport::pop_a;
BisexualPopulation* DerevyankoReport::pop_A;
BisexualPopulation* DerevyankoReport::pop_B;
BisexualPopulation* DerevyankoReport::pop_C;

int DerevyankoReport::basePopSize = 5000;
float DerevyankoReport::initBirthRate = 0.25f;
float DerevyankoReport::deltaBirthRate = 0.0002f;

int DerevyankoReport::genPerMigr_f_G;
float DerevyankoReport::part_f_to_G;
float DerevyankoReport::part_G_to_f;

int DerevyankoReport::genPerMigr_A_B;
int DerevyankoReport::genPerMigr_A_C;
int DerevyankoReport::genPerMigr_A_D;
int DerevyankoReport::genPerMigr_A_E;
int DerevyankoReport::genPerMigr_A_F;

float DerevyankoReport::part_A_to_B;
float DerevyankoReport::part_B_to_A;
float DerevyankoReport::part_A_to_C;
float DerevyankoReport::part_A_to_D;
float DerevyankoReport::part_A_to_E;
float DerevyankoReport::part_A_to_F;

float DerevyankoReport::fraction_e_founder;
float DerevyankoReport::fraction_F_founder;
float DerevyankoReport::fraction_E_founder;
float DerevyankoReport::fraction_D_founder;
float DerevyankoReport::fraction_C_founder;
float DerevyankoReport::fraction_B_founder;

QVector<double> DerevyankoReport::popSize_f;
QVector<double> DerevyankoReport::popSize_G;
QVector<double> DerevyankoReport::popSize_e;
QVector<double> DerevyankoReport::popSize_F;
QVector<double> DerevyankoReport::popSize_d;
QVector<double> DerevyankoReport::popSize_E;
QVector<double> DerevyankoReport::popSize_c;
QVector<double> DerevyankoReport::popSize_D;
QVector<double> DerevyankoReport::popSize_b;
QVector<double> DerevyankoReport::popSize_a;
QVector<double> DerevyankoReport::popSize_A;
QVector<double> DerevyankoReport::popSize_B;
QVector<double> DerevyankoReport::popSize_C;

QVector<BisexualPopulation*> DerevyankoReport::pops;
QVector<QString> DerevyankoReport::populNames;
QVector<int> DerevyankoReport::maxYval(2);
// if uncomment report, set size to 13
//QVector<int> DerevyankoReport::globalGenerations(13);
int DerevyankoReport::globalGenerations;
QVector< QVector<double> > DerevyankoReport::popSizes(2);
QVector< QVector<double> > DerevyankoReport::generations(2);



void DerevyankoReport::initVectors()
{
    DerevyankoReport::popSizes[0].push_back(DerevyankoReport::basePopSize);

    DerevyankoReport::popSizes[1].push_back(DerevyankoReport::basePopSize);
    DerevyankoReport::generations[0].push_back(0);
    DerevyankoReport::generations[1].push_back(0);

    for (int i = 0; i < 2; i++)
    {
        DerevyankoReport::maxYval[i] = 0;
    }
}

void DerevyankoReport::fillVectors(BisexualPopulation *pop, int popNum)
{

    DerevyankoReport::generations[popNum].push_back(globalGenerations);
    DerevyankoReport::popSizes[popNum].push_back(pop->males.size() + pop->males.size());
    if (pop->males.size() + pop->males.size() > DerevyankoReport::maxYval[popNum])
    {
        DerevyankoReport::maxYval[popNum] = pop->males.size() + pop->males.size();
    }
}

BisexualPopulation* DerevyankoReport::populationFactory(int size, std::string initMtGenome){
	BisexualPopulation* ans;

	std::list<Individual*> males;
	std::list<Individual*> females;

	Gene gene1(Gene::Sequence, "mtDna1", initMtGenome);
	Chromosome chrom1("Mitochondrial chromosome");
	chrom1.insertGeneToEnd(gene1);
		
	std::vector<Chromosome> fGenome;
	std::vector<Chromosome> mGenome;
	fGenome.push_back(chrom1);
	mGenome.push_back(chrom1);
	
	// Фенотип
	Trait trait1(Trait::Discrete, "Age", 20);
	// Пул субстратов
	InnerSubstratesPool* subPool = 0;
	// (END) Пул субстратов

	for(int i = 0; i < size/2; i++){
		Genotype* genotype = new Genotype(fGenome, mGenome);
		Phenotype* phenotype = new Phenotype(trait1);
		males.push_back(new Individual(genotype, phenotype, subPool, Individual::male, 0));
		
		genotype = new Genotype(fGenome, mGenome);
		phenotype = new Phenotype(trait1);
		females.push_back(new Individual(genotype, phenotype, subPool, Individual::female, 0));
	}

	ans = new BisexualPopulation(males,females);
	return ans;
}

void DerevyankoReport::separatePop(QString popName, double founder, int sepPopInd)
{
    //Derfraction_founder = founder;
    BisexualPopulation* population = DerevyankoReport::pops[sepPopInd]->createSubpopulation(founder);


    BisexualPopulation* population_rest = DerevyankoReport::pops[sepPopInd]; // Остаток становится d
    NeutralEvolutionBreedingStrategy* breedStrat_d =
        dynamic_cast<NeutralEvolutionBreedingStrategy*>(PopulationBreedingStrategy::getInstance("neutral"));
    breedStrat_d->setBirthRate(initBirthRate);
    breedStrat_d->setDeathRate(initBirthRate-deltaBirthRate*2);
    population_rest->setBreedingStrategy(breedStrat_d);
    DerevyankoReport::pops.push_back(population);
    DerevyankoReport::pops.push_back(population_rest);

    QVector<double> pop_gen;
    QVector<double> pop_size;

    QVector<double> pop_gen_2;
    QVector<double> pop_size_2;

    DerevyankoReport::popSizes.push_back(pop_size);
    DerevyankoReport::generations.push_back(pop_gen);
    DerevyankoReport::maxYval.push_back(0);

    DerevyankoReport::popSizes.push_back(pop_size_2);
    DerevyankoReport::generations.push_back(pop_gen_2);
    DerevyankoReport::maxYval.push_back(0);

    DerevyankoReport::populNames.push_back(popName);
    QString name = DerevyankoReport::populNames[sepPopInd] + "_rest";
    DerevyankoReport::populNames.push_back(name);
}

void DerevyankoReport::evolution(int evol_time)
{
    for(int i = 0; i < evol_time; i++)
    {
        for (int j = 0; j < DerevyankoReport::pops.size(); j++)
        {
            DerevyankoReport::pops[j]->breedAll();
            DerevyankoReport::pops[j]->mutationAll();
            DerevyankoReport::fillVectors(DerevyankoReport::pops[j], j);
        }
        DerevyankoReport::globalGenerations++;

    }
}

void DerevyankoReport::reportRFBR2013_01(){
	
    std::cout << "ReportRFBR" << std::endl;
	// Митохондриальная ДНК (популяция f)
//    DerevyankoReport::initMtDNA = "TTCTTTCATGGGGAAGCAGATTTGGGTACCACCCAAGTATTGACTCACCCATCAACAACC";
//    DerevyankoReport::initMtDNA += "GCTATGTATTTCGTACATTACTGCCAGCCACCATGAATATTGTACGGTACCATAAATACT";
//    DerevyankoReport::initMtDNA += "TGACCACCTGTAGTACATAAAAACCCAATCCACATCAAAACCCCCCCCTCATGCTTACAA";
//    DerevyankoReport::initMtDNA += "GCAAGTACAGCAATCAACCTTCAACTATCACACATCAACTGCAACTCCAAAGCCACCCCT";
//    DerevyankoReport::initMtDNA += "CACCCACTAGGATATCAACAAACCTACCCATCCTTAACAGTACATGGTACATAAAGCCAT";
//    DerevyankoReport::initMtDNA += "TTACCGTACATAGCACATTACAGTCAAATCCCTTCTCGTCCCCATGGATGACCCCCCTCA";

//	// Мутантная мтДНК (популяция G)
//    DerevyankoReport::initMtDNA_G = DerevyankoReport::initMtDNA;
//    DerevyankoReport::initMtDNA_G.replace(60,1,"T");
//    DerevyankoReport::initMtDNA_G.replace(120,1,"A");
//    DerevyankoReport::initMtDNA_G.replace(180,1,"C");
//    DerevyankoReport::initMtDNA_G.replace(240,1,"G");
	
//	// Генерация стартовых популяций
//	//
//    DerevyankoReport::basePopSize = 5000;
//    DerevyankoReport::initBirthRate = 0.25f;
//    DerevyankoReport::deltaBirthRate = 0.0002f;
    BisexualPopulation *pop_f = populationFactory(basePopSize, DerevyankoReport::initMtDNA);
	NeutralEvolutionBreedingStrategy* breedStrat_f = 
		dynamic_cast<NeutralEvolutionBreedingStrategy*>(PopulationBreedingStrategy::getInstance("neutral"));
	breedStrat_f->setBirthRate(initBirthRate);
	breedStrat_f->setDeathRate(initBirthRate-deltaBirthRate);
    pop_f->setBreedingStrategy(breedStrat_f);

    BisexualPopulation *pop_G = populationFactory(basePopSize, DerevyankoReport::initMtDNA_G);
	NeutralEvolutionBreedingStrategy* breedStrat_G = 
		dynamic_cast<NeutralEvolutionBreedingStrategy*>(PopulationBreedingStrategy::getInstance("neutral"));
	breedStrat_G->setBirthRate(initBirthRate);
	breedStrat_G->setDeathRate(initBirthRate-deltaBirthRate);
    pop_G->setBreedingStrategy(breedStrat_G);
    DerevyankoReport::pops.push_back(pop_f);
    DerevyankoReport::pops.push_back(pop_G);

    DerevyankoReport::populNames.push_back("Pop_f");
    DerevyankoReport::populNames.push_back("Pop_G");

	///////////////////////////////////////////
	//
	//		Эволюционный процесс
	//
	///////////////////////////////////////////

	unsigned int generation;

	// Шаг 1.
	// Вариант 1
    DerevyankoReport::genPerMigr_f_G = 100;
    DerevyankoReport::part_f_to_G = 0.01f;
    DerevyankoReport::part_G_to_f = 0.01f;
	std::cout<<"Variant 1"<<std::endl;

	// Вариант 2
	//int genPerMigr_f_G = 1000;
	//float part_f_to_G = 0.1f;
	//float part_G_to_f = 0.1f;
	//std::cout<<"Variant 2"<<std::endl;
    DerevyankoReport::initVectors();
    for(generation = 0; generation < 7/*7000*/; generation++){
        std::cout<<"gen\t"<<generation<<std::endl;
        DerevyankoReport::pops[0]->breedAll();
        DerevyankoReport::pops[0]->mutationAll();
		
        DerevyankoReport::pops[1]->breedAll();
       DerevyankoReport::pops[1]->mutationAll();

        if(generation != 0 && ((generation % genPerMigr_f_G) == 0)){
            std::string code = BisexualPopulation::mutualMigration(DerevyankoReport::pops[0], DerevyankoReport::pops[1], part_f_to_G, part_G_to_f);
            std::cout<<"Migration f<->G\t"<<code<<std::endl;
        }

        DerevyankoReport::globalGenerations++;
        DerevyankoReport::fillVectors(DerevyankoReport::pops[0], 0);
        DerevyankoReport::fillVectors(DerevyankoReport::pops[1], 1);

    }

//	// Шаг 2.
//	// Вычленение популяции e и её жизнь (10 поколений) f нас больше не интересует
//    DerevyankoReport::fraction_e_founder = 0.5f;
//    DerevyankoReport::pop_e = DerevyankoReport::pop_f->createSubpopulation(fraction_e_founder);
//	std::cout<<"pop_e has been created"<<std::endl;

//    for(; generation < 15/*7010*/; generation++){
//		std::cout<<"gen\t"<<generation<<std::endl;
//        DerevyankoReport::pop_e->breedAll();
//        DerevyankoReport::pop_e->mutationAll();

//        DerevyankoReport::pop_G->breedAll();
//        DerevyankoReport::pop_G->mutationAll();
//        DerevyankoReport::globalGenerations++;
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_e, 2);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_G, 1);
//	}

//	// Шаг 3.
//	// Разделение популяции е на F и d
//	// Далее эволюция 50 поколений
//	// мажорная ветка - это популяция d, ей остаётся 90% популяции
//    DerevyankoReport::fraction_F_founder = 0.1f;
//    DerevyankoReport::pop_F = DerevyankoReport::pop_e->createSubpopulation(fraction_F_founder);
//	std::cout<<"pop_F has been created"<<std::endl;
	
//    DerevyankoReport::pop_d = DerevyankoReport::pop_e; // Остаток становится d
//	NeutralEvolutionBreedingStrategy* breedStrat_d =
//		dynamic_cast<NeutralEvolutionBreedingStrategy*>(PopulationBreedingStrategy::getInstance("neutral"));
//	breedStrat_d->setBirthRate(initBirthRate);
//	breedStrat_d->setDeathRate(initBirthRate-deltaBirthRate*2);
//    DerevyankoReport::pop_d->setBreedingStrategy(breedStrat_d);
//	std::cout<<"pop_e -> pop_d\tPop dynamics coeffs have been changed:\td =\t";
//	std::cout<<(initBirthRate-deltaBirthRate*2)<<std::endl;

//    for(; generation < 25/*7060*/; generation++){
//		std::cout<<"gen\t"<<generation<<std::endl;
//        DerevyankoReport::pop_d->breedAll();
//        DerevyankoReport::pop_d->mutationAll();

//        DerevyankoReport::pop_F->breedAll();
//        DerevyankoReport::pop_F->mutationAll();

//        DerevyankoReport::pop_G->breedAll();
//        DerevyankoReport::pop_G->mutationAll();
//        DerevyankoReport::globalGenerations++;
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_F, 3);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_d, 4);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_G, 1);
//	}

//	// Шаг 4.
//	// Разделение популяции d на E и c
//	// Далее эволюция 100 поколений
//	// мажорная ветка - это популяция c, ей остаётся 90% популяции
//    DerevyankoReport::fraction_E_founder = 0.1f;
//    DerevyankoReport::pop_E = DerevyankoReport::pop_d->createSubpopulation(fraction_E_founder);
//	std::cout<<"pop_E has been created"<<std::endl;
	
//    DerevyankoReport::pop_c = DerevyankoReport::pop_d; // Остаток становится c
//	NeutralEvolutionBreedingStrategy* breedStrat_c =
//		dynamic_cast<NeutralEvolutionBreedingStrategy*>(PopulationBreedingStrategy::getInstance("neutral"));
//	breedStrat_c->setBirthRate(initBirthRate);
//	breedStrat_c->setDeathRate(initBirthRate-deltaBirthRate*2.5f);
//    DerevyankoReport::pop_c->setBreedingStrategy(breedStrat_c);
//	std::cout<<"pop_d -> pop_c\tPop dynamics coeffs have been changed:\td =\t";
//	std::cout<<(initBirthRate-deltaBirthRate*2.5f)<<std::endl;

//    for(; generation < 35/*7160*/; generation++){
//		std::cout<<"gen\t"<<generation<<std::endl;
//        DerevyankoReport::pop_c->breedAll();
//        DerevyankoReport::pop_c->mutationAll();

//        DerevyankoReport::pop_E->breedAll();
//        DerevyankoReport::pop_E->mutationAll();

//        DerevyankoReport::pop_F->breedAll();
//        DerevyankoReport::pop_F->mutationAll();

//        DerevyankoReport::pop_G->breedAll();
//        DerevyankoReport::pop_G->mutationAll();
//        DerevyankoReport::globalGenerations++;
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_F, 3);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_c, 5);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_G, 1);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_E, 6);
//	}

//	// Шаг 5.
//	// Разделение популяции c на D и b
//	// Далее эволюция 100 поколений
//	// мажорная ветка - это популяция b, ей остаётся 90% популяции
//    DerevyankoReport::fraction_D_founder = 0.1f;
//    DerevyankoReport::pop_D = DerevyankoReport::pop_c->createSubpopulation(fraction_D_founder);
//	std::cout<<"pop_D has been created"<<std::endl;
	
//    DerevyankoReport::pop_b = DerevyankoReport::pop_c; // Остаток становится b
//	NeutralEvolutionBreedingStrategy* breedStrat_b =
//		dynamic_cast<NeutralEvolutionBreedingStrategy*>(PopulationBreedingStrategy::getInstance("neutral"));
//	breedStrat_b->setBirthRate(initBirthRate);
//	breedStrat_b->setDeathRate(initBirthRate-deltaBirthRate*3.f);
//    DerevyankoReport::pop_b->setBreedingStrategy(breedStrat_b);
//	std::cout<<"pop_c -> pop_b\tPop dynamics coeffs have been changed:\td =\t";
//	std::cout<<(initBirthRate-deltaBirthRate*3.f)<<std::endl;

//    for(; generation < 45/*7260*/; generation++){
//		std::cout<<"gen\t"<<generation<<std::endl;
//        DerevyankoReport::pop_b->breedAll();
//        DerevyankoReport::pop_b->mutationAll();

//        DerevyankoReport::pop_D->breedAll();
//        DerevyankoReport::pop_D->mutationAll();

//        DerevyankoReport::pop_E->breedAll();
//        DerevyankoReport::pop_E->mutationAll();

//        DerevyankoReport::pop_F->breedAll();
//        DerevyankoReport::pop_F->mutationAll();

//        DerevyankoReport::pop_G->breedAll();
//        DerevyankoReport::pop_G->mutationAll();
//        DerevyankoReport::globalGenerations++;
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_F, 3);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_b, 7);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_G, 1);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_E, 6);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_D, 8);

//	}

//	// Шаг 6.
//	// Разделение популяции b на C и a
//	// Далее эволюция 200 поколений
//	// мажорная ветка - это популяция a, ей остаётся 90% популяции
//    DerevyankoReport::fraction_C_founder = 0.1f;
//    DerevyankoReport::pop_C = DerevyankoReport::pop_b->createSubpopulation(fraction_C_founder);
//	std::cout<<"pop_C has been created"<<std::endl;
	
//    DerevyankoReport::pop_a = DerevyankoReport::pop_b; // Остаток становится b
//	NeutralEvolutionBreedingStrategy* breedStrat_a =
//		dynamic_cast<NeutralEvolutionBreedingStrategy*>(PopulationBreedingStrategy::getInstance("neutral"));
//	breedStrat_a->setBirthRate(initBirthRate);
//	breedStrat_a->setDeathRate(initBirthRate-deltaBirthRate*3.5f);
//    DerevyankoReport::pop_a->setBreedingStrategy(breedStrat_a);
//	std::cout<<"pop_b -> pop_a\tPop dynamics coeffs have been changed:\td =\t";
//	std::cout<<(initBirthRate-deltaBirthRate*3.5f)<<std::endl;

//    for(; generation < 55/*7460*/; generation++){
//		std::cout<<"gen\t"<<generation<<std::endl;
//        DerevyankoReport::pop_a->breedAll();
//        DerevyankoReport::pop_a->mutationAll();

//        DerevyankoReport::pop_C->breedAll();
//        DerevyankoReport::pop_C->mutationAll();

//        DerevyankoReport::pop_D->breedAll();
//        DerevyankoReport::pop_D->mutationAll();

//        DerevyankoReport::pop_E->breedAll();
//        DerevyankoReport::pop_E->mutationAll();

//        DerevyankoReport::pop_F->breedAll();
//        DerevyankoReport::pop_F->mutationAll();

//        DerevyankoReport::pop_G->breedAll();
//        DerevyankoReport::pop_G->mutationAll();
//        DerevyankoReport::globalGenerations++;
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_F, 3);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_a, 9);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_G, 1);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_E, 6);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_D, 8);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_C, 10);
//	}

//	// Шаг 7.
//	// Разделение популяции a на A и B
//	// Далее эволюция 2540 поколений
//	// полумажорная ветка - это популяция A, ей остаётся 50% популяции,
//	// но чуть меньшая смертность.
//	// На протяжении эволюции миграции между A и B, а также из A в C, D, E, F (G выводится из эволюции)
//    DerevyankoReport::fraction_B_founder = 0.5f;
//    DerevyankoReport::pop_B = DerevyankoReport::pop_a->createSubpopulation(fraction_B_founder);
//	std::cout<<"pop_B has been created"<<std::endl;
	
//    DerevyankoReport::pop_A = DerevyankoReport::pop_a; // Остаток становится A
//	NeutralEvolutionBreedingStrategy* breedStrat_A =
//		dynamic_cast<NeutralEvolutionBreedingStrategy*>(PopulationBreedingStrategy::getInstance("neutral"));
//	breedStrat_A->setBirthRate(initBirthRate);
//	breedStrat_A->setDeathRate(initBirthRate-deltaBirthRate*4.f);
//    DerevyankoReport::pop_A->setBreedingStrategy(breedStrat_A);
//	std::cout<<"pop_a -> pop_A\tPop dynamics coeffs have been changed:\td =\t";
//	std::cout<<(initBirthRate-deltaBirthRate*4.f)<<std::endl;

//	// Вариант 1
//    DerevyankoReport::genPerMigr_A_B = 100;
//    DerevyankoReport::genPerMigr_A_C = 150;
//    DerevyankoReport::genPerMigr_A_D = 200;
//    DerevyankoReport::genPerMigr_A_E = 250;
//    DerevyankoReport::genPerMigr_A_F = 300;

//    DerevyankoReport::part_A_to_B = 0.01f;
//    DerevyankoReport::part_B_to_A = 0.01f;
//    DerevyankoReport::part_A_to_C = 0.005f;
//    DerevyankoReport::part_A_to_D = 0.005f;
//    DerevyankoReport::part_A_to_E = 0.005f;
//    DerevyankoReport::part_A_to_F = 0.005f;

//    for(; generation < 65/*10001*/; generation++){
//		std::cout<<"gen\t"<<generation<<std::endl;
//        DerevyankoReport::pop_A->breedAll();
//        DerevyankoReport::pop_A->mutationAll();

//        DerevyankoReport::pop_B->breedAll();
//        DerevyankoReport::pop_B->mutationAll();

//        DerevyankoReport::pop_C->breedAll();
//        DerevyankoReport::pop_C->mutationAll();

//        DerevyankoReport::pop_D->breedAll();
//        DerevyankoReport::pop_D->mutationAll();

//        DerevyankoReport::pop_E->breedAll();
//        DerevyankoReport::pop_E->mutationAll();

//        DerevyankoReport::pop_F->breedAll();
//        DerevyankoReport::pop_F->mutationAll();

//		if((generation % genPerMigr_A_B) == 0){
//            std::string code = BisexualPopulation::mutualMigration(DerevyankoReport::pop_A, DerevyankoReport::pop_B, part_A_to_B, part_B_to_A);
//			std::cout<<"Migration A<->B\t"<<code<<std::endl;
//		}
//		if((generation % genPerMigr_A_C) == 0){
//            std::string code = BisexualPopulation::mutualMigration(DerevyankoReport::pop_A, DerevyankoReport::pop_C, part_A_to_C, 0.f);
//			std::cout<<"Migration A->C\t"<<code<<std::endl;
//		}
//		if((generation % genPerMigr_A_D) == 0){
//            std::string code = BisexualPopulation::mutualMigration(DerevyankoReport::pop_A, DerevyankoReport::pop_D, part_A_to_D, 0.f);
//			std::cout<<"Migration A->D\t"<<code<<std::endl;
//		}
//		if((generation % genPerMigr_A_E) == 0){
//            std::string code = BisexualPopulation::mutualMigration(DerevyankoReport::pop_A, DerevyankoReport::pop_E, part_A_to_E, 0.f);
//			std::cout<<"Migration A->E\t"<<code<<std::endl;
//		}
//		if((generation % genPerMigr_A_F) == 0){
//            std::string code = BisexualPopulation::mutualMigration(DerevyankoReport::pop_A, DerevyankoReport::pop_F, part_A_to_F, 0.f);
//			std::cout<<"Migration A->F\t"<<code<<std::endl;
//		}
//        DerevyankoReport::globalGenerations++;
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_F, 3);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_A, 11);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_B, 12);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_E, 6);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_D, 8);
//        DerevyankoReport::fillVectors(DerevyankoReport::pop_C, 10);
//	}

//	// Конец эволюции - вывод статистики в файлы
//	std::ofstream file("GenStatistics.pop_A.fasta");
//    DerevyankoReport::pop_A->putGeneticStatisticsToStream(file);
//	file.close();

//	file.open("GenStatistics.pop_A.txt");
//    DerevyankoReport::pop_A->putGeneticSimpleStatisticsToStream(file);
//	file.close();

//	////////////////////////////////////////
//	file.open("GenStatistics.pop_B.fasta");
//    DerevyankoReport::pop_B->putGeneticStatisticsToStream(file);
//	file.close();

//	file.open("GenStatistics.pop_B.txt");
//    DerevyankoReport::pop_B->putGeneticSimpleStatisticsToStream(file);
//	file.close();
//	////////////////////////////////////////

//	////////////////////////////////////////
//	file.open("GenStatistics.pop_C.fasta");
//    DerevyankoReport::pop_C->putGeneticStatisticsToStream(file);
//	file.close();

//	file.open("GenStatistics.pop_C.txt");
//    DerevyankoReport::pop_C->putGeneticSimpleStatisticsToStream(file);
//	file.close();
//	////////////////////////////////////////

//	////////////////////////////////////////
//	file.open("GenStatistics.pop_D.fasta");
//    DerevyankoReport::pop_D->putGeneticStatisticsToStream(file);
//	file.close();

//	file.open("GenStatistics.pop_D.txt");
//    DerevyankoReport::pop_D->putGeneticSimpleStatisticsToStream(file);
//	file.close();
//	////////////////////////////////////////

//	////////////////////////////////////////
//	file.open("GenStatistics.pop_E.fasta");
//    DerevyankoReport::pop_E->putGeneticStatisticsToStream(file);
//	file.close();

//	file.open("GenStatistics.pop_E.txt");
//    DerevyankoReport::pop_E->putGeneticSimpleStatisticsToStream(file);
//	file.close();
//	////////////////////////////////////////

//	////////////////////////////////////////
//	file.open("GenStatistics.pop_F.fasta");
//    DerevyankoReport::pop_F->putGeneticStatisticsToStream(file);
//	file.close();

//	file.open("GenStatistics.pop_F.txt");
//    DerevyankoReport::pop_F->putGeneticSimpleStatisticsToStream(file);
//	file.close();
//	////////////////////////////////////////

//	////////////////////////////////////////
//	file.open("GenStatistics.pop_G.fasta");
//    DerevyankoReport::pop_G->putGeneticStatisticsToStream(file);
//	file.close();

//	file.open("GenStatistics.pop_G.txt");
//    DerevyankoReport::pop_G->putGeneticSimpleStatisticsToStream(file);
//	file.close();
//	////////////////////////////////////////

//	////////////////////////////////////////
//	file.open("GenStatistics.pop_flittle.fasta");
//    DerevyankoReport::pop_f->putGeneticStatisticsToStream(file);
//	file.close();

//	file.open("GenStatistics.pop_flittle.txt");
//    DerevyankoReport::pop_f->putGeneticSimpleStatisticsToStream(file);
//	file.close();
//	////////////////////////////////////////
}