WindFarm Class Reference

Manage a collection of wind turbine models. More...

#include <ERF_WindFarm.H>

Inheritance diagram for WindFarm:

Collaboration diagram for WindFarm:

Public Member Functions
	WindFarm ()
virtual	~WindFarm ()=default
	WindFarm (int nlev, const WindFarmType &a_windfarm_type)
void	read_tables (std::string windfarm_loc_table, std::string windfarm_spec_table, bool x_y, bool lat_lon, const amrex::Real windfarm_x_shift=zero, const amrex::Real windfarm_y_shift=zero)
	Read turbine location and specification tables. More...
void	init_windfarm_lat_lon (const std::string windfarm_loc_table, const amrex::Real windfarm_x_shift, const amrex::Real windfarm_y_shift)
	Initialize wind farm using latitude and longitude coordinates. More...
void	init_windfarm_x_y (const std::string windfarm_loc_table)
	Initialize wind farm using Cartesian coordinates. More...
void	read_windfarm_locations_table (const std::string windfarm_loc_table, bool x_y, bool lat_lon, const amrex::Real windfarm_x_shift=zero, const amrex::Real windfarm_y_shift=zero)
	Read the turbine location table. More...
void	read_windfarm_spec_table (const std::string windfarm_spec_table)
	Read the turbine specification table. More...
void	read_windfarm_blade_table (const std::string windfarm_blade_table)
	Read the turbine blade table. More...
void	read_windfarm_airfoil_tables (const std::string windfarm_airfoil_tables, const std::string windfarm_blade_table)
	Read the airfoil tables. More...
void	read_windfarm_spec_table_extra (const std::string windfarm_spec_table_extra)
	Read extra turbine specifications. More...
void	fill_Nturb_multifab (const amrex::Geometry &geom, amrex::MultiFab &mf_Nturb, std::unique_ptr< amrex::MultiFab > &z_phys_nd)
	Fill the turbine count MultiFab. More...
void	fill_SMark_multifab (const amrex::Geometry &geom, amrex::MultiFab &mf_SMark, const amrex::Real &sampling_distance_by_D, const amrex::Real &turb_disk_angle, std::unique_ptr< amrex::MultiFab > &z_phys_cc)
	Fill the SMark MultiFab. More...
void	fill_SMark_multifab_mesoscale_models (const amrex::Geometry &geom, amrex::MultiFab &mf_SMark, const amrex::MultiFab &mf_Nturb, std::unique_ptr< amrex::MultiFab > &z_phys_cc)
	Fill the SMark MultiFab for mesoscale models. More...
void	write_turbine_locations_vtk ()
	Write turbine locations to a VTK file. More...
void	write_actuator_disks_vtk (const amrex::Geometry &geom, const amrex::Real &sampling_distance_by_D)
	Write actuator disks to a VTK file. More...
void	advance (const amrex::Geometry &a_geom, const double &dt_advance, amrex::MultiFab &cons_in, amrex::MultiFab &mf_vars_windfarm, amrex::MultiFab &U_old, amrex::MultiFab &V_old, amrex::MultiFab &W_old, const amrex::MultiFab &mf_Nturb, const amrex::MultiFab &mf_SMark, const double &time) override
	Advance the wind farm model in time. More...
void	set_turb_spec (const amrex::Real &a_rotor_rad, const amrex::Real &a_hub_height, const amrex::Real &a_thrust_coeff_standing, const amrex::Vector< amrex::Real > &a_wind_speed, const amrex::Vector< amrex::Real > &a_thrust_coeff, const amrex::Vector< amrex::Real > &a_power) override
	Set general turbine specifications. More...
void	set_turb_loc (const amrex::Vector< amrex::Real > &a_xloc, const amrex::Vector< amrex::Real > &a_yloc) override
	Set turbine locations. More...
void	set_turb_disk_angle (const amrex::Real &a_turb_disk_angle) override
	Set the turbine disk angle. More...
void	set_blade_spec (const amrex::Vector< amrex::Real > &a_bld_rad_loc, const amrex::Vector< amrex::Real > &a_bld_twist, const amrex::Vector< amrex::Real > &a_bld_chord) override
	Set blade specifications. More...
void	set_blade_airfoil_spec (const amrex::Vector< amrex::Vector< amrex::Real >> &a_bld_airfoil_aoa, const amrex::Vector< amrex::Vector< amrex::Real >> &a_bld_airfoil_Cl, const amrex::Vector< amrex::Vector< amrex::Real >> &a_bld_airfoil_Cd) override
	Set blade airfoil specifications. More...
void	set_turb_spec_extra (const amrex::Vector< amrex::Real > &a_velocity, const amrex::Vector< amrex::Real > &a_C_P, const amrex::Vector< amrex::Real > &a_C_T, const amrex::Vector< amrex::Real > &a_rotor_RPM, const amrex::Vector< amrex::Real > &a_blade_pitch) override
	Set extra turbine specifications. More...
Public Member Functions inherited from NullWindFarm
	NullWindFarm ()
virtual	~NullWindFarm ()=default
void	get_turb_spec (amrex::Real &rotor_rad, amrex::Real &hub_height, amrex::Real &thrust_coeff_standing, amrex::Vector< amrex::Real > &wind_speed, amrex::Vector< amrex::Real > &thrust_coeff, amrex::Vector< amrex::Real > &power)
void	get_turb_loc (amrex::Vector< amrex::Real > &xloc, amrex::Vector< amrex::Real > &yloc)
void	get_turb_disk_angle (amrex::Real &turb_disk_angle)
void	get_blade_spec (amrex::Vector< amrex::Real > &bld_rad_loc, amrex::Vector< amrex::Real > &bld_twist, amrex::Vector< amrex::Real > &bld_chord)
void	get_blade_airfoil_spec (amrex::Vector< amrex::Vector< amrex::Real >> &bld_airfoil_aoa, amrex::Vector< amrex::Vector< amrex::Real >> &bld_airfoil_Cl, amrex::Vector< amrex::Vector< amrex::Real >> &bld_airfoil_Cd)
void	get_turb_spec_extra (amrex::Vector< amrex::Real > &velocity, amrex::Vector< amrex::Real > &C_P, amrex::Vector< amrex::Real > &C_T, amrex::Vector< amrex::Real > &rotor_RPM, amrex::Vector< amrex::Real > &blade_pitch)

Protected Member Functions
template<class NewWindFarmModel >
void	SetModel ()
	Create and set the specified windfarm model. More...

Protected Attributes
amrex::Vector< amrex::Real >	xloc
amrex::Vector< amrex::Real >	yloc
amrex::Vector< amrex::Real >	zloc
amrex::Real	my_turb_disk_angle
amrex::Real	hub_height
amrex::Real	rotor_rad
amrex::Real	thrust_coeff_standing
amrex::Real	nominal_power
amrex::Vector< amrex::Real >	wind_speed
amrex::Vector< amrex::Real >	thrust_coeff
amrex::Vector< amrex::Real >	power
amrex::Vector< amrex::Real >	bld_rad_loc
amrex::Vector< amrex::Real >	bld_twist
amrex::Vector< amrex::Real >	bld_chord
amrex::Vector< amrex::Vector< amrex::Real > >	bld_airfoil_aoa
amrex::Vector< amrex::Vector< amrex::Real > >	bld_airfoil_Cl
amrex::Vector< amrex::Vector< amrex::Real > >	bld_airfoil_Cd
int	n_bld_sections
amrex::Vector< amrex::Real >	velocity
amrex::Vector< amrex::Real >	C_P
amrex::Vector< amrex::Real >	C_T
amrex::Vector< amrex::Real >	rotor_RPM
amrex::Vector< amrex::Real >	blade_pitch
Protected Attributes inherited from NullWindFarm
amrex::Vector< amrex::Real >	m_xloc
amrex::Vector< amrex::Real >	m_yloc
amrex::Real	m_turb_disk_angle
amrex::Real	m_hub_height
amrex::Real	m_rotor_rad
amrex::Real	m_thrust_coeff_standing
amrex::Real	m_nominal_power
amrex::Vector< amrex::Real >	m_wind_speed
amrex::Vector< amrex::Real >	m_thrust_coeff
amrex::Vector< amrex::Real >	m_power
amrex::Vector< amrex::Real >	m_bld_rad_loc
amrex::Vector< amrex::Real >	m_bld_twist
amrex::Vector< amrex::Real >	m_bld_chord
amrex::Vector< amrex::Vector< amrex::Real > >	m_bld_airfoil_aoa
amrex::Vector< amrex::Vector< amrex::Real > >	m_bld_airfoil_Cl
amrex::Vector< amrex::Vector< amrex::Real > >	m_bld_airfoil_Cd
amrex::Vector< amrex::Real >	m_velocity
amrex::Vector< amrex::Real >	m_C_P
amrex::Vector< amrex::Real >	m_C_T
amrex::Vector< amrex::Real >	m_rotor_RPM
amrex::Vector< amrex::Real >	m_blade_pitch

Private Attributes
amrex::Vector< std::unique_ptr< NullWindFarm > >	m_windfarm_model

Additional Inherited Members
Static Public Member Functions inherited from NullWindFarm
static AMREX_GPU_DEVICE bool	find_if_marked (amrex::Real x1, amrex::Real x2, amrex::Real y1, amrex::Real y2, amrex::Real x0, amrex::Real y0, amrex::Real nx, amrex::Real ny, amrex::Real d_hub_height, amrex::Real d_rotor_rad, amrex::Real z)

Detailed Description

Manage a collection of wind turbine models.

Constructor & Destructor Documentation

WindFarm() [1/2]

WindFarm::WindFarm ( )

inline

{}

~WindFarm()

virtual WindFarm::~WindFarm ( )

virtualdefault

WindFarm() [2/2]

WindFarm::WindFarm ( int  nlev, const WindFarmType &  a_windfarm_type  )

inline

    {
        m_windfarm_model.resize(nlev);
        if (a_windfarm_type == WindFarmType::Fitch) {
            SetModel<Fitch>();
            amrex::Print() << "Fitch windfarm model!\n";
        }
        else if (a_windfarm_type == WindFarmType::EWP) {
            SetModel<EWP>();
            amrex::Print() << "EWP windfarm model!\n";
        }
        else if (a_windfarm_type == WindFarmType::SimpleAD) {
            SetModel<SimpleAD>();
            amrex::Print() << "Simplified actuator disk windfarm model!\n";
        }
        else if (a_windfarm_type == WindFarmType::GeneralAD) {
            SetModel<GeneralAD>();
            amrex::Print() << "Generalized actuator disk windfarm model!\n";
        }
         else {
            amrex::Abort("WindFarm: Dont know this windfarm_type!") ;
        }
    }

Member Function Documentation

advance()

void WindFarm::advance ( const amrex::Geometry &  a_geom, const double &  dt_advance, amrex::MultiFab &  cons_in, amrex::MultiFab &  mf_vars_windfarm, amrex::MultiFab &  U_old, amrex::MultiFab &  V_old, amrex::MultiFab &  W_old, const amrex::MultiFab &  mf_Nturb, const amrex::MultiFab &  mf_SMark, const double &  time  )

inlineoverridevirtual

Advance the wind farm model in time.

Parameters

[in]	a_geom	Geometry
[in]	dt_advance	Timestep.
[in,out]	cons_in	Conservative variables.
[in,out]	mf_vars_windfarm	Wind farm variables MultiFab.
[in,out]	U_old	Old x-velocity MultiFab.
[in,out]	V_old	Old y-velocity MultiFab.
[in,out]	W_old	Old z-velocity MultiFab.
[in]	mf_Nturb	Turbine count MultiFab.
[in]	mf_SMark	SMark MultiFab.
[in]	time	Current simulation time.

Implements NullWindFarm.

    {
        m_windfarm_model[0]->advance(a_geom, dt_advance, cons_in, mf_vars_windfarm,
                                     U_old, V_old, W_old, mf_Nturb, mf_SMark, time);
    }

fill_Nturb_multifab()

void WindFarm::fill_Nturb_multifab	(	const amrex::Geometry &	geom,
		amrex::MultiFab &	mf_Nturb,
		std::unique_ptr< amrex::MultiFab > &	z_phys_nd
	)

Fill the turbine count MultiFab.

Parameters

[in]	geom	Geometry
[out]	mf_Nturb	MultiFab to fill with turbine counts.
[in,out]	z_phys_nd	Physical height MultiFab.

Fill a MultiFab with the number of turbines per cell and determine base heights.

Parameters

[in]	geom	Geometry defining the domain.
[in,out]	mf_Nturb	MultiFab to be filled with turbine counts per cell.
[in]	z_phys_nd	Node-centered physical height FAB.

