turbine_kynema_fmb_ops.H

Go to the documentation of this file.

#ifndef TURBINE_KYNEMA_FMB_OPS_H
#define TURBINE_KYNEMA_FMB_OPS_H
 
#include <numbers>
#include <yaml-cpp/yaml.h>
#include "src/wind_energy/actuator/turbine/kynema_fmb/TurbineKynemaFMB.H"
#include "src/wind_energy/actuator/turbine/external/turbine_external_ops.H"
#include "AMReX_REAL.H"
 
using namespace amrex::literals;
 
namespace kynema_sgf::actuator::ops {
 
template <typename SrcTrait>
struct ReadInputsOp<TurbineKynemaFMB, SrcTrait>
{
    void
    operator()(TurbineKynemaFMB::DataType& data, const utils::ActParser& pp)
    {
        auto& tf = data.meta().ext_data;
        // Always need an input file
        pp.get("kynema_fmb_input_file", tf.input_file);
        // Get hub height and turbine diameter from turbine input,
        // not Kynema-SGF input file
        const YAML::Node wio = YAML::LoadFile(tf.input_file);
        {
            const auto& wio_blade = wio["components"]["blade"];
            const auto& ref_axis = wio_blade["reference_axis"];
            const auto z_values =
                ref_axis["z"]["values"].as<std::vector<amrex::Real>>();
            data.info().rotor_diameter = 2.0_rt * z_values[z_values.size() - 1];
        }
        {
            const auto& wio_tower = wio["components"]["tower"];
            const auto& tower_ref_axis = wio_tower["reference_axis"];
            const auto z_values =
                tower_ref_axis["z"]["values"].as<std::vector<amrex::Real>>();
            data.info().hub_height = z_values[z_values.size() - 1];
        }
 
        read_ops<TurbineKynemaFMB::DataType>(data, pp);
 
        // Avoid using directly specified "modes"
        // Use a restart file if included
 
        pp.query("kynema_fmb_restart_step", tf.checkpoint_file);
 
        std::string sim_mode = "init";
        if (!tf.checkpoint_file.empty()) {
            std::string checkpoint_dir = ".";
            pp.query("kynema_fmb_restart_directory", checkpoint_dir);
            int checkpoint_step = std::stoi(tf.checkpoint_file);
            tf.time_index = checkpoint_step;
            tf.checkpoint_file =
                checkpoint_dir + "/" +
                sgf_fmb::checkpoint_filename(checkpoint_step, tf.tlabel);
            sim_mode = "restart";
            AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
                amrex::FileSystem::Exists(tf.checkpoint_file),
                "turbine_kynema_fmb_ops: Cannot find Kynema-FMB checkpoint "
                "file: " +
                    tf.checkpoint_file);
        }
        if (sim_mode == "init") {
            tf.sim_mode = ::ext_turb::SimMode::init;
            amrex::Print() << "Initializing turbine: " << tf.tlabel
                           << std::endl;
        } else {
            tf.sim_mode = ::ext_turb::SimMode::restart;
            amrex::Print() << "Restarting turbine: " << tf.tlabel << std::endl;
        }
 
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
            amrex::FileSystem::Exists(tf.input_file),
            "turbine_kynema_fmb_ops: Cannot find Kynema-FMB input file: " +
                tf.input_file);
 
        pp.query(
            "controller_shared_library_path", tf.controller_shared_lib_path);
        pp.query("controller_input_file", tf.controller_input_file);
 
        // Do Kynema-SGF inputs specific to kynema_fmb turbine
        tf.fluid_density = data.meta().density;
 
        tf.dt_ext = -1.;
        pp.query("dt", tf.dt_ext);
        if (tf.dt_ext < 0.0_rt) {
            tf.dt_ext = tf.dt_cfd;
        }
 
        // One-way coupling flag for aerodynamic loads
        pp.query("decouple_structure_from_aero_loading", tf.one_way_coupled);
 
