◆ setup_flow()

VolumeGridBuffer::FlowStages MayaFlux::Buffers::VolumeGridBuffer::setup_flow ( const FlowConfig & config )

Build and append the incompressible flow stages.

Parameters

config Fields and parameters. Every ref must have been issued by this volume.

Returns: The stages built, all already in the chain.

Appends in the order: self-advection, buoyancy, diffusion, wall, divergence, pressure, solenoidal, wall, then one advection per carried scalar. Carriers run last so they are transported by the projected velocity.

Stages added to the chain before this call keep their position ahead of it, which is where an influx stage belongs.

Definition at line 316 of file VolumeGridBuffer.cpp.

{
    FlowStages stages;
 
    auto self = std::dynamic_pointer_cast<VolumeGridBuffer>(shared_from_this());
    auto chain = get_processing_chain();
 
    if (!chain) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "setup_flow: no processing chain, call after registration");
        return stages;
    }
 
    const auto require = [this](const std::string& name, const char* role) {
        if (name.empty()) {
            MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
                "setup_flow: no field supplied for '{}'", role);
            return false;
        }
        if (!has_field(name)) {
            MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
                "setup_flow: '{}' names no field on this volume, supplied as '{}'",
                name, role);
            return false;
        }
        return true;
    };
 
    if (!require(config.velocity, "velocity")
        || !require(config.divergence, "divergence")
        || !require(config.pressure, "pressure")) {
        return stages;
    }
 
    if (config.viscosity > 0.0F && !require(config.scratch, "scratch")) {
        return stages;
    }
 
    stages.self_advect = std::make_shared<AdvectProcessor>(
        config.velocity, config.velocity, "volume_advect_vector.comp.spv");
    stages.self_advect->set_time_step(config.time_step);
    chain->add_processor(stages.self_advect, self);
 
    if (config.buoyancy) {
        const auto& b = *config.buoyancy;
 
        if (!require(b.temperature, "buoyancy.temperature")
            || !require(b.density, "buoyancy.density")) {
            return stages;
        }
 
        stages.buoyancy = std::make_shared<BuoyancyProcessor>(
            b.temperature, b.density, config.velocity,
            b.direction, "volume_buoyancy.comp.spv");
        stages.buoyancy->set_time_step(config.time_step);
        stages.buoyancy->set_temperature_gain(b.temperature_gain);
        stages.buoyancy->set_density_gain(b.density_gain);
        stages.buoyancy->set_ambient(b.ambient);
        chain->add_processor(stages.buoyancy, self);
    }
 
    if (config.viscosity > 0.0F) {
        stages.diffuse = std::make_shared<DiffuseProcessor>(
            config.velocity, config.scratch, "volume_diffuse_vector.comp.spv");
        stages.diffuse->set_rate(config.viscosity);
        stages.diffuse->set_time_step(config.time_step);
        chain->add_processor(stages.diffuse, self);
    }
 
    if (config.walls) {
        stages.wall_advected = std::make_shared<WallProcessor>(
            config.velocity, "volume_wall.comp.spv");
        chain->add_processor(stages.wall_advected, self);
    }
 
    stages.divergence = std::make_shared<DivergenceProcessor>(
        config.velocity, config.divergence, "volume_divergence.comp.spv");
    chain->add_processor(stages.divergence, self);
 
    stages.pressure = std::make_shared<PressureProcessor>(
        config.divergence, config.pressure, "volume_pressure_jacobi.comp.spv");
    stages.pressure->set_iteration_count(config.jacobi_iterations);
    chain->add_processor(stages.pressure, self);
 
    stages.solenoidal = std::make_shared<SolenoidalProcessor>(
        config.pressure, config.velocity, "volume_solenoidal.comp.spv");
    chain->add_processor(stages.solenoidal, self);
 
    if (config.walls) {
        stages.wall_projected = std::make_shared<WallProcessor>(
            config.velocity, "volume_wall.comp.spv");
        chain->add_processor(stages.wall_projected, self);
    }
 
    for (const auto& carried : config.carried) {
        if (!require(carried.field, "carried")) {
            continue;
        }
 
        auto advect = std::make_shared<AdvectProcessor>(
            config.velocity, carried.field, "volume_advect_scalar.comp.spv");
        advect->set_time_step(config.time_step);
        advect->set_dissipation(carried.dissipation);
        chain->add_processor(advect, self);
 
        stages.carriers.push_back(std::move(advect));
    }
 
    MF_INFO(Journal::Component::Buffers, Journal::Context::Init,
        "VolumeGridBuffer::setup_flow: {} carried, buoyancy {}, viscosity {}, walls {}",
        stages.carriers.size(), config.buoyancy ? "on" : "off",
        config.viscosity, config.walls ? "on" : "off");
 
    return stages;
}

Here is the call graph for this function: