dummy.hh

Go to the documentation of this file.

#ifndef UTOPIA_MODELS_DUMMY_HH
#define UTOPIA_MODELS_DUMMY_HH
 
#include <utopia/core/model.hh>
 
 
namespace Utopia {
namespace Models {
namespace Dummy {
 
using DummyTypes = ModelTypes<>;
 
 
class Dummy : public Model<Dummy, DummyTypes>
{
public:
    using Base = Model<Dummy, DummyTypes>;
 
    using Data = std::vector<double>;
 
    // Type shortcut for dataset
    using DataSet = Base::DataSet;
 
private:
    Data _state;
 
    Data _bc;
 
    std::shared_ptr<DataSet> _dset_state;
 
public:
 
    template <class ParentModel>
    Dummy (
        const std::string& name,
        const ParentModel& parent_model,
        const Data& initial_state,
        const DataIO::Config& custom_cfg = {}
    )
    :
        // Use the base constructor for the main parts
        Base(name, parent_model, custom_cfg),
 
        // Initialise state and boundary condition members
        _state(initial_state),
        _bc(_state.size(), 1.0),
        _dset_state(this->create_dset("state", {_state.size()}))
    {}
 
 
 
    void perform_step()
    {
        // Write some random numbers into the state vector
        auto gen = std::bind(std::uniform_real_distribution<>(), *this->_rng);
        std::generate(_bc.begin(), _bc.end(), gen);
        std::transform(_state.begin(), _state.end(),
                       _bc.begin(), _state.begin(),
                       [](const auto a, const auto b) { return a + b; });
    }
 
 
 
    void monitor ()
    {
        // Supply the state mean to the monitor
        _monitor.set_by_func("state_mean", [this](){
            const double sum = std::accumulate(this->_state.begin(),
                                               this->_state.end(),
                                               0);
            return sum / this->_state.size();
        });
    }
 
 
    void write_data()
    {
        _dset_state->write(_state.begin(), _state.end(),
                           [](auto& value) { return value; });
    }
 
 
    // -- Getters and Setters -- //
 
};
 
} // namespace Dummy
} // namespace Models
} // namespace Utopia
 
#endif // UTOPIA_MODELS_DUMMY_HH