FireCoupler Class Reference

#include <ERF_FireCoupler.H>

Collaboration diagram for FireCoupler:

Public Member Functions
	FireCoupler (const FireCouplingParams &params, std::unique_ptr< FireEngine > engine)
void	initialize (const ERF &erf, int lev, const SurfaceLayer *surface_layer, const amrex::MultiFab *z_phys_nd_atm)
	Check the configuration, build the fire grid and set the engine up. More...
void	set_fire_grid (int lev, const FireGrid &fg, const amrex::BoxArray &ba_atm, const amrex::DistributionMapping &dm_atm, const amrex::Geometry &geom_atm)
	Lay the coupling out on a fire grid: what initialize() does after its start-up checks and before it sets the engine up. More...
void	advance (amrex::Real time, amrex::Real dt, const amrex::MultiFab &S_old, const amrex::MultiFab &xvel_old, const amrex::MultiFab &yvel_old, const amrex::MultiFab &xvel_new, const amrex::MultiFab &yvel_new, const amrex::MultiFab &z_phys_cc, const amrex::BoxArray &ba2d, const amrex::Geometry &geom, const SurfacePrecipAccumulationSources &precip_sources)
	Advance the fire one step of its level and refill the lagged fluxes. More...
void	add_sources (amrex::MultiFab &cc_source, const amrex::MultiFab &S_old, const amrex::MultiFab &z_phys_cc, const amrex::MultiFab *z_phys_nd, const amrex::Geometry &geom, bool has_moisture, int step)
	Inject the lagged fire heat, vapour and smoke into the cell sources. More...
void	write_checkpoint (const std::string &checkpointname) const
	Write the fire to a checkpoint: the engine's state (FireEngine::write_checkpoint), then the coupling's lagged fluxes (FireQAtmPrev and FireQLatAtmPrev) under checkpointname/Level_<lev>/. More...
std::string	checkpoint_mismatch (int chk_lev, const amrex::Box &chk_region) const
	Why a checkpoint's lagged fluxes do not belong to this run's fire grid, or an empty string when they do. More...
void	read_checkpoint (const std::string &restart_chkfile, int max_level, int step)
	Restore the engine's state, then the lagged fluxes, on a restart. More...
const std::vector< std::string > &	plot_var_names () const
void	fill_plot_var (const std::string &name, amrex::MultiFab &dst, int dcomp, int lev) const
	Fill component dcomp of an ERF plotfile MultiFab of level lev with the fire field name. More...
int	level () const
	The level the fire grid refines (erf.fire.anchor_level, resolved at initialize). More...
const FireCouplingParams &	params () const
	The coupling inputs. More...
FireEngine &	engine ()
	The fire engine. More...
const FireEngine &	engine () const
const FireGrid &	fire_grid () const
	The fire grid. More...
const amrex::MultiFab *	get_Q_atm_prev () const
	Sensible heat flux [W/m2] of the previous fire step on the atmospheric columns of the fire grid's level, with 5 ghost columns (for a reader that samples a halo around each tile, such as a boundary-layer scheme taking the fire's heat into its mixing); zero outside the fire region. Allocated at initialize, so never null afterwards. More...
const amrex::MultiFab *	get_Q_lat_atm_prev () const
	Latent heat flux [W/m2] of the previous fire step, laid out as get_Q_atm_prev(). More...

Private Member Functions
void	update_flux_buffer (const amrex::Geometry &geom_atm)
	Average the engine's fluxes onto the atmospheric columns for the next step. More...

Private Attributes
FireCouplingParams	m_params
std::unique_ptr< FireEngine >	m_engine
FireGrid	m_fg
int	m_lev = 0
amrex::Geometry	m_geom_atm
	geometry of the fire grid's level More...
std::unique_ptr< amrex::MultiFab >	m_Q_atm_prev
	sensible [W/m2] More...
