ForestDrag Class Reference

#include <ERF_ForestDrag.H>

Collaboration diagram for ForestDrag:

Public Member Functions
	ForestDrag (std::string forestfile)
	ForestDrag (std::string lai_file, std::string height_file, std::string cd_file, int tree_type=1, amrex::Real laimax=0.8)
	ForestDrag (std::string lai_file, std::string height_file, amrex::Real cd_const, int tree_type=1, amrex::Real laimax=0.8)
	~ForestDrag ()=default
void	define_drag_field (const amrex::BoxArray &ba, const amrex::DistributionMapping &dm, amrex::Geometry &geom, amrex::MultiFab *z_phys_cc, amrex::MultiFab *z_phys_nd, bool need_frontal_area, int level)
amrex::MultiFab *	get_drag_field ()
amrex::MultiFab *	get_frontal_area ()

Private Member Functions
void	read_netcdf_file (const std::string &filename, const std::string &varname, amrex::Vector< amrex::Real > &data, int &nx, int &ny, amrex::Real &dx, amrex::Real &dy, amrex::Real &xmin, amrex::Real &ymin)

Private Attributes
bool	m_use_gridded_data {false}
bool	m_need_frontal_area {true}
bool	m_use_const_cd {false}
amrex::Real	m_cd_const {0.0}
amrex::Vector< amrex::Real >	m_type_forest
amrex::Vector< amrex::Real >	m_x_forest
amrex::Vector< amrex::Real >	m_y_forest
amrex::Vector< amrex::Real >	m_height_forest
amrex::Vector< amrex::Real >	m_diameter_forest
amrex::Vector< amrex::Real >	m_cd_forest
amrex::Vector< amrex::Real >	m_lai_forest
amrex::Vector< amrex::Real >	m_laimax_forest
amrex::Vector< amrex::Real >	m_gridded_lai
amrex::Vector< amrex::Real >	m_gridded_height
amrex::Vector< amrex::Real >	m_gridded_cd
int	m_grid_nx {0}
int	m_grid_ny {0}
amrex::Real	m_grid_dx {0.0}
amrex::Real	m_grid_dy {0.0}
amrex::Real	m_grid_xmin {0.0}
amrex::Real	m_grid_ymin {0.0}
int	m_tree_type {1}
amrex::Real	m_laimax {0.8}
amrex::Real	m_lad_normalization {1.0}
std::unique_ptr< amrex::MultiFab >	m_forest_drag
std::unique_ptr< amrex::MultiFab >	m_frontal_area

Detailed Description

Build canopy leaf-area-density and momentum-drag fields.

The vertical leaf-area-density profiles follow Lalic and Mihailovic (2004), https://doi.org/10.1175/1520-0450(2004)043%3C0641:AERDLD%3E2.0.CO;2. Canopies may be supplied as discrete patches in a text file or as gridded LAI, height, and drag-coefficient NetCDF fields.

Constructor & Destructor Documentation

ForestDrag() [1/3]

ForestDrag::ForestDrag ( std::string  forestfile )

explicit

Construct a discrete-patch canopy from a text file.

{
    std::ifstream file(forestfile, std::ios::in);
    if (!file.good()) {
        Abort("Cannot find forest file: " + forestfile);
    }
    // TreeType xc yc height diameter cd lai laimax
    Real value1, value2, value3, value4, value5, value6, value7, value8;
    int row_number = 0;
    while (file >> value1 >> value2 >> value3 >> value4 >> value5 >> value6 >>
           value7 >> value8) {
        ++row_number;
        if (value1 == Real(2.0)) {
            const std::string error = erf_forest_utils::validate_laimax(
                value8, "Forest file '" + forestfile + "' row " +
                std::to_string(row_number) + " column 8 (laimax)");
            if (!error.empty()) {
                Abort(error);
            }
        }
        m_type_forest.push_back(value1);
        m_x_forest.push_back(value2);
        m_y_forest.push_back(value3);
        m_height_forest.push_back(value4);
        m_diameter_forest.push_back(value5);
        m_cd_forest.push_back(value6);
        m_lai_forest.push_back(value7);
        m_laimax_forest.push_back(value8);
    }
    file.close();
}

Here is the call graph for this function:

ForestDrag() [2/3]

ForestDrag::ForestDrag	(	std::string	lai_file,
		std::string	height_file,
		std::string	cd_file,
		int	tree_type = 1,
		amrex::Real	laimax = 0.8
	)

Construct a gridded canopy with drag coefficient read from NetCDF.

Parameters

lai_file	NetCDF file containing the horizontal LAI field.
height_file	NetCDF file containing canopy height.
cd_file	NetCDF file containing the cd field.
tree_type	LAD profile selector (1 uniform, 2 Lalic–Mihailovic).
laimax	Fractional height of maximum LAD for profile type 2.

{
    m_use_gridded_data = true;
    m_tree_type = tree_type;
    m_laimax = laimax;
 
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
        tree_type == 1 || tree_type == 2,
        "forest_tree_type must be 1 or 2");
    if (tree_type == 2) {
        const std::string error = erf_forest_utils::validate_laimax(
            laimax, "erf.forest_laimax");
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(error.empty(), error.c_str());
        m_lad_normalization = compute_lad_normalization(laimax);
    }
 
#ifdef ERF_USE_NETCDF
    read_netcdf_file(lai_file, "LAI", m_gridded_lai,
                     m_grid_nx, m_grid_ny,
                     m_grid_dx, m_grid_dy,
                     m_grid_xmin, m_grid_ymin);
 
    int nx_check, ny_check;
    Real dx_check, dy_check, xmin_check, ymin_check;
    read_netcdf_file(height_file, "height", m_gridded_height,
                     nx_check, ny_check, dx_check, dy_check,
                     xmin_check, ymin_check);
 
    const erf_grid_utils::UniformGridMetadata lai_grid{
        m_grid_nx, m_grid_ny, m_grid_dx, m_grid_dy, m_grid_xmin, m_grid_ymin};
    const erf_grid_utils::UniformGridMetadata height_grid{
        nx_check, ny_check, dx_check, dy_check, xmin_check, ymin_check};
    std::string grid_error = erf_grid_utils::validate_matching_grid(
        lai_grid, height_grid, "forest field 'LAI' in '" + lai_file + "'",
        "forest field 'height' in '" + height_file + "'");
    if (!grid_error.empty()) {
        Abort(grid_error);
    }
 
    read_netcdf_file(cd_file, "cd", m_gridded_cd,
                     nx_check, ny_check, dx_check, dy_check,
                     xmin_check, ymin_check);
 
    const erf_grid_utils::UniformGridMetadata cd_grid{
        nx_check, ny_check, dx_check, dy_check, xmin_check, ymin_check};
    grid_error = erf_grid_utils::validate_matching_grid(
        lai_grid, cd_grid, "forest field 'LAI' in '" + lai_file + "'",
        "forest field 'cd' in '" + cd_file + "'");
    if (!grid_error.empty()) {
        Abort(grid_error);
    }
 
    Print() << "ForestDrag: Successfully read gridded forest data\n"
            << "  Grid size: " << m_grid_nx << " x " << m_grid_ny << "\n"
            << "  Grid spacing: dx=" << m_grid_dx << ", dy=" << m_grid_dy << "\n"
            << "  Domain: x=[" << m_grid_xmin << ", "
            << (m_grid_xmin + (m_grid_nx-1)*m_grid_dx) << "], y=["
            << m_grid_ymin << ", "
            << (m_grid_ymin + (m_grid_ny-1)*m_grid_dy) << "]\n"
            << "  Tree type: " << m_tree_type << "\n"
            << "  LAImax: " << m_laimax << "\n";
 
#else
    amrex::ignore_unused(lai_file, height_file, cd_file);
    Abort("ERF must be compiled with NetCDF support to use gridded forest data");
#endif
}

Here is the call graph for this function:

ForestDrag() [3/3]

ForestDrag::ForestDrag	(	std::string	lai_file,
		std::string	height_file,
		amrex::Real	cd_const,
		int	tree_type = 1,
		amrex::Real	laimax = 0.8
	)

Construct a gridded canopy with a spatially constant drag coefficient.

Parameters

lai_file	NetCDF file containing the horizontal LAI field.
height_file	NetCDF file containing canopy height.
cd_const	Spatially constant drag coefficient.
tree_type	LAD profile selector (1 uniform, 2 Lalic–Mihailovic).
laimax	Fractional height of maximum LAD for profile type 2.

