ActuatorModel.H

Go to the documentation of this file.

#ifndef ACTUATORMODEL_H
#define ACTUATORMODEL_H
 
#include "src/core/Factory.H"
#include "src/wind_energy/actuator/actuator_types.H"
#include "src/wind_energy/actuator/actuator_ops.H"
#include "src/wind_energy/actuator/ActSrcLineOp.H"
#include "src/wind_energy/actuator/turbine/ActSrcDiskOp_Turbine.H"
#include "src/wind_energy/actuator/disk/ActSrcDiskOp.H"
#include "src/wind_energy/actuator/ActParser.H"
 
namespace kynema_sgf {
 
class CFDSim;
 
namespace actuator {

class ActuatorModel
    : public Factory<ActuatorModel, CFDSim&, const std::string&, const int>
{
public:
    static std::string base_identifier() { return "ActuatorModel"; }
 
    ~ActuatorModel() override = default;
 
    [[nodiscard]] virtual const std::string& label() const = 0;
 
    [[nodiscard]] virtual int id() const = 0;
 
    [[nodiscard]] virtual const ActInfo& info() const = 0;
 
    virtual ActInfo& info() = 0;
 
    virtual void read_inputs(const utils::ActParser&) = 0;
 
    virtual void determine_influenced_procs() = 0;
 
    virtual void determine_root_proc(amrex::Vector<int>&) = 0;
 
    virtual void init_actuator_source() = 0;
 
    [[nodiscard]] virtual int num_velocity_points() const = 0;
 
    virtual void update_positions(VecSlice&) = 0;
 
    virtual void update_fields(const VecSlice&, const RealSlice&) = 0;
 
    virtual void compute_forces() = 0;
 
    virtual void compute_source_term(
        int lev, const amrex::MFIter& mfi, const amrex::Geometry& geom) = 0;
 
    virtual void prepare_outputs(const std::string&) = 0;
 
    virtual void write_outputs() = 0;
};

template <typename ActTrait, typename SrcTrait = ActSrcLine>
class ActModel : public ActuatorModel::Register<ActModel<ActTrait, SrcTrait>>
{
private:
    typename ActTrait::DataType m_data;

    ops::ActSrcOp<ActTrait, SrcTrait> m_src_op;

    ops::ProcessOutputsOp<ActTrait, SrcTrait> m_out_op;
 
public:
    static std::string identifier()
    {
        return ActTrait::identifier() + SrcTrait::identifier();
    }

    ActModel(CFDSim& sim, const std::string& label, const int id)
        : m_data(sim, label, id), m_src_op(m_data), m_out_op(m_data)
    {}

    [[nodiscard]] const std::string& label() const override
    {
        return m_data.info().label;
    }

    [[nodiscard]] int id() const override { return m_data.info().id; }

    [[nodiscard]] const ActInfo& info() const override { return m_data.info(); }

    ActInfo& info() override { return m_data.info(); }

    [[nodiscard]] const auto& meta() const { return m_data.meta(); }

    [[nodiscard]] const auto& grid() const { return m_data.grid(); }
 
    void read_inputs(const utils::ActParser& pp) override
    {
        ops::ReadInputsOp<ActTrait, SrcTrait>()(m_data, pp);
        m_out_op.read_io_options(pp);
    }
 
    void determine_influenced_procs() override
    {
        ops::determine_influenced_procs<ActTrait>(m_data);
    }
 
    void determine_root_proc(amrex::Vector<int>& act_proc_count) override;
 
    [[nodiscard]] int num_velocity_points() const override;
 
    void update_positions(VecSlice& pos) override
    {
        ops::UpdatePosOp<ActTrait, SrcTrait>()(m_data);
        const auto& vpos = m_data.grid().vel_pos;
        std::copy(vpos.begin(), vpos.end(), pos.begin());
    }
 
    void update_fields(const VecSlice& vel, const RealSlice& density) override
    {
        std::copy(vel.begin(), vel.end(), m_data.grid().vel.begin());
        std::copy(
            density.begin(), density.end(), m_data.grid().density.begin());
        ops::UpdateVelOp<ActTrait, SrcTrait>()(m_data);
    }
 
    void compute_forces() override
    {
        ops::ComputeForceOp<ActTrait, SrcTrait>()(m_data);
        m_src_op.setup_op();
    }
 
    void compute_source_term(
        const int lev,
        const amrex::MFIter& mfi,
        const amrex::Geometry& geom) override
    {
        m_src_op(lev, mfi, geom);
    }
 
    void prepare_outputs(const std::string& out_dir) override
    {
        m_out_op.prepare_outputs(out_dir);
    }
 
    void write_outputs() override { m_out_op.write_outputs(); }
 
    void init_actuator_source() override
    {
        ops::InitDataOp<ActTrait, SrcTrait>()(m_data);
        m_src_op.initialize();
    }
};
 
template <typename ActTrait, typename SrcTrait>
void ActModel<ActTrait, SrcTrait>::determine_root_proc(
    amrex::Vector<int>& act_proc_count)
{
    ops::determine_root_proc<ActTrait>(m_data, act_proc_count);
    {
        // Sanity checks
        const auto& linfo = m_data.info();
        const auto& plist = linfo.procs;
        AMREX_ALWAYS_ASSERT(linfo.root_proc > -1);
        AMREX_ALWAYS_ASSERT(plist.find(linfo.root_proc) != plist.end());
    }
}
 
template <typename ActTrait, typename SrcTrait>
int ActModel<ActTrait, SrcTrait>::num_velocity_points() const
{
    const auto& linfo = m_data.info();
    auto& grid = m_data.grid();
 
    return (linfo.sample_vel_in_proc) ? grid.vel.size() : 0;
}
 
} // namespace actuator
} // namespace kynema_sgf
 
#endif /* ACTUATORMODEL_H */