SimpleAD Class Reference

#include <ERF_SimpleAD.H>

Inheritance diagram for SimpleAD:

Collaboration diagram for SimpleAD:

Public Member Functions
	SimpleAD ()
virtual	~SimpleAD ()=default
void	advance (const amrex::Geometry &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	compute_freestream_velocity (const amrex::MultiFab &cons_in, const amrex::MultiFab &U_old, const amrex::MultiFab &V_old, const amrex::MultiFab &mf_SMark)
void	source_terms_cellcentered (const amrex::Geometry &geom, const amrex::MultiFab &cons_in, const amrex::MultiFab &mf_Smark, amrex::MultiFab &mf_vars_simpleAD)
void	update (const double &dt_advance, amrex::MultiFab &cons_in, amrex::MultiFab &U_old, amrex::MultiFab &V_old, const amrex::MultiFab &mf_vars)
void	compute_power_output (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	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 >	freestream_velocity
amrex::Vector< amrex::Real >	freestream_phi
amrex::Vector< amrex::Real >	disk_cell_count
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

SimpleAD()

SimpleAD::SimpleAD ( )

inline

{}

~SimpleAD()

virtual SimpleAD::~SimpleAD ( )

virtualdefault

Member Function Documentation

advance()

void SimpleAD::advance ( const amrex::Geometry &  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  )

overridevirtual

Implements NullWindFarm.

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

Here is the call graph for this function:

compute_freestream_velocity()

void SimpleAD::compute_freestream_velocity	(	const amrex::MultiFab &	cons_in,
		const amrex::MultiFab &	U_old,
		const amrex::MultiFab &	V_old,
		const amrex::MultiFab &	mf_SMark
	)

{
     get_turb_loc(xloc, yloc);
     freestream_velocity.clear();
     freestream_phi.clear();
     disk_cell_count.clear();
     freestream_velocity.resize(xloc.size(),zero);
     freestream_phi.resize(xloc.size(),zero);
     disk_cell_count.resize(xloc.size(),zero);
 
     Gpu::DeviceVector<Real> d_freestream_velocity(xloc.size());
     Gpu::DeviceVector<Real> d_freestream_phi(yloc.size());
     Gpu::DeviceVector<Real> d_disk_cell_count(yloc.size());
     Gpu::copy(Gpu::hostToDevice, freestream_velocity.begin(), freestream_velocity.end(), d_freestream_velocity.begin());
     Gpu::copy(Gpu::hostToDevice, freestream_phi.begin(), freestream_phi.end(), d_freestream_phi.begin());
     Gpu::copy(Gpu::hostToDevice, disk_cell_count.begin(), disk_cell_count.end(), d_disk_cell_count.begin());
 
     Real* d_freestream_velocity_ptr = d_freestream_velocity.data();
     Real* d_freestream_phi_ptr = d_freestream_phi.data();
     Real* d_disk_cell_count_ptr     = d_disk_cell_count.data();
 
 
     for ( MFIter mfi(cons_in,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        auto SMark_array    = mf_SMark.array(mfi);
        auto u_vel          = U_old.array(mfi);
        auto v_vel          = V_old.array(mfi);
        // NOTE: this reduction is driven by the cell-centered SMark, 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 sums 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) {
                int turb_index = static_cast<int>(SMark_array(i,j,k,0));
                Real phi = std::atan2(v_vel(i,j,k),u_vel(i,j,k)); // Wind direction w.r.t the x-direction
                Gpu::Atomic::Add(&d_freestream_velocity_ptr[turb_index],std::pow(u_vel(i,j,k)*u_vel(i,j,k) + v_vel(i,j,k)*v_vel(i,j,k),myhalf));
                Gpu::Atomic::Add(&d_disk_cell_count_ptr[turb_index],one);
                Gpu::Atomic::Add(&d_freestream_phi_ptr[turb_index],phi);
            }
        });
    }
 
    // Copy back to host
    Gpu::copy(Gpu::deviceToHost, d_freestream_velocity.begin(), d_freestream_velocity.end(), freestream_velocity.begin());
    Gpu::copy(Gpu::deviceToHost, d_freestream_phi.begin(), d_freestream_phi.end(), freestream_phi.begin());
    Gpu::copy(Gpu::deviceToHost, d_disk_cell_count.begin(), d_disk_cell_count.end(), disk_cell_count.begin());
 
    // Reduce the data on every processor
    amrex::ParallelAllReduce::Sum(freestream_velocity.data(),
                                  static_cast<int>(freestream_velocity.size()),
                                  amrex::ParallelContext::CommunicatorAll());
 
    amrex::ParallelAllReduce::Sum(freestream_phi.data(),
                                  static_cast<int>(freestream_phi.size()),
                                  amrex::ParallelContext::CommunicatorAll());
 
 
   amrex::ParallelAllReduce::Sum(disk_cell_count.data(),
                                 static_cast<int>(disk_cell_count.size()),
                                 amrex::ParallelContext::CommunicatorAll());
 
    get_turb_loc(xloc, yloc);
    /*if (ParallelDescriptor::IOProcessor()){
        for(int it=0; it<xloc.size(); it++){
 
            std::cout << "turbine index, freestream velocity is " << it << " " << freestream_velocity[it] << " " <<
                                                               disk_cell_count[it]  <<  " " <<
                                                                freestream_velocity[it]/(disk_cell_count[it] + 1e-10) << " " <<
                                                                freestream_phi[it]/(disk_cell_count[it] + 1e-10) << "\n";
        }
    }*/
}

Here is the call graph for this function:

compute_power_output()

void SimpleAD::compute_power_output

(

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());
  // Compute power based on the look-up table
 
    if (ParallelDescriptor::IOProcessor()){
        static std::ofstream file("power_output_SimpleAD.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");
        }
        Real total_power = zero;
        for(int it=0; it<static_cast<int>(xloc.size()); it++){
            Real avg_vel = freestream_velocity[it]/(disk_cell_count[it] + Real(1e-10));
            Real turb_power = interpolate_1d(wind_speed.data(), power.data(), avg_vel, n_spec_table);
            total_power = total_power + turb_power;
            //printf("avg vel and power is %d %0.15g, %0.15g\n", it, avg_vel, turb_power);
        }
        file << time << " " << total_power << "\n";
        file.flush();
    }
}

Here is the call graph for this function:

source_terms_cellcentered()

void SimpleAD::source_terms_cellcentered	(	const amrex::Geometry &	geom,
		const amrex::MultiFab &	cons_in,
		const amrex::MultiFab &	mf_Smark,
		amrex::MultiFab &	mf_vars_simpleAD
	)

{
 
    get_turb_loc(xloc, yloc);
    get_turb_spec(rotor_rad, hub_height, thrust_coeff_standing,
                  wind_speed, thrust_coeff, power);
 
    Gpu::DeviceVector<Real> d_xloc(xloc.size());
    Gpu::DeviceVector<Real> d_yloc(yloc.size());
    Gpu::copy(Gpu::hostToDevice, xloc.begin(), xloc.end(), d_xloc.begin());
    Gpu::copy(Gpu::hostToDevice, yloc.begin(), yloc.end(), d_yloc.begin());
 
      auto dx = geom.CellSizeArray();
 
  // Domain valid box
      const amrex::Box& domain = geom.Domain();
      int domlo_x = domain.smallEnd(0);
      int domhi_x = domain.bigEnd(0) + 1;
      int domlo_y = domain.smallEnd(1);
      int domhi_y = domain.bigEnd(1) + 1;
      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_simpleAD.setVal(0.0);
 
      long unsigned int nturbs = static_cast<long unsigned int>(xloc.size());
 
     Gpu::DeviceVector<Real> d_freestream_velocity(nturbs);
     Gpu::DeviceVector<Real> d_freestream_phi(nturbs);
     Gpu::DeviceVector<Real> d_disk_cell_count(nturbs);
     Gpu::copy(Gpu::hostToDevice, freestream_velocity.begin(), freestream_velocity.end(), d_freestream_velocity.begin());
     Gpu::copy(Gpu::hostToDevice, freestream_phi.begin(), freestream_phi.end(), d_freestream_phi.begin());
     Gpu::copy(Gpu::hostToDevice, disk_cell_count.begin(), disk_cell_count.end(), d_disk_cell_count.begin());
 
     Real* d_freestream_velocity_ptr = d_freestream_velocity.data();
     Real* d_freestream_phi_ptr = d_freestream_phi.data();
     Real* d_disk_cell_count_ptr     = d_disk_cell_count.data();
 
    get_turb_disk_angle(turb_disk_angle);
    Real nx = -std::cos(turb_disk_angle);
    Real ny = -std::sin(turb_disk_angle);
 
    // How much rotor area to attribute to each cell that the disk passes through.
    // WindFarm::fill_SMark_multifab marks the staircase of cells that the disk plane
    // cuts -- one cell per crossing -- so the average area of disk inside a marked cell
    // is dz times the mean chord of a line with normal (nx,ny) across a dx by dy cell,
    //
    //     A_cell = dx*dy*dz / (|nx|*dx + |ny|*dy)
    //
    // This is dy*dz for a disk facing x and dx*dz for a disk facing y, and summing it
    // over the marked cells recovers the rotor area at any angle in between. It replaces
    // a signed dy*dz*cos(turb_disk_angle), which vanished for a disk facing y (i.e. for
    // erf.turb_disk_angle_from_x of 0 or 180) and changed sign past 180 degrees, turning
    // the momentum sink into a source (issue #3673)
    Real area_over_vol = one/(std::abs(nx)*dx[0] + std::abs(ny)*dx[1]);
 
    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());
 
    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());
 
    for ( MFIter mfi(cons_in,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        const Box& gbx      = mfi.growntilebox(1);
        auto SMark_array    = mf_SMark.array(mfi);
        auto simpleAD_array = mf_vars_simpleAD.array(mfi);
 
        ParallelFor(gbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
            int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
            int kk = amrex::min(amrex::max(k, domlo_z), domhi_z);
 
 
            Real source_x = zero;
            Real source_y = zero;
 
            int it = static_cast<int>(SMark_array(ii,jj,kk,1));
 
              if(it != -1) {
                Real avg_vel  = d_freestream_velocity_ptr[it]/(d_disk_cell_count_ptr[it] + Real(1e-10));
                Real phi      = d_freestream_phi_ptr[it]/(d_disk_cell_count_ptr[it] + Real(1e-10));
 
                Real C_T = interpolate_1d(wind_speed_d, thrust_coeff_d, avg_vel, n_spec_table);
                Real a;
                if(C_T <= 1) {
                    a = myhalf - myhalf*std::pow(one-C_T,myhalf);
                }
                Real Uinfty_dot_nhat = avg_vel*(std::cos(phi)*nx + std::sin(phi)*ny);
                    if(C_T <= 1) {
                        source_x = -two*std::pow(Uinfty_dot_nhat, two)*a*(one-a)*area_over_vol*std::cos(phi);
                        source_y = -two*std::pow(Uinfty_dot_nhat, two)*a*(one-a)*area_over_vol*std::sin(phi);
                    }
                    else {
                        source_x = -myhalf*C_T*std::pow(Uinfty_dot_nhat, two)*area_over_vol*std::cos(phi);
                        source_y = -myhalf*C_T*std::pow(Uinfty_dot_nhat, two)*area_over_vol*std::sin(phi);
                    }
             }
 
            simpleAD_array(i,j,k,0) = source_x;
            simpleAD_array(i,j,k,1) = source_y;
         });
    }
}