{
 
    zloc.resize(xloc.size(),zero);
    Vector<int> is_counted;
    is_counted.resize(xloc.size(),0);
 
    amrex::Gpu::DeviceVector<Real> d_xloc(xloc.size());
    amrex::Gpu::DeviceVector<Real> d_yloc(yloc.size());
    amrex::Gpu::DeviceVector<Real> d_zloc(xloc.size());
    amrex::Gpu::DeviceVector<int> d_is_counted(xloc.size());
    amrex::Gpu::copyAsync(amrex::Gpu::hostToDevice, xloc.begin(), xloc.end(), d_xloc.begin());
    amrex::Gpu::copyAsync(amrex::Gpu::hostToDevice, yloc.begin(), yloc.end(), d_yloc.begin());
    amrex::Gpu::copyAsync(amrex::Gpu::hostToDevice, zloc.begin(), zloc.end(), d_zloc.begin());
    amrex::Gpu::copyAsync(amrex::Gpu::hostToDevice, is_counted.begin(), is_counted.end(), d_is_counted.begin());
 
    Real* d_xloc_ptr       = d_xloc.data();
    Real* d_yloc_ptr       = d_yloc.data();
    Real* d_zloc_ptr       = d_zloc.data();
    int* d_is_counted_ptr = d_is_counted.data();
 
    mf_Nturb.setVal(0);
 
    int i_lo = geom.Domain().smallEnd(0); int i_hi = geom.Domain().bigEnd(0);
    int j_lo = geom.Domain().smallEnd(1); int j_hi = geom.Domain().bigEnd(1);
    auto dx = geom.CellSizeArray();
    if(dx[0]<= 1e-3 or dx[1]<=1e-3 or dx[2]<= 1e-3) {
        Abort("The value of grid spacing for wind farm parametrization cannot be less than 1e-3 m. "
              "It should be usually of order 1 m");
    }
    auto ProbLoArr = geom.ProbLoArray();
    auto ProbHiArr = geom.ProbHiArray();
    int num_turb = xloc.size();
 
    bool is_terrain = z_phys_nd ? true: false;
 
    // The ground is at the bottom of the domain, not at the bottom of each box --
    //    these differ for every box that doesn't touch the ground, which happens
    //    whenever the grids are decomposed in the vertical direction
    const int k0 = geom.Domain().smallEnd(2);
 
     // Initialize wind farm
    for ( MFIter mfi(mf_Nturb,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
        const Box& bx     = mfi.tilebox();
        auto  Nturb_array = mf_Nturb.array(mfi);
        const Array4<const Real>& z_nd_arr = z_phys_nd->const_array(mfi);
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            int li = amrex::min(amrex::max(i, i_lo), i_hi);
            int lj = amrex::min(amrex::max(j, j_lo), j_hi);
 
            Real x1 = ProbLoArr[0] + li*dx[0];
            Real x2 = ProbLoArr[0] + (li+1)*dx[0];
            Real y1 = ProbLoArr[1] + lj*dx[1];
            Real y2 = ProbLoArr[1] + (lj+1)*dx[1];
 
            for(int it=0; it<num_turb; it++){
                if( d_xloc_ptr[it]+1e-3 > x1 and d_xloc_ptr[it]+1e-3 < x2 and
                    d_yloc_ptr[it]+1e-3 > y1 and d_yloc_ptr[it]+1e-3 < y2){
                    Nturb_array(i,j,k,0) = Nturb_array(i,j,k,0) + 1;
                    //
                    // Only the cell at the bottom of the domain counts this turbine and
                    //    stores its surface elevation.  d_is_counted is a per-rank array
                    //    which is summed over all ranks below, so if we counted at every k
                    //    then a column spread over more than one rank (which happens when
                    //    the grids are decomposed in z) would be counted more than once.
                    //
                    if (is_terrain and k == k0) {
                        int expected = 0;
                        int desired = 1;
                        // Atomic Compare-And-Swap: Increment only if d_is_counted_ptr[it] was 0
                        if (Gpu::Atomic::CAS(&d_is_counted_ptr[it], expected, desired) == expected) {
                            // The current thread successfully set d_is_counted_ptr[it] from 0 to 1
                            Gpu::Atomic::Add(&d_zloc_ptr[it], z_nd_arr(i, j, k0));
                        }
                    }
                }
            }
        });
    }
 
    mf_Nturb.FillBoundary(geom.periodicity());
 
    Gpu::copy(Gpu::deviceToHost, d_zloc.begin(), d_zloc.end(), zloc.begin());
    Gpu::copy(Gpu::deviceToHost, d_is_counted.begin(), d_is_counted.end(), is_counted.begin());
 
    amrex::ParallelAllReduce::Sum(zloc.data(),
                                  zloc.size(),
                                  amrex::ParallelContext::CommunicatorAll());
 
    amrex::ParallelAllReduce::Sum(is_counted.data(),
                                  is_counted.size(),
                                  amrex::ParallelContext::CommunicatorAll());
 
    for(int it=0;it<num_turb;it++) {
        if(is_terrain and
           xloc[it] > ProbLoArr[0] and
           xloc[it] < ProbHiArr[0] and
           yloc[it] > ProbLoArr[1] and
           yloc[it] < ProbHiArr[1]    ) {
            if(is_counted[it] != 1) {
                Abort("Wind turbine " + std::to_string(it) + "has been counted " + std::to_string(is_counted[it]) + " times" +
                      " It should have been counted only once. Aborting....");
            }
        }
    }
 
    // Debugging
    /*int my_rank = amrex::ParallelDescriptor::MyProc();
 
    for(int it=0;it<num_turb;it++) {
        std::cout << "The value of zloc is " << my_rank << " " << zloc[it] << " " << is_counted[it] << "\n";
    }*/
}

Here is the call graph for this function:

fill_SMark_multifab()

void WindFarm::fill_SMark_multifab	(	const amrex::Geometry &	geom,
		amrex::MultiFab &	mf_SMark,
		const amrex::Real &	sampling_distance_by_D,
		const amrex::Real &	turb_disk_angle,
		std::unique_ptr< amrex::MultiFab > &	z_phys_cc
	)

Fill the SMark MultiFab.

Parameters

[in]	geom	Geometry
[out]	mf_SMark	MultiFab to fill with SMark values.
[in]	sampling_distance_by_D	Sampling distance normalized by rotor diameter.
[in]	turb_disk_angle	Turbine disk angle.
[in,out]	z_phys_cc	Physical height MultiFab.

Fill the SMark MultiFab identifying turbine disks and sampling points.

Parameters

[in]	geom	Geometry defining the domain.
[in,out]	mf_SMark	MultiFab to be filled with turbine markers.
[in]	sampling_distance_by_D	Normalized sampling distance.
[in]	turb_disk_angle	Angle of the turbine disk in degrees.
[in]	z_phys_cc	Cell-centered physical height FAB.

