EWP Class Reference

#include <ERF_EWP.H>

Inheritance diagram for EWP:

Collaboration diagram for EWP:

Public Member Functions
	EWP ()
virtual	~EWP ()=default
void	advance (const amrex::Geometry &geom, const double &dt_advance, amrex::MultiFab &cons_in, amrex::MultiFab &mf_vars_ewp, 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	source_terms_cellcentered (const amrex::Geometry &geom, const amrex::MultiFab &cons_in, amrex::MultiFab &mf_vars, const amrex::MultiFab &U_old, const amrex::MultiFab &V_old, const amrex::MultiFab &W_old, const amrex::MultiFab &mf_Nturb)
void	update (const double &dt_advance, amrex::MultiFab &cons_in, amrex::MultiFab &U_old, amrex::MultiFab &V_old, const amrex::MultiFab &mf_vars_ewp)
void	compute_power_output (const amrex::MultiFab &cons_in, const amrex::MultiFab &U_old, const amrex::MultiFab &V_old, const amrex::MultiFab &W_old, const amrex::MultiFab &mf_SMark, const amrex::MultiFab &mf_Nturb, const double &time)
Public Member Functions inherited from NullWindFarm
	NullWindFarm ()
virtual	~NullWindFarm ()=default
virtual void	set_turb_spec (const amrex::Real &rotor_rad, const amrex::Real &hub_height, const amrex::Real &thrust_coeff_standing, const amrex::Vector< amrex::Real > &wind_speed, const amrex::Vector< amrex::Real > &thrust_coeff, const amrex::Vector< amrex::Real > &power)
virtual void	set_turb_loc (const amrex::Vector< amrex::Real > &xloc, const amrex::Vector< amrex::Real > &yloc)
virtual void	set_turb_disk_angle (const amrex::Real &turb_disk_angle)
virtual void	set_blade_spec (const amrex::Vector< amrex::Real > &bld_rad_loc, const amrex::Vector< amrex::Real > &bld_twist, const amrex::Vector< amrex::Real > &bld_chord)
virtual void	set_blade_airfoil_spec (const amrex::Vector< amrex::Vector< amrex::Real >> &bld_airfoil_aoa, const amrex::Vector< amrex::Vector< amrex::Real >> &bld_airfoil_Cl, const amrex::Vector< amrex::Vector< amrex::Real >> &bld_airfoil_Cd)
virtual void	set_turb_spec_extra (const amrex::Vector< amrex::Real > &velocity, const amrex::Vector< amrex::Real > &C_P, const amrex::Vector< amrex::Real > &C_T, const amrex::Vector< amrex::Real > &rotor_RPM, const amrex::Vector< amrex::Real > &blade_pitch)
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 Attributes
amrex::Vector< amrex::Real >	xloc
amrex::Vector< amrex::Real >	yloc
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
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

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

EWP()

EWP::EWP ( )

inline

{}

~EWP()

virtual EWP::~EWP ( )

virtualdefault

Member Function Documentation

advance()

void EWP::advance ( const amrex::Geometry &  geom, const double &  dt_advance, amrex::MultiFab &  cons_in, amrex::MultiFab &  mf_vars_ewp, 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  )

overridevirtual

Implements NullWindFarm.

 {
    AMREX_ALWAYS_ASSERT(mf_SMark.nComp() > 0);
    AMREX_ALWAYS_ASSERT(time > -one);
    source_terms_cellcentered(geom, cons_in, mf_vars_ewp, U_old, V_old, W_old, mf_Nturb);
    update(dt_advance, cons_in, U_old, V_old, mf_vars_ewp);
    compute_power_output(cons_in, U_old, V_old, W_old, mf_SMark, mf_Nturb, time);
}

Here is the call graph for this function:

compute_power_output()

void EWP::compute_power_output	(	const amrex::MultiFab &	cons_in,
		const amrex::MultiFab &	U_old,
		const amrex::MultiFab &	V_old,
		const amrex::MultiFab &	W_old,
		const amrex::MultiFab &	mf_SMark,
		const amrex::MultiFab &	mf_Nturb,
		const double &	time
	)

{
     get_turb_loc(xloc, yloc);
     get_turb_spec(rotor_rad, hub_height, thrust_coeff_standing,
                  wind_speed, thrust_coeff, power);
 
     const int n_spec_table = static_cast<int>(wind_speed.size());
 
     Gpu::DeviceVector<Real> d_wind_speed(wind_speed.size());
     Gpu::DeviceVector<Real> d_power(wind_speed.size());
     Gpu::copy(Gpu::hostToDevice, wind_speed.begin(), wind_speed.end(), d_wind_speed.begin());
     Gpu::copy(Gpu::hostToDevice, power.begin(), power.end(), d_power.begin());
 
    Gpu::DeviceScalar<Real> d_total_power(zero);
    Real* d_total_power_ptr = d_total_power.dataPtr();
 
     const Real* d_wind_speed_ptr  = d_wind_speed.dataPtr();
     const Real* d_power_ptr  = d_power.dataPtr();
 
     for ( MFIter mfi(cons_in,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        auto SMark_array    = mf_SMark.array(mfi);
        auto Nturb_array    = mf_Nturb.array(mfi);
        auto u_vel          = U_old.array(mfi);
        auto v_vel          = V_old.array(mfi);
        auto w_vel          = W_old.array(mfi);
        // NOTE: this reduction is driven by the cell-centered SMark/Nturb, so it
        //       must run over the cell-centered tilebox. Using nodaltilebox(0)
        //       here would include the plane at bigEnd(0)+1, which is a ghost
        //       cell of this box and a valid cell of its x-neighbor, and so
        //       would count that plane twice in the power sum below.
        Box tbx = mfi.tilebox();
 
        ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
 
            if(SMark_array(i,j,k,0) == one) {
                Real avg_vel = std::pow(u_vel(i,j,k)*u_vel(i,j,k) +
                                        v_vel(i,j,k)*v_vel(i,j,k) +
                                        w_vel(i,j,k)*w_vel(i,j,k),myhalf);
                Real turb_power = interpolate_1d(d_wind_speed_ptr, d_power_ptr, avg_vel, n_spec_table);
                turb_power = turb_power*Nturb_array(i,j,k,0);
                Gpu::Atomic::Add(d_total_power_ptr,turb_power);
            }
        });
    }
 
    Real h_total_power = zero;
    Gpu::copy(Gpu::deviceToHost, d_total_power.dataPtr(), d_total_power.dataPtr()+1, &h_total_power);
 
    amrex::ParallelAllReduce::Sum(&h_total_power, 1, amrex::ParallelContext::CommunicatorAll());
 
    if (ParallelDescriptor::IOProcessor()){
        static std::ofstream file("power_output_EWP.txt", std::ios::app);
        // Check if the file opened successfully
        if (!file.is_open()) {
            std::cerr << "Error opening file!" << std::endl;
            Abort("Could not open file to write power output in ERF_AdvanceSimpleAD.cpp");
        }
        file << time << " " << h_total_power << "\n";
        file.flush();
    }
}