Here is the call graph for this function:

update()

void SimpleAD::update	(	const double &	dt_advance,
		amrex::MultiFab &	cons_in,
		amrex::MultiFab &	U_old,
		amrex::MultiFab &	V_old,
		const amrex::MultiFab &	mf_vars
	)

{
 
    for ( MFIter mfi(cons_in,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        Box tbx = mfi.nodaltilebox(0);
        Box tby = mfi.nodaltilebox(1);
 
        auto simpleAD_array = mf_vars_simpleAD.array(mfi);
        auto u_vel       = U_old.array(mfi);
        auto v_vel       = V_old.array(mfi);
 
        ParallelFor(tbx, tby,
        [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            u_vel(i,j,k) = u_vel(i,j,k) + (simpleAD_array(i-1,j,k,0) + simpleAD_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) + (simpleAD_array(i,j-1,k,1) + simpleAD_array(i,j,k,1))/two*dt_advance;
        });
    }
}

Here is the call graph for this function:

Member Data Documentation

disk_cell_count

amrex::Vector<amrex::Real> SimpleAD::disk_cell_count

protected

freestream_phi

amrex::Vector<amrex::Real> SimpleAD::freestream_phi

protected

freestream_velocity

amrex::Vector<amrex::Real> SimpleAD::freestream_velocity

protected

hub_height

amrex::Real SimpleAD::hub_height

protected

nominal_power

amrex::Real SimpleAD::nominal_power

protected

power

amrex::Vector<amrex::Real> SimpleAD::power

protected

rotor_rad

amrex::Real SimpleAD::rotor_rad

protected

thrust_coeff

amrex::Vector<amrex::Real> SimpleAD::thrust_coeff

protected

thrust_coeff_standing

amrex::Real SimpleAD::thrust_coeff_standing

protected

turb_disk_angle

amrex::Real SimpleAD::turb_disk_angle

protected

wind_speed

amrex::Vector<amrex::Real> SimpleAD::wind_speed

protected

xloc

amrex::Vector<amrex::Real> SimpleAD::xloc

protected

yloc

amrex::Vector<amrex::Real> SimpleAD::yloc

protected

---

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

• Source/WindFarmParametrization/SimpleActuatorDisk/ERF_SimpleAD.H
• Source/WindFarmParametrization/SimpleActuatorDisk/ERF_AdvanceSimpleAD.cpp