        // Number of beam elements read in from file
        pp.get("num_struct_nodes_blade", tf.num_blade_elem);
        pp.get("num_struct_nodes_tower", tf.num_tower_elem);
        // Section refinement for blades and tower
        pp.query("section_ref_blade", tf.section_refinement_blade);
        pp.query("section_ref_tower", tf.section_refinement_tower);
        // Initial or constant angular rotation speed
        pp.query("rot_speed_radps", tf.rotational_speed);
        if (!pp.contains("rot_speed_radps")) {
            pp.query("rot_speed_rpm", tf.rotational_speed);
            tf.rotational_speed *=
                2.0_rt * std::numbers::pi_v<amrex::Real> / 60.0_rt;
        }
        // Initial generator speed
        pp.query("generator_power_init", tf.generator_power);
        // Initial wind speed
        amrex::Vector<amrex::Real> vel_vec{tf.wind_speed, 0., 0.};
        pp.queryarr("hub_wind_vector_init", vel_vec);
        tf.wind_speed = std::sqrt(
            vel_vec[0] * vel_vec[0] + vel_vec[1] * vel_vec[1] +
            vel_vec[2] * vel_vec[2]);
        // Initial or constant nacelle yaw
        pp.query("yaw_rad", tf.yaw);
        if (!pp.contains("yaw_rad")) {
            pp.query("yaw_deg", tf.yaw);
            tf.yaw *= std::numbers::pi_v<amrex::Real> / 180.0_rt;
        }
        // Generator efficiency
        pp.query("generator_efficiency", tf.generator_efficiency);
    }
};
 
template <>
void determine_influenced_procs<TurbineKynemaFMB>(
    typename TurbineKynemaFMB::DataType& data)
{
    external_determine_influenced_procs<TurbineKynemaFMB::DataType>(data);
}
 
template <>
void determine_root_proc<TurbineKynemaFMB>(
    typename TurbineKynemaFMB::DataType& data,
    amrex::Vector<int>& act_proc_count)
{
    external_determine_root_proc<
        TurbineKynemaFMB::DataType, ::ext_turb::KynemaFMBTurbine,
        ::ext_turb::KynemaFMBSolverData>(data, act_proc_count);
}
 
template <typename SrcTrait>
struct InitDataOp<TurbineKynemaFMB, SrcTrait>
{
    void operator()(TurbineKynemaFMB::DataType& data)
    {
        BL_PROFILE("kynema-sgf::InitDataOp<TurbineKynemaFMB>");
        init_data_op<TurbineKynemaFMB::DataType>(data);
    }
};
 
template <typename SrcTrait>
struct UpdatePosOp<TurbineKynemaFMB, SrcTrait>
{
    void operator()(typename TurbineKynemaFMB::DataType& data)
    {
        BL_PROFILE("kynema-sgf::actuator::UpdatePosOp<TurbineKynemaFMB>");
        update_pos_op<TurbineKynemaFMB::DataType>(data);
    }
};
 
template <typename SrcTrait>
struct UpdateVelOp<TurbineKynemaFMB, SrcTrait>
{
    void operator()(typename TurbineKynemaFMB::DataType& data)
    {
        BL_PROFILE("kynema-sgf::actuator::UpdateVelOp<TurbineKynemaFMB>");
        update_vel_op<TurbineKynemaFMB::DataType>(data);
    }
};
 
template <typename SrcTrait>
struct ComputeForceOp<TurbineKynemaFMB, SrcTrait>
{
    void operator()(typename TurbineKynemaFMB::DataType& data)
    {
        BL_PROFILE("kynema-sgf::actuator::ComputeForceOp<TurbineKynemaFMB>");
        compute_force_op<TurbineKynemaFMB::DataType>(data);
    }
};
 
template <typename SrcTrait>
struct ProcessOutputsOp<TurbineKynemaFMB, SrcTrait>
{
private:
    typename TurbineKynemaFMB::DataType& m_data;

    std::string m_out_dir;

    std::string m_nc_filename;

    int m_out_freq{10};
 
public:
    explicit ProcessOutputsOp(typename TurbineKynemaFMB::DataType& data)
        : m_data(data)
    {}
 
    void read_io_options(const utils::ActParser& pp)
    {
        pp.query("output_frequency", m_out_freq);
    }
 
    void prepare_outputs(const std::string& out_dir)
    {
        m_nc_filename = out_dir + "/" + m_data.info().label + ".nc";
        utils::prepare_netcdf_file(
            m_nc_filename, m_data.meta(), m_data.info(), m_data.grid());
    }
 
    void write_outputs()
    {
        const auto& time = m_data.sim().time();
        const int tidx = time.time_index();
        if ((m_out_freq > 0) && (tidx % m_out_freq != 0)) {
            return;
        }
 
        utils::write_netcdf(
            m_nc_filename, m_data.meta(), m_data.info(), m_data.grid(),
            time.new_time());
    }
};
 
} // namespace kynema_sgf::actuator::ops
 
#endif /* TURBINE_KYNEMA_FMB_OPS_H */