{
    m_use_gridded_data = true;
    m_use_const_cd     = true;
    m_cd_const         = cd_const;
    m_tree_type        = tree_type;
    m_laimax           = laimax;
 
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
        tree_type == 1 || tree_type == 2,
        "forest_tree_type must be 1 or 2");
    if (tree_type == 2) {
        const std::string error = erf_forest_utils::validate_laimax(
            laimax, "erf.forest_laimax");
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(error.empty(), error.c_str());
        m_lad_normalization = compute_lad_normalization(laimax);
    }
 
#ifdef ERF_USE_NETCDF
    read_netcdf_file(lai_file, "LAI", m_gridded_lai,
                     m_grid_nx, m_grid_ny,
                     m_grid_dx, m_grid_dy,
                     m_grid_xmin, m_grid_ymin);
 
    int nx_check, ny_check;
    Real dx_check, dy_check, xmin_check, ymin_check;
    read_netcdf_file(height_file, "height", m_gridded_height,
                     nx_check, ny_check, dx_check, dy_check,
                     xmin_check, ymin_check);
 
    const erf_grid_utils::UniformGridMetadata lai_grid{
        m_grid_nx, m_grid_ny, m_grid_dx, m_grid_dy, m_grid_xmin, m_grid_ymin};
    const erf_grid_utils::UniformGridMetadata height_grid{
        nx_check, ny_check, dx_check, dy_check, xmin_check, ymin_check};
    const std::string height_grid_error = erf_grid_utils::validate_matching_grid(
        lai_grid, height_grid, "forest field 'LAI' in '" + lai_file + "'",
        "forest field 'height' in '" + height_file + "'");
    if (!height_grid_error.empty()) {
        Abort(height_grid_error);
    }
 
    Print() << "ForestDrag: Gridded LAI/height + constant Cd=" << m_cd_const << "\n"
            << "  Grid size: " << m_grid_nx << " x " << m_grid_ny << "\n"
            << "  Grid spacing: dx=" << m_grid_dx << ", dy=" << m_grid_dy << "\n"
            << "  Tree type: " << m_tree_type << "  LAImax: " << m_laimax << "\n";
 
#else
    amrex::ignore_unused(lai_file, height_file);
    Abort("ERF must be compiled with NetCDF support to use gridded forest data");
#endif
}

Here is the call graph for this function:

~ForestDrag()

ForestDrag::~ForestDrag ( )

default

Member Function Documentation

define_drag_field()

void ForestDrag::define_drag_field	(	const amrex::BoxArray &	ba,
		const amrex::DistributionMapping &	dm,
		amrex::Geometry &	geom,
		amrex::MultiFab *	z_phys_cc,
		amrex::MultiFab *	z_phys_nd,
		bool	need_frontal_area,
		int	level
	)

Allocate and fill drag and, optionally, frontal-area-density fields.

Parameters

need_frontal_area	Allocate the frontal-area-density field, which is only consumed by the fixed-leaf-temperature path.
level	Level index, used only in diagnostic messages.

Neither argument is defaulted on purpose: every caller must state whether the frontal-area field is needed, so that a new call site cannot silently allocate and fill it when forest biophysics is off, nor report a placeholder level in the coverage warning.