std::unique_ptr< amrex::MultiFab >	m_Q_lat_atm_prev
	latent [W/m2] More...
std::vector< std::string >	m_plot_var_names
	FireEngine::plot_var_names(), read at construction. More...

Constructor & Destructor Documentation

FireCoupler()

FireCoupler::FireCoupler	(	const FireCouplingParams &	params,
		std::unique_ptr< FireEngine >	engine
	)

Parameters

[in]	params	The coupling inputs (FireCouplingParams::read())
[in]	engine	The fire engine erf.fire.engine selects

    : m_params(params), m_engine(std::move(engine))
{
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_engine != nullptr, "[FIRE] FireCoupler needs a fire engine");
    m_plot_var_names = m_engine->plot_var_names();
    if (!m_plot_var_names.empty()) {
        amrex::Print() << "[FIRE] " << m_engine->name()
                       << ": the following additional variables are available to plot:\n";
        for (const auto& n : m_plot_var_names) { amrex::Print() << "    " << n << "\n"; }
    }
}

Here is the call graph for this function:

Member Function Documentation

add_sources()

void FireCoupler::add_sources	(	amrex::MultiFab &	cc_source,
		const amrex::MultiFab &	S_old,
		const amrex::MultiFab &	z_phys_cc,
		const amrex::MultiFab *	z_phys_nd,
		const amrex::Geometry &	geom,
		bool	has_moisture,
		int	step
	)

Inject the lagged fire heat, vapour and smoke into the cell sources.

Called from the slow right-hand side at every Runge-Kutta stage on the fire grid's level, after make_sources has rebuilt cc_source. The lagged fluxes are fixed over the step, so every stage receives the same tendency (erf.fire.source_mode decides whether it replaces or adds to the theta and vapour sources). Heat and vapour only with lagged or synchronous coupling; smoke with erf.fire.smoke_enable.

Parameters

[in,out]	cc_source	Cell-centred sources of the level
[in]	S_old	Conserved state at the start of the step (density)
[in]	z_phys_cc	Cell-centre height [m]
[in]	z_phys_nd	Nodal height [m] (ERF always passes it): the cell thickness and roof datum of the heat, and the smoke cell's thickness
[in]	geom	Geometry of the level
[in]	has_moisture	The vapour source exists
[in]	step	Step of the level, for the debug output

{
    // Heat and vapour, with the WRF-Fire profile (ERF_FireAtmCoupling.H)
    if (m_params.injects_flux() && m_Q_atm_prev && m_params.fire_atm_feedback > 0.0_rt) {
        if (m_params.fire_debug) {
            amrex::Print() << "[FIRE DEBUG] Applying fire coupling to atmosphere (coupling_type="
                           << m_params.coupling_type << ", feedback=" << m_params.fire_atm_feedback
                           << ", max_Q_prev=" << m_Q_atm_prev->max(0) << " W/m2)" << std::endl;
        }
 
        const MultiFab* Q_lat_ptr = (m_params.inject_latent && has_moisture)
            ? m_Q_lat_atm_prev.get() : nullptr;
 
        // Pass fire_debug so apply_fire_tendency_to_cc_source prints tendency diagnostics.
        // With fire_debug=true you will see per-RK-stage output:
        //   [FIRE COUPLING] Q_atm_max=...  alfg=...
        //   [FIRE COUPLING] RhoTheta tendency sum=...  max=...  expected_surface_max=...
        apply_fire_tendency_to_cc_source(
            cc_source,
            *m_Q_atm_prev,
            Q_lat_ptr,
            z_phys_cc,
            z_phys_nd,
            S_old,
            geom,
            m_params.heat_flux_alfg,
            m_params.fire_atm_feedback,
            has_moisture,
            m_params.fire_debug,
            m_params.source_mode == "add",
            m_engine->heat_open_fraction_atm(),
            m_engine->roof_height_atm(),
            m_params.heat_open_fraction,
            m_params.heat_tendency_density,
            m_params.heat_tendency_exner,
            m_params.heat_in_bottom_cell());
    }
 
    // The smoke tracer, after the heat: proportional to the fuel burnt, which
    // the engine's heat per kilogram recovers from the lagged sensible flux
    if (m_params.smoke_enable && m_Q_atm_prev) {
        inject_smoke_from_fire(
            cc_source,
            *m_Q_atm_prev,
            z_phys_nd,
            geom,
            m_params.smoke_emission_factor,
            m_engine->smoke_heat_per_kg(),
            RhoSmoke_comp,
            m_params.fire_debug,
            step);
    }
}

Here is the call graph for this function:

advance()

void FireCoupler::advance	(	amrex::Real	time,
		amrex::Real	dt,
		const amrex::MultiFab &	S_old,
		const amrex::MultiFab &	xvel_old,
		const amrex::MultiFab &	yvel_old,
		const amrex::MultiFab &	xvel_new,
		const amrex::MultiFab &	yvel_new,
		const amrex::MultiFab &	z_phys_cc,
		const amrex::BoxArray &	ba2d,
		const amrex::Geometry &	geom,
		const SurfacePrecipAccumulationSources &	precip_sources
	)

Advance the fire one step of its level and refill the lagged fluxes.

Called from ERF::Advance() once per step of the fire grid's level, after that level's dycore. The air temperature and humidity at k = 0 come from the state before the dycore; the wind from before the dycore (passive and lagged coupling) or after it (synchronous).

Parameters

[in]	time	Start of the step [s]
[in]	dt	Step of the level [s]
[in]	S_old	Conserved state before the dycore
[in]	xvel_old,yvel_old	Face velocities before the dycore [m/s]
[in]	xvel_new,yvel_new	Face velocities after the dycore [m/s]
[in]	z_phys_cc	Cell-centre height of the level [m]
[in]	ba2d	The level's boxes coarsened to one cell in z
[in]	geom	Geometry of the level
[in]	precip_sources	The microphysics surface precipitation accumulators of the level

{
    // Air temperature and RH at k=0 (an engine may drive a fuel moisture
    // model with them), derived from the pre-dycore state. This is used in both lagged and synchronous
    // modes: the moisture ODE uses time-averaged T, and the change in T from
    // fire heating within one atmospheric step is small relative to the
    // moisture time lag. The temperature is theta * Exner(p) (the moisture
    // curves, Balbi's T_a and the threshold ignition take an air
    // temperature); the plain k = 0 potential temperature used here before
    // was 14-16 K too warm at 840 hPa.
    MultiFab T_atm_k0(ba2d, S_old.DistributionMap(), 1, 0);
    compute_t_from_conservative(T_atm_k0, S_old);
    MultiFab RH_atm_k0(ba2d, S_old.DistributionMap(), 1, 0);
    compute_rh_from_conservative(RH_atm_k0, S_old, geom);
 
    // Surface precipitation accumulation of every column after this step's
    // microphysics, for an engine that takes the rain per column
    // (FireEngine::wants_surface_precip); the engine differences it against the
    // accumulation it saw at its previous step.
    std::unique_ptr<MultiFab> precip_accum_k0;
    if (m_engine->wants_surface_precip()) {
        precip_accum_k0 = std::make_unique<MultiFab>(ba2d, S_old.DistributionMap(), 1, 0);
        fire_surface_precip_accum_k0(*precip_accum_k0, precip_sources, geom.Domain().smallEnd(2));
    }
 
    // In passive and lagged modes, fire uses pre-dycore wind (vars_old).
    // In synchronous mode, fire uses post-dycore wind (vars_new) so that
    // the fire spread rate at step n+1 reflects the atmospheric momentum
    // response to fire heating from step n.
    const bool post_dycore = m_params.is_synchronous();
    if (m_params.fire_debug) {
        const char* mode = m_params.is_synchronous() ? "SYNCHRONOUS coupling with POST-dycore"
                         : m_params.is_lagged()      ? "LAGGED coupling with PRE-dycore"
                                                     : "PASSIVE coupling with PRE-dycore";
        amrex::Print() << "[FIRE DEBUG] Fire advance using " << mode << " wind at t="
                       << time << ", dt=" << dt << std::endl;
    }
    const FireForcing forcing{time, dt,
                              post_dycore ? xvel_new : xvel_old,
                              post_dycore ? yvel_new : yvel_old,
                              z_phys_cc, T_atm_k0, RH_atm_k0, precip_accum_k0.get()};
    m_engine->advance(forcing);
    if (m_params.fire_debug) {
        const Real area = m_engine->burned_area();   // every rank: it may reduce over the fire grid
        if (area >= 0.0_rt) {
            amrex::Print() << "[FIRE DEBUG] Burned area at t=" << time + dt << ": " << area << " m2" << std::endl;
        }
    }
 
    // Store the fire flux of this step for injection at the next step via the
    // Runge-Kutta source term (add_sources). This applies in both lagged and
    // synchronous modes; in passive mode the buffer keeps its zero unless the
    // smoke tracer needs it.
    update_flux_buffer(geom);
}

Here is the call graph for this function:

checkpoint_mismatch()

std::string FireCoupler::checkpoint_mismatch	(	int	chk_lev,
		const amrex::Box &	chk_region
	)		const

Why a checkpoint's lagged fluxes do not belong to this run's fire grid, or an empty string when they do.

Parameters

[in]	chk_lev	The level the checkpoint holds them on
[in]	chk_region	The columns they cover (minimal box of their boxes)

{
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_Q_atm_prev, "[FIRE] FireCoupler: set_fire_grid() before the checkpoint");
    // The fluxes cover the columns of the level's boxes, which form the fire
    // region (verify_fire_prerequisites, check 7b)
    const Box run_region = m_Q_atm_prev->boxArray().minimalBox();
    if (chk_lev == m_lev && chk_region == run_region) { return {}; }
    std::ostringstream msg;
    msg << "holds the lagged fire fluxes on level " << chk_lev << " over the columns " << chk_region
        << ", but this run's fire grid covers the columns " << run_region << " of level " << m_lev
        << ". Restart with the erf.fire.anchor_level and the refinement the checkpoint was written with.";
    return msg.str();
}

Referenced by read_checkpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

engine() [1/2]

FireEngine& FireCoupler::engine ( )

inline

The fire engine.

{ return *m_engine; }

engine() [2/2]

const FireEngine& FireCoupler::engine ( ) const

inline

{ return *m_engine; }

fill_plot_var()

void FireCoupler::fill_plot_var	(	const std::string &	name,
		amrex::MultiFab &	dst,
		int	dcomp,
		int	lev
	)		const

Fill component dcomp of an ERF plotfile MultiFab of level lev with the fire field name.

On the fire grid's level, the k = 0 cell of each column holds the mean of the engine's field (FireEngine::plot_var) over the fire cells under it; every other cell, every other level and a field the engine returns as nullptr hold zero.

Parameters

[in]	name	One of plot_var_names()
[out]	dst	Cell-centred MultiFab on the boxes of level lev
[in]	dcomp	Component of dst to fill
[in]	lev	The level dst belongs to

{
    dst.setVal(0.0_rt, dcomp, 1, 0);
    if (lev != m_lev || !m_Q_atm_prev) { return; }
    const MultiFab* fire_field = m_engine->plot_var(name);
    if (!fire_field) { return; }
 
    // The column means, on the k = 0 slabs the lagged fluxes use
    MultiFab col(m_Q_atm_prev->boxArray(), m_Q_atm_prev->DistributionMap(), 1, 0);
    col.setVal(0.0_rt);
    coarsen_fire_flux_to_atm(col, *fire_field, m_geom_atm, m_fg);
 
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(dst.boxArray().size() == col.boxArray().size() &&
                                     dst.DistributionMap() == col.DistributionMap(),
                                     "[FIRE] fill_plot_var: the plotfile MultiFab is not on the fire grid's level");
    const int k0 = m_geom_atm.Domain().smallEnd(2);
    for (MFIter mfi(dst); mfi.isValid(); ++mfi) {
        Box bx = mfi.validbox();
        if (bx.smallEnd(2) > k0) { continue; }
        bx.setSmall(2, k0);
        bx.setBig(2, k0);
        const auto d = dst.array(mfi);
        const auto c = col.const_array(mfi);
        const int kc = col.boxArray()[mfi.index()].smallEnd(2);
        ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
        {
            d(i, j, k, dcomp) = c(i, j, kc);
        });
    }
}

Here is the call graph for this function:

fire_grid()

const FireGrid& FireCoupler::fire_grid ( ) const

inline

The fire grid.

{ return m_fg; }

get_Q_atm_prev()

const amrex::MultiFab* FireCoupler::get_Q_atm_prev ( ) const

inline

Sensible heat flux [W/m2] of the previous fire step on the atmospheric columns of the fire grid's level, with 5 ghost columns (for a reader that samples a halo around each tile, such as a boundary-layer scheme taking the fire's heat into its mixing); zero outside the fire region. Allocated at initialize, so never null afterwards.

{ return m_Q_atm_prev.get(); }

get_Q_lat_atm_prev()

const amrex::MultiFab* FireCoupler::get_Q_lat_atm_prev ( ) const

inline

Latent heat flux [W/m2] of the previous fire step, laid out as get_Q_atm_prev().

{ return m_Q_lat_atm_prev.get(); }

initialize()

void FireCoupler::initialize	(	const ERF &	erf,
		int	lev,
		const SurfaceLayer *	surface_layer,
		const amrex::MultiFab *	z_phys_nd_atm
	)

Check the configuration, build the fire grid and set the engine up.

Called once from ERF::InitData_post() after every surface layer exists. Runs the coupling's checks (verify_fire_prerequisites), then the engine's, builds the fire grid on level lev, allocates the lagged flux buffers (zero) and initialises the engine.

Parameters

[in]	erf	ERF instance (public AmrCore accessors only)
[in]	lev	The level the fire grid refines (fire_anchor_level)
[in]	surface_layer	The bottom surface layer, or nullptr (aborts when the engine needs one, FireEngine::needs_surface_layer)
[in]	z_phys_nd_atm	Nodal height of level lev [m] (ERF always passes it)

{
    // The ERF configuration a fire grid needs, then the engine's own inputs
    verify_fire_prerequisites(erf, lev, surface_layer, m_params.grid_ratio,
                              m_engine->needs_surface_layer());
    m_engine->verify_prerequisites(erf, lev);
 
    FireGrid fg = create_fire_grid(erf.boxArray(lev), erf.DistributionMap(lev),
                                   erf.Geom(lev), m_params.grid_ratio);
    fg.lev = lev;
    report_fire_region(erf, lev, fg);
    set_fire_grid(lev, fg, erf.boxArray(lev), erf.DistributionMap(lev), erf.Geom(lev));
 
    m_engine->initialize(erf, lev, m_fg, surface_layer, z_phys_nd_atm);
 
    // erf.fire.heat_open_fraction places the heat by the open fraction the
    // engine reports; without one the heat is placed as if every column were open
    if (m_params.heat_open_fraction && m_params.injects_flux() &&
        (!m_engine->heat_open_fraction_atm() || !m_engine->roof_height_atm())) {
        amrex::Print() << "[FIRE] WARNING: erf.fire.heat_open_fraction = true, but the fire engine ("
                       << m_engine->name() << ") reports no open fraction;"
                       << " the heat is placed as if every column were open\n";
    }
}

Here is the call graph for this function:

level()

int FireCoupler::level ( ) const

inline

The level the fire grid refines (erf.fire.anchor_level, resolved at initialize).

{ return m_lev; }

params()

const FireCouplingParams& FireCoupler::params ( ) const

inline

The coupling inputs.

{ return m_params; }

plot_var_names()

const std::vector<std::string>& FireCoupler::plot_var_names ( ) const

inline

Fire fields the ERF plotfile can carry (FireEngine::plot_var_names(), read at construction, before ERF reads erf.plot_vars_*).

{ return m_plot_var_names; }

read_checkpoint()

void FireCoupler::read_checkpoint	(	const std::string &	restart_chkfile,
		int	max_level,
		int	step
	)

Restore the engine's state, then the lagged fluxes, on a restart.

Aborts when the checkpoint holds the lagged fluxes on another level or over another region than this run's fire grid. A checkpoint without them (no fire state, or written before they were checkpointed) leaves them at zero: the first restarted step injects no fire heat.

Parameters

[in]	restart_chkfile	The checkpoint directory
[in]	max_level	ERF's max_level
[in]	step	The step count of the fire grid's level at the checkpoint

{
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_Q_atm_prev, "[FIRE] FireCoupler: set_fire_grid() before the checkpoint");
    // The engine first: it may check, naming its own fields, that the
    // checkpoint's fire grid sits on this level and region
    m_engine->read_checkpoint(restart_chkfile, max_level, step);
 
    // The lagged fluxes, on the level of the fire grid. A checkpoint without them
    // (written with no fire running): the buffers keep their zero, said once.
    // Decided on the I/O rank and broadcast, so every rank takes the same branch
    // into the collective reads below
    int chk_lev = -1;
    if (ParallelDescriptor::IOProcessor()) {
        for (int l = 0; l <= max_level; ++l) {
            if (amrex::FileExists(restart_chkfile + "/Level_" + std::to_string(l) + "/FireQAtmPrev_H")) {
                chk_lev = l;
                break;
            }
        }
    }
    ParallelDescriptor::Bcast(&chk_lev, 1, ParallelDescriptor::IOProcessorNumber());
    if (chk_lev < 0) {
        amrex::Print() << "[FIRE] Checkpoint has no lagged fire fluxes; the first restarted step injects none.\n";
        return;
    }
    // Whatever the engine: the fluxes belong to this run's fire grid, on its
    // level and over its region (an engine may have checked its own fields
    // already; this check holds whatever the engine)
    const Box chk_region = VisMF(MultiFabFileFullPrefix(chk_lev, restart_chkfile, "Level_", "FireQAtmPrev"))
                               .boxArray().minimalBox();
    if (const std::string why = checkpoint_mismatch(chk_lev, chk_region); !why.empty()) {
        amrex::Abort("[FIRE] The checkpoint " + restart_chkfile + " " + why);
    }
    for (const auto& [mf, name] : {std::pair<MultiFab*, const char*>{m_Q_atm_prev.get(), "FireQAtmPrev"},
                                   std::pair<MultiFab*, const char*>{m_Q_lat_atm_prev.get(), "FireQLatAtmPrev"}}) {
        if (mf == nullptr) { continue; }
        // decided on one rank and broadcast, so every rank takes the same
        // path into the collective read below
        const std::string header = restart_chkfile + "/Level_" + std::to_string(m_lev) + "/" + name + "_H";
        int has_field = 0;
        if (ParallelDescriptor::IOProcessor()) { has_field = amrex::FileExists(header) ? 1 : 0; }
        ParallelDescriptor::Bcast(&has_field, 1, ParallelDescriptor::IOProcessorNumber());
        if (has_field == 0) {
            amrex::Print() << "[FIRE] Checkpoint has no " << name << "; keeping the initialized values.\n";
            continue;
        }
        VisMF::Read(*mf, MultiFabFileFullPrefix(m_lev, restart_chkfile, "Level_", name));
        // VisMF restores the valid cells (a checkpoint may hold no ghost
        // columns), so refill the ghosts the way update_flux_buffer() does.
        fire_fill_boundary(*mf, m_geom_atm);
    }
}

