Arg.hpp

/*
    Copyright 2009-2010 Stéphane De Mita, Mathieu Siol

    This file is part of the EggLib library.

    EggLib 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 3 of the License, or
    (at your option) any later version.

    EggLib 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 EggLib.  If not, see <http://www.gnu.org/licenses/>.
*/


#ifndef EGGLIB_ARG_HPP
#define EGGLIB_ARG_HPP


#include "Current.hpp"
#include "Edge.hpp"
#include <string>


namespace egglib {
    
    class Random;

    class Arg {

        public:
        
            Arg();

            
            void set(Current* current, unsigned int numberOfSegments);

            
            void reset(Current* current);


            Arg(Current* current, unsigned int numberOfSegments);

            
            virtual ~Arg();
            

            double time() const;
            

            void addTime(double increment);
            

            void coalescence(double incr, unsigned int pop, unsigned int index1, unsigned int index2);


            void coalescence(double incr, unsigned int pop, Random* random);


            void recombination(double incr, Random* random);
            

            Edge* mute(unsigned int segment, double treePosition);

            
            inline double ageUltimateMRCA() const {
                return _time;
            }
            

            inline double ageMRCA(unsigned int segmentIndex) {
                return _MRCA[segmentIndex]->bottom;
            }

            inline const Edge* MRCA(unsigned int segmentIndex) {
                return _MRCA[segmentIndex];
            }

            
            inline const Edge* uMRCA() {
                return edges[numberOfEdges-1];
            }
            
            
            unsigned int numberOfSegments;

            std::string newick(unsigned int segment);
            

            unsigned int numberOfSamples;


            double totalLength;

            double* segmentLengths;

            unsigned int numberOfEdges;

            unsigned int numberOfRecombinationEvents;
           
            void set_actualNumberOfSites(unsigned int actualNumberOfSites);
           
            
        private:
        
            Arg(const Arg&) { }
            
            Arg& operator=(const Arg&) { return *this; }

            void init_stable_parameters();
            void init_variable_parameters();
            void clear();
            void addEdge(Edge*);
            std::string rnewick(Edge* edge, unsigned int segment, double cache);

            Current* current;
            double _time;
            Edge** edges;
            
            void findMRCA(unsigned int segmentIndex);
            void computeTotalLength();
            void computeSegmentLength(unsigned int segmentIndex);

            unsigned int* numberOfEdgesPerSegment;
            Edge** _MRCA;
            
            EdgePool edgePool;
    };

}

#endif