Here is the call graph for this function:

source_terms_cellcentered()

void EWP::source_terms_cellcentered	(	const amrex::Geometry &	geom,
		const amrex::MultiFab &	cons_in,
		amrex::MultiFab &	mf_vars,
		const amrex::MultiFab &	U_old,
		const amrex::MultiFab &	V_old,
		const amrex::MultiFab &	W_old,
		const amrex::MultiFab &	mf_Nturb
	)

{
 
  get_turb_spec(rotor_rad, hub_height, thrust_coeff_standing,
                  wind_speed, thrust_coeff, power);
 
  auto dx = geom.CellSizeArray();
  auto ProbLoArr = geom.ProbLoArray();
  Real sigma_0 = Real(1.7)*rotor_rad;
 
  Real d_rotor_rad = rotor_rad;
  Real d_hub_height = hub_height;
 
  Gpu::DeviceVector<Real> d_wind_speed(wind_speed.size());
  Gpu::DeviceVector<Real> d_thrust_coeff(thrust_coeff.size());
 
  // Copy data from host vectors to device vectors
  Gpu::copy(Gpu::hostToDevice, wind_speed.begin(), wind_speed.end(), d_wind_speed.begin());
  Gpu::copy(Gpu::hostToDevice, thrust_coeff.begin(), thrust_coeff.end(), d_thrust_coeff.begin());
 
 
  // Domain valid box
  const amrex::Box& domain = geom.Domain();
  int domlo_z = domain.smallEnd(2);
  int domhi_z = domain.bigEnd(2) + 1;
 
  // The order of variables are - Vabs dVabsdt, dudt, dvdt, dTKEdt
  mf_vars_ewp.setVal(0.0);
 
  for ( MFIter mfi(cons_in,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        const Box& gbx = mfi.growntilebox(1);
        auto ewp_array = mf_vars_ewp.array(mfi);
        auto Nturb_array = mf_Nturb.array(mfi);
        auto u_vel       = U_old.array(mfi);
        auto v_vel       = V_old.array(mfi);
        auto w_vel       = W_old.array(mfi);
 
        const Real* wind_speed_d     = d_wind_speed.dataPtr();
        const Real* thrust_coeff_d   = d_thrust_coeff.dataPtr();
        const int n_spec_table = static_cast<int>(d_wind_speed.size());
 
        ParallelFor(gbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
 
            int kk = amrex::min(amrex::max(k, domlo_z), domhi_z);
            Real z = ProbLoArr[2] + (kk+myhalf) * dx[2];
 
            // Compute Fitch source terms
 
            Real Vabs = std::pow(u_vel(i,j,k)*u_vel(i,j,k) +
                                 v_vel(i,j,k)*v_vel(i,j,k) +
                                 w_vel(i,j,kk)*w_vel(i,j,kk), myhalf);
 
            Real C_T = interpolate_1d(wind_speed_d, thrust_coeff_d, Vabs, n_spec_table);
 
            Real C_TKE = zero;
            Real K_turb = Real(6.0);
 
            Real L_wake = std::pow(dx[0]*dx[1],myhalf)/two;
            Real sigma_e = Vabs/(three*K_turb*L_wake)*
                           (std::pow(two*K_turb*L_wake/Vabs + std::pow(sigma_0,2),three/two) - amrex::Math::powi<3>(sigma_0));
 
            Real phi     = std::atan2(v_vel(i,j,k),u_vel(i,j,k)); // Wind direction w.r.t the x-dreiction
            Real fac = -std::pow(PI/Real(8.0),myhalf)*C_T*amrex::Math::powi<2>(d_rotor_rad)*
                        amrex::Math::powi<2>(Vabs)/(dx[0]*dx[1]*sigma_e)*
                        std::exp(-myhalf*amrex::Math::powi<2>((z - d_hub_height)/sigma_e));
            ewp_array(i,j,k,0) = fac*std::cos(phi)*Nturb_array(i,j,k);
            ewp_array(i,j,k,1) = fac*std::sin(phi)*Nturb_array(i,j,k);
            ewp_array(i,j,k,2) = C_TKE*zero;
         });
    }
}