{
    m_need_frontal_area = need_frontal_area;
    // Geometry params
    const auto& dx = geom.CellSizeArray();
    const auto& prob_lo = geom.ProbLoArray();
 
    bool all_boxes_touch_bottom = true;
    for (int i = 0; i < ba.size(); i++) {
        if (ba[i].smallEnd(2) != geom.Domain().smallEnd(2)) {
            all_boxes_touch_bottom = false;
        }
    }
    AMREX_ALWAYS_ASSERT(all_boxes_touch_bottom);
 
    // Allocate the forest drag MF and frontal area MF
    // NOTE: 1 ghost cell for averaging to faces
    m_forest_drag.reset();
    m_forest_drag = std::make_unique<MultiFab>(ba,dm,1,1);
    m_forest_drag->setVal(zero);
 
    m_frontal_area.reset();
    if (m_need_frontal_area) {
        m_frontal_area = std::make_unique<MultiFab>(ba,dm,1,1);
        m_frontal_area->setVal(zero);
    }
 
    // Copy namespace-scope constants into automatic-storage values before
    // entering GPU lambdas.  NVCC does not make these host-side constexpr
    // variables available as device symbols automatically.
    const Real zero_d   = zero;
    const Real one_d    = one;
    const Real myhalf_d = myhalf;
    const Real fourth_d = fourth;
    const bool store_frontal_area = m_need_frontal_area;
 
    if (m_use_gridded_data) {
        // =====================================================================
        // Gridded NetCDF mode: interpolate from gridded LAI/height/cd data
        // =====================================================================
 
        const Real* lai_data_h    = m_gridded_lai.data();
        const Real* height_data_h = m_gridded_height.data();
        const Real* cd_data_h     = m_use_const_cd ? nullptr : m_gridded_cd.data();
 
        const int grid_nx   = m_grid_nx;
        const int grid_ny   = m_grid_ny;
        const Real grid_dx  = m_grid_dx;
        const Real grid_dy  = m_grid_dy;
        const Real grid_xmin = m_grid_xmin;
        const Real grid_ymin = m_grid_ymin;
 
        warn_if_forest_grid_does_not_cover_targets(
            *m_forest_drag, geom, grid_xmin, grid_ymin, grid_dx, grid_dy,
            grid_nx, grid_ny, level);
 
        const int grid_size = m_grid_nx * m_grid_ny;
        Gpu::DeviceVector<Real> lai_data_d(grid_size);
        Gpu::DeviceVector<Real> height_data_d(grid_size);
        Gpu::DeviceVector<Real> cd_data_d;
        if (!m_use_const_cd) {
            cd_data_d.resize(grid_size);
        }
 
        Gpu::copy(Gpu::hostToDevice, lai_data_h, lai_data_h + grid_size,
                  lai_data_d.begin());
        Gpu::copy(Gpu::hostToDevice, height_data_h, height_data_h + grid_size,
                  height_data_d.begin());
        if (!m_use_const_cd) {
            Gpu::copy(Gpu::hostToDevice, cd_data_h, cd_data_h + grid_size,
                      cd_data_d.begin());
        }
 
        const Real* lai_data    = lai_data_d.data();
        const Real* height_data = height_data_d.data();
        const Real* cd_data     = m_use_const_cd ? nullptr : cd_data_d.data();
        const Real cd_const     = m_cd_const;
        const bool use_const_cd = m_use_const_cd;
 
        const int tree_type = m_tree_type;
        const Real laimax   = m_laimax;
        const Real lad_normalization = m_lad_normalization;
 
        for (MFIter mfi(*m_forest_drag); mfi.isValid(); ++mfi) {
            Box gtbx = mfi.growntilebox();
            const Array4<Real>& levelDrag   = m_forest_drag->array(mfi);
            const Array4<Real> frontalArea = store_frontal_area
                ? m_frontal_area->array(mfi) : Array4<Real>{};
            const Array4<const Real>& z_cc  = z_phys_cc->const_array(mfi);
            const Array4<const Real>& z_nd  = z_phys_nd->const_array(mfi);
 
            ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
            {
                const Real x = prob_lo[0] + (i + myhalf_d) * dx[0];
                const Real y = prob_lo[1] + (j + myhalf_d) * dx[1];
 
                const Real z_sfc = fourth_d * (z_nd(i, j, 0) + z_nd(i + 1, j, 0) +
                                               z_nd(i, j + 1, 0) + z_nd(i + 1, j + 1, 0));
                const Real z = amrex::max((z_cc(i, j, k) - z_sfc), zero_d);
 
                const auto x_stencil = erf_grid_utils::uniform_interpolation_stencil(
                    x, grid_xmin, grid_dx, grid_nx);
                const auto y_stencil = erf_grid_utils::uniform_interpolation_stencil(
                    y, grid_ymin, grid_dy, grid_ny);
 
                if (x_stencil.inside && y_stencil.inside) {
                    const int ii_c = x_stencil.lower;
                    const int jj_c = y_stencil.lower;
                    const Real wx = x_stencil.weight;
                    const Real wy = y_stencil.weight;
 
                    // Bilinear interpolation of LAI
                    Real lai00 = lai_data[jj_c * grid_nx + ii_c];
                    Real lai10 = lai_data[jj_c * grid_nx + (ii_c + 1)];
                    Real lai01 = lai_data[(jj_c + 1) * grid_nx + ii_c];
                    Real lai11 = lai_data[(jj_c + 1) * grid_nx + (ii_c + 1)];
                    Real lai_interp = (lai00 * (one_d - wx) + lai10 * wx) * (one_d - wy) +
                                      (lai01 * (one_d - wx) + lai11 * wx) * wy;
 
                    // Bilinear interpolation of height
                    Real h00 = height_data[jj_c * grid_nx + ii_c];
                    Real h10 = height_data[jj_c * grid_nx + (ii_c + 1)];
                    Real h01 = height_data[(jj_c + 1) * grid_nx + ii_c];
                    Real h11 = height_data[(jj_c + 1) * grid_nx + (ii_c + 1)];
                    Real height_interp = (h00 * (one_d - wx) + h10 * wx) * (one_d - wy) +
                                         (h01 * (one_d - wx) + h11 * wx) * wy;
 
                    Real cd_interp = cd_const;
                    if (!use_const_cd) {
                        // Bilinear interpolation of Cd from file.
                        Real cd00 = cd_data[jj_c * grid_nx + ii_c];
                        Real cd10 = cd_data[jj_c * grid_nx + (ii_c + 1)];
                        Real cd01 = cd_data[(jj_c + 1) * grid_nx + ii_c];
                        Real cd11 = cd_data[(jj_c + 1) * grid_nx + (ii_c + 1)];
                        cd_interp = (cd00 * (one_d - wx) + cd10 * wx) * (one_d - wy) +
                                    (cd01 * (one_d - wx) + cd11 * wx) * wy;
                    }
 
                    // Compute drag if within canopy
                    if (z < height_interp && height_interp > zero_d && lai_interp > zero_d) {
                        Real af;
                        Real factor = one_d;
 
                        if (tree_type == 1) {
                            af = lai_interp / height_interp;
                        } else {
                            const Real treeZm = laimax * height_interp;
                            af = lai_interp / (height_interp * lad_normalization);
 
                            Real ratio = (height_interp - treeZm) / (height_interp - z);
                            if (z < treeZm) {
                                factor = amrex::Math::powi<6>(ratio) *
                                         std::exp(Real(6.0) * (one_d - ratio));
                            } else {
                                factor = std::sqrt(ratio) *
                                         std::exp(myhalf_d * (one_d - ratio));
                            }
                        }
 
                        levelDrag(i, j, k)   = cd_interp * af * factor;
                        if (store_frontal_area) {
                            frontalArea(i, j, k) = af * factor;
                        }
                    }
                }
            });
        } // mfi
 
        // Synchronize before DeviceVectors go out of scope
        Gpu::synchronize();
 
    } else {
        // =====================================================================
        // Discrete patch mode: original implementation
        // =====================================================================
 
        for (unsigned ii = 0; ii < m_x_forest.size(); ++ii) {
            Real af;
            Real treeZm = zero_d;
            int  tf      = int(m_type_forest[ii]);
            Real hf      = m_height_forest[ii];
            Real xf      = m_x_forest[ii];
            Real yf      = m_y_forest[ii];
            Real df      = m_diameter_forest[ii];
            Real cdf     = m_cd_forest[ii];
            Real laif    = m_lai_forest[ii];
            Real laimaxf = m_laimax_forest[ii];
 
            if (tf == 1) {
                af = laif / hf;
            } else {
                treeZm = laimaxf * hf;
                af = laif / (hf * compute_lad_normalization(laimaxf));
            }
 
            for (MFIter mfi(*m_forest_drag); mfi.isValid(); ++mfi) {
                Box gtbx = mfi.growntilebox();
                const Array4<Real>& levelDrag   = m_forest_drag->array(mfi);
                const Array4<Real> frontalArea = store_frontal_area
                    ? m_frontal_area->array(mfi) : Array4<Real>{};
                const Array4<const Real>& z_cc  = z_phys_cc->const_array(mfi);
                const Array4<const Real>& z_nd  = z_phys_nd->const_array(mfi);
 
                ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
                {
                    const Real x = prob_lo[0] + (i + myhalf_d) * dx[0];
                    const Real y = prob_lo[1] + (j + myhalf_d) * dx[1];
 
                    const Real z_sfc = fourth_d * (z_nd(i,j  ,0) + z_nd(i+1,j  ,0)
                                              + z_nd(i,j+1,0) + z_nd(i+1,j+1,0));
                    const Real z = std::max((z_cc(i,j,k)-z_sfc), amrex::Real(0));
 
                    const Real radius = std::sqrt((x - xf) * (x - xf) +
                                                  (y - yf) * (y - yf));
 
                    Real factor = one_d;
                    if ((z <= hf) && (radius <= (myhalf_d * df))) {
                        if (tf == 2) {
                            Real ratio = (hf - treeZm) / (hf - z);
                            if (z < treeZm) {
                                factor = amrex::Math::powi<6>(ratio) *
                                         std::exp(Real(6.0) * (one_d - ratio));
                            } else if (z <= hf) {
                                factor = std::sqrt(ratio) *
                                         std::exp(myhalf_d * (one_d - ratio));
                            }
                        }
                        levelDrag(i, j, k)   = cdf * af * factor;
                        if (store_frontal_area) {
                            frontalArea(i, j, k) = af * factor;
                        }
                    }
                });
            } // mfi
        } // ii (forest patch)
 
    } // end else (discrete patch mode)
 
    // Fillboundary for periodic ghost cell copy
    m_forest_drag->FillBoundary(geom.periodicity());
    if (m_frontal_area != nullptr) {
        m_frontal_area->FillBoundary(geom.periodicity());
    }
 
} // define_drag_field

