← back to ncmaclachlan__me523-cfd-project

Function bodies 112 total

All specs Real LLM only Function bodies
main function · cpp · L3-L19 (17 LOC)
apps/ns_solver.cpp
int main(int argc, char* argv[]) {
    Kokkos::initialize(argc, argv);
    {
        RunConfig cfg;
        cfg.nx    = 64;
        cfg.ny    = 64;
        cfg.re    = 100.0;
        cfg.cfl   = 0.5;
        cfg.t_end = 10.0;

        Solver<PeriodicBC, CrankThatNicolson> solver(cfg);
        solver.run();
    }
    Kokkos::finalize();
    return 0;
}
apply_u method · cpp · L10-L31 (22 LOC)
include/boundary_conditions.hpp
    void apply_u(const MacGrid2D& g, Kokkos::View<double**> u) const {
        const double u_lid = lid_velocity;

        // Left/right walls: u-face sits exactly on the wall, enforce no-slip directly
        Kokkos::parallel_for("ldc_u_lr",
            Kokkos::RangePolicy<>(g.u_j_begin(), g.u_j_end()),
            KOKKOS_LAMBDA(int j) {
                u(g.u_i_begin(),     j) = 0.0;   // left wall
                u(g.u_i_end() - 1,   j) = 0.0;   // right wall
            });

        // Bottom/top: u-face is half a cell from the wall, enforce via ghost cell
        //   bottom (y=0, no-slip): u_ghost = -u_interior  -> avg = 0 at wall
        //   top    (y=Ly, lid):    u_ghost = 2*U_lid - u_interior
        Kokkos::parallel_for("ldc_u_tb",
            Kokkos::RangePolicy<>(g.u_i_begin(), g.u_i_end()),
            KOKKOS_LAMBDA(int i) {
                u(i, g.u_j_begin() - 1) = -u(i, g.u_j_begin());
                u(i, g.u_j_end())       = 2.0 * u_lid - u(i, g.u_j_end() - 1);
KOKKOS_LAMBDA method · cpp · L17-L20 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(int j) {
                u(g.u_i_begin(),     j) = 0.0;   // left wall
                u(g.u_i_end() - 1,   j) = 0.0;   // right wall
            });
KOKKOS_LAMBDA method · cpp · L27-L30 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(int i) {
                u(i, g.u_j_begin() - 1) = -u(i, g.u_j_begin());
                u(i, g.u_j_end())       = 2.0 * u_lid - u(i, g.u_j_end() - 1);
            });
apply_v method · cpp · L32-L51 (20 LOC)
include/boundary_conditions.hpp
    void apply_v(const MacGrid2D& g, Kokkos::View<double**> v) const {
        // Bottom/top walls: v-face sits exactly on the wall, enforce no-slip directly
        Kokkos::parallel_for("ldc_v_tb",
            Kokkos::RangePolicy<>(g.v_i_begin(), g.v_i_end()),
            KOKKOS_LAMBDA(int i) {
                v(i, g.v_j_begin())     = 0.0;   // bottom wall
                v(i, g.v_j_end() - 1)   = 0.0;   // top wall
            });

        // Left/right: v-face is half a cell from the wall, enforce via ghost cell
        //   left  (x=0,  no-slip): v_ghost = -v_interior
        //   right (x=Lx, no-slip): v_ghost = -v_interior
        Kokkos::parallel_for("ldc_v_lr",
            Kokkos::RangePolicy<>(g.v_j_begin(), g.v_j_end()),
            KOKKOS_LAMBDA(int j) {
                v(g.v_i_begin() - 1, j) = -v(g.v_i_begin(), j);
                v(g.v_i_end(),       j) = -v(g.v_i_end() - 1, j);
            });
    }
KOKKOS_LAMBDA method · cpp · L37-L40 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(int i) {
                v(i, g.v_j_begin())     = 0.0;   // bottom wall
                v(i, g.v_j_end() - 1)   = 0.0;   // top wall
            });
KOKKOS_LAMBDA method · cpp · L47-L50 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(int j) {
                v(g.v_i_begin() - 1, j) = -v(g.v_i_begin(), j);
                v(g.v_i_end(),       j) = -v(g.v_i_end() - 1, j);
            });
