population.h

Go to the documentation of this file.

#ifndef POPULATION_H

#define POPULATION_H

//#define SIMPLEMNRM -> now defined using the CMakeList.txt file

#include "simplestate.h"
#include "mutex.h"

class GslRandomNumberGenerator;
class PersonBase;
class PopulationEvent;

#ifndef SIMPLEMNRM
class Population : public State
#else
class Population : public SimpleState
#endif // SIMPLEMNRM
{
public:
        Population(bool parallel, GslRandomNumberGenerator *pRng);
        ~Population();

        bool isParallel() const                                                 { return m_parallel; }
        
        bool run(double &tMax, int64_t &maxEvents, double startTime = 0)        { return State::evolve(tMax, maxEvents, startTime, false); }

        PersonBase **getAllPeople()                                             { if (m_people.size() == 0) return 0; return &(m_people[0]); }

        PersonBase **getMen();

        PersonBase **getWomen();

        int getNumberOfPeople() const                                           { return m_people.size(); }

        int getNumberOfMen() const                                              { return m_numMen; }

        int getNumberOfWomen() const                                            { return m_numWomen; }

        void addNewPerson(PersonBase *pPerson);

        void setPersonDied(PersonBase *pPerson);

        void onNewEvent(PopulationEvent *pEvt);

        // TODO: shield these from the user somehow? These functions should not be used
        //       directly by the user, they are used internally by the algorithm
        void scheduleForRemoval(PopulationEvent *pEvt);
        void lockEvent(PopulationEvent *pEvt) const;
        void unlockEvent(PopulationEvent *pEvt) const;
        void lockPerson(PersonBase *pPerson) const;
        void unlockPerson(PersonBase *pPerson) const;
private:
        bool initEventTimes() const;
#ifndef SIMPLEMNRM
        EventBase *getNextScheduledEvent(double &dt);
        void advanceEventTimes(EventBase *pScheduledEvent, double dt);
#else
        const std::vector<EventBase *> &getCurrentEvents() const                                        { return m_allEvents; }
        void onFiredEvent(EventBase *pEvt, int position);

        std::vector<EventBase *> m_allEvents;
#endif // SIMPLEMNRM

#ifdef STATE_SHOW_EVENTS
        void showEvents(); // FOR DEBUGGING
#endif // STATE_SHOW_EVENTS
        void onAlgorithmLoop();

        PopulationEvent *getEarliestEvent(const std::vector<PersonBase *> &people);
        int64_t getNextEventID();
        int64_t getNextPersonID();
        
        // These are living persons, the first part men, the second are women
        std::vector<PersonBase *> m_people;
        int m_numMen, m_numWomen;

        // Deceased persons
        std::vector<PersonBase *> m_deceasedPersons;

        Mutex m_eventsToRemoveMutex;
        std::vector<EventBase *> m_eventsToRemove;

        // For the parallel version
        bool m_parallel;

        int64_t m_nextEventID, m_nextPersonID;
        Mutex m_nextEventIDMutex, m_nextPersonIDMutex;

        std::vector<PopulationEvent *> m_tmpEarliestEvents;
        std::vector<double> m_tmpEarliestTimes;

        mutable std::vector<Mutex> m_eventMutexes;
        mutable std::vector<Mutex> m_personMutexes;
};

inline int64_t Population::getNextEventID()
{
        if (m_parallel)
                m_nextEventIDMutex.lock();
        
        int64_t id = m_nextEventID++;

        if (m_parallel)
                m_nextEventIDMutex.unlock();

        return id;
}

inline int64_t Population::getNextPersonID()
{
        if (m_parallel)
                m_nextPersonIDMutex.lock();
        
        int64_t id = m_nextPersonID++;

        if (m_parallel)
                m_nextPersonIDMutex.unlock();

        return id;
}

#ifdef NDEBUG

inline PersonBase **Population::getMen()
{
        if (m_numMen == 0)
                return 0;

        return &(m_people[0]);
}

inline PersonBase **Population::getWomen()
{
        if (m_numWomen == 0)
                return 0;

        return &(m_people[m_numMen]);
}

#endif // NDEBUG

#endif // POPULATION_H