Here is the call graph for this function:

get_drag_field()

amrex::MultiFab* ForestDrag::get_drag_field ( )

inline

Return the cell-centered product of drag coefficient and LAD.

{ return m_forest_drag.get(); }

get_frontal_area()

amrex::MultiFab* ForestDrag::get_frontal_area ( )

inline

Return cell-centered leaf/frontal area density without drag coefficient.

{ return m_frontal_area.get(); }

read_netcdf_file()

void ForestDrag::read_netcdf_file ( const std::string &  filename, const std::string &  varname, amrex::Vector< amrex::Real > &  data, int &  nx, int &  ny, amrex::Real &  dx, amrex::Real &  dy, amrex::Real &  xmin, amrex::Real &  ymin  )

private

Member Data Documentation

m_cd_const

amrex::Real ForestDrag::m_cd_const {0.0}

private

m_cd_forest

amrex::Vector<amrex::Real> ForestDrag::m_cd_forest

private

m_diameter_forest

amrex::Vector<amrex::Real> ForestDrag::m_diameter_forest

private

m_forest_drag

std::unique_ptr<amrex::MultiFab> ForestDrag::m_forest_drag

private

Referenced by get_drag_field().

m_frontal_area

std::unique_ptr<amrex::MultiFab> ForestDrag::m_frontal_area