Here is the call graph for this function:

set_fire_grid()

void FireCoupler::set_fire_grid	(	int	lev,
		const FireGrid &	fg,
		const amrex::BoxArray &	ba_atm,
		const amrex::DistributionMapping &	dm_atm,
		const amrex::Geometry &	geom_atm
	)

Lay the coupling out on a fire grid: what initialize() does after its start-up checks and before it sets the engine up.

Takes the fire grid and allocates the lagged flux buffers (zero) on the k = 0 slabs of ba_atm, with 5 ghost columns. Public so that a test can drive the coupling with an engine of its own without an ERF object (Tests/Unit/Fire/ERF_GTestFireCoupler.cpp).

Parameters

[in]	lev	The level the fire grid refines
[in]	fg	The fire grid (create_fire_grid)
[in]	ba_atm	The level's boxes
[in]	dm_atm	Their owners
[in]	geom_atm	The level's geometry

{
    m_lev      = lev;
    m_fg       = fg;
    m_geom_atm = geom_atm;
    const int nz = geom_atm.Domain().length(2);
 
    // The lagged fluxes live on the k = 0 slabs of the level's boxes, with the
    // level's owners. Ghost columns for a reader that samples the fluxes in the
    // halo around every tile: 5, the most ERF's state carries
    // (ComputeGhostCells() + 1); update_flux_buffer() fills them.
    BoxArray ba_atm_2d = ba_atm;
    ba_atm_2d.coarsen(IntVect(1, 1, nz));
    const IntVect ng_flux(5, 5, 0);
    m_Q_atm_prev     = std::make_unique<MultiFab>(ba_atm_2d, dm_atm, 1, ng_flux);
    m_Q_lat_atm_prev = std::make_unique<MultiFab>(ba_atm_2d, dm_atm, 1, ng_flux);
    m_Q_atm_prev->setVal(0.0_rt);
    m_Q_lat_atm_prev->setVal(0.0_rt);
}

Referenced by initialize().

Here is the caller graph for this function:

update_flux_buffer()

void FireCoupler::update_flux_buffer ( const amrex::Geometry &  geom_atm )

private

Average the engine's fluxes onto the atmospheric columns for the next step.

{
    if (!m_params.injects_flux() && !m_params.smoke_enable) {
        if (m_params.fire_debug) {
            amrex::Print() << "[FIRE DEBUG] Skipping flux buffer update: coupling_type is passive (injects_flux=false) and smoke_enable=false" << std::endl;
        }
        return;
    }
 
    if (!m_Q_atm_prev) { return; }
    FireFluxes fluxes;
    m_engine->fill_fluxes(fluxes);
    if (fluxes.sensible) {
        coarsen_fire_flux_to_atm(*m_Q_atm_prev, *fluxes.sensible, geom_atm, m_fg);
        if (m_params.fire_debug) {
            amrex::Print() << "[FIRE DEBUG] Sensible flux to the atmosphere: max " << m_Q_atm_prev->max(0)
                           << " W/m2" << fluxes.debug_note << std::endl;
        }
    } else {
        // Clear the stale sensible flux without discarding independent latent
        // feedback reported by the engine during this same step.
        m_Q_atm_prev->setVal(0.0_rt);
    }
 
    if (m_params.inject_latent && fluxes.latent) {
        coarsen_fire_flux_to_atm(*m_Q_lat_atm_prev, *fluxes.latent, geom_atm, m_fg);
    } else {
        if (m_params.fire_debug && m_params.injects_flux()) {
            amrex::Print() << "[FIRE DEBUG] Skipping latent heat injection (inject_latent=false or the engine reports no latent flux)" << std::endl;
        }
        m_Q_lat_atm_prev->setVal(0.0_rt);
    }
 
    // A reader may sample these fluxes in the halo columns around every tile;
    // give them the neighbouring box's value (and the edge column's
    // outside a non-periodic face), so a column sees the same flux whichever box
    // holds it. On a finer level the columns outside the refined region have no
    // fire grid and keep the zero they were allocated with.
    fire_fill_boundary(*m_Q_atm_prev, geom_atm);
    fire_fill_boundary(*m_Q_lat_atm_prev, geom_atm);
}

