GeneralAD Class Reference

#include <ERF_GeneralAD.H>

Inheritance diagram for GeneralAD:

Collaboration diagram for GeneralAD:

Public Member Functions
	GeneralAD ()
virtual	~GeneralAD ()=default
void	advance (const amrex::Geometry &geom, const amrex::Real &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 amrex::Real &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_generalAD)
void	update (const amrex::Real &dt_advance, amrex::MultiFab &cons_in, amrex::MultiFab &U_old, amrex::MultiFab &V_old, amrex::MultiFab &W_old, const amrex::MultiFab &mf_vars)
void	compute_power_output (const amrex::Real &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
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
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

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

GeneralAD()

GeneralAD::GeneralAD ( )

inline

{}

~GeneralAD()

virtual GeneralAD::~GeneralAD ( )

virtualdefault

Member Function Documentation

advance()

void GeneralAD::advance ( const amrex::Geometry &  geom, const amrex::Real &  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 amrex::Real &  time  )

overridevirtual

Implements NullWindFarm.

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

compute_freestream_velocity()

void GeneralAD::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(),0.0);
     freestream_phi.resize(xloc.size(),0.0);
     disk_cell_count.resize(xloc.size(),0.0);
 
     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);
        Box tbx = mfi.nodaltilebox(0);
 
        ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
 
            if(SMark_array(i,j,k,0) != -1.0) {
                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-dreiction
                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),0.5));
                Gpu::Atomic::Add(&d_disk_cell_count_ptr[turb_index],1.0);
                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(),
                                  freestream_velocity.size(),
                                  amrex::ParallelContext::CommunicatorAll());
 
    amrex::ParallelAllReduce::Sum(freestream_phi.data(),
                                  freestream_phi.size(),
                                  amrex::ParallelContext::CommunicatorAll());
 
 
   amrex::ParallelAllReduce::Sum(disk_cell_count.data(),
                                 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";
        }
    }*/
}

compute_power_output()

void GeneralAD::compute_power_output

