ERF_Interpolation_1D.H File Reference

#include <AMReX_REAL.H>
#include "ERF_Constants.H"

Include dependency graph for ERF_Interpolation_1D.H:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	interpolate_1d (const amrex::Real *alpha, const amrex::Real *beta, const amrex::Real alpha_interp, const int alpha_size)
AMREX_FORCE_INLINE void	expand_and_interpolate_1d (amrex::Vector< amrex::Real > &znew, const amrex::Vector< amrex::Real > &zorig, int refine_fac, bool destag=false)

Function Documentation

expand_and_interpolate_1d()

AMREX_FORCE_INLINE void expand_and_interpolate_1d	(	amrex::Vector< amrex::Real > &	znew,
		const amrex::Vector< amrex::Real > &	zorig,
		int	refine_fac,
		bool	destag = false
	)

{
    const int Nz = zorig.size();
    const int Nz_refined = refine_fac*(Nz-1) + 1;
    if (destag) {
        AMREX_ALWAYS_ASSERT(znew.size() == Nz_refined-1);
    } else {
        AMREX_ALWAYS_ASSERT(znew.size() == Nz_refined);
    }
    amrex::Vector<amrex::Real> znew_stag(Nz_refined);
    for (int k=0; k < Nz; ++k) {
        znew_stag[refine_fac*k] = zorig[k];
    }
    if (refine_fac > 1) {
        for (int k=0; k < Nz-1; ++k) {
            amrex::Real z1 = zorig[k];
            amrex::Real dz = zorig[k+1] - z1;
            for (int koff=1; koff < refine_fac; ++koff) {
                znew_stag[refine_fac*k + koff] = amrex::Real(koff)/refine_fac * dz + z1;
            }
        }
    }
    if (destag) {
        for (int k=0; k < Nz_refined-1; ++k) {
            znew[k] = myhalf*(znew_stag[k] + znew_stag[k+1]);
        }
    } else {
        znew = znew_stag;
    }
}

Referenced by init_zlevels(), and ERF::setRayleighRefFromSounding().

Here is the call graph for this function:

Here is the caller graph for this function:

interpolate_1d()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real interpolate_1d	(	const amrex::Real *	alpha,
		const amrex::Real *	beta,
		const amrex::Real	alpha_interp,
		const int	alpha_size
	)

Interpolates 1D array beta at the location alpha_interp in the array alpha requiring 1D arrays alpha and beta to be the same size alpha_size. This routine assumes the alpha data are monotonic from lowest to highest.

{
    // We put this value here so beta_interp is initialized but the logic
    // below is such that it will always be assigned some other value.
    amrex::Real beta_interp = bogus_large_value;
 
    // A single point gives a constant: there is no second point to interpolate or
    //    extrapolate with
    if (alpha_size == 1) {
        return beta[0];
    }
 
    // If the interpolation point already exists in the array,
    // just return it
    for (int i = 0; i < alpha_size; ++i) {
        if (alpha[i] == alpha_interp) {
            beta_interp = beta[i];
            return beta_interp;
        }
    }
 
    // We didn't find an exact match for alpha_interp in alpha,
    // so we need linear interpolation/extrapolation
    amrex::Real alpha_min = alpha[0];
    amrex::Real alpha_max = alpha[alpha_size-1];
    if (alpha_interp >= alpha_min && alpha_interp <= alpha_max) //interpolate
    {
        for (int i = 0; i < alpha_size - 1; ++i)
        {
            if (alpha_interp >= alpha[i] && alpha_interp <= alpha[i + 1])
            {
                //y = y0 + (y1-y0)*(x-x0)/(x1-x0);
                amrex::Real y0 = beta[i];
                amrex::Real y1 = beta[i + 1];
                amrex::Real x = alpha_interp;
                amrex::Real x0 = alpha[i];
                amrex::Real x1 = alpha[i + 1];
                beta_interp = y0 + (y1 - y0)*(x - x0) / (x1 - x0);
                return beta_interp;
            }
        }
    }
    else //extrapolate
    {
        // y = y0 + ((x - x0) / (x1 - x0)) * (y1 - y0)
        int i = 0;
        if (alpha_interp > alpha_max)
        {
            i = alpha_size-2;
        }
        else if (alpha_interp >= alpha_min)
        {
            amrex::Abort("interpolate_1d: we shouldn't be here!");
        }
 
        amrex::Real y0 = beta[i];
        amrex::Real y1 = beta[i + 1];
        amrex::Real x = alpha_interp;
        amrex::Real x0 = alpha[i];
        amrex::Real x1 = alpha[i + 1];
        beta_interp = y0 + ((x - x0) / (x1 - x0)) * (y1 - y0);
        return beta_interp;
    }
 
    return beta_interp;
}

Referenced by Fitch::compute_power_output(), EWP::compute_power_output(), GeneralAD::compute_power_output(), SimpleAD::compute_power_output(), compute_source_terms_Fn_Ft(), ERF::init_Dirichlet_bc_data(), ERF::init_geo_wind_profile(), init_state_from_input_sounding(), init_state_from_input_sounding_hse(), init_velocities_from_input_sounding(), InputSpongeData::read_from_file(), InputSoundingData::read_from_file(), ERF::setRayleighRefFromSounding(), ERF::setSpongeRefFromSounding(), EWP::source_terms_cellcentered(), Fitch::source_terms_cellcentered(), and SimpleAD::source_terms_cellcentered().

Here is the caller graph for this function: