Sim.h

Go to the documentation of this file.

#ifndef SIMPT_SIM_H_
#define SIMPT_SIM_H_
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include "CoreData.h"
#include "bio/Mesh.h"
#include "math/RandomEngine.h"
#include "math/RandomEngineType.h"
#include "model/ComponentInterfaces.h"
#include "sim/event/SimEvent.h"
#include "sim/CoreData.h"
#include "sim/SimState.h"
#include "SimInterface.h"
#include "TimeSlicer.h"

#include "util/clock_man/Timeable.h"
#include "util/misc/Subject.h"

#include <boost/property_tree/ptree_fwd.hpp>
#include <functional>
#include <random>
#include <string>
#include <thread>
#include <mutex>

namespace SimPT_Sim {

class TimeSlicer;

class Sim : public SimPT_Sim::SimInterface,
            public SimPT_Sim::Util::Subject<SimPT_Sim::Event::SimEvent, std::weak_ptr<const void>>,
            public std::enable_shared_from_this<Sim>
{
public:
        Sim();

        Sim(const Sim& other) =delete;

        Sim& operator=(const Sim& other);

        virtual ~Sim();

        CoreData& GetCoreData() override final { return m_cd; }

        const boost::property_tree::ptree& GetParameters() const;

        std::string GetProjectName() const;

        std::string GetRunDate() const;

        int GetSimStep() const;

        double GetSimTime() const;

        SimState GetState() const;

        std::string GetStatusMessage() const;

        Timings GetTimings() const;

        void Initialize(const boost::property_tree::ptree& pt);

        void Initialize(const SimState& sim_state);

        bool IsAtTermination() const;

        bool IsStationary() const;

        void Reinitialize(const boost::property_tree::ptree& p);

        void ResetTimings();

        std::unique_ptr<TimeSlicer> TimeSlicing();

        void TimeStep();

        boost::property_tree::ptree ToPtree() const;

private:
        friend class TimeSlicer;

        void TimeSliceGo(const std::lock_guard<std::mutex>&, double time_slice, SimPhase phase = SimPhase::NONE);

        void TimeSliceSetup(const std::lock_guard<std::mutex>&);

        void TimeSliceWrapup(const std::lock_guard<std::mutex>&);

private:
        bool RandomEngineInitialize(const boost::property_tree::ptree& pt);

        bool RandomEngineInitialize(const SimState& sim_state);

private:
        bool                   m_is_stationary;    
        CoreData               m_cd;               
        std::string            m_project_name;     
        std::string            m_run_date;         
        TimeEvolverComponent   m_time_evolver;     
        std::mutex             m_timestep_mutex;   
        Timings                m_timings;          
};

} // namespace

#endif // end_of_include_guard