SolverChoice Struct Reference

#include <DataStruct.H>

Collaboration diagram for SolverChoice:

Public Member Functions
void	init_params ()
void	display ()

Public Attributes
std::string	pp_prefix {"remora"}
bool	flat_bathymetry = true
bool	use_salt = true
bool	use_coriolis = false
bool	use_prestep = true
bool	use_uv3dmix = true
bool	use_baroclinic = true
bool	use_barotropic = true
AdvectionScheme	Hadv_scheme
CouplingType	coupling_type
IC_BC_Type	ic_bc_type
Cor_Type	coriolis_type
amrex::Real	theta_s = 3.0
amrex::Real	theta_b = 0.0
amrex::Real	tcline = 150.0
amrex::Real	rdrag = 3e-4
amrex::Real	R0 = 1028
amrex::Real	S0 = 35.0
amrex::Real	T0 = 5.0
amrex::Real	Tcoef = 1.7e-4
amrex::Real	Scoef = 0.0
amrex::Real	rho0 = 1025.0
amrex::Real	coriolis_f0 = 0.0
amrex::Real	coriolis_beta = 0.0
amrex::Real	g = 9.81
int	spatial_order = 2

Member Function Documentation

display()

void SolverChoice::display ( )

inline

    {
        amrex::Print() << "SOLVER CHOICE: " << std::endl;
        amrex::Print() << "use_salt              : " << use_salt     << std::endl;
        amrex::Print() << "use_coriolis          : " << use_coriolis << std::endl;
        amrex::Print() << "use_prestep           : " << use_prestep << std::endl;
        amrex::Print() << "use_uv3dmix           : " << use_uv3dmix << std::endl;
        amrex::Print() << "use_barotropic        : " << use_barotropic << std::endl;
        amrex::Print() << "flat_bathymetry       : " << flat_bathymetry << std::endl;
        amrex::Print() << "spatial_order         : " << spatial_order << std::endl;
 
        if (ic_bc_type == IC_BC_Type::Custom) {
            amrex::Print() << "Using custom initial and boundary conditions (No mesoscale forcing!)" << std::endl;
        }
        else if (ic_bc_type == IC_BC_Type::Real) {
            amrex::Print() << "Using REAL initial and boundary conditions (Mesoscale forcing!)" << std::endl;
        }
 
        if (Hadv_scheme == AdvectionScheme::centered4) {
            amrex::Print() << "Horizontal advection scheme: " << "Centered 4" << std::endl;
        }
        else if (Hadv_scheme == AdvectionScheme::upstream3) {
            amrex::Print() << "Horizontal advection scheme: " << "Upstream 3" << std::endl;
        }
        else {
            amrex::Error("Invalid horizontal advection scheme.");
        }
 
        if (coupling_type == CouplingType::TwoWay) {
            amrex::Print() << "Using two-way coupling " << std::endl;
        } else if (coupling_type == CouplingType::OneWay) {
            amrex::Print() << "Using one-way coupling " << std::endl;
        }
 
        if (use_coriolis) {
            if (coriolis_type == Cor_Type::Custom) {
                amrex::Print() << "Using custom coriolis forcing " << std::endl;
            } else if (coriolis_type == Cor_Type::Beta_Plane) {
                amrex::Print() << "Using beta plane coriolis forcing " << std::endl;
            } else if (coriolis_type == Cor_Type::Real) {
                amrex::Print() << "Using coriolis forcing loaded from file " << std::endl;
            }
        }
    }

init_params()

void SolverChoice::init_params ( )

