InputSoundingData Struct Reference

#include <ERF_InputSoundingData.H>

Collaboration diagram for InputSoundingData:

Public Member Functions
	InputSoundingData ()
	Construct input sounding metadata from the ERF input namespace. More...
void	resize_arrays ()
	Resize host and device sounding arrays for the configured sounding times. More...
void	read_from_file (const amrex::Geometry &geom, const amrex::Vector< amrex::Real > &zlevels_stag, int itime, bool is_moist)
	Read and interpolate one input sounding profile onto level-0 heights. More...
void	calc_rho_p (int itime)
	Hydrostatically integrate density and pressure for one sounding. More...
void	calc_rho_p_isentropic (int itime)
	Compute density and pressure for an isentropic sounding profile. More...
void	host_to_device (int itime)
	Copy host sounding arrays for one time index to device storage. More...
int	size (int itime) const
	Return the number of interpolated samples for one sounding time. More...

Public Attributes
int	ntimes
	Number of sounding times represented in the arrays. More...
amrex::Real	tau_nudging = amrex::Real(5.0)
	Nudging time scale for relaxing toward input sounding data. More...
amrex::Vector< std::string >	input_sounding_file = {}
	Sounding file path for each configured sounding time. More...
amrex::Vector< amrex::Real >	input_sounding_time = {}
	Physical time associated with each input sounding file. More...
int	n_sounding_files = 0
	Number of input sounding files. More...
int	n_sounding_times = 0
	Number of input sounding times. More...
bool	assume_dry {false}
	Whether to ignore moisture in isentropic pressure integration. More...
amrex::Real	press_ref_inp_sound
	Surface reference pressure read from the input sounding [Pa]. More...
amrex::Real	theta_ref_inp_sound
	Surface reference potential temperature read from the input sounding [K]. More...
amrex::Real	qv_ref_inp_sound
	Surface reference water vapor mixing ratio read from the input sounding [kg/kg]. More...
amrex::Vector< amrex::Vector< amrex::Real > >	z_inp_sound
	Interpolated host sounding heights for each sounding time [m]. More...
amrex::Vector< amrex::Vector< amrex::Real > >	theta_inp_sound
	Interpolated host potential temperature profiles [K]. More...
amrex::Vector< amrex::Vector< amrex::Real > >	qv_inp_sound
	Interpolated host water vapor mixing ratio profiles [kg/kg]. More...
amrex::Vector< amrex::Vector< amrex::Real > >	U_inp_sound
	Interpolated host x velocity profiles. More...
amrex::Vector< amrex::Vector< amrex::Real > >	V_inp_sound
	Interpolated host y velocity profiles. More...
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > >	z_inp_sound_d
	Device sounding heights for each sounding time [m]. More...
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > >	theta_inp_sound_d
	Device potential temperature profiles [K]. More...
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > >	qv_inp_sound_d
	Device water vapor mixing ratio profiles [kg/kg]. More...
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > >	U_inp_sound_d
	Device x velocity profiles. More...
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > >	V_inp_sound_d
	Device y velocity profiles. More...
amrex::Vector< amrex::Real >	pm_integ
	Hydrostatically integrated moist pressure profile. More...
amrex::Vector< amrex::Real >	rhod_integ
	Hydrostatically integrated dry density profile. More...
amrex::Gpu::DeviceVector< amrex::Real >	p_inp_sound_d
	Device pressure profile used to initialize solution fields. More...
amrex::Gpu::DeviceVector< amrex::Real >	rho_inp_sound_d
	Device density profile used to initialize solution fields. More...

Detailed Description

Data structure storing input sounding data. Also handles reading the input file for sounding data and hydrostatic column integration.

Constructor & Destructor Documentation

InputSoundingData()

InputSoundingData::InputSoundingData ( )

inline