Here is the call graph for this function:

update()

void EWP::update	(	const double &	dt_advance,
		amrex::MultiFab &	cons_in,
		amrex::MultiFab &	U_old,
		amrex::MultiFab &	V_old,
		const amrex::MultiFab &	mf_vars_ewp
	)

{
 
    for ( MFIter mfi(cons_in,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        Box bx  = mfi.tilebox();
        Box tbx = mfi.nodaltilebox(0);
        Box tby = mfi.nodaltilebox(1);
 
        auto cons_array  = cons_in.array(mfi);
        auto ewp_array = mf_vars_ewp.array(mfi);
        auto u_vel       = U_old.array(mfi);
        auto v_vel       = V_old.array(mfi);
 
        ParallelFor(tbx, tby, bx,
        [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            u_vel(i,j,k) = u_vel(i,j,k) + (ewp_array(i-1,j,k,0) + ewp_array(i,j,k,0))/two*dt_advance;
        },
        [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            v_vel(i,j,k) = v_vel(i,j,k) + (ewp_array(i,j-1,k,1) + ewp_array(i,j,k,1))/two*dt_advance;
        },
        [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            cons_array(i,j,k,RhoKE_comp) = cons_array(i,j,k,RhoKE_comp) + ewp_array(i,j,k,2)*dt_advance;
        });
    }
}

Here is the call graph for this function:

Member Data Documentation

hub_height

amrex::Real EWP::hub_height

protected

nominal_power

amrex::Real EWP::nominal_power

protected

power

amrex::Vector<amrex::Real> EWP::power

protected

rotor_rad

amrex::Real EWP::rotor_rad

protected

thrust_coeff

amrex::Vector<amrex::Real> EWP::thrust_coeff

protected

thrust_coeff_standing

amrex::Real EWP::thrust_coeff_standing

protected

wind_speed

amrex::Vector<amrex::Real> EWP::wind_speed

protected

xloc

amrex::Vector<amrex::Real> EWP::xloc

protected

yloc

amrex::Vector<amrex::Real> EWP::yloc

protected

---

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

• Source/WindFarmParametrization/EWP/ERF_EWP.H
• Source/WindFarmParametrization/EWP/ERF_AdvanceEWP.cpp