inline

    {
        amrex::ParmParse pp(pp_prefix);
 
        pp.query("flat_bathymetry", flat_bathymetry);
 
        // Which horizontal advection scheme
        static std::string hadv_string = "upstream3";
        pp.query("horizontal_advection_scheme",hadv_string);
        if (hadv_string == "centered4")
            Hadv_scheme = AdvectionScheme::centered4;
        else if (hadv_string == "upstream3")
            Hadv_scheme = AdvectionScheme::upstream3;
        else
            amrex::Error("Advection scheme unknown.");
 
        pp.query("rdrag", rdrag);
 
        // Order of spatial discretization
        pp.query("spatial_order", spatial_order);
 
        // Include salinity?
        pp.query("use_salt", use_salt);
 
        // Include Coriolis forcing?
        pp.query("use_coriolis", use_coriolis);
 
        // Include prestep / lagged predictor / corrections
        pp.query("use_prestep", use_prestep);
 
        //This affect forcing and some of the mixing terms for velocity
        pp.query("use_uv3dmix", use_uv3dmix);
 
        //This accounts for the main 2d loop but may not include coupling and copying properly
        pp.query("use_barotropic", use_barotropic);
 
        //Read in linear eos parameters
        pp.query("R0",R0);
        pp.query("S0",S0);
        pp.query("T0",T0);
        pp.query("Tcoef",Tcoef);
        pp.query("Scoef",Scoef);
        pp.query("rho0", rho0);
 
        //Grid stretching
        pp.query("theta_s",theta_s);
        pp.query("theta_b",theta_b);
        pp.query("tcline",tcline);
 
        //coriolis factor
        pp.query("coriolis_f0",coriolis_f0);
        pp.query("coriolis_beta",coriolis_beta);
 
        pp.query("ggrav",g);
 
        static std::string ic_bc_type_string = "custom";
        pp.query("ic_bc_type", ic_bc_type_string);
 
        if ( !ic_bc_type_string.compare("Custom") ||
             !ic_bc_type_string.compare("custom") ) {
            ic_bc_type = IC_BC_Type::Custom;
        } else if ( !ic_bc_type_string.compare("Real") ||
                    !ic_bc_type_string.compare("real") ) {
            ic_bc_type = IC_BC_Type::Real;
        } else {
            amrex::Error("Don't know this ic_bc_type");
        }
 
        // Which type of refinement
        static std::string coupling_type_string = "TwoWay";
        pp.query("coupling_type",coupling_type_string);
        if (coupling_type_string == "TwoWay") {
            coupling_type = CouplingType::TwoWay;
        } else if (coupling_type_string == "OneWay") {
            coupling_type = CouplingType::OneWay;
        } else {
            amrex::Abort("Dont know this coupling_type");
        }
 
        // Which type of coriolis forcing
        if (use_coriolis) {
            static std::string coriolis_type_string = "beta_plane";
            pp.query("coriolis_type",coriolis_type_string);
            if ( (coriolis_type_string == "Custom") || (coriolis_type_string == "custom") ) {
                coriolis_type = Cor_Type::Custom;
            } else if ((coriolis_type_string == "Beta_Plane") ||
                       (coriolis_type_string == "beta_Plane") ||
                       (coriolis_type_string == "beta_plane") ||
                       (coriolis_type_string == "Beta_plane")) {
                coriolis_type = Cor_Type::Beta_Plane;
            } else if ( (coriolis_type_string == "Real") || (coriolis_type_string == "real") ) {
                coriolis_type = Cor_Type::Real;
            } else {
                amrex::Abort("Don't know this coriolis_type");
            }
        }
    }

Member Data Documentation

coriolis_beta

amrex::Real SolverChoice::coriolis_beta = 0.0

Referenced by init_params().

coriolis_f0

amrex::Real SolverChoice::coriolis_f0 = 0.0

Referenced by init_params().

coriolis_type

Cor_Type SolverChoice::coriolis_type

Referenced by display(), and init_params().

coupling_type

CouplingType SolverChoice::coupling_type

Referenced by display(), and init_params().

flat_bathymetry

bool SolverChoice::flat_bathymetry = true

Referenced by display(), and init_params().

g

amrex::Real SolverChoice::g = 9.81

Referenced by init_params().

Hadv_scheme

AdvectionScheme SolverChoice::Hadv_scheme

Referenced by display(), and init_params().

ic_bc_type

IC_BC_Type SolverChoice::ic_bc_type

Referenced by display(), and init_params().

pp_prefix

std::string SolverChoice::pp_prefix {"remora"}

Referenced by init_params().

R0

amrex::Real SolverChoice::R0 = 1028

Referenced by init_params().

rdrag

amrex::Real SolverChoice::rdrag = 3e-4

Referenced by init_params().

rho0

amrex::Real SolverChoice::rho0 = 1025.0

Referenced by init_params().

S0

amrex::Real SolverChoice::S0 = 35.0

Referenced by init_params().

Scoef

amrex::Real SolverChoice::Scoef = 0.0

Referenced by init_params().

spatial_order

int SolverChoice::spatial_order = 2

Referenced by display(), and init_params().

T0

amrex::Real SolverChoice::T0 = 5.0

Referenced by init_params().

tcline

amrex::Real SolverChoice::tcline = 150.0

Referenced by init_params().

Tcoef

amrex::Real SolverChoice::Tcoef = 1.7e-4

Referenced by init_params().

theta_b

amrex::Real SolverChoice::theta_b = 0.0

Referenced by init_params().

theta_s

amrex::Real SolverChoice::theta_s = 3.0

Referenced by init_params().

use_baroclinic

bool SolverChoice::use_baroclinic = true

use_barotropic

bool SolverChoice::use_barotropic = true

Referenced by display(), and init_params().

use_coriolis

bool SolverChoice::use_coriolis = false

Referenced by display(), and init_params().

use_prestep

bool SolverChoice::use_prestep = true

Referenced by display(), and init_params().

use_salt

bool SolverChoice::use_salt = true

Referenced by display(), and init_params().

use_uv3dmix

bool SolverChoice::use_uv3dmix = true

Referenced by display(), and init_params().

---

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

• /home/runner/work/REMORA/REMORA/Source/DataStruct.H