Construct input sounding metadata from the ERF input namespace.

    {
        amrex::ParmParse pp("erf");
        pp.query("tau_nudging", tau_nudging);
 
        // Read in input_sounding filename
        n_sounding_files = pp.countval("input_sounding_file");
        if (n_sounding_files > 0) {
            input_sounding_file.resize(n_sounding_files);
            pp.queryarr("input_sounding_file", input_sounding_file, 0, n_sounding_files);
        } else {
            n_sounding_files = 1;
            input_sounding_file.resize(n_sounding_files);
            input_sounding_file[0] = "input_sounding";
        }
 
        // Read in input_sounding times
        n_sounding_times = pp.countval("input_sounding_time");
 
        if (n_sounding_times > 0) {
            input_sounding_time.resize(n_sounding_times);
            pp.queryarr("input_sounding_time", input_sounding_time, 0, n_sounding_times);
        } else {
            n_sounding_times = 1;
            input_sounding_time.resize(n_sounding_times);
            input_sounding_time[0] = zero;
        }
 
        // If we have more files than times or times than files we just use the minimum
        int n = std::min(n_sounding_times, n_sounding_files);
        n_sounding_files = n;
        n_sounding_times = n;
        input_sounding_file.resize(n);
        input_sounding_time.resize(n);
    }

Here is the call graph for this function:

Member Function Documentation

calc_rho_p()

void InputSoundingData::calc_rho_p ( int  itime )

inline

Hydrostatically integrate density and pressure for one sounding.

Parameters

itime

Sounding time/file index to integrate.

    {
        /* Calculate density and pressure, roughly following the procedure in
         * WRF dyn_em/module_initialize_ideal.F. We integrate hydrostatically
         * from the surface up through the air column to get the dry density
         * and moist pressure.
         */
        const amrex::Real tol = amrex::Real(1.0e-12);
        const int Ninp = size(itime);
        pm_integ.resize(Ninp);
        rhod_integ.resize(Ninp);
 
        // evaluate surface quantities (k=0): total pressure and dry air
          pm_integ[0] = press_ref_inp_sound;
        rhod_integ[0] = getRhogivenThetaPress(theta_ref_inp_sound,
                                              press_ref_inp_sound,
                                              RdoCp,
                                              qv_ref_inp_sound);
 
        amrex::Print() << "ideal sounding init: surface dry air density = "
                       << std::setprecision(15)
                       << rhod_integ[0] << " kg/m^3" << std::endl;
 
        // Note:
        //   p_dry = rho_d R_d T
        //   p_tot = rho_m R_d T_v
        //         = rho_d(1 + q_v) R_d T_v
 
#if 0   // Printing
        // In this absence of moisture, this moist profile will match the
        // following dry profile
        amrex::Print() << "z  p_m  rho_d  theta  qv  U  V" << std::endl;
        amrex::Print() << z_inp_sound[itime][0]
                       << " " << pm_integ[0]
                       << " " << rhod_integ[0]
                       << " " << theta_inp_sound[itime][0]
                       << " " << qv_inp_sound[itime][0]
                       << " " << U_inp_sound[itime][0]
                       << " " << V_inp_sound[itime][0]
                       << std::endl;
#endif
 
         // integrate from surface to domain top
        amrex::Real dz, F, C;
        amrex::Real T_hi;
        amrex::Real rho_tot_hi, rho_tot_lo;
        for (int k=1; k < size(itime); ++k)
        {
            // Vertical grid spacing
            dz = z_inp_sound[itime][k] - z_inp_sound[itime][k-1];
 
            // Establish known constant
            rho_tot_lo = rhod_integ[k-1] * (one + qv_inp_sound[itime][k-1]);
            C  = -pm_integ[k-1] + myhalf*rho_tot_lo*CONST_GRAV*dz;
 
            // Initial guess and residual
            pm_integ[k]   = pm_integ[k-1];
            T_hi          = getTgivenPandTh(pm_integ[k], theta_inp_sound[itime][k], RdoCp);
            rhod_integ[k] = getRhogivenThetaPress(theta_inp_sound[itime][k],
                                                  pm_integ[k],
                                                  RdoCp,
                                                  qv_inp_sound[itime][k]);
            rho_tot_hi = rhod_integ[k] * (one + qv_inp_sound[itime][k]);
            F = pm_integ[k] + myhalf*rho_tot_hi*CONST_GRAV*dz + C;
 
            // Do iterations
            if (std::abs(F)>tol) {
                bool maintain_Th = true;
                HSEutils::Newton_Raphson_hse(tol, RdoCp, dz,
                                             CONST_GRAV, C, theta_inp_sound[itime][k], T_hi,
                                             qv_inp_sound[itime][k], qv_inp_sound[itime][k],
                                             pm_integ[k], rhod_integ[k], F, maintain_Th);
            }
 
#if 0       // Printing
            amrex::Print() << z_inp_sound[itime][k]
                           << " " << pm_integ[k]
                           << " " << rhod_integ[k]
                           << " " << theta_inp_sound[itime][k]
                           << " " << qv_inp_sound[itime][k]
                           << " " << U_inp_sound[itime][k]
                           << " " << V_inp_sound[itime][k]
                           << std::endl;
#endif
        }
        // Note: at this point, the surface pressure, density of the dry air
        // column is stored in pm_integ[0], rhod_integ[0]
 
        // update
        host_to_device(itime);
    }

