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>
 
#ifdef STATE_SHOW_EVENTS
#include <iostream>
#endif // STATE_SHOW_EVENTS
 
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);
        PopulationEvent *getEarliestEvent(const std::vector<PersonBase *> &people);
        PersonalEventList *personalEventList(PersonBase *pPerson);
 
        PopulationStateAdvanced &m_popState;
        bool m_init;
 
#ifdef ALGORITHM_SHOW_EVENTS
        void showEvents(); // FOR DEBUGGING
#endif // ALGORITHM_SHOW_EVENTS
        void onAlgorithmLoop(bool finished);
 
        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;
}
 
inline void PopulationAlgorithmAdvanced::onAboutToFire(EventBase *pEvt)                                                                                         
{ 
#ifdef STATE_SHOW_EVENTS
        std::cerr << getTime() << "\t" << static_cast<PopulationEvent *>(pEvt)->getDescription(getTime()) << std::endl;
#endif // STATE_SHOW_EVENTS
 
        if (m_pOnAboutToFire) 
                m_pOnAboutToFire->onAboutToFire(static_cast<PopulationEvent *>(pEvt)); 
}
 
#endif // POPULATIONALGORITHMADVANCED_H