FireCouplingParams Struct Reference

#include <ERF_FireCouplingParams.H>

Collaboration diagram for FireCouplingParams:

Public Member Functions
bool	is_passive () const
bool	is_lagged () const
bool	is_synchronous () const
bool	injects_flux () const
	Heat (and vapour) reach the atmosphere: lagged and synchronous coupling. More...
bool	heat_in_bottom_cell () const

Static Public Member Functions
static FireCouplingParams	read ()

Public Attributes
bool	enable = false
	erf.fire.enable: run a fire More...
std::string	engine
int	grid_ratio = 5
	erf.fire.grid_ratio: fire cells per atmospheric cell in x and y More...
int	anchor_level = -1
	erf.fire.anchor_level: the level the fire grid refines, -1 = the finest More...
std::string	coupling_type = "lagged"
	erf.fire.coupling_type: passive, lagged or synchronous More...
amrex::Real	heat_flux_alfg = 45.0
	erf.fire.heat_flux_alfg: e-folding height of the injected heat [m] More...
amrex::Real	fire_atm_feedback = 1.0
	erf.fire.fire_atm_feedback: multiplier on the injected fluxes More...
bool	inject_latent = true
	erf.fire.inject_latent: inject the engine's latent flux as vapour More...
std::string	source_mode = "overwrite"
	erf.fire.source_mode: overwrite or add to the theta and vapour sources More...
bool	source_mode_given = false
bool	heat_open_fraction = false
	erf.fire.heat_open_fraction: place the heat by the engine's open fraction More...
bool	heat_tendency_density = false
	erf.fire.heat_tendency_density: density factor of the theta tendency More...
bool	heat_tendency_exner = true
	erf.fire.heat_tendency_exner: Exner factor of the theta tendency More...
std::string	heat_profile = "exponential"
bool	smoke_enable = false
	erf.fire.smoke_enable: inject the smoke tracer More...
amrex::Real	smoke_emission_factor = 0.02
	erf.fire.smoke_emission_factor: kg smoke per kg fuel burned [-] More...
bool	fire_debug = false
	erf.fire.fire_debug: debug output of the coupling More...

Member Function Documentation

heat_in_bottom_cell()

bool FireCouplingParams::heat_in_bottom_cell ( ) const

inline

{ return heat_profile == "bottom_cell"; }

Referenced by FireCoupler::add_sources(), and read().

Here is the caller graph for this function:

injects_flux()

bool FireCouplingParams::injects_flux ( ) const

inline

Heat (and vapour) reach the atmosphere: lagged and synchronous coupling.

{ return is_lagged() || is_synchronous(); }

Referenced by FireCoupler::add_sources(), FireCoupler::initialize(), and FireCoupler::update_flux_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

is_lagged()

bool FireCouplingParams::is_lagged ( ) const

inline

{ return coupling_type == "lagged"; }

Referenced by FireCoupler::advance(), and injects_flux().

Here is the caller graph for this function:

is_passive()

bool FireCouplingParams::is_passive ( ) const

inline

{ return coupling_type == "passive"; }

Referenced by read().

Here is the caller graph for this function:

is_synchronous()

bool FireCouplingParams::is_synchronous ( ) const

inline

{ return coupling_type == "synchronous"; }

Referenced by FireCoupler::advance(), and injects_flux().

Here is the caller graph for this function:

read()

FireCouplingParams FireCouplingParams::read ( )

static

Parse and check the keys above from erf.fire.*. With erf.fire.enable, erf.fire.engine must name an engine compiled into this executable (fire_engine_names(), ERF_FireEngineRegistry.H).