Here is the call graph for this function:

calc_rho_p_isentropic()

void InputSoundingData::calc_rho_p_isentropic ( int  itime )

inline

Compute density and pressure for an isentropic sounding profile.

Parameters

itime

Sounding time/file index to integrate.

    {
        /* Calculate density and pressure assuming isentropic (constant theta)
           background conditions. This does not use Newton-Raphson iterations
           to calculate rho and p.
         */
        const int Ninp = size(itime);
        pm_integ.resize(Ninp);
        rhod_integ.resize(Ninp);
 
        // evaluate surface quantities (k=0): total pressure and dry air
        pm_integ[0]   = press_ref_inp_sound;
        rhod_integ[0] = getRhogivenThetaPress(theta_ref_inp_sound,
                                              press_ref_inp_sound,
                                              RdoCp,
                                              qv_ref_inp_sound);
 
        const amrex::Real th0 = theta_ref_inp_sound;
        const amrex::Real p0_pow = std::pow(p_0, (Gamma-1)/Gamma);
 
        amrex::Print() << "isentropic sounding init: surface dry air density = "
                       << std::setprecision(15)
                       << rhod_integ[0] << " kg/m^3" << std::endl;
 
#if 0   // Printing
        // In this absence of moisture, this moist profile will match the
        // following dry profile
        amrex::Print() << "z  p_m  rho_d  theta  qv  U  V" << std::endl;
        amrex::Print() << z_inp_sound[itime][0]
                       << " " << pm_integ[0]
                       << " " << rhod_integ[0]
                       << " " << theta_inp_sound[itime][0]
                       << " " << qv_inp_sound[itime][0]
                       << " " << U_inp_sound[itime][0]
                       << " " << V_inp_sound[itime][0]
                       << std::endl;
#endif
 
         // integrate from surface to domain top
        amrex::Real dz;
        for (int k=1; k < size(itime); ++k)
        {
            // Vertical grid spacing
            dz = z_inp_sound[itime][k] - z_inp_sound[itime][k-1];
 
            // Isentropic pressure at next level
            amrex::Real qvmean = (assume_dry) ? zero : myhalf*(qv_inp_sound[itime][k-1] + qv_inp_sound[itime][k]);
            amrex::Real thm0 = th0 * (one + RvoRd * qvmean);
            amrex::Real plo_pow = std::pow(pm_integ[k-1], (Gamma-1)/Gamma);
            pm_integ[k] = (Gamma-1)/Gamma *
                (-CONST_GRAV * p0_pow / (R_d * thm0) * (1 + qvmean) * dz
                 + Gamma/(Gamma-1) * plo_pow);
            pm_integ[k] = std::pow(pm_integ[k], Gamma / (Gamma-1));
 
            // Note: The pressure calculated here is copied to `p_inp_sound_d`
            // and currently not used.
 
            // Get corresponding dry air density
            rhod_integ[k] = getRhogivenThetaPress(theta_inp_sound[itime][k],
                                                  pm_integ[k],
                                                  RdoCp,
                                                  qv_inp_sound[itime][k]);
 
#if 0       // Printing
            amrex::Print() << z_inp_sound[itime][k]
                           << " " << pm_integ[k]
                           << " " << rhod_integ[k]
                           << " " << theta_inp_sound[itime][k]
                           << " " << qv_inp_sound[itime][k]
                           << " " << U_inp_sound[itime][k]
                           << " " << V_inp_sound[itime][k]
                           << std::endl;
#endif
        }
        // Note: at this point, the surface pressure, density of the dry air
        // column is stored in pm_integ[0], rhod_integ[0]
 
        // update
        host_to_device(itime);
    }