{
    // Copy turbine locations to device
    Gpu::DeviceVector<Real> d_xloc(xloc.size());
    Gpu::DeviceVector<Real> d_yloc(yloc.size());
    Gpu::DeviceVector<Real> d_zloc(zloc.size());
 
    Gpu::copy(Gpu::hostToDevice, xloc.begin(), xloc.end(), d_xloc.begin());
 
    Gpu::copy(Gpu::hostToDevice, yloc.begin(), yloc.end(), d_yloc.begin());
 
    Gpu::copy(Gpu::hostToDevice, zloc.begin(), zloc.end(), d_zloc.begin());
 
    Real d_rotor_rad = rotor_rad;
    Real d_hub_height = hub_height;
    Real d_sampling_distance = sampling_distance_by_D * two * rotor_rad;
 
    Real* d_xloc_ptr = d_xloc.data();
    Real* d_yloc_ptr = d_yloc.data();
    Real* d_zloc_ptr = d_zloc.data();
 
    mf_SMark.setVal(-1.0);
 
    const int i_lo = geom.Domain().smallEnd(0);
    const int i_hi = geom.Domain().bigEnd(0);
    const int j_lo = geom.Domain().smallEnd(1);
    const int j_hi = geom.Domain().bigEnd(1);
    const int k_lo = geom.Domain().smallEnd(2);
    const int k_hi = geom.Domain().bigEnd(2);
 
    auto dx = geom.CellSizeArray();
    auto ProbLoArr = geom.ProbLoArray();
 
    const int num_turb = static_cast<int>(xloc.size());
 
    Real theta = turb_disk_angle * M_PI / Real(180.0) - myhalf * M_PI;
 
    set_turb_disk_angle(theta);
    my_turb_disk_angle = theta;
 
    Real nx = -std::cos(theta);
    Real ny = -std::sin(theta);
 
    // ------------------------------------------------------------
    // Device-side overlap information
    //
    // overlap_info[0] = overlap flag
    // overlap_info[1] = first turbine index
    // overlap_info[2] = second turbine index
    // ------------------------------------------------------------
 
    int h_overlap_info[3] = {0, -1, -1};
 
    Gpu::DeviceVector<int> d_overlap_info(3);
 
    Gpu::copy(Gpu::hostToDevice, h_overlap_info, h_overlap_info + 3, d_overlap_info.begin());
 
    int* d_overlap_info_ptr = d_overlap_info.data();
 
    // ------------------------------------------------------------
    // Initialize wind farm
    // ------------------------------------------------------------
 
    for (MFIter mfi(mf_SMark, TilingIfNotGPU()); mfi.isValid(); ++mfi)
    {
        const Box& gbx = mfi.growntilebox(1);
 
        auto SMark_array = mf_SMark.array(mfi);
 
        const Array4<const Real>& z_cc_arr = z_phys_cc->const_array(mfi);
 
        ParallelFor(
            gbx,
            [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
            {
                int ii = amrex::min(amrex::max(i, i_lo), i_hi);
                int jj = amrex::min(amrex::max(j, j_lo), j_hi);
                int kk = amrex::min(amrex::max(k, k_lo), k_hi);
 
                // ------------------------------------------------
                // Mesh-cell x/y extents
                // ------------------------------------------------
 
                Real x1 = ProbLoArr[0] + ii * dx[0];
                Real x2 = ProbLoArr[0] + (ii + 1) * dx[0];
 
                Real y1 = ProbLoArr[1] + jj * dx[1];
                Real y2 = ProbLoArr[1] + (jj + 1) * dx[1];
 
                // ------------------------------------------------
                // Cell-centered physical z
                // ------------------------------------------------
 
                Real z = z_cc_arr(ii, jj, kk);
 
                int check_int = 0;
                int first_turb = -1;
 
                for (int it = 0; it < num_turb; ++it)
                {
                    Real z0 = d_zloc_ptr[it];
 
                    // ------------------------------------------------
                    // Sampling point upstream/downstream of turbine
                    // ------------------------------------------------
 
                    Real x0 = d_xloc_ptr[it] + d_sampling_distance * nx;
 
                    Real y0 = d_yloc_ptr[it] + d_sampling_distance * ny;
 
                    bool is_cell_marked =
                        find_if_marked(
                            x1, x2, y1, y2,
                            x0, y0,
                            nx, ny,
                            d_hub_height + z0,
                            d_rotor_rad,
                            z);
 
                    if (is_cell_marked)
                    {
                        SMark_array(i, j, k, 0) = it;
                    }
 
                    // ------------------------------------------------
                    // Actual turbine disk
                    // ------------------------------------------------
 
                    x0 = d_xloc_ptr[it];
                    y0 = d_yloc_ptr[it];
 
                    is_cell_marked =
                        find_if_marked(
                            x1, x2, y1, y2,
                            x0, y0,
                            nx, ny,
                            d_hub_height + z0,
                            d_rotor_rad,
                            z);
 
                    if (is_cell_marked)
                    {
                        SMark_array(i, j, k, 1) = it;
 
                        if (check_int == 0)
                        {
                            first_turb = it;
                        }
 
                        ++check_int;
 
                        // ------------------------------------------------
                        // More than one turbine disk marks this cell
                        // ------------------------------------------------
 
                        if (check_int > 1)
                        {
                            // Set overlap flag.
                            amrex::Gpu::Atomic::Exch(&d_overlap_info_ptr[0], 1);
 
                            // Save the turbine indices. Multiple threads
                            // may write these, so use atomics.
                            amrex::Gpu::Atomic::Exch(&d_overlap_info_ptr[1], first_turb);
 
                            amrex::Gpu::Atomic::Exch(&d_overlap_info_ptr[2], it);
                        }
                    }
                }
            });
    }
 
    // ------------------------------------------------------------
    // Copy overlap information back to host.
    // This also synchronizes the GPU work.
    // ------------------------------------------------------------
 
    Gpu::copy(Gpu::deviceToHost, d_overlap_info.begin(), d_overlap_info.end(), h_overlap_info);
 
    // ------------------------------------------------------------
    // Handle overlap on the HOST, not inside the GPU kernel.
    // ------------------------------------------------------------
 
    if (h_overlap_info[0] != 0)
    {
        amrex::Error(
            "Actuator disks with indices " + std::to_string(h_overlap_info[1]) +
            " and " + std::to_string(h_overlap_info[2]) + " are overlapping. "
            "Visualize actuator_disks.vtk and check the "
            "windturbine locations input file. Exiting..");
    }
}

Here is the call graph for this function:

fill_SMark_multifab_mesoscale_models()

void WindFarm::fill_SMark_multifab_mesoscale_models	(	const amrex::Geometry &	geom,
		amrex::MultiFab &	mf_SMark,
		const amrex::MultiFab &	mf_Nturb,
		std::unique_ptr< amrex::MultiFab > &	z_phys_cc
	)

Fill the SMark MultiFab for mesoscale models.

Parameters

[in]	geom	Geometry
[out]	mf_SMark	MultiFab to fill with SMark values.
[in]	mf_Nturb	MultiFab containing turbine counts.
[in,out]	z_phys_cc	Physical height MultiFab.

Fill the SMark MultiFab for mesoscale model parametrization.

Parameters

[in]	geom	Geometry defining the domain.
[in,out]	mf_SMark	MultiFab to be filled with turbine markers.
[in]	mf_Nturb	MultiFab containing turbine counts per cell.
[in]	z_phys_nd	Node-centered physical height FAB.

{
    mf_SMark.setVal(-1.0);
 
    Real d_hub_height = hub_height;
 
    amrex::Gpu::DeviceVector<Real> d_xloc(xloc.size());
    amrex::Gpu::DeviceVector<Real> d_yloc(yloc.size());
    amrex::Gpu::DeviceVector<Real> d_zloc(xloc.size());
    amrex::Gpu::copyAsync(amrex::Gpu::hostToDevice, xloc.begin(), xloc.end(), d_xloc.begin());
    amrex::Gpu::copyAsync(amrex::Gpu::hostToDevice, yloc.begin(), yloc.end(), d_yloc.begin());
    amrex::Gpu::copyAsync(amrex::Gpu::hostToDevice, zloc.begin(), zloc.end(), d_zloc.begin());
 
    int i_lo = geom.Domain().smallEnd(0); int i_hi = geom.Domain().bigEnd(0);
    int j_lo = geom.Domain().smallEnd(1); int j_hi = geom.Domain().bigEnd(1);
    int k_lo = geom.Domain().smallEnd(2); int k_hi = geom.Domain().bigEnd(2);
 
    //auto dx = geom.CellSizeArray();
    //auto ProbLoArr = geom.ProbLoArray();
 
     // Initialize wind farm
    for ( MFIter mfi(mf_SMark,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        const Box& gbx    = mfi.growntilebox(1);
        auto  SMark_array = mf_SMark.array(mfi);
        auto  Nturb_array = mf_Nturb.array(mfi);
        const Array4<const Real>& z_nd_arr = z_phys_nd->const_array(mfi);
        int k0 = std::max(gbx.smallEnd(2), geom.Domain().smallEnd(2));
 
        ParallelFor(gbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            if(Nturb_array(i,j,k,0) > 0) {
                int li = amrex::min(amrex::max(i, i_lo), i_hi);
                int lj = amrex::min(amrex::max(j, j_lo), j_hi);
                int lk = amrex::min(amrex::max(k, k_lo), k_hi);
 
                Real z1 = z_nd_arr(li,lj,lk  );
                Real z2 = z_nd_arr(li,lj,lk+1);
 
                Real zturb = z_nd_arr(li,lj,k0) + d_hub_height;
                if (zturb+1e-3 > z1 and zturb+1e-3 < z2) {
                    SMark_array(i,j,k,0) = one;
                }
            }
        });
    }
}

Here is the call graph for this function:

init_windfarm_lat_lon()

void WindFarm::init_windfarm_lat_lon	(	const std::string	windfarm_loc_table,
		const amrex::Real	windfarm_x_shift,
		const amrex::Real	windfarm_y_shift
	)

Initialize wind farm using latitude and longitude coordinates.

Parameters

[in]	windfarm_loc_table	Path to the location table.
[in]	windfarm_x_shift	X-coordinate shift.
[in]	windfarm_y_shift	Y-coordinate shift.

Initialize turbine locations from latitude and longitude coordinates.

Parameters

[in]	windfarm_loc_table	Path to the turbine locations table.
[in]	windfarm_x_shift	Shift applied to the resulting x coordinates.
[in]	windfarm_y_shift	Shift applied to the resulting y coordinates.

{
    // Re-reading the file must not append to a previous level's list.
    xloc.clear();
    yloc.clear();
 
    // Read turbine locations from windturbines.txt
    std::ifstream file(windfarm_loc_table);
    if (!file.is_open()) {
        amrex::Error("Wind turbines location table not found. Either the inputs is missing the"
                     " erf.windfarm_loc_table entry or the file specified in the entry " + windfarm_loc_table + " is missing.");
    }
    // Vector of vectors to store the matrix
    Vector<Real> lat, lon;
    Real value1, value2, value3;
 
    while (file >> value1 >> value2 >> value3) {
 
        if(std::fabs(value1) > Real(90.0)) {
            amrex::Error("The value of latitude for entry " + std::to_string(lat.size() + 1) +
                         " in " + windfarm_loc_table + " should be within -90 and 90");
        }
 
        if(std::fabs(value2) > Real(180.0)) {
            amrex::Error("The value of longitude for entry " + std::to_string(lat.size() + 1) +
                         " in " + windfarm_loc_table + " should be within -180 and 180");
        }
        lat.push_back(value1);
        lon.push_back(value2);
    }
    file.close();
 
    Real rad_earth = Real(6371.0e3); // Radius of the earth
    Real m_per_deg_lat = rad_earth*two*M_PI/(two*Real(180.0));
 
    // Find the coordinates of average of min and max of the farm
    // Rotate about that point
    ParmParse pp("erf");
    std::string fname_usgs;
    auto valid_fname_USGS = pp.queryAdd("terrain_file_name_USGS",fname_usgs);
    Real lon_ref, lat_ref;
 
    if (valid_fname_USGS) {
        std::ifstream file_usgs(fname_usgs);
        file_usgs >> lon_ref >> lat_ref;
        file_usgs.close();
        lon_ref = lon_ref*M_PI/Real(180.0);
        lat_ref = lat_ref*M_PI/Real(180.0);
    } else {
        Real lat_min = *std::min_element(lat.begin(), lat.end());
        Real lon_min = *std::min_element(lon.begin(), lon.end());
 
        lon_ref = lon_min*M_PI/Real(180.0);
        lat_ref = lat_min*M_PI/Real(180.0);
    }
 
 
    for(int it=0;it<lat.size();it++){
        lat[it] = lat[it]*M_PI/Real(180.0);
        lon[it] = lon[it]*M_PI/Real(180.0);
        Real delta_lat = (lat[it] - lat_ref);
        Real delta_lon = (lon[it] - lon_ref);
 
        Real term1 = amrex::Math::powi<2>(sin(delta_lat/two));
        Real term2 = cos(lat[it])*cos(lat_ref)*amrex::Math::powi<2>(sin(delta_lon/two));
        Real dist =  two*rad_earth*std::asin(std::sqrt(term1 + term2));
        Real dy_turb = delta_lat * m_per_deg_lat * Real(180.0)/M_PI ;
 
        if(dist<dy_turb){
            if(std::fabs(dist-dy_turb)<1e-8){
                dist=dy_turb;
            }
            else{
                Abort("The value of dist is less than dy_turb "+ std::to_string(dist) + " " + std::to_string(dy_turb));
            }
        }
        Real tmp = amrex::Math::powi<2>(dist) - amrex::Math::powi<2>(dy_turb);
 
        if(std::fabs(tmp)<1e-8){
            tmp = zero;
        }
        Real dx_turb = std::sqrt(tmp);
 
 
        if(delta_lon >= zero) {
            xloc.push_back(dx_turb);
        }
        else {
            xloc.push_back(-dx_turb);
        }
        yloc.push_back(dy_turb);
    }
 
    for(int it = 0;it<xloc.size(); it++){
        xloc[it] = xloc[it] + windfarm_x_shift;
        yloc[it] = yloc[it] + windfarm_y_shift;
    }
}

Here is the call graph for this function:

init_windfarm_x_y()

void WindFarm::init_windfarm_x_y

(

const std::string

windfarm_loc_table

)

Initialize wind farm using Cartesian coordinates.

Parameters

[in]

windfarm_loc_table

Path to the location table.

Initialize turbine locations from Cartesian x and y coordinates.

Parameters

[in]

windfarm_loc_table

Path to the turbine locations table.

{
    // Read turbine locations from windturbines.txt
    std::ifstream file(windfarm_loc_table);
    if (!file.is_open()) {
        amrex::Error("Wind turbines location table not found. Either the inputs is missing the"
                     " erf.windfarm_loc_table entry or the file specified in the entry " + windfarm_loc_table + " is missing.");
    }
    // Vector of vectors to store the matrix
    Real value1, value2;
 
    // Re-reading the file must not append to a previous level's list.
    xloc.clear();
    yloc.clear();
 
    while (file >> value1 >> value2) {
        value1 = value1 + 1e-3;
        value2 = value2 + 1e-3;
        xloc.push_back(value1);
        yloc.push_back(value2);
    }
    file.close();
}

read_tables()

void WindFarm::read_tables	(	std::string	windfarm_loc_table,
		std::string	windfarm_spec_table,
		bool	x_y,
		bool	lat_lon,
		const amrex::Real	windfarm_x_shift = zero,
		const amrex::Real	windfarm_y_shift = zero
	)

Read turbine location and specification tables.

Parameters

[in]	windfarm_loc_table	Path to the location table.
[in]	windfarm_spec_table	Path to the specification table.
[in]	x_y	Whether to use Cartesian coordinates.
[in]	lat_lon	Whether to use latitude and longitude coordinates.
[in]	windfarm_x_shift	X-coordinate shift.
[in]	windfarm_y_shift	Y-coordinate shift.

Read in the turbine locations in latitude-longitude from windturbines.txt and convert it into x and y coordinates in metres

Parameters

lev	Integer specifying the current level

{
    amrex::Print() << "Reading wind turbine locations table" << "\n";
    read_windfarm_locations_table(windfarm_loc_table,
                                  x_y, lat_lon,
                                  windfarm_x_shift, windfarm_y_shift);
 
    amrex::Print() << "Reading wind turbine specifications table" << "\n";
    read_windfarm_spec_table(windfarm_spec_table);
}

read_windfarm_airfoil_tables()

void WindFarm::read_windfarm_airfoil_tables	(	const std::string	windfarm_airfoil_tables,
		const std::string	windfarm_blade_table
	)

Read the airfoil tables.

Parameters

[in]	windfarm_airfoil_tables	Path to the airfoil tables.
[in]	windfarm_blade_table	Path to the blade table.

Read airfoil data from a directory of tables.

Parameters

[in]	windfarm_airfoil_tables	Path to the directory containing airfoil tables.
[in]	windfarm_blade_table	Path to the turbine blade properties table.

{
    DIR* dir;
    struct dirent* entry;
    std::vector<std::string> files;
 
    // Check if directory exists
    if ((dir = opendir(windfarm_airfoil_tables.c_str())) == nullptr) {
       Abort("You are using a generalized actuator disk model based on blade element theory. This needs info of airfoil"
             " cross sections over the span of the blade. There needs to be an entry erf.airfoil_tables which is the directory that"
             " contains the angle of attack, Cl, Cd data for each airfoil cross-section. Either the entry is missing or the directory specified"
             " in the entry - " + windfarm_airfoil_tables + " is missing. Exiting...");
    }
 
    // Loop through directory entries and collect filenames
    while ((entry = readdir(dir)) != nullptr) {
        // Skip special directory entries "." and ".."
        if (std::string(entry->d_name) == "." || std::string(entry->d_name) == "..") {
            continue;
        }
        files.emplace_back(windfarm_airfoil_tables + "/" + entry->d_name);  // Add file path to vector
    }
 
    // Close the directory
    closedir(dir);
 
    if (files.empty()) {
        Abort("It seems the directory containing the info of airfoil cross sections of the blades - " + windfarm_airfoil_tables +
              " is empty. Exiting...");
    }
 
    if(files.size() != static_cast<long double>(n_bld_sections)) {
        printf("There are %d airfoil sections in the last column of %s. But the number"
               " of files in %s is only %ld.\n", n_bld_sections, windfarm_blade_table.c_str(),
                windfarm_airfoil_tables.c_str(), files.size());
        Abort("The number of blade sections from " + windfarm_blade_table + " should match the number of"
              " files in " + windfarm_airfoil_tables + ". Exiting...");
    }
 
    // Sort filenames in lexicographical (alphabetical) order
    std::sort(files.begin(), files.end());
 
    // Process each file
    int count = 0;
    bld_airfoil_aoa.resize(n_bld_sections);
    bld_airfoil_Cl.resize(n_bld_sections);
    bld_airfoil_Cd.resize(n_bld_sections);
    for (const auto& filePath : files) {
        std::ifstream filename(filePath.c_str());
 
        if (!filename.is_open()) {
            std::cerr << "Failed to open file: " << filePath << std::endl;
            continue;  // Move on to the next file
        }
 
           std::cout << "Reading file: " << filePath << std::endl;
 
        std::string line;
        for (int i = 0; i < 54; ++i) {
            if (std::getline(filename, line)) {  // Read one line into the array
            }
        }
 
        Real var1, var2, var3, temp;
 
        while(filename >> var1 >> var2 >> var3 >> temp) {
            bld_airfoil_aoa[count].push_back(var1);
            bld_airfoil_Cl[count].push_back(var2);
            bld_airfoil_Cd[count].push_back(var3);
            //int idx = bld_airfoil_aoa.size()-1;
            //printf("Values are = %0.15g %0.15g %0.15g\n", bld_airfoil_aoa[idx], bld_airfoil_Cl[idx], bld_airfoil_Cd[idx]);
        }
        count++;
    }
 
    set_blade_airfoil_spec(bld_airfoil_aoa, bld_airfoil_Cl, bld_airfoil_Cd);
}

read_windfarm_blade_table()

void WindFarm::read_windfarm_blade_table

(

const std::string

windfarm_blade_table

)

Read the turbine blade table.

Parameters

[in]

windfarm_blade_table

Path to the blade table.

Read turbine blade geometry and properties from a table.

Parameters

[in]

windfarm_blade_table

Path to the turbine blade properties table.

{
    std::ifstream filename(windfarm_blade_table);
    std::string line;
    Real temp, var1, var2, var3;
    if (!filename.is_open()) {
        Error("You are using a generalized actuator disk model based on blade element theory. This needs info of blades."
                      " An entry erf.windfarm_blade_table is needed. Either the entry is missing or the file specified"
                      " in the entry - " + windfarm_blade_table + " is missing.");
    }
    else {
        Print() << "Reading in wind farm blade table: " << windfarm_blade_table << "\n";
 
        // First 6 lines are comments
 
        for (int i = 0; i < 6; ++i) {
            if (std::getline(filename, line)) {  // Read one line into the array
            }
        }
 
        while(filename >> var1 >> temp >> temp >> temp >> var2 >> var3 >> temp) {
            bld_rad_loc.push_back(var1);
            bld_twist.push_back(var2);
            bld_chord.push_back(var3);
            //int idx = bld_rad_loc.size()-1;
            //printf("Values are = %0.15g %0.15g %0.15g\n", bld_rad_loc[idx], bld_twist[idx], bld_chord[idx]);
        }
        set_blade_spec(bld_rad_loc, bld_twist, bld_chord);
        n_bld_sections = bld_rad_loc.size();
    }
}

read_windfarm_locations_table()

void WindFarm::read_windfarm_locations_table	(	const std::string	windfarm_loc_table,
		bool	x_y,
		bool	lat_lon,
		const amrex::Real	windfarm_x_shift = zero,
		const amrex::Real	windfarm_y_shift = zero
	)

Read the turbine location table.

Parameters

[in]	windfarm_loc_table	Path to the location table.
[in]	x_y	Whether to use Cartesian coordinates.
[in]	lat_lon	Whether to use latitude and longitude coordinates.
[in]	windfarm_x_shift	X-coordinate shift.
[in]	windfarm_y_shift	Y-coordinate shift.

Read turbine locations from a table and convert them to Cartesian coordinates.

Parameters

[in]	windfarm_loc_table	Path to the turbine locations table.
[in]	x_y	Boolean indicating if locations are provided as x and y coordinates.
[in]	lat_lon	Boolean indicating if locations are provided as latitude and longitude.
[in]	windfarm_x_shift	Shift applied to the resulting x coordinates.
[in]	windfarm_y_shift	Shift applied to the resulting y coordinates.

{
    if(x_y) {
        init_windfarm_x_y(windfarm_loc_table);
    }
    else if(lat_lon) {
        init_windfarm_lat_lon(windfarm_loc_table, windfarm_x_shift, windfarm_y_shift);
    }
    else {
        amrex::Abort("Are you using windfarms? For windfarm simulations, the inputs need to have an"
                     " entry erf.windfarm_loc_type which should be either lat_lon or x_y. \n");
    }
 
    set_turb_loc(xloc, yloc);
}

read_windfarm_spec_table()

void WindFarm::read_windfarm_spec_table

(

const std::string

windfarm_spec_table

)

Read the turbine specification table.

Parameters

[in]

windfarm_spec_table

Path to the specification table.

Read turbine performance specifications from a table.

Parameters

[in]

windfarm_spec_table

Path to the turbine specifications table.

{
    //The first line is the number of pairs entries for the power curve and thrust coefficient.
    //The second line gives first the height in meters of the turbine hub, second, the diameter in
    //meters of the rotor, third the standing thrust coefficient, and fourth the nominal power of
    //the turbine in MW.
    //The remaining lines contain the three values of: wind speed, thrust coefficient, and power production in kW.
 
     // Read turbine data from wind-turbine-1.tbl
    std::ifstream file_turb_table(windfarm_spec_table);
    if (!file_turb_table.is_open()) {
        Error("Wind farm specifications table not found. Either the inputs is missing the "
                      "erf.windfarm_spec_table entry or the file specified in the entry - " + windfarm_spec_table + " is missing.");
    }
    else {
        Print() << "Reading in wind farm specifications table: " << windfarm_spec_table << "\n";
    }
 
    int nlines;
    file_turb_table >> nlines;
    wind_speed.resize(nlines);
    thrust_coeff.resize(nlines);
    power.resize(nlines);
 
    Real rotor_dia;
    file_turb_table >> hub_height >> rotor_dia >> thrust_coeff_standing >> nominal_power;
    rotor_rad = rotor_dia*myhalf;
    if(rotor_rad > hub_height) {
        Abort("The blade length is more than the hub height. Check the second line in wind-turbine-1.tbl. Aborting.....");
    }
    if(thrust_coeff_standing > one) {
        Abort("The standing thrust coefficient is greater than one. Check the second line in wind-turbine-1.tbl. Aborting.....");
    }
 
    for(int iline=0;iline<nlines;iline++){
        file_turb_table >> wind_speed[iline] >> thrust_coeff[iline] >> power[iline];
        if(thrust_coeff[iline] > one) {
            Abort("The thrust coefficient is greater than one. Check wind-turbine-1.tbl. Aborting.....");
        }
    }
    file_turb_table.close();
 
    set_turb_spec(rotor_rad, hub_height, thrust_coeff_standing,
                  wind_speed, thrust_coeff, power);
 
}

read_windfarm_spec_table_extra()

void WindFarm::read_windfarm_spec_table_extra

(

const std::string

windfarm_spec_table_extra

)

Read extra turbine specifications.

Parameters

[in]

windfarm_spec_table_extra

Path to the extra specification table.

Read extended turbine performance specifications from a table.

Parameters

[in]

windfarm_spec_table_extra

Path to the extended turbine specifications table.

{
    // Open the file
    std::ifstream file(windfarm_spec_table_extra);
 
    // Check if file opened successfully
    if (!file.is_open()) {
        Abort("Error: You are using generalized wind farms option. This requires an input file erf.windfarm_spec_table_extra."
              " Either this entry is missing in the inputs or the file specified -" + windfarm_spec_table_extra + " does"
              " not exist. Exiting...");
    } else {
        printf("Reading in windfarm_spec_table_extra %s", windfarm_spec_table_extra.c_str());
    }
 
    // Ignore the first line (header)
    std::string header;
    std::getline(file, header);
 
    // Variables to hold each row's values
    double V, Cp, Ct, rpm, pitch, temp;
 
    // Read the file row by row
    while (file >> V) {
        char comma;  // To ignore the commas
        file >> comma >> Cp >> comma >> Ct >> comma >> temp >> comma >> temp >> comma
             >> temp >> comma >> rpm >> comma >> pitch >> comma >> temp;
 
        velocity.push_back(V);
        C_P.push_back(Cp);
        C_T.push_back(Ct);
        rotor_RPM.push_back(rpm);
        blade_pitch.push_back(pitch);
    }
 
    set_turb_spec_extra(velocity, C_P, C_T, rotor_RPM, blade_pitch);
}

set_blade_airfoil_spec()

void WindFarm::set_blade_airfoil_spec ( const amrex::Vector< amrex::Vector< amrex::Real >> &  a_bld_airfoil_aoa, const amrex::Vector< amrex::Vector< amrex::Real >> &  a_bld_airfoil_Cl, const amrex::Vector< amrex::Vector< amrex::Real >> &  a_bld_airfoil_Cd  )

inlineoverridevirtual

Set blade airfoil specifications.

Parameters

[in]	a_bld_airfoil_aoa	Angle of attack.
[in]	a_bld_airfoil_Cl	Lift coefficient.
[in]	a_bld_airfoil_Cd	Drag coefficient.

Reimplemented from NullWindFarm.

    {
        m_windfarm_model[0]->set_blade_airfoil_spec(a_bld_airfoil_aoa, a_bld_airfoil_Cl, a_bld_airfoil_Cd);
    }

set_blade_spec()

void WindFarm::set_blade_spec ( const amrex::Vector< amrex::Real > &  a_bld_rad_loc, const amrex::Vector< amrex::Real > &  a_bld_twist, const amrex::Vector< amrex::Real > &  a_bld_chord  )

inlineoverridevirtual

Set blade specifications.

Parameters

[in]	a_bld_rad_loc	Blade radial locations.
[in]	a_bld_twist	Blade twist.
[in]	a_bld_chord	Blade chord.

Reimplemented from NullWindFarm.

    {
        m_windfarm_model[0]->set_blade_spec(a_bld_rad_loc, a_bld_twist, a_bld_chord);
    }

set_turb_disk_angle()

void WindFarm::set_turb_disk_angle ( const amrex::Real &  a_turb_disk_angle )

inlineoverridevirtual

Set the turbine disk angle.

Parameters

[in]

a_turb_disk_angle

Disk angle.

Reimplemented from NullWindFarm.

    {
        m_windfarm_model[0]->set_turb_disk_angle(a_turb_disk_angle);
    }

set_turb_loc()

void WindFarm::set_turb_loc ( const amrex::Vector< amrex::Real > &  a_xloc, const amrex::Vector< amrex::Real > &  a_yloc  )

inlineoverridevirtual

Set turbine locations.

Parameters

[in]	a_xloc	X locations.
[in]	a_yloc	Y locations.

Reimplemented from NullWindFarm.

    {
        m_windfarm_model[0]->set_turb_loc(a_xloc, a_yloc);
    }

set_turb_spec()

void WindFarm::set_turb_spec ( const amrex::Real &  a_rotor_rad, const amrex::Real &  a_hub_height, const amrex::Real &  a_thrust_coeff_standing, const amrex::Vector< amrex::Real > &  a_wind_speed, const amrex::Vector< amrex::Real > &  a_thrust_coeff, const amrex::Vector< amrex::Real > &  a_power  )

inlineoverridevirtual

Set general turbine specifications.

Parameters

[in]	a_rotor_rad	Rotor radius.
[in]	a_hub_height	Hub height.
[in]	a_thrust_coeff_standing	Standing thrust coefficient.
[in]	a_wind_speed	Wind speed vector.
[in]	a_thrust_coeff	Thrust coefficient vector.
[in]	a_power	Power vector.

Reimplemented from NullWindFarm.

    {
        m_windfarm_model[0]->set_turb_spec(a_rotor_rad, a_hub_height, a_thrust_coeff_standing,
                  a_wind_speed, a_thrust_coeff, a_power);
    }

set_turb_spec_extra()

void WindFarm::set_turb_spec_extra ( const amrex::Vector< amrex::Real > &  a_velocity, const amrex::Vector< amrex::Real > &  a_C_P, const amrex::Vector< amrex::Real > &  a_C_T, const amrex::Vector< amrex::Real > &  a_rotor_RPM, const amrex::Vector< amrex::Real > &  a_blade_pitch  )

inlineoverridevirtual

Set extra turbine specifications.

Parameters

[in]	a_velocity	Velocity.
[in]	a_C_P	Power coefficient.
[in]	a_C_T	Thrust coefficient.
[in]	a_rotor_RPM	Rotor RPM.
[in]	a_blade_pitch	Blade pitch.

Reimplemented from NullWindFarm.

    {
        m_windfarm_model[0]->set_turb_spec_extra(a_velocity, a_C_P, a_C_T, a_rotor_RPM, a_blade_pitch);
    }

SetModel()

template<class NewWindFarmModel >

void WindFarm::SetModel ( )

inlineprotected

Create and set the specified windfarm model.

    {
        for (int lev(0); lev<m_windfarm_model.size(); ++lev) {
            m_windfarm_model[lev] = std::make_unique<NewWindFarmModel>();
        }
    }

write_actuator_disks_vtk()

void WindFarm::write_actuator_disks_vtk	(	const amrex::Geometry &	geom,
		const amrex::Real &	sampling_distance_by_D
	)

Write actuator disks to a VTK file.

Parameters

[in]	geom	Geometry
[in]	sampling_distance_by_D	Sampling distance normalized by rotor diameter.

Write the actuator disks and sampling disks to VTK files.

Parameters

[in]	geom	Geometry defining the domain.
[in]	sampling_distance_by_D	Normalized sampling distance.

{
 
    Real sampling_distance = sampling_distance_by_D*two*rotor_rad;
 
    if (ParallelDescriptor::IOProcessor()){
        FILE *file_actuator_disks_all, *file_actuator_disks_in_dom, *file_averaging_disks_in_dom;
        file_actuator_disks_all = fopen("actuator_disks_all.vtk","w");
        fprintf(file_actuator_disks_all, "%s\n","# vtk DataFile Version 3.0");
        fprintf(file_actuator_disks_all, "%s\n","Actuator Disks");
        fprintf(file_actuator_disks_all, "%s\n","ASCII");
        fprintf(file_actuator_disks_all, "%s\n","DATASET POLYDATA");
 
        file_actuator_disks_in_dom = fopen("actuator_disks_in_dom.vtk","w");
        fprintf(file_actuator_disks_in_dom, "%s\n","# vtk DataFile Version 3.0");
        fprintf(file_actuator_disks_in_dom, "%s\n","Actuator Disks");
        fprintf(file_actuator_disks_in_dom, "%s\n","ASCII");
        fprintf(file_actuator_disks_in_dom, "%s\n","DATASET POLYDATA");
 
        file_averaging_disks_in_dom = fopen("averaging_disks_in_dom.vtk","w");
        fprintf(file_averaging_disks_in_dom, "%s\n","# vtk DataFile Version 3.0");
        fprintf(file_averaging_disks_in_dom, "%s\n","Actuator Disks");
        fprintf(file_averaging_disks_in_dom, "%s\n","ASCII");
        fprintf(file_averaging_disks_in_dom, "%s\n","DATASET POLYDATA");
 
 
        int npts = 100;
        fprintf(file_actuator_disks_all, "%s %ld %s\n", "POINTS", xloc.size()*npts, "float");
        auto ProbLoArr = geom.ProbLoArray();
        auto ProbHiArr = geom.ProbHiArray();
        int num_turb_in_dom = 0;
 
        // Find the number of turbines inside the specified computational domain
 
        for(int it=0; it<xloc.size(); it++){
            Real x = xloc[it];
            Real y = yloc[it];
            if(x > ProbLoArr[0] and x < ProbHiArr[0] and y > ProbLoArr[1] and y < ProbHiArr[1]) {
                num_turb_in_dom++;
            }
        }
        fprintf(file_actuator_disks_in_dom, "%s %ld %s\n", "POINTS", static_cast<long int>(num_turb_in_dom*npts), "float");
        fprintf(file_averaging_disks_in_dom, "%s %ld %s\n", "POINTS", static_cast<long int>(num_turb_in_dom*npts), "float");
 
        Real nx = std::cos(my_turb_disk_angle+myhalf*M_PI);
        Real ny = std::sin(my_turb_disk_angle+myhalf*M_PI);
 
        Real nx1 = -std::cos(my_turb_disk_angle);
        Real ny1 = -std::sin(my_turb_disk_angle);
 
        for(int it=0; it<xloc.size(); it++){
            for(int pt=0;pt<100;pt++){
                Real x, y, z, xavg, yavg;
                Real theta = two*M_PI/npts*pt;
                x = xloc[it] + rotor_rad*cos(theta)*nx;
                y = yloc[it] + rotor_rad*cos(theta)*ny;
                z = hub_height + zloc[it] + rotor_rad*sin(theta);
 
                xavg = xloc[it] + sampling_distance*nx1 + rotor_rad*cos(theta)*nx;
                yavg = yloc[it] + sampling_distance*ny1 + rotor_rad*cos(theta)*ny;
 
                fprintf(file_actuator_disks_all, "%0.15g %0.15g %0.15g\n", x, y, z);
                if(xloc[it] > ProbLoArr[0] and xloc[it] < ProbHiArr[0] and yloc[it] > ProbLoArr[1] and yloc[it] < ProbHiArr[1]) {
                    fprintf(file_actuator_disks_in_dom, "%0.15g %0.15g %0.15g\n", x, y, z);
                    fprintf(file_averaging_disks_in_dom, "%0.15g %0.15g %0.15g\n", xavg, yavg, z);
                }
            }
        }
        fprintf(file_actuator_disks_all, "%s %ld %ld\n", "LINES", xloc.size()*(npts-1), static_cast<long int>(xloc.size()*(npts-1)*3));
        fprintf(file_actuator_disks_in_dom, "%s %ld %ld\n", "LINES", static_cast<long int>(num_turb_in_dom*(npts-1)), static_cast<long int>(num_turb_in_dom*(npts-1)*3));
        fprintf(file_averaging_disks_in_dom, "%s %ld %ld\n", "LINES", static_cast<long int>(num_turb_in_dom*(npts-1)), static_cast<long int>(num_turb_in_dom*(npts-1)*3));
        for(int it=0; it<xloc.size(); it++){
            for(int pt=0;pt<99;pt++){
                fprintf(file_actuator_disks_all, "%ld %ld %ld\n",
                                             static_cast<long int>(2),
                                             static_cast<long int>(it*npts+pt),
                                             static_cast<long int>(it*npts+pt+1));
            }
        }
         for(int it=0; it<num_turb_in_dom; it++){
            for(int pt=0;pt<99;pt++){
                fprintf(file_actuator_disks_in_dom, "%ld %ld %ld\n",
                                             static_cast<long int>(2),
                                             static_cast<long int>(it*npts+pt),
                                             static_cast<long int>(it*npts+pt+1));
            }
        }
 
         for(int it=0; it<num_turb_in_dom; it++){
            for(int pt=0;pt<99;pt++){
                fprintf(file_averaging_disks_in_dom, "%ld %ld %ld\n",
                                             static_cast<long int>(2),
                                             static_cast<long int>(it*npts+pt),
                                             static_cast<long int>(it*npts+pt+1));
            }
        }
 
        fclose(file_actuator_disks_all);
        fclose(file_actuator_disks_in_dom);
        fclose(file_averaging_disks_in_dom);
    }
}

write_turbine_locations_vtk()

void WindFarm::write_turbine_locations_vtk

(

)

Write turbine locations to a VTK file.

Write the turbine hub locations to a VTK file.

{
    if (ParallelDescriptor::IOProcessor()){
        FILE* file_turbloc_vtk;
        file_turbloc_vtk = fopen("turbine_locations.vtk","w");
        fprintf(file_turbloc_vtk, "%s\n","# vtk DataFile Version 3.0");
        fprintf(file_turbloc_vtk, "%s\n","Wind turbine locations");
        fprintf(file_turbloc_vtk, "%s\n","ASCII");
        fprintf(file_turbloc_vtk, "%s\n","DATASET POLYDATA");
        fprintf(file_turbloc_vtk, "%s %ld %s\n", "POINTS", xloc.size(), "float");
        for(int it=0; it<xloc.size(); it++){
            fprintf(file_turbloc_vtk, "%0.15g %0.15g %0.15g\n", xloc[it], yloc[it], hub_height);
        }
        fclose(file_turbloc_vtk);
    }
}

Member Data Documentation

blade_pitch

amrex::Vector<amrex::Real> WindFarm::blade_pitch

protected

bld_airfoil_aoa

amrex::Vector<amrex::Vector<amrex::Real> > WindFarm::bld_airfoil_aoa

protected

bld_airfoil_Cd

amrex::Vector<amrex::Vector<amrex::Real> > WindFarm::bld_airfoil_Cd

protected

bld_airfoil_Cl

amrex::Vector<amrex::Vector<amrex::Real> > WindFarm::bld_airfoil_Cl

protected

bld_chord

amrex::Vector<amrex::Real> WindFarm::bld_chord

protected

bld_rad_loc

amrex::Vector<amrex::Real> WindFarm::bld_rad_loc

protected

bld_twist

amrex::Vector<amrex::Real> WindFarm::bld_twist

protected

C_P

amrex::Vector<amrex::Real> WindFarm::C_P

protected

C_T

amrex::Vector<amrex::Real> WindFarm::C_T

protected

hub_height

amrex::Real WindFarm::hub_height

protected

m_windfarm_model

amrex::Vector<std::unique_ptr<NullWindFarm> > WindFarm::m_windfarm_model

private

windfarm model

Referenced by advance(), set_blade_airfoil_spec(), set_blade_spec(), set_turb_disk_angle(), set_turb_loc(), set_turb_spec(), set_turb_spec_extra(), SetModel(), and WindFarm().

my_turb_disk_angle

amrex::Real WindFarm::my_turb_disk_angle

protected

n_bld_sections

int WindFarm::n_bld_sections

protected

nominal_power

amrex::Real WindFarm::nominal_power

protected

power

amrex::Vector<amrex::Real> WindFarm::power

protected

rotor_rad

amrex::Real WindFarm::rotor_rad

protected

rotor_RPM

amrex::Vector<amrex::Real> WindFarm::rotor_RPM

protected

thrust_coeff

amrex::Vector<amrex::Real> WindFarm::thrust_coeff

protected

thrust_coeff_standing

amrex::Real WindFarm::thrust_coeff_standing

protected

velocity

amrex::Vector<amrex::Real> WindFarm::velocity

protected

wind_speed

amrex::Vector<amrex::Real> WindFarm::wind_speed

protected

xloc

amrex::Vector<amrex::Real> WindFarm::xloc

protected

yloc

amrex::Vector<amrex::Real> WindFarm::yloc

protected

zloc

amrex::Vector<amrex::Real> WindFarm::zloc

protected

---

The documentation for this class was generated from the following files:

• Source/WindFarmParametrization/ERF_WindFarm.H
• Source/WindFarmParametrization/ERF_WindFarm.cpp