(

const amrex::Real &

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

Here is the call graph for this function:

source_terms_cellcentered()

void GeneralAD::source_terms_cellcentered	(	const amrex::Geometry &	geom,
		const amrex::MultiFab &	cons_in,
		const amrex::MultiFab &	mf_Smark,
		amrex::MultiFab &	mf_vars_generalAD
	)

{
 
    get_turb_loc(xloc, yloc);
 
    get_turb_spec(rotor_rad, hub_height, thrust_coeff_standing,
                  wind_speed, thrust_coeff, power);
 
    get_blade_spec(bld_rad_loc,bld_twist,bld_chord);
 
    get_blade_airfoil_spec(bld_airfoil_aoa, bld_airfoil_Cl, bld_airfoil_Cd);
 
    get_turb_spec_extra(velocity, C_P, C_T, rotor_RPM, blade_pitch);
 
    Real d_hub_height = hub_height;
    Real d_rotor_rad = rotor_rad;
 
    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();
      auto ProbLoArr = geom.ProbLoArray();
      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_generalAD.setVal(0.0);
 
     long unsigned int nturbs = xloc.size();
 
    // This is the angle phi in Fig. 10 in Mirocha et. al. 2014
    // set_turb_disk angle in ERF_InitWindFarm.cpp sets this phi as
    // the turb_disk_angle
    get_turb_disk_angle(turb_disk_angle);
    Real d_turb_disk_angle = turb_disk_angle;
 
    Gpu::DeviceVector<Real> d_freestream_velocity(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, disk_cell_count.begin(), disk_cell_count.end(), d_disk_cell_count.begin());
 
    Real* d_xloc_ptr = d_xloc.data();
    Real* d_yloc_ptr = d_yloc.data();
    Real* d_freestream_velocity_ptr = d_freestream_velocity.data();
    Real* d_disk_cell_count_ptr     = d_disk_cell_count.data();
 
    int n_bld_sections = bld_rad_loc.size();
 
    Gpu::DeviceVector<Real>    d_bld_rad_loc(n_bld_sections);
    Gpu::DeviceVector<Real>    d_bld_twist(n_bld_sections);
    Gpu::DeviceVector<Real>    d_bld_chord(n_bld_sections);
 
    Gpu::copy(Gpu::hostToDevice, bld_rad_loc.begin(), bld_rad_loc.end(), d_bld_rad_loc.begin());
    Gpu::copy(Gpu::hostToDevice, bld_twist.begin(), bld_twist.end(), d_bld_twist.begin());
    Gpu::copy(Gpu::hostToDevice, bld_chord.begin(), bld_chord.end(), d_bld_chord.begin());
 
    Real* bld_rad_loc_ptr = d_bld_rad_loc.data();
    Real* bld_twist_ptr = d_bld_twist.data();
    Real* bld_chord_ptr = d_bld_chord.data();
 
    Vector<Gpu::DeviceVector<Real>> d_bld_airfoil_aoa(n_bld_sections);
    Vector<Gpu::DeviceVector<Real>> d_bld_airfoil_Cl(n_bld_sections);
    Vector<Gpu::DeviceVector<Real>> d_bld_airfoil_Cd(n_bld_sections);
 
    int n_pts_airfoil = bld_airfoil_aoa[0].size();
 
    for(int i=0;i<n_bld_sections;i++){
        d_bld_airfoil_aoa[i].resize(n_pts_airfoil);
        d_bld_airfoil_Cl[i].resize(n_pts_airfoil);
        d_bld_airfoil_Cd[i].resize(n_pts_airfoil);
        Gpu::copy(Gpu::hostToDevice, bld_airfoil_aoa[i].begin(), bld_airfoil_aoa[i].end(), d_bld_airfoil_aoa[i].begin());
        Gpu::copy(Gpu::hostToDevice, bld_airfoil_Cl[i].begin(), bld_airfoil_Cl[i].end(), d_bld_airfoil_Cl[i].begin());
        Gpu::copy(Gpu::hostToDevice, bld_airfoil_Cd[i].begin(), bld_airfoil_Cd[i].end(), d_bld_airfoil_Cd[i].begin());
    }
 
    Vector<Real*> hp_bld_airfoil_aoa, hp_bld_airfoil_Cl, hp_bld_airfoil_Cd;
    for (auto & v :d_bld_airfoil_aoa) {
        hp_bld_airfoil_aoa.push_back(v.data());
    }
    for (auto & v :d_bld_airfoil_Cl) {
        hp_bld_airfoil_Cl.push_back(v.data());
    }
    for (auto & v :d_bld_airfoil_Cd) {
        hp_bld_airfoil_Cd.push_back(v.data());
    }
 
    Gpu::AsyncArray<Real*> aoa(hp_bld_airfoil_aoa.data(), n_bld_sections);
    Gpu::AsyncArray<Real*> Cl(hp_bld_airfoil_Cl.data(), n_bld_sections);
    Gpu::AsyncArray<Real*> Cd(hp_bld_airfoil_Cd.data(), n_bld_sections);
 
    auto d_bld_airfoil_aoa_ptr = aoa.data();
    auto d_bld_airfoil_Cl_ptr  = Cl.data();
    auto d_bld_airfoil_Cd_ptr  = Cd.data();
 
    int n_spec_extra = velocity.size();
 
    Gpu::DeviceVector<Real> d_velocity(n_spec_extra);
    Gpu::DeviceVector<Real> d_rotor_RPM(n_spec_extra);
    Gpu::DeviceVector<Real> d_blade_pitch(n_spec_extra);
 
    Gpu::copy(Gpu::hostToDevice, velocity.begin(), velocity.end(), d_velocity.begin());
    Gpu::copy(Gpu::hostToDevice, rotor_RPM.begin(), rotor_RPM.end(), d_rotor_RPM.begin());
    Gpu::copy(Gpu::hostToDevice, blade_pitch.begin(), blade_pitch.end(), d_blade_pitch.begin());
 
    auto d_velocity_ptr = d_velocity.data();
    auto d_rotor_RPM_ptr = d_rotor_RPM.data();
    auto d_blade_pitch_ptr = d_blade_pitch.data();
 
    for ( MFIter mfi(cons_in,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        const Box& gbx      = mfi.growntilebox(1);
        auto SMark_array    = mf_SMark.array(mfi);
        auto generalAD_array = mf_vars_generalAD.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 x   = ProbLoArr[0] + (ii+0.5)*dx[0];
            Real y   = ProbLoArr[1] + (jj+0.5)*dx[1];
            Real z   = ProbLoArr[2] + (kk+0.5)*dx[2];
            // ?? Density needed here
 
            int check_int = 0;
 
            Real source_x = 0.0, source_y = 0.0, source_z = 0.0;
            std::array<Real,2> Fn_and_Ft;
 
            for(long unsigned int it=0;it<nturbs;it++) {
                 Real avg_vel  = d_freestream_velocity_ptr[it]/(d_disk_cell_count_ptr[it] + 1e-10);
                 Real phi = d_turb_disk_angle;
 
                // This if check makes sure it is a point on the actuator disk
                if(SMark_array(ii,jj,kk,1) == static_cast<double>(it)) {
                    check_int++;
 
                    // Find radial distance of the point and the zeta angle
                    Real rad = std::pow( (x-d_xloc_ptr[it])*(x-d_xloc_ptr[it]) +
                                         (y-d_yloc_ptr[it])*(y-d_yloc_ptr[it]) +
                                         (z-d_hub_height)*(z-d_hub_height), 0.5 );
 
                    int index = find_rad_loc_index(rad, bld_rad_loc_ptr, n_bld_sections);
 
                    // This if check makes sure it is a point with radial distance
                    // between the hub radius and the rotor radius.
                    // ?? hub radius needed here
                    if(rad >= 2.0 and rad <= d_rotor_rad) {
                        //AMREX_ASSERT( (z-d_hub_height) <= rad );
                        // Consider the vector that joines the point and the turbine center.
                        // Dot it on to the vector that joins the turbine center and along
                        // the plane of the disk. See fig. 10 in Mirocha et. al. 2014.
 
                        Real vec_proj = (x-d_xloc_ptr[it])*(std::sin(phi)) +
                                        (y-d_yloc_ptr[it])*(-std::cos(phi));
 
 
                        Real zeta = std::atan2(z-d_hub_height, vec_proj);
                        //printf("zeta val is %0.15g\n", zeta*180.0/PI);
                        Fn_and_Ft = compute_source_terms_Fn_Ft(rad, avg_vel,
                                                               bld_rad_loc_ptr,
                                                               bld_twist_ptr,
                                                               bld_chord_ptr,
                                                               n_bld_sections,
                                                               d_bld_airfoil_aoa_ptr[index],
                                                               d_bld_airfoil_Cl_ptr[index],
                                                               d_bld_airfoil_Cd_ptr[index],
                                                               n_pts_airfoil,
                                                               d_velocity_ptr,
                                                               d_rotor_RPM_ptr,
                                                               d_blade_pitch_ptr,
                                                               n_spec_extra);
 
                        Real Fn = 3.0*Fn_and_Ft[0];
                        Real Ft = 3.0*Fn_and_Ft[1];
                        // Compute the source terms - pass in radial distance, free stream velocity
 
                        Real Fx = Fn*std::cos(phi) + Ft*std::sin(zeta)*std::sin(phi);
                        Real Fy = Fn*std::sin(phi) - Ft*std::sin(zeta)*std::cos(phi);
                        Real Fz = -Ft*std::cos(zeta);
 
                        //Real dn = (
 
                        source_x = -Fx/(2.0*PI*rad*dx[0])*1.0/std::pow(2.0*PI,0.5);
                        source_y = -Fy/(2.0*PI*rad*dx[0])*1.0/std::pow(2.0*PI,0.5);
                        source_z = -Fz/(2.0*PI*rad*dx[0])*1.0/std::pow(2.0*PI,0.5);
 
 
                        //printf("Val source_x, is %0.15g, %0.15g, %0.15g %0.15g %0.15g %0.15g\n", rad, Fn, Ft, source_x, source_y, source_z);
                    }
                }
            }
 
            if(check_int > 1){
                amrex::Error("Actuator disks are overlapping. Visualize actuator_disks.vtk "
                             "and check the windturbine locations input file. Exiting..");
            }
 
            generalAD_array(i,j,k,0) = source_x;
            generalAD_array(i,j,k,1) = source_y;
            generalAD_array(i,j,k,2) = source_z;
         });
    }
}