Here is the call graph for this function:

host_to_device()

void InputSoundingData::host_to_device ( int  itime )

inline

Copy host sounding arrays for one time index to device storage.

Parameters

itime

Sounding time/file index to copy.

    {
        const int Ninp = size(itime);
        z_inp_sound_d[itime].resize(Ninp);
        theta_inp_sound_d[itime].resize(Ninp);
        qv_inp_sound_d[itime].resize(Ninp);
        U_inp_sound_d[itime].resize(Ninp);
        V_inp_sound_d[itime].resize(Ninp);
 
        amrex::Gpu::copy(amrex::Gpu::hostToDevice,
                         z_inp_sound[itime].begin(), z_inp_sound[itime].end(),
                         z_inp_sound_d[itime].begin());
        amrex::Gpu::copy(amrex::Gpu::hostToDevice,
                         theta_inp_sound[itime].begin(), theta_inp_sound[itime].end(),
                         theta_inp_sound_d[itime].begin());
        amrex::Gpu::copy(amrex::Gpu::hostToDevice,
                         qv_inp_sound[itime].begin(), qv_inp_sound[itime].end(),
                         qv_inp_sound_d[itime].begin());
        amrex::Gpu::copy(amrex::Gpu::hostToDevice,
                         U_inp_sound[itime].begin(), U_inp_sound[itime].end(),
                         U_inp_sound_d[itime].begin());
        amrex::Gpu::copy(amrex::Gpu::hostToDevice,
                         V_inp_sound[itime].begin(), V_inp_sound[itime].end(),
                         V_inp_sound_d[itime].begin());
 
        if (rhod_integ.size() > 0)
        {
            //amrex::Print() << "Copying rho_d, p_d to device" << std::endl;
            rho_inp_sound_d.resize(size(itime)+2);
            p_inp_sound_d.resize(size(itime)+2);
            amrex::Gpu::copy(amrex::Gpu::hostToDevice,
                             rhod_integ.begin(), rhod_integ.end(),
                             rho_inp_sound_d.begin());
            amrex::Gpu::copy(amrex::Gpu::hostToDevice,
                             pm_integ.begin(), pm_integ.end(),
                             p_inp_sound_d.begin());
        }
    }

Referenced by calc_rho_p(), calc_rho_p_isentropic(), and read_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

read_from_file()

void InputSoundingData::read_from_file ( const amrex::Geometry &  geom, const amrex::Vector< amrex::Real > &  zlevels_stag, int  itime, bool  is_moist  )

inline

Read and interpolate one input sounding profile onto level-0 heights.

Parameters