Referenced by advance().

Here is the call graph for this function:

Here is the caller graph for this function:

write_checkpoint()

void FireCoupler::write_checkpoint

(

const std::string &

checkpointname

)

const

Write the fire to a checkpoint: the engine's state (FireEngine::write_checkpoint), then the coupling's lagged fluxes (FireQAtmPrev and FireQLatAtmPrev) under checkpointname/Level_<lev>/.

{
    // The engine's own state first, as read_checkpoint restores it
    m_engine->write_checkpoint(checkpointname);
 
    // The lagged fluxes injected into the atmosphere on the next step. Without
    // them the first step after a restart injects no fire heat at all.
    if (m_Q_atm_prev) {
        amrex::Print() << "Writing fire atmosphere flux buffer to checkpoint" << std::endl;
        VisMF::Write(*m_Q_atm_prev, MultiFabFileFullPrefix(m_lev, checkpointname, "Level_", "FireQAtmPrev"));
    }
    if (m_Q_lat_atm_prev) {
        VisMF::Write(*m_Q_lat_atm_prev, MultiFabFileFullPrefix(m_lev, checkpointname, "Level_", "FireQLatAtmPrev"));
    }
}

Member Data Documentation

m_engine

std::unique_ptr<FireEngine> FireCoupler::m_engine

private

Referenced by add_sources(), advance(), engine(), fill_plot_var(), FireCoupler(), initialize(), read_checkpoint(), update_flux_buffer(), and write_checkpoint().

m_fg

FireGrid FireCoupler::m_fg

private

Referenced by fill_plot_var(), fire_grid(), initialize(), set_fire_grid(), and update_flux_buffer().

m_geom_atm

amrex::Geometry FireCoupler::m_geom_atm

private

geometry of the fire grid's level

Referenced by fill_plot_var(), read_checkpoint(), and set_fire_grid().

m_lev

int FireCoupler::m_lev = 0

private

Referenced by checkpoint_mismatch(), fill_plot_var(), level(), read_checkpoint(), set_fire_grid(), and write_checkpoint().

m_params

FireCouplingParams FireCoupler::m_params

private

Referenced by add_sources(), advance(), initialize(), params(), and update_flux_buffer().

m_plot_var_names

std::vector<std::string> FireCoupler::m_plot_var_names

private

FireEngine::plot_var_names(), read at construction.

Referenced by FireCoupler(), and plot_var_names().

m_Q_atm_prev

std::unique_ptr<amrex::MultiFab> FireCoupler::m_Q_atm_prev

private

sensible [W/m2]

Referenced by add_sources(), checkpoint_mismatch(), fill_plot_var(), get_Q_atm_prev(), read_checkpoint(), set_fire_grid(), update_flux_buffer(), and write_checkpoint().

m_Q_lat_atm_prev

std::unique_ptr<amrex::MultiFab> FireCoupler::m_Q_lat_atm_prev

private

latent [W/m2]

Referenced by add_sources(), get_Q_lat_atm_prev(), read_checkpoint(), set_fire_grid(), update_flux_buffer(), and write_checkpoint().

---

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

• Source/FireCoupling/ERF_FireCoupler.H
• Source/FireCoupling/ERF_FireCoupler.cpp