Powered by Repobility — scan your code at https://repobility.com
apply method · cpp · L52-L56 (5 LOC)
include/boundary_conditions.hpp
    void apply(SimState& s) const {
        apply_u(s.grid, s.u);
        apply_v(s.grid, s.v);
    }
apply_u method · cpp · L60-L94 (35 LOC)
include/boundary_conditions.hpp
    void apply_u(const MacGrid2D& g, Kokkos::View<double**> u) const {
        // Sync duplicate periodic face: u at i=begin and i=end-1 are the same
        // physical face.  Average to keep both sides symmetric, then set ghosts.
        Kokkos::parallel_for("periodic_u_sync",
            Kokkos::RangePolicy<>(g.u_j_begin(), g.u_j_end()),
            KOKKOS_LAMBDA(const int j) {
                const double avg = 0.5 * (u(g.u_i_begin(), j)
                                        + u(g.u_i_end() - 1, j));
                u(g.u_i_begin(),     j) = avg;
                u(g.u_i_end() - 1,   j) = avg;
            });

        Kokkos::parallel_for("periodic_u_x",
            Kokkos::RangePolicy<>(g.u_j_begin(), g.u_j_end()),
            KOKKOS_LAMBDA(const int j) {
                u(g.u_i_begin() - 1, j) = u(g.u_i_end() - 1, j);
                u(g.u_i_end(),       j) = u(g.u_i_begin(),   j);
            });

        Kokkos::parallel_for("periodic_u_y",
            Kokkos::RangePolicy<>(g.
KOKKOS_LAMBDA method · cpp · L65-L70 (6 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int j) {
                const double avg = 0.5 * (u(g.u_i_begin(), j)
                                        + u(g.u_i_end() - 1, j));
                u(g.u_i_begin(),     j) = avg;
                u(g.u_i_end() - 1,   j) = avg;
            });
KOKKOS_LAMBDA method · cpp · L74-L77 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int j) {
                u(g.u_i_begin() - 1, j) = u(g.u_i_end() - 1, j);
                u(g.u_i_end(),       j) = u(g.u_i_begin(),   j);
            });
KOKKOS_LAMBDA method · cpp · L81-L84 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int i) {
                u(i, g.u_j_begin() - 1) = u(i, g.u_j_end() - 1);
                u(i, g.u_j_end())       = u(i, g.u_j_begin());
            });
KOKKOS_LAMBDA method · cpp · L88-L93 (6 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int) {
                u(g.u_i_begin() - 1, g.u_j_begin() - 1) = u(g.u_i_end() - 1, g.u_j_end() - 1);
                u(g.u_i_begin() - 1, g.u_j_end())       = u(g.u_i_end() - 1, g.u_j_begin());
                u(g.u_i_end(),       g.u_j_begin() - 1) = u(g.u_i_begin(),   g.u_j_end() - 1);
                u(g.u_i_end(),       g.u_j_end())       = u(g.u_i_begin(),   g.u_j_begin());
            });
apply_v method · cpp · L95-L129 (35 LOC)
include/boundary_conditions.hpp
    void apply_v(const MacGrid2D& g, Kokkos::View<double**> v) const {
        // Sync duplicate periodic face: v at j=begin and j=end-1 are the same
        Kokkos::parallel_for("periodic_v_sync",
            Kokkos::RangePolicy<>(g.v_i_begin(), g.v_i_end()),
            KOKKOS_LAMBDA(const int i) {
                const double avg = 0.5 * (v(i, g.v_j_begin())
                                        + v(i, g.v_j_end() - 1));
                v(i, g.v_j_begin())     = avg;
                v(i, g.v_j_end() - 1)   = avg;
            });

        Kokkos::parallel_for("periodic_v_x",
            Kokkos::RangePolicy<>(g.v_j_begin(), g.v_j_end()),
            KOKKOS_LAMBDA(const int j) {
                v(g.v_i_begin() - 1, j) = v(g.v_i_end() - 1, j);
                v(g.v_i_end(),       j) = v(g.v_i_begin(),   j);
            });

        Kokkos::parallel_for("periodic_v_y",
            Kokkos::RangePolicy<>(g.v_i_begin(), g.v_i_end()),
            KOKKOS_LAMBDA(const int i) {
KOKKOS_LAMBDA method · cpp · L100-L105 (6 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int i) {
                const double avg = 0.5 * (v(i, g.v_j_begin())
                                        + v(i, g.v_j_end() - 1));
                v(i, g.v_j_begin())     = avg;
                v(i, g.v_j_end() - 1)   = avg;
            });
Repobility · code-quality intelligence · https://repobility.com
KOKKOS_LAMBDA method · cpp · L109-L112 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int j) {
                v(g.v_i_begin() - 1, j) = v(g.v_i_end() - 1, j);
                v(g.v_i_end(),       j) = v(g.v_i_begin(),   j);
            });
KOKKOS_LAMBDA method · cpp · L116-L119 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int i) {
                v(i, g.v_j_begin() - 1) = v(i, g.v_j_end() - 1);
                v(i, g.v_j_end())       = v(i, g.v_j_begin());
            });
KOKKOS_LAMBDA method · cpp · L123-L128 (6 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int) {
                v(g.v_i_begin() - 1, g.v_j_begin() - 1) = v(g.v_i_end() - 1, g.v_j_end() - 1);
                v(g.v_i_begin() - 1, g.v_j_end())       = v(g.v_i_end() - 1, g.v_j_begin());
                v(g.v_i_end(),       g.v_j_begin() - 1) = v(g.v_i_begin(),   g.v_j_end() - 1);
                v(g.v_i_end(),       g.v_j_end())       = v(g.v_i_begin(),   g.v_j_begin());
            });
apply method · cpp · L130-L160 (31 LOC)
include/boundary_conditions.hpp
    void apply(SimState& s) const {
        const MacGrid2D& g = s.grid;

        // pressure
        Kokkos::parallel_for("periodic_p_x",
            Kokkos::RangePolicy<>(g.p_j_begin(), g.p_j_end()),
            KOKKOS_LAMBDA(const int j) {
                s.p(g.p_i_begin() - 1, j) = s.p(g.p_i_end() - 1, j);
                s.p(g.p_i_end(),       j) = s.p(g.p_i_begin(),   j);
            });

        Kokkos::parallel_for("periodic_p_y",
            Kokkos::RangePolicy<>(g.p_i_begin(), g.p_i_end()),
            KOKKOS_LAMBDA(const int i) {
                s.p(i, g.p_j_begin() - 1) = s.p(i, g.p_j_end() - 1);
                s.p(i, g.p_j_end())       = s.p(i, g.p_j_begin());
            });

        Kokkos::parallel_for("periodic_p_corners",
            Kokkos::RangePolicy<>(0, 1),
            KOKKOS_LAMBDA(const int) {
                s.p(g.p_i_begin() - 1, g.p_j_begin() - 1) = s.p(g.p_i_end() - 1, g.p_j_end() - 1);
                s.p(g.p_i_begin() - 1, g.p_j_end())       = s.p(g.p_i
KOKKOS_LAMBDA method · cpp · L137-L140 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int j) {
                s.p(g.p_i_begin() - 1, j) = s.p(g.p_i_end() - 1, j);
                s.p(g.p_i_end(),       j) = s.p(g.p_i_begin(),   j);
            });
KOKKOS_LAMBDA method · cpp · L144-L147 (4 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int i) {
                s.p(i, g.p_j_begin() - 1) = s.p(i, g.p_j_end() - 1);
                s.p(i, g.p_j_end())       = s.p(i, g.p_j_begin());
            });
KOKKOS_LAMBDA method · cpp · L151-L156 (6 LOC)
include/boundary_conditions.hpp
            KOKKOS_LAMBDA(const int) {
                s.p(g.p_i_begin() - 1, g.p_j_begin() - 1) = s.p(g.p_i_end() - 1, g.p_j_end() - 1);
                s.p(g.p_i_begin() - 1, g.p_j_end())       = s.p(g.p_i_end() - 1, g.p_j_begin());
                s.p(g.p_i_end(),       g.p_j_begin() - 1) = s.p(g.p_i_begin(),   g.p_j_end() - 1);
                s.p(g.p_i_end(),       g.p_j_end())       = s.p(g.p_i_begin(),   g.p_j_begin());
            });
apply method · cpp · L6-L10 (5 LOC)
include/initial_conditions.hpp
    void apply(SimState& s) const {
        Kokkos::deep_copy(s.u, 0.0);
        Kokkos::deep_copy(s.v, 0.0);
        Kokkos::deep_copy(s.p, 0.0);
    }
Repobility · severity-and-effort ranking · https://repobility.com
apply method · cpp · L14-L43 (30 LOC)
include/initial_conditions.hpp
    void apply(SimState& s) const {
        const auto& g  = s.grid;
        const double dx = g.dx;
        const double dy = g.dy;
        const int ng    = MacGrid2D::ng;

        auto u = s.u;
        Kokkos::parallel_for("TG_u",
            Kokkos::MDRangePolicy<Kokkos::Rank<2>>(
                {g.u_i_begin(), g.u_j_begin()},
                {g.u_i_end(),   g.u_j_end()}),
            KOKKOS_LAMBDA(int i, int j) {
                double x = (i - ng) * dx;
                double y = (j - ng + 0.5) * dy;
                u(i, j) = Kokkos::sin(x) * Kokkos::cos(y);
            });

        auto v = s.v;
        Kokkos::parallel_for("TG_v",
            Kokkos::MDRangePolicy<Kokkos::Rank<2>>(
                {g.v_i_begin(), g.v_j_begin()},
                {g.v_i_end(),   g.v_j_end()}),
            KOKKOS_LAMBDA(int i, int j) {
                double x = (i - ng + 0.5) * dx;
                double y = (j - ng) * dy;
                v(i, j) = -Kokkos::cos(x) * Kokkos::sin(y);
            }
KOKKOS_LAMBDA method · cpp · L25-L29 (5 LOC)
include/initial_conditions.hpp
            KOKKOS_LAMBDA(int i, int j) {
                double x = (i - ng) * dx;
                double y = (j - ng + 0.5) * dy;
                u(i, j) = Kokkos::sin(x) * Kokkos::cos(y);
            });
KOKKOS_LAMBDA method · cpp · L36-L40 (5 LOC)
include/initial_conditions.hpp
            KOKKOS_LAMBDA(int i, int j) {
                double x = (i - ng + 0.5) * dx;
                double y = (j - ng) * dy;
                v(i, j) = -Kokkos::cos(x) * Kokkos::sin(y);
            });