geom	Geometry defining the level-0 vertical domain.
zlevels_stag	Staggered vertical coordinates used for interpolation.
itime	Sounding time/file index to read.
is_moist	Whether the selected physics permits nonzero water vapor.

    {
        const int klo = 0;
        const int khi = geom.Domain().bigEnd()[AMREX_SPACEDIM-1];
        const int Nz = geom.Domain().size()[AMREX_SPACEDIM-1];
 
        const amrex::Real zbot = zlevels_stag[klo];
        const amrex::Real ztop = zlevels_stag[khi+1];
 
        z_inp_sound[itime].resize(Nz+2);
        theta_inp_sound[itime].resize(Nz+2);
        qv_inp_sound[itime].resize(Nz+2);
        U_inp_sound[itime].resize(Nz+2);
        V_inp_sound[itime].resize(Nz+2);
 
        // Read the input_sounding file
        amrex::Print() << "input_sounding file location : " << input_sounding_file[itime] << std::endl;
        std::ifstream input_sounding_reader(input_sounding_file[itime]);
        if(!input_sounding_reader.is_open()) {
            amrex::Error("Error opening the input_sounding file\n");
        }
        else {
            // Read the contents of the input_sounding file
            amrex::Print() << "Successfully opened the input_sounding file. Now reading... " << std::endl;
            std::string line;
 
            // First, read the input data into temp vectors; then, interpolate vectors to the
            // domain lo/hi and cell centers (from level 0)
            amrex::Vector<amrex::Real> z_inp_sound_tmp, theta_inp_sound_tmp, qv_inp_sound_tmp,
                                       U_inp_sound_tmp, V_inp_sound_tmp;
 
            // Read surface quantities from the first line
            std::getline(input_sounding_reader, line);
            std::istringstream iss(line);
            iss >> press_ref_inp_sound >> theta_ref_inp_sound >> qv_ref_inp_sound;
            press_ref_inp_sound *= 100; // convert from hPa to Pa
            qv_ref_inp_sound *= amrex::Real(0.001); // convert from g/kg to kg/kg
 
            // Add surface
            z_inp_sound_tmp.push_back(zbot); // height above sea level [m]
            theta_inp_sound_tmp.push_back(theta_ref_inp_sound);
            qv_inp_sound_tmp.push_back(qv_ref_inp_sound);
            U_inp_sound_tmp.push_back(0);
            V_inp_sound_tmp.push_back(0);
 
            // *************************************************************************************************
            // Make sure that if we specify surface values for temp in the inputs file and in the input sounding file,
            //      those values must match
            // *************************************************************************************************
            amrex::ParmParse pp_erf("erf");
 
            amrex::Real surf_temp;
            bool surf_temp_specified = pp_erf.query("most.surf_temp", surf_temp);
            if ( surf_temp_specified && (surf_temp != theta_inp_sound_tmp[0]) ) {
                amrex::Print() << "Input sounding temp does not match most.surf_temp" << std::endl;
                amrex::Print() << "Modify one or both to match." << std::endl;
                amrex::Abort();
            }
 
            // *************************************************************************************************
            // Make sure that if we specify surface values for qv in the inputs file and in the input sounding file,
            //      those values must match
            // *************************************************************************************************
            amrex::Real surf_moist;
            bool surf_moist_specified = pp_erf.query("most.surf_moist", surf_moist);
            if ( surf_moist_specified && (surf_moist != qv_inp_sound_tmp[0]) ) {
                amrex::Print() << "Input sounding qv does not match most.surf_moist" << std::endl;
                amrex::Print() << "Modify one or both to match." << std::endl;
                amrex::Abort();
            }
 
            // Read the vertical profile at each given height
            amrex::Real z, theta, qv, U, V;
 
            while(std::getline(input_sounding_reader, line)) {
                std::istringstream iss_z(line);
                iss_z >> z >> theta >> qv >> U >> V;
 
                // Dont read in non-zero qv if not using a moisture model
                AMREX_ALWAYS_ASSERT(qv == zero || is_moist);
 
                if (z == zbot) {
                    AMREX_ALWAYS_ASSERT(theta == theta_inp_sound_tmp[0]);
                    AMREX_ALWAYS_ASSERT(qv*amrex::Real(0.001) == qv_inp_sound_tmp[0]); // convert from g/kg to kg/kg
                    U_inp_sound_tmp[0] = U;
                    V_inp_sound_tmp[0] = V;
                } else {
                    AMREX_ALWAYS_ASSERT(z > z_inp_sound_tmp[z_inp_sound_tmp.size()-1]); // sounding is increasing in height
                    z_inp_sound_tmp.push_back(z);
 
                    theta_inp_sound_tmp.push_back(theta);
                    qv_inp_sound_tmp.push_back(qv*amrex::Real(0.001)); // convert from g/kg to kg/kg
                    U_inp_sound_tmp.push_back(U);
                    V_inp_sound_tmp.push_back(V);
                    if (z >= ztop) break;
                }
            }
 
            // At this point, we have an input_sounding from zbot up to
            // z_inp_sound_tmp[N-1] >= ztop. Now, interpolate to grid level 0 heights
            const int Ninp = z_inp_sound_tmp.size();
            z_inp_sound[itime][0]     = zbot;
            theta_inp_sound[itime][0] = theta_inp_sound_tmp[0];
            qv_inp_sound[itime][0]    = qv_inp_sound_tmp[0];
            U_inp_sound[itime][0]     = U_inp_sound_tmp[0];
            V_inp_sound[itime][0]     = V_inp_sound_tmp[0];
            for (int k=0; k < Nz; ++k) {
                z_inp_sound[itime][k+1] = myhalf * (zlevels_stag[k] + zlevels_stag[k+1]);
                theta_inp_sound[itime][k+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), theta_inp_sound_tmp.dataPtr(), z_inp_sound[itime][k+1], Ninp);
                   qv_inp_sound[itime][k+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(),    qv_inp_sound_tmp.dataPtr(), z_inp_sound[itime][k+1], Ninp);
                    U_inp_sound[itime][k+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(),     U_inp_sound_tmp.dataPtr(), z_inp_sound[itime][k+1], Ninp);
                    V_inp_sound[itime][k+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(),     V_inp_sound_tmp.dataPtr(), z_inp_sound[itime][k+1], Ninp);
            }
            z_inp_sound[itime][Nz+1]     = ztop;
            theta_inp_sound[itime][Nz+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), theta_inp_sound_tmp.dataPtr(), ztop, Ninp);
               qv_inp_sound[itime][Nz+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(),    qv_inp_sound_tmp.dataPtr(), ztop, Ninp);
                U_inp_sound[itime][Nz+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(),     U_inp_sound_tmp.dataPtr(), ztop, Ninp);
                V_inp_sound[itime][Nz+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(),     V_inp_sound_tmp.dataPtr(), ztop, Ninp);
        }
 
        amrex::Print() << "Successfully read the " << itime << "th input_sounding file..." << std::endl;
        input_sounding_reader.close();
 
        host_to_device(itime);
    }