{
    FireCouplingParams c;
    amrex::ParmParse pp("erf.fire");
    // Every message names the key and the value
    auto fail = [](const std::string& msg) { amrex::Abort("[FIRE] " + msg); };
    auto one_of = [&](const char* key, const std::string& v, const std::vector<std::string>& allowed) {
        for (const auto& a : allowed) { if (v == a) { return; } }
        std::string list;
        for (const auto& a : allowed) { list += (list.empty() ? "" : ", ") + std::string("\"") + a + "\""; }
        fail(std::string("erf.fire.") + key + " = \"" + v + "\" is not one of " + list);
    };
    auto positive = [&](const char* key, amrex::Real v) {
        if (!(v > 0.0)) { fail(std::string("erf.fire.") + key + " must be > 0, got " + std::to_string(v)); }
    };
    auto nonneg = [&](const char* key, amrex::Real v) {
        if (!(v >= 0.0)) { fail(std::string("erf.fire.") + key + " must be >= 0, got " + std::to_string(v)); }
    };
 
    pp.query("enable", c.enable);
    pp.query("fire_debug", c.fire_debug);
    pp.query("grid_ratio", c.grid_ratio);
    if (c.grid_ratio < 1) {
        fail("erf.fire.grid_ratio must be >= 1, got " + std::to_string(c.grid_ratio));
    }
    pp.query("anchor_level", c.anchor_level);
    if (c.anchor_level < -1) {
        fail("erf.fire.anchor_level must be -1 (the finest level) or a level >= 0, got "
             + std::to_string(c.anchor_level));
    }
 
    // The engine: one compiled into this executable (ERF_REGISTER_FIRE_ENGINE).
    // With a single engine it is the default; with several the deck names one.
    const std::vector<std::string> engines = fire_engine_names();
    if (engines.size() == 1) { c.engine = engines.front(); }
    const bool engine_given = pp.query("engine", c.engine);
    if (engine_given || c.enable) {
        if (engines.empty()) {
            fail(std::string(c.enable ? "erf.fire.enable = true" : "erf.fire.engine is set")
                 + ", but no fire engine is compiled into this executable: Source/FireCoupling holds "
                   "only the coupling to the atmosphere. Build with an engine directory (GNU make "
                   "FIRE_HOME, CMake ERF_FIRE_ENGINE_DIRS); Source/FireCoupling/ERF_FireEngineTemplate.H "
                   "lists what an engine provides.");
        }
        if (!engine_given && engines.size() > 1) {
            std::string list;
            for (const auto& a : engines) { list += (list.empty() ? "" : ", ") + std::string("\"") + a + "\""; }
            fail("several fire engines are compiled in (" + list + "): set erf.fire.engine to one of them");
        }
        one_of("engine", c.engine, engines);
    }
 
    pp.query("heat_flux_alfg", c.heat_flux_alfg);
    pp.query("fire_atm_feedback", c.fire_atm_feedback);
    pp.query("coupling_type", c.coupling_type);
    one_of("coupling_type", c.coupling_type, {"passive", "lagged", "synchronous"});
    positive("heat_flux_alfg", c.heat_flux_alfg);
    nonneg("fire_atm_feedback", c.fire_atm_feedback);   // 0 = one-way, the documented switch
    pp.query("inject_latent", c.inject_latent);
    c.source_mode_given = pp.query("source_mode", c.source_mode);
    one_of("source_mode", c.source_mode, {"overwrite", "add"});
    pp.query("heat_open_fraction", c.heat_open_fraction);
    pp.query("heat_tendency_density", c.heat_tendency_density);
    pp.query("heat_tendency_exner", c.heat_tendency_exner);
    pp.query("heat_profile", c.heat_profile);
    one_of("heat_profile", c.heat_profile, {"exponential", "bottom_cell"});
    if (c.heat_in_bottom_cell() && c.heat_open_fraction) {
        fail("erf.fire.heat_open_fraction places the heat along the exponential profile;"
             " it cannot be combined with erf.fire.heat_profile = bottom_cell");
    }
    if (c.heat_in_bottom_cell() && pp.contains("heat_flux_alfg")) {
        amrex::Print() << "[FIRE] WARNING: erf.fire.heat_flux_alfg is ignored with"
                       << " erf.fire.heat_profile = bottom_cell\n";
    }
    // The keys of the heat injection, given with passive coupling, which
    // injects no heat: warn once per key
    if (c.is_passive()) {
        for (const char* k : {"heat_flux_alfg", "fire_atm_feedback", "inject_latent", "source_mode",
                              "heat_open_fraction", "heat_tendency_density", "heat_tendency_exner",
                              "heat_profile"}) {
            if (pp.contains(k)) {
                amrex::Print() << "[FIRE] WARNING: erf.fire." << k << " is ignored with erf.fire.coupling_type"
                               << " = passive (no heat is injected)\n";
            }
        }
    }
    pp.query("smoke_enable", c.smoke_enable);
    pp.query("smoke_emission_factor", c.smoke_emission_factor);
    nonneg("smoke_emission_factor", c.smoke_emission_factor);
    // A smoke key without the smoke switch: a deck that sets the smoke switch,
    // or the fire switch, to false explicitly is a variant switching smoke off,
    // so warn; a deck that set neither forgot the smoke switch, so stop
    if (!c.smoke_enable && pp.contains("smoke_emission_factor")) {
        if (pp.contains("smoke_enable")) {
            amrex::Print() << "[FIRE] WARNING: erf.fire.smoke_emission_factor is ignored with"
                           << " erf.fire.smoke_enable = false\n";
        } else if (pp.contains("enable") && !c.enable) {
            amrex::Print() << "[FIRE] WARNING: erf.fire.smoke_emission_factor is ignored with"
                           << " erf.fire.enable = false\n";
        } else {
            fail("erf.fire.smoke_emission_factor needs erf.fire.smoke_enable = true");
        }
    }
    return c;
}