Here is the call graph for this function:

update()

void GeneralAD::update	(	const amrex::Real &	dt_advance,
		amrex::MultiFab &	cons_in,
		amrex::MultiFab &	U_old,
		amrex::MultiFab &	V_old,
		amrex::MultiFab &	W_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);
        Box tbz = mfi.nodaltilebox(2);
 
        auto generalAD_array = mf_vars_generalAD.array(mfi);
        auto u_vel       = U_old.array(mfi);
        auto v_vel       = V_old.array(mfi);
        auto w_vel       = W_old.array(mfi);
 
        ParallelFor(tbx, tby, tbz,
        [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            u_vel(i,j,k) = u_vel(i,j,k) + (generalAD_array(i-1,j,k,0) + generalAD_array(i,j,k,0))/2.0*dt_advance;
        },
        [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            v_vel(i,j,k) = v_vel(i,j,k) + (generalAD_array(i,j-1,k,1) + generalAD_array(i,j,k,1))/2.0*dt_advance;
        },
        [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            w_vel(i,j,k) = w_vel(i,j,k) + (generalAD_array(i,j,k-1,2) + generalAD_array(i,j,k,2))/2.0*dt_advance;
        });
 
    }
}

Member Data Documentation

blade_pitch

amrex::Vector<amrex::Real> GeneralAD::blade_pitch