Here is the call graph for this function:

resize_arrays()

void InputSoundingData::resize_arrays ( )

inline

Resize host and device sounding arrays for the configured sounding times.

    {
        ntimes = n_sounding_files;
 
        z_inp_sound.resize(ntimes);
        theta_inp_sound.resize(ntimes);
        qv_inp_sound.resize(ntimes);
        U_inp_sound.resize(ntimes);
        V_inp_sound.resize(ntimes);
 
        z_inp_sound_d.resize(ntimes);
        theta_inp_sound_d.resize(ntimes);
        qv_inp_sound_d.resize(ntimes);
        U_inp_sound_d.resize(ntimes);
        V_inp_sound_d.resize(ntimes);
    }

size()

int InputSoundingData::size ( int  itime ) const

inline

Return the number of interpolated samples for one sounding time.

Parameters

itime

Sounding time/file index to query.

Returns

Number of stored sounding profile levels.

    {
        AMREX_ALWAYS_ASSERT(z_inp_sound[itime].size() == theta_inp_sound[itime].size());
        AMREX_ALWAYS_ASSERT(z_inp_sound[itime].size() == qv_inp_sound[itime].size());
        AMREX_ALWAYS_ASSERT(z_inp_sound[itime].size() == U_inp_sound[itime].size());
        AMREX_ALWAYS_ASSERT(z_inp_sound[itime].size() == V_inp_sound[itime].size());
        return z_inp_sound[itime].size();
    }

Referenced by calc_rho_p(), calc_rho_p_isentropic(), host_to_device(), init_state_from_input_sounding(), init_state_from_input_sounding_hse(), and init_velocities_from_input_sounding().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

assume_dry

InputSoundingData::assume_dry {false}

Whether to ignore moisture in isentropic pressure integration.

Referenced by calc_rho_p_isentropic(), and init_state_from_input_sounding_hse().

input_sounding_file

InputSoundingData::input_sounding_file = {}

Sounding file path for each configured sounding time.

Referenced by InputSoundingData(), and read_from_file().

input_sounding_time

InputSoundingData::input_sounding_time = {}

Physical time associated with each input sounding file.

Referenced by InputSoundingData(), make_mom_sources(), and make_sources().

n_sounding_files

InputSoundingData::n_sounding_files = 0

Number of input sounding files.

Referenced by InputSoundingData(), and resize_arrays().

n_sounding_times

InputSoundingData::n_sounding_times = 0

Number of input sounding times.

Referenced by InputSoundingData().

ntimes

InputSoundingData::ntimes

Number of sounding times represented in the arrays.

Referenced by resize_arrays().

