#include <ERF_WindFarm.H>

Inheritance diagram for WindFarm:

Collaboration diagram for WindFarm:

[legend]

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)

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

void	init_windfarm_x_y (const std::string windfarm_loc_table)

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)

void	read_windfarm_spec_table (const std::string windfarm_spec_table)

void	read_windfarm_blade_table (const std::string windfarm_blade_table)

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

void	read_windfarm_spec_table_extra (const std::string windfarm_spec_table_extra)

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

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)

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)

void	write_turbine_locations_vtk ()

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

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

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

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

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

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

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

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

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)

Constructor & Destructor Documentation

◆ WindFarm() [1/2]

WindFarm::WindFarm ( )

inline

18 {}

◆ ~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

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
	)

 {
  
     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;
  
      // 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);
         int k0 = bx.smallEnd()[2];
         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;
                     // Perform atomic operations to ensure "increment only once"
                     if (is_terrain) {
                         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));
                         }
                     }
                 }
             }
         });
     }
  
     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
	)

 {
     // 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
	)

 {
     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
	)

 {
  
     // 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.query("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 )

 {
     // 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;
  
     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 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
	)

 {
     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 )

 {
     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`
	)

 {
     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 )

 {
     //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 )

 {
     // 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

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

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

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

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

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

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
	)

 {
  
     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 ( )

 {
     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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ WindFarm() [1/2]

◆ ~WindFarm()

◆ WindFarm() [2/2]

Member Function Documentation

◆ advance()

◆ fill_Nturb_multifab()

◆ fill_SMark_multifab()

◆ fill_SMark_multifab_mesoscale_models()

◆ init_windfarm_lat_lon()

◆ init_windfarm_x_y()

◆ read_tables()

◆ read_windfarm_airfoil_tables()

◆ read_windfarm_blade_table()

◆ read_windfarm_locations_table()

◆ read_windfarm_spec_table()

◆ read_windfarm_spec_table_extra()

◆ set_blade_airfoil_spec()

◆ set_blade_spec()

◆ set_turb_disk_angle()

◆ set_turb_loc()

◆ set_turb_spec()

◆ set_turb_spec_extra()

◆ SetModel()

◆ write_actuator_disks_vtk()

◆ write_turbine_locations_vtk()

Member Data Documentation

◆ blade_pitch

◆ bld_airfoil_aoa

◆ bld_airfoil_Cd

◆ bld_airfoil_Cl

◆ bld_chord

◆ bld_rad_loc

◆ bld_twist

◆ C_P

◆ C_T

◆ hub_height

◆ m_windfarm_model

◆ my_turb_disk_angle

◆ n_bld_sections

◆ nominal_power

◆ power

◆ rotor_rad

◆ rotor_RPM

◆ thrust_coeff

◆ thrust_coeff_standing

◆ velocity

◆ wind_speed

◆ xloc

◆ yloc

◆ zloc