private

Referenced by get_frontal_area().

m_grid_dx

amrex::Real ForestDrag::m_grid_dx {0.0}

private

m_grid_dy

amrex::Real ForestDrag::m_grid_dy {0.0}

private

m_grid_nx

int ForestDrag::m_grid_nx {0}

private

m_grid_ny

int ForestDrag::m_grid_ny {0}

private

m_grid_xmin

amrex::Real ForestDrag::m_grid_xmin {0.0}

private

m_grid_ymin

amrex::Real ForestDrag::m_grid_ymin {0.0}

private

m_gridded_cd

amrex::Vector<amrex::Real> ForestDrag::m_gridded_cd

private

m_gridded_height

amrex::Vector<amrex::Real> ForestDrag::m_gridded_height

private

m_gridded_lai

amrex::Vector<amrex::Real> ForestDrag::m_gridded_lai

private

m_height_forest

amrex::Vector<amrex::Real> ForestDrag::m_height_forest

private

m_lad_normalization

amrex::Real ForestDrag::m_lad_normalization {1.0}

private

m_lai_forest

amrex::Vector<amrex::Real> ForestDrag::m_lai_forest

private

m_laimax

amrex::Real ForestDrag::m_laimax {0.8}

private

m_laimax_forest

amrex::Vector<amrex::Real> ForestDrag::m_laimax_forest

private

m_need_frontal_area

bool ForestDrag::m_need_frontal_area {true}

private

m_tree_type

int ForestDrag::m_tree_type {1}

private

m_type_forest

amrex::Vector<amrex::Real> ForestDrag::m_type_forest

private

m_use_const_cd

bool ForestDrag::m_use_const_cd {false}

private

m_use_gridded_data

bool ForestDrag::m_use_gridded_data {false}

private

m_x_forest

amrex::Vector<amrex::Real> ForestDrag::m_x_forest

private

m_y_forest

amrex::Vector<amrex::Real> ForestDrag::m_y_forest

private

---

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

• Source/SourceTerms/ERF_ForestDrag.H
• Source/SourceTerms/ERF_ForestDrag.cpp