p_inp_sound_d

InputSoundingData::p_inp_sound_d

Device pressure profile used to initialize solution fields.

Referenced by host_to_device().

pm_integ

InputSoundingData::pm_integ

Hydrostatically integrated moist pressure profile.

Referenced by calc_rho_p(), calc_rho_p_isentropic(), and host_to_device().

press_ref_inp_sound

InputSoundingData::press_ref_inp_sound

Surface reference pressure read from the input sounding [Pa].

Referenced by calc_rho_p(), calc_rho_p_isentropic(), and read_from_file().

qv_inp_sound

InputSoundingData::qv_inp_sound

Interpolated host water vapor mixing ratio profiles [kg/kg].

Referenced by calc_rho_p(), calc_rho_p_isentropic(), host_to_device(), read_from_file(), resize_arrays(), and size().

qv_inp_sound_d

InputSoundingData::qv_inp_sound_d

Device water vapor mixing ratio profiles [kg/kg].

Referenced by host_to_device(), init_state_from_input_sounding(), init_state_from_input_sounding_hse(), and resize_arrays().

qv_ref_inp_sound

InputSoundingData::qv_ref_inp_sound

Surface reference water vapor mixing ratio read from the input sounding [kg/kg].

Referenced by calc_rho_p(), calc_rho_p_isentropic(), and read_from_file().

rho_inp_sound_d

InputSoundingData::rho_inp_sound_d

Device density profile used to initialize solution fields.

Referenced by host_to_device(), and init_state_from_input_sounding_hse().

rhod_integ

InputSoundingData::rhod_integ

Hydrostatically integrated dry density profile.

Referenced by calc_rho_p(), calc_rho_p_isentropic(), and host_to_device().

tau_nudging

InputSoundingData::tau_nudging = amrex::Real(5.0)

Nudging time scale for relaxing toward input sounding data.

Referenced by InputSoundingData(), make_mom_sources(), and make_sources().

theta_inp_sound

InputSoundingData::theta_inp_sound

Interpolated host potential temperature profiles [K].

Referenced by calc_rho_p(), calc_rho_p_isentropic(), host_to_device(), read_from_file(), resize_arrays(), and size().

theta_inp_sound_d

InputSoundingData::theta_inp_sound_d

Device potential temperature profiles [K].

Referenced by host_to_device(), init_state_from_input_sounding(), init_state_from_input_sounding_hse(), make_sources(), and resize_arrays().

theta_ref_inp_sound

InputSoundingData::theta_ref_inp_sound

Surface reference potential temperature read from the input sounding [K].

Referenced by calc_rho_p(), calc_rho_p_isentropic(), and read_from_file().

U_inp_sound

InputSoundingData::U_inp_sound

Interpolated host x velocity profiles.

Referenced by calc_rho_p(), calc_rho_p_isentropic(), host_to_device(), read_from_file(), resize_arrays(), and size().

U_inp_sound_d

InputSoundingData::U_inp_sound_d

Device x velocity profiles.

Referenced by host_to_device(), init_velocities_from_input_sounding(), make_mom_sources(), and resize_arrays().

V_inp_sound

InputSoundingData::V_inp_sound

Interpolated host y velocity profiles.

Referenced by calc_rho_p(), calc_rho_p_isentropic(), host_to_device(), read_from_file(), resize_arrays(), and size().

V_inp_sound_d

InputSoundingData::V_inp_sound_d

Device y velocity profiles.

Referenced by host_to_device(), init_velocities_from_input_sounding(), make_mom_sources(), and resize_arrays().

z_inp_sound

InputSoundingData::z_inp_sound

Interpolated host sounding heights for each sounding time [m].

Referenced by calc_rho_p(), calc_rho_p_isentropic(), host_to_device(), read_from_file(), resize_arrays(), and size().

z_inp_sound_d

InputSoundingData::z_inp_sound_d

Device sounding heights for each sounding time [m].

Referenced by host_to_device(), init_state_from_input_sounding(), init_state_from_input_sounding_hse(), init_velocities_from_input_sounding(), and resize_arrays().

---

The documentation for this struct was generated from the following file:

• Source/DataStructs/ERF_InputSoundingData.H