protected

bld_airfoil_aoa

amrex::Vector<amrex::Vector<amrex::Real> > GeneralAD::bld_airfoil_aoa

protected

bld_airfoil_Cd

amrex::Vector<amrex::Vector<amrex::Real> > GeneralAD::bld_airfoil_Cd

protected

bld_airfoil_Cl

amrex::Vector<amrex::Vector<amrex::Real> > GeneralAD::bld_airfoil_Cl

protected

bld_chord

amrex::Vector<amrex::Real> GeneralAD::bld_chord

protected

bld_rad_loc

amrex::Vector<amrex::Real> GeneralAD::bld_rad_loc

protected

bld_twist

amrex::Vector<amrex::Real> GeneralAD::bld_twist

protected

C_P

amrex::Vector<amrex::Real> GeneralAD::C_P

protected

C_T

amrex::Vector<amrex::Real> GeneralAD::C_T

protected

disk_cell_count

amrex::Vector<amrex::Real> GeneralAD::disk_cell_count

protected

freestream_phi

amrex::Vector<amrex::Real> GeneralAD::freestream_phi

protected

freestream_velocity

amrex::Vector<amrex::Real> GeneralAD::freestream_velocity

protected

hub_height

amrex::Real GeneralAD::hub_height

protected

nominal_power

amrex::Real GeneralAD::nominal_power

protected

power

amrex::Vector<amrex::Real> GeneralAD::power

protected

rotor_rad

amrex::Real GeneralAD::rotor_rad

protected

rotor_RPM

amrex::Vector<amrex::Real> GeneralAD::rotor_RPM

protected

thrust_coeff

amrex::Vector<amrex::Real> GeneralAD::thrust_coeff

protected

thrust_coeff_standing

amrex::Real GeneralAD::thrust_coeff_standing

protected

turb_disk_angle

amrex::Real GeneralAD::turb_disk_angle

protected

velocity

amrex::Vector<amrex::Real> GeneralAD::velocity

protected

wind_speed

amrex::Vector<amrex::Real> GeneralAD::wind_speed

protected

xloc

amrex::Vector<amrex::Real> GeneralAD::xloc

protected

yloc

amrex::Vector<amrex::Real> GeneralAD::yloc

protected

---

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

• Source/WindFarmParametrization/GeneralActuatorDisk/ERF_GeneralAD.H
• Source/WindFarmParametrization/GeneralActuatorDisk/ERF_AdvanceGeneralAD.cpp