Referenced by ERF::initializeFire().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

anchor_level

int FireCouplingParams::anchor_level = -1

erf.fire.anchor_level: the level the fire grid refines, -1 = the finest

Referenced by read().

coupling_type

std::string FireCouplingParams::coupling_type = "lagged"

erf.fire.coupling_type: passive, lagged or synchronous

Referenced by FireCoupler::add_sources(), is_lagged(), is_passive(), is_synchronous(), and read().

enable

bool FireCouplingParams::enable = false

erf.fire.enable: run a fire

Referenced by read().

engine

std::string FireCouplingParams::engine

erf.fire.engine: the fire engine behind the coupling (default: the only engine compiled in; required when there are several)

Referenced by read().

fire_atm_feedback

amrex::Real FireCouplingParams::fire_atm_feedback = 1.0

erf.fire.fire_atm_feedback: multiplier on the injected fluxes

Referenced by FireCoupler::add_sources(), and read().

fire_debug

bool FireCouplingParams::fire_debug = false

erf.fire.fire_debug: debug output of the coupling

Referenced by FireCoupler::add_sources(), FireCoupler::advance(), read(), and FireCoupler::update_flux_buffer().

grid_ratio

int FireCouplingParams::grid_ratio = 5

erf.fire.grid_ratio: fire cells per atmospheric cell in x and y

Referenced by FireCoupler::initialize(), and read().

heat_flux_alfg

amrex::Real FireCouplingParams::heat_flux_alfg = 45.0

erf.fire.heat_flux_alfg: e-folding height of the injected heat [m]

Referenced by FireCoupler::add_sources(), and read().

heat_open_fraction

bool FireCouplingParams::heat_open_fraction = false

erf.fire.heat_open_fraction: place the heat by the engine's open fraction

Referenced by FireCoupler::add_sources(), FireCoupler::initialize(), and read().

heat_profile

std::string FireCouplingParams::heat_profile = "exponential"

erf.fire.heat_profile: exponential (WRF-SFIRE, e-folding heat_flux_alfg) or bottom_cell (all of the flux into the lowest cell)

Referenced by heat_in_bottom_cell(), and read().

heat_tendency_density

bool FireCouplingParams::heat_tendency_density = false

erf.fire.heat_tendency_density: density factor of the theta tendency

Referenced by FireCoupler::add_sources(), and read().

heat_tendency_exner

bool FireCouplingParams::heat_tendency_exner = true

erf.fire.heat_tendency_exner: Exner factor of the theta tendency

Referenced by FireCoupler::add_sources(), and read().

inject_latent

bool FireCouplingParams::inject_latent = true

erf.fire.inject_latent: inject the engine's latent flux as vapour

Referenced by FireCoupler::add_sources(), read(), and FireCoupler::update_flux_buffer().

smoke_emission_factor

amrex::Real FireCouplingParams::smoke_emission_factor = 0.02

erf.fire.smoke_emission_factor: kg smoke per kg fuel burned [-]

Referenced by FireCoupler::add_sources(), and read().

smoke_enable

bool FireCouplingParams::smoke_enable = false

erf.fire.smoke_enable: inject the smoke tracer

Referenced by FireCoupler::add_sources(), read(), and FireCoupler::update_flux_buffer().

source_mode

std::string FireCouplingParams::source_mode = "overwrite"

erf.fire.source_mode: overwrite or add to the theta and vapour sources

Referenced by FireCoupler::add_sources(), and read().

source_mode_given

bool FireCouplingParams::source_mode_given = false

erf.fire.source_mode was given in the deck (the default overwrite must be chosen explicitly when another theta source would be discarded)

Referenced by read().

---

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

• Source/FireCoupling/ERF_FireCouplingParams.H
• Source/FireCoupling/ERF_FireCouplingParams.cpp