predict method · cpp · L8-L42 (35 LOC)
include/integrator.hpp
    template<typename BC>
    void predict(const SimState& s, const BC& /*bc*/,
                 Kokkos::View<double**> u_star,
                 Kokkos::View<double**> v_star,
                 double re, double dt) const {
        if (rhs_u.extent(0) == 0) {
            rhs_u = Kokkos::View<double**>("fe_rhs_u", s.grid.u_nx_total(), s.grid.u_ny_total());
            rhs_v = Kokkos::View<double**>("fe_rhs_v", s.grid.v_nx_total(), s.grid.v_ny_total());
        }

        physics::compute_u_rhs(s, re, rhs_u);
        physics::compute_v_rhs(s, re, rhs_v);

        SimState::View2D u       = s.u;
        SimState::View2D v       = s.v;
        auto             local_rhs_u = rhs_u;
        auto             local_rhs_v = rhs_v;

        Kokkos::parallel_for("fe_u_star",
            Kokkos::MDRangePolicy<Kokkos::Rank<2>>(
                {s.grid.u_i_begin(), s.grid.u_j_begin()},
                {s.grid.u_i_end(),   s.grid.u_j_end()}),
            KOKKOS_LAMBDA(int i, int j) {
KOKKOS_LAMBDA method · cpp · L31-L33 (3 LOC)
include/integrator.hpp
            KOKKOS_LAMBDA(int i, int j) {
                u_star(i, j) = u(i, j) + dt * local_rhs_u(i, j);
            });
KOKKOS_LAMBDA method · cpp · L39-L41 (3 LOC)
include/integrator.hpp
            KOKKOS_LAMBDA(int i, int j) {
                v_star(i, j) = v(i, j) + dt * local_rhs_v(i, j);
            });
predict method · cpp · L49-L69 (21 LOC)
include/integrator.hpp
    template<typename BC>
    void predict(const SimState& s, const BC& /*bc*/,
                 Kokkos::View<double**> u_star,
                 Kokkos::View<double**> v_star,
                 double re, double dt) const {
        if (u_tilde.extent(0) == 0) {
            u_tilde = Kokkos::View<double**>("u_tilde", s.grid.u_nx_total(), s.grid.u_ny_total());
            v_tilde = Kokkos::View<double**>("v_tilde", s.grid.v_nx_total(), s.grid.v_ny_total());
            rhs_u   = Kokkos::View<double**>("rk2_rhs_u",  s.grid.u_nx_total(), s.grid.u_ny_total());
            rhs_v   = Kokkos::View<double**>("rk2_rhs_v",  s.grid.v_nx_total(), s.grid.v_ny_total());
            rhs_u2  = Kokkos::View<double**>("rk2_rhs_u2", s.grid.u_nx_total(), s.grid.u_ny_total());
            rhs_v2  = Kokkos::View<double**>("rk2_rhs_v2", s.grid.v_nx_total(), s.grid.v_ny_total());
        }

        // TODO: Heun's method — requires BC applied to u_tilde/v_tilde at stage 2
        // k1 = RHS(u, v)
        // u
predict method · cpp · L78-L135 (58 LOC)
include/integrator.hpp
    template<typename BC>
    void predict(const SimState& s, const BC& bc,
                 Kokkos::View<double**> u_star,
                 Kokkos::View<double**> v_star,
                 double re, double dt) const {
        if (rhs_u_conv.extent(0) == 0) {
            rhs_u_conv = Kokkos::View<double**>("rhs_u_conv", s.grid.u_nx_total(), s.grid.u_ny_total());
            rhs_v_conv = Kokkos::View<double**>("rhs_v_conv", s.grid.v_nx_total(), s.grid.v_ny_total());
            rhs_u_diff = Kokkos::View<double**>("rhs_u_diff", s.grid.u_nx_total(), s.grid.u_ny_total());
            rhs_v_diff = Kokkos::View<double**>("rhs_v_diff", s.grid.v_nx_total(), s.grid.v_ny_total());
            rhs_u      = Kokkos::View<double**>("rhs_u",      s.grid.u_nx_total(), s.grid.u_ny_total());
            rhs_v      = Kokkos::View<double**>("rhs_v",      s.grid.v_nx_total(), s.grid.v_ny_total());
        }

        physics::compute_u_conv_rhs(s, rhs_u_conv);
        physics::compute_v_conv_rhs(s, rhs_v_c
Want this analysis on your repo? https://repobility.com/scan/
KOKKOS_LAMBDA method · cpp · L112-L116 (5 LOC)
include/integrator.hpp
            KOKKOS_LAMBDA(int i, int j) {
                local_rhs_u(i, j) = u(i, j)
                            + dt       * local_rhs_u_conv(i, j)
                            + 0.5 * dt * local_rhs_u_diff(i, j);
            });
KOKKOS_LAMBDA method · cpp · L122-L126 (5 LOC)
include/integrator.hpp
            KOKKOS_LAMBDA(int i, int j) {
                local_rhs_v(i, j) = v(i, j)
                            + dt       * local_rhs_v_conv(i, j)
                            + 0.5 * dt * local_rhs_v_diff(i, j);
            });
pwrap function · cpp · L8-L13 (6 LOC)
include/multigrid.hpp
KOKKOS_INLINE_FUNCTION
int pwrap(int idx, int n) {
    if (idx < 1)  return idx + n;
    if (idx > n)  return idx - n;
    return idx;
}
laplacian function · cpp · L8-L14 (7 LOC)
include/physics.hpp
KOKKOS_INLINE_FUNCTION
double laplacian(const Kokkos::View<double**>& f, int i, int j,
                 double inv_dx2, double inv_dy2) {
    return (f(i+1, j) - 2.0*f(i, j) + f(i-1, j)) * inv_dx2
         + (f(i, j+1) - 2.0*f(i, j) + f(i, j-1)) * inv_dy2;
}
divergence function · cpp · L15-L23 (9 LOC)
include/physics.hpp
KOKKOS_INLINE_FUNCTION
double divergence(const Kokkos::View<double**>& u, 
                 const Kokkos::View<double**>& v,
                 int i, int j,
                 double inv_dx, double inv_dy) {
    return (u(i+1, j) - u(i, j)) * inv_dx
         + (v(i, j+1) - v(i, j)) * inv_dy;
}
avg_x function · cpp · L24-L28 (5 LOC)
include/physics.hpp
KOKKOS_INLINE_FUNCTION
double avg_x(const Kokkos::View<double**>& f, int i, int j) {
    return 0.5 * (f(i, j) + f(i+1, j));
}
avg_y function · cpp · L29-L33 (5 LOC)
include/physics.hpp
KOKKOS_INLINE_FUNCTION
double avg_y(const Kokkos::View<double**>& f, int i, int j) {
    return 0.5 * (f(i, j) + f(i, j+1));
}
run_dir method · cpp · L21-L25 (5 LOC)
include/run_config.hpp
    std::string run_dir() const {
        std::ostringstream oss;
        oss << "data/run_" << nx << "_" << ny << "_" << re << "_" << dt;
        return oss.str();
    }
Powered by Repobility — scan your code at https://repobility.com
output_path method · cpp · L28-L30 (3 LOC)
include/run_config.hpp
    std::string output_path() const {
        return run_dir() + "/output/" + output_filename;
    }
n_steps_estimate method · cpp · L39-L47 (9 LOC)
include/solver.hpp
    static int n_steps_estimate(const RunConfig& cfg) {
        MacGrid2D g(cfg);
        double dt_min;
        if (cfg.cfl > 0.0)
            dt_min = cfg.cfl * std::min(g.dx, g.dy) / 2.0;
        else
            dt_min = cfg.dt;
        return static_cast<int>(std::ceil(cfg.t_end / dt_min)) + 10;
    }
advance method · cpp · L48-L78 (31 LOC)
include/solver.hpp
    void advance() {
        // Compute time step: adaptive CFL or fixed
        const double dt = (config.cfl > 0.0)
                          ? physics::compute_cfl_dt(state, config.cfl)
                          : config.dt;

        // 1. Apply boundary conditions
        bc.apply(state);

        // 2. Predict velocity (writes into u_star, v_star)
        integrator.predict(state, bc, u_star, v_star, config.re, dt);

        // 3. Compute pressure Poisson RHS from divergence of u_star
        physics::compute_pressure_rhs(state, u_star, v_star, dt, rhs);

        // 4. Solve pressure Poisson equation (reads rhs, writes s.p)
        pressure.solve(state, rhs);

        // 5. Correct velocity with pressure gradient
        physics::correct_velocity(state, u_star, v_star, dt);

        if (state.step < state.n_steps) {
            state.ke_history(state.step)   = physics::compute_kinetic_energy(state);
            state.div_history(state.step)  = physics::compute_l2_divergence(state
run method · cpp · L79-L95 (17 LOC)
include/solver.hpp
    void run() {
        CSVOutput output(config.output_path());

        while (state.step < state.n_steps) {
            advance();

            /* if (config.output_interval > 0 &&
                state.step % config.output_interval == 0) {
                output.write(state);
            } */
        }

        output.write(state);
        output.write_kinetic_energy(state);
        output.write_l2_divergence(state);
    }
solve_u method · cpp · L13-L65 (53 LOC)
include/viscous_solver.hpp
    template<typename BC>
    void solve_u(const SimState& s, const BC& bc,
                 Kokkos::View<double**> u_star,
                 Kokkos::View<double**> rhs,
                 double re, double dt) const {
        const double inv_dx2  = 1.0 / (s.grid.dx * s.grid.dx);
        const double inv_dy2  = 1.0 / (s.grid.dy * s.grid.dy);
        const double alpha    = dt / (2.0 * re);
        const double diag_inv = 1.0 / (1.0 + 2.0 * alpha * (inv_dx2 + inv_dy2));
        const int    ncells   = (s.grid.u_i_end() - s.grid.u_i_begin())
                              * (s.grid.u_j_end() - s.grid.u_j_begin());

        for (int iter = 0; iter < max_iters; ++iter) {
            bc.apply_u(s.grid, u_star);

            Kokkos::parallel_for("vs_u_red",
                Kokkos::MDRangePolicy<Kokkos::Rank<2>>(
                    {s.grid.u_i_begin(), s.grid.u_j_begin()},
                    {s.grid.u_i_end(),   s.grid.u_j_end()}),
                KOKKOS_LAMBDA(int i, int j) {
KOKKOS_LAMBDA method · cpp · L33-L38 (6 LOC)
include/viscous_solver.hpp
                KOKKOS_LAMBDA(int i, int j) {
                    if ((i + j) % 2 != 0) return;
                    u_star(i, j) = (rhs(i, j)
                        + alpha * (physics::laplacian(u_star, i, j, inv_dx2, inv_dy2)
                                   + 2.0 * u_star(i, j) * (inv_dx2 + inv_dy2))) * diag_inv;
                });
KOKKOS_LAMBDA method · cpp · L44-L49 (6 LOC)
include/viscous_solver.hpp
                KOKKOS_LAMBDA(int i, int j) {
                    if ((i + j) % 2 != 1) return;
                    u_star(i, j) = (rhs(i, j)
                        + alpha * (physics::laplacian(u_star, i, j, inv_dx2, inv_dy2)
                                   + 2.0 * u_star(i, j) * (inv_dx2 + inv_dy2))) * diag_inv;
                });
KOKKOS_LAMBDA method · cpp · L56-L61 (6 LOC)
include/viscous_solver.hpp
                KOKKOS_LAMBDA(int i, int j, double& lsum) {
                    const double r = u_star(i, j)
                        - alpha * physics::laplacian(u_star, i, j, inv_dx2, inv_dy2)
                        - rhs(i, j);
                    lsum += r * r;
                }, res2);
Repobility · code-quality intelligence · https://repobility.com
solve_v method · cpp · L66-L118 (53 LOC)
include/viscous_solver.hpp
    template<typename BC>
    void solve_v(const SimState& s, const BC& bc,
                 Kokkos::View<double**> v_star,
                 Kokkos::View<double**> rhs,
                 double re, double dt) const {
        const double inv_dx2  = 1.0 / (s.grid.dx * s.grid.dx);
        const double inv_dy2  = 1.0 / (s.grid.dy * s.grid.dy);
        const double alpha    = dt / (2.0 * re);
        const double diag_inv = 1.0 / (1.0 + 2.0 * alpha * (inv_dx2 + inv_dy2));
        const int    ncells   = (s.grid.v_i_end() - s.grid.v_i_begin())
                              * (s.grid.v_j_end() - s.grid.v_j_begin());

        for (int iter = 0; iter < max_iters; ++iter) {
            bc.apply_v(s.grid, v_star);

            Kokkos::parallel_for("vs_v_red",
                Kokkos::MDRangePolicy<Kokkos::Rank<2>>(
                    {s.grid.v_i_begin(), s.grid.v_j_begin()},
                    {s.grid.v_i_end(),   s.grid.v_j_end()}),
                KOKKOS_LAMBDA(int i, int j) {
KOKKOS_LAMBDA method · cpp · L86-L91 (6 LOC)
include/viscous_solver.hpp
                KOKKOS_LAMBDA(int i, int j) {
                    if ((i + j) % 2 != 0) return;
                    v_star(i, j) = (rhs(i, j)
                        + alpha * (physics::laplacian(v_star, i, j, inv_dx2, inv_dy2)
                                   + 2.0 * v_star(i, j) * (inv_dx2 + inv_dy2))) * diag_inv;
                });
KOKKOS_LAMBDA method · cpp · L97-L102 (6 LOC)
include/viscous_solver.hpp
                KOKKOS_LAMBDA(int i, int j) {
                    if ((i + j) % 2 != 1) return;
                    v_star(i, j) = (rhs(i, j)
                        + alpha * (physics::laplacian(v_star, i, j, inv_dx2, inv_dy2)
                                   + 2.0 * v_star(i, j) * (inv_dx2 + inv_dy2))) * diag_inv;
                });
page 1 / 3next ›