populationalgorithmadvanced.h

Go to the documentation of this file.

#ifndef POPULATIONALGORITHMADVANCED_H

#define POPULATIONALGORITHMADVANCED_H

#include "algorithm.h"
#include "mutex.h"
#include "personbase.h"
#include "populationinterfaces.h"
#include "populationevent.h"
#include "personaleventlist.h"
#include <assert.h>

class GslRandomNumberGenerator;
class PersonBase;
class PopulationEvent;
class PopulationStateAdvanced;

class PopulationAlgorithmAdvanced : public Algorithm, public PopulationAlgorithmInterface
{
public:
        PopulationAlgorithmAdvanced(PopulationStateAdvanced &state, GslRandomNumberGenerator &rng, bool parallel);
        ~PopulationAlgorithmAdvanced();

        bool_t init();

        bool isParallel() const                                                 { return m_parallel; }
        bool_t run(double &tMax, int64_t &maxEvents, double startTime = 0);
        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;

        double getTime() const                                                                                                                  { return Algorithm::getTime(); }
        GslRandomNumberGenerator *getRandomNumberGenerator() const                                              { return Algorithm::getRandomNumberGenerator(); }

        void setAboutToFireAction(PopulationAlgorithmAboutToFireInterface *pAction)             { m_pOnAboutToFire = pAction; }
private:
        bool_t initEventTimes() const;
        bool_t getNextScheduledEvent(double &dt, EventBase **ppEvt);
        void advanceEventTimes(EventBase *pScheduledEvent, double dt);
        void onAboutToFire(EventBase *pEvt)                                                                                             { if (m_pOnAboutToFire) m_pOnAboutToFire->onAboutToFire(static_cast<PopulationEvent *>(pEvt)); }
        PopulationEvent *getEarliestEvent(const std::vector<PersonBase *> &people);
        PersonalEventList *personalEventList(PersonBase *pPerson);

        PopulationStateAdvanced &m_popState;
        bool m_init;

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

        int64_t getNextEventID();

#ifndef DISABLEOPENMP
        Mutex m_eventsToRemoveMutex;
#endif // !DISABLEOPENMP
        std::vector<EventBase *> m_eventsToRemove;

        // For the parallel version
        bool m_parallel;

        int64_t m_nextEventID;
#ifndef DISABLEOPENMP
        Mutex m_nextEventIDMutex;
#endif // !DISABLEOPENMP

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

#ifndef DISABLEOPENMP
        mutable std::vector<Mutex> m_eventMutexes;
#endif // !DISABLEOPENMP

        PopulationAlgorithmAboutToFireInterface *m_pOnAboutToFire;
};

inline int64_t PopulationAlgorithmAdvanced::getNextEventID()
{
#ifndef DISABLEOPENMP
        if (m_parallel)
                m_nextEventIDMutex.lock();
#endif // !DISABLEOPENMP
        
        int64_t id = m_nextEventID++;

#ifndef DISABLEOPENMP
        if (m_parallel)
                m_nextEventIDMutex.unlock();
#endif // !DISABLEOPENMP

        return id;
}

inline PersonalEventList *PopulationAlgorithmAdvanced::personalEventList(PersonBase *pPerson)
{
        assert(pPerson);
        PersonalEventList *pEvtList = static_cast<PersonalEventList *>(pPerson->getAlgorithmInfo());
        assert(pEvtList);
        return pEvtList;
}

#endif // POPULATIONALGORITHMADVANCED_H