AddScalarBC Namespace Reference

Classes
struct	BC1D
	Structure to hold boundary condition data for 1D problems. More...
struct	BC2D
	Structure to hold boundary condition data for 2D problems. More...
struct	BC3D
	Structure to hold boundary condition data for 3D problems. More...

Functions
void	addScalarBClhs (u16 k, u32 m, Real dx, const vec &dc, const vec &nc, sp_mat &Al, sp_mat &Ar)
	Compute LHS boundary condition matrices for a 1D problem.
void	addScalarBClhs (u16 k, u32 m, Real dx, u32 n, Real dy, const vec &dc, const vec &nc, sp_mat &Al, sp_mat &Ar, sp_mat &Ab, sp_mat &At)
void	addScalarBClhs (u16 k, u32 m, Real dx, u32 n, Real dy, u32 o, Real dz, const vec &dc, const vec &nc, sp_mat &Al, sp_mat &Ar, sp_mat &Ab, sp_mat &At, sp_mat &Af, sp_mat &Ak)
void	addScalarBCrhs (vec &b, const vec &v, const uvec &indices)
	Apply boundary values to the RHS vector for a 1D problem.
void	addScalarBCrhs (vec &b, const vec &dc, const vec &nc, const std::vector< vec > &v, const uvec &rl, const uvec &rr, const uvec &rb, const uvec &rt)
void	addScalarBCrhs (vec &b, const vec &dc, const vec &nc, const std::vector< vec > &v, const uvec &rl, const uvec &rr, const uvec &rb, const uvec &rt, const uvec &rf, const uvec &rk)
	Apply boundary values to the RHS vector for a 3D problem.
void	addScalarBC (sp_mat &A, vec &b, u16 k, u32 m, Real dx, const BC1D &bc)
	Apply boundary conditions to a 1D discrete operator and RHS.
void	addScalarBC (sp_mat &A, vec &b, u16 k, u32 m, Real dx, u32 n, Real dy, const BC2D &bc)
	Apply boundary conditions to a 2D discrete operator and RHS.
void	addScalarBC (sp_mat &A, vec &b, u16 k, u32 m, Real dx, u32 n, Real dy, u32 o, Real dz, const BC3D &bc)
	Apply boundary conditions to a 3D discrete operator and RHS.

Detailed Description

file addscalarbc.cpp

brief Implementation of boundary condition application for scalar PDEs

date 2025/01/26 Last Modified: 2026/03/04

Function Documentation

addScalarBC() [1/3]

void AddScalarBC::addScalarBC	(	sp_mat &	A,
		vec &	b,
		u16	k,
		u32	m,
		Real	dx,
		const BC1D &	bc )

Apply boundary conditions to a 1D discrete operator and RHS.

Modifies the linear system A*u = b to enforce boundary conditions.

Parameters

A	Linear operator (modified in place)
b	Right-hand side vector (modified in place)
k	Order of accuracy
m	Number of cells
dx	Cell spacing
bc	Boundary condition data

Definition at line 286 of file addscalarbc.cpp.

                                                                           {
    assert(bc.dc.n_elem == 2 && "dc must be a 2x1 vector");
    assert(bc.nc.n_elem == 2 && "nc must be a 2x1 vector");
    assert(A.n_rows == A.n_cols && "A must be square");
    assert(A.n_cols == b.n_elem && "b size must equal A columns");
 
    if (boundaryNorm(bc.dc, bc.nc, 0, 1) == 0.0) return;
 
    assert(bc.v.n_elem == 2 && "v must be a 2x1 vector");
 
    uvec indices = {0, (uword)(A.n_rows - 1)};
    zeroRows(A, indices);
    b(indices).zeros();
 
    sp_mat Al, Ar;
    addScalarBClhs(k, m, dx, bc.dc, bc.nc, Al, Ar);
    A = A + Al + Ar;
 
    addScalarBCrhs(b, bc.v, indices);
}

addScalarBC() [2/3]

void AddScalarBC::addScalarBC	(	sp_mat &	A,
		vec &	b,
		u16	k,
		u32	m,
		Real	dx,
		u32	n,
		Real	dy,
		const BC2D &	bc )

Apply boundary conditions to a 2D discrete operator and RHS.

Modifies the linear system A*u = b to enforce boundary conditions.

Parameters

A	Linear operator (modified in place)
b	Right-hand side vector (modified in place)
k	Order of accuracy
m	Number of cells in x-direction
dx	Cell spacing in x-direction
n	Number of cells in y-direction
dy	Cell spacing in y-direction
bc	Boundary condition data

Definition at line 307 of file addscalarbc.cpp.

                                                 {
    assert(bc.dc.n_elem == 4 && "dc must be a 4x1 vector");
    assert(bc.nc.n_elem == 4 && "nc must be a 4x1 vector");
    assert(bc.v.size() == 4  && "v must have 4 vectors");
    assert(A.n_rows == A.n_cols && "A must be square");
    assert(A.n_cols == b.n_elem && "b size must equal A columns");
 
    sp_mat Al, Ar, Ab, At;
    addScalarBClhs(k, m, dx, n, dy, bc.dc, bc.nc, Al, Ar, Ab, At);
 
    uvec rl, rr, rb, rt;
 
    BCPairLhs pairs[] = {
        {boundaryNorm(bc.dc, bc.nc, 0, 1), Al, Ar, rl, rr},  // Left  / Right
        {boundaryNorm(bc.dc, bc.nc, 2, 3), Ab, At, rb, rt},  // Bottom / Top
    };
    for (auto &p : pairs) applyBCPair(A, b, p);
 
    addScalarBCrhs(b, bc.dc, bc.nc, bc.v, rl, rr, rb, rt);
}

addScalarBC() [3/3]

void AddScalarBC::addScalarBC	(	sp_mat &	A,
		vec &	b,
		u16	k,
		u32	m,
		Real	dx,
		u32	n,
		Real	dy,
		u32	o,
		Real	dz,
		const BC3D &	bc )

Apply boundary conditions to a 3D discrete operator and RHS.

Modifies the linear system A*u = b to enforce boundary conditions.

Parameters

A	Linear operator (modified in place)
b	Right-hand side vector (modified in place)
k	Order of accuracy
m	Number of cells in x-direction
dx	Cell spacing in x-direction
n	Number of cells in y-direction
dy	Cell spacing in y-direction
o	Number of cells in z-direction
dz	Cell spacing in z-direction
bc	Boundary condition data

Definition at line 329 of file addscalarbc.cpp.

                                                                 {
    assert(bc.dc.n_elem == 6 && "dc must be a 6x1 vector");
    assert(bc.nc.n_elem == 6 && "nc must be a 6x1 vector");
    assert(bc.v.size() == 6  && "v must have 6 vectors");
    assert(A.n_rows == A.n_cols && "A must be square");
    assert(A.n_cols == b.n_elem && "b size must equal A columns");
 
    sp_mat Al, Ar, Ab, At, Af, Ak;
    addScalarBClhs(k, m, dx, n, dy, o, dz, bc.dc, bc.nc,
                   Al, Ar, Ab, At, Af, Ak);
 
    uvec rl, rr, rb, rt, rf, rk;
 
    BCPairLhs pairs[] = {
        {boundaryNorm(bc.dc, bc.nc, 0, 1), Al, Ar, rl, rr},  // Left  / Right
        {boundaryNorm(bc.dc, bc.nc, 2, 3), Ab, At, rb, rt},  // Bottom / Top
        {boundaryNorm(bc.dc, bc.nc, 4, 5), Af, Ak, rf, rk},  // Front  / Back
    };
    for (auto &p : pairs) applyBCPair(A, b, p);
 
    addScalarBCrhs(b, bc.dc, bc.nc, bc.v, rl, rr, rb, rt, rf, rk);
}

addScalarBClhs() [1/3]

void AddScalarBC::addScalarBClhs	(	u16	k,
		u32	m,
		Real	dx,
		const vec &	dc,
		const vec &	nc,
		sp_mat &	Al,
		sp_mat &	Ar )

Compute LHS boundary condition matrices for a 1D problem.

Parameters

k	Order of accuracy
m	Number of cells
dx	Cell spacing
dc	Dirichlet coefficients (2x1: left, right)
nc	Neumann coefficients (2x1: left, right)
Al	Output: left boundary modification matrix
Ar	Output: right boundary modification matrix

Definition at line 145 of file addscalarbc.cpp.

                                            {
    Al = sp_mat(m+2, m+2);
    Ar = sp_mat(m+2, m+2);
 
    if (dc(0) != 0.0) Al(0, 0) = dc(0);
    if (dc(1) != 0.0) Ar(m+1, m+1) = dc(1);
 
    if (nc(0) != 0.0 || nc(1) != 0.0) {
        Gradient G(k, m, dx);
        sp_mat G_mat = sp_mat(G);
 
        if (nc(0) != 0.0) {
            sp_mat Bl(m+2, m+1);
            Bl(0, 0) = -nc(0);
            Al = Al + Bl * G_mat;
        }
        if (nc(1) != 0.0) {
            sp_mat Br(m+2, m+1);
            Br(m+1, m) = nc(1);
            Ar = Ar + Br * G_mat;
        }
    }
}

addScalarBClhs() [2/3]

void AddScalarBC::addScalarBClhs	(	u16	k,
		u32	m,
		Real	dx,
		u32	n,
		Real	dy,
		const vec &	dc,
		const vec &	nc,
		sp_mat &	Al,
		sp_mat &	Ar,
		sp_mat &	Ab,
		sp_mat &	At )

brief Compute LHS boundary condition matrices for a 2D problem

Parameters

k	Order of accuracy
m	Number of cells in x-direction
dx	Cell spacing in x-direction
n	Number of cells in y-direction
dy	Cell spacing in y-direction
dc	Dirichlet coefficients (4x1: left, right, bottom, top)
nc	Neumann coefficients (4x1: left, right, bottom, top)
Al	Output: left edge modification matrix
Ar	Output: right edge modification matrix
Ab	Output: bottom edge modification matrix
At	Output: top edge modification matrix

Definition at line 171 of file addscalarbc.cpp.

                                                                    {
    Al.set_size(0, 0); Ar.set_size(0, 0);
    Ab.set_size(0, 0); At.set_size(0, 0);
 
    Real qrl = boundaryNorm(dc, nc, 0, 1);
    Real qbt = boundaryNorm(dc, nc, 2, 3);
 
    if (qrl > 0) {
        sp_mat Al0, Ar0;
        addScalarBClhs(k, m, dx, {dc(0), dc(1)}, {nc(0), nc(1)}, Al0, Ar0);
 
        sp_mat In = (qbt == 0) ? buildIdentity(n)
                               : buildIdentity(n+2, /*zeroCorners=*/true);
        Al = kron(In, Al0);
        Ar = kron(In, Ar0);
    }
 
    if (qbt > 0) {
        sp_mat Ab0, At0;
        addScalarBClhs(k, n, dy, {dc(2), dc(3)}, {nc(2), nc(3)}, Ab0, At0);
 
        sp_mat Im = (qrl == 0) ? buildIdentity(m)
                               : buildIdentity(m+2);
        Ab = kron(Ab0, Im);
        At = kron(At0, Im);
    }
}

addScalarBClhs() [3/3]

void AddScalarBC::addScalarBClhs	(	u16	k,
		u32	m,
		Real	dx,
		u32	n,
		Real	dy,
		u32	o,
		Real	dz,
		const vec &	dc,
		const vec &	nc,
		sp_mat &	Al,
		sp_mat &	Ar,
		sp_mat &	Ab,
		sp_mat &	At,
		sp_mat &	Af,
		sp_mat &	Ak )

brief Compute LHS boundary condition matrices for a 3D problem

Parameters

k	Order of accuracy
m	Number of cells in x-direction
dx	Cell spacing in x-direction
n	Number of cells in y-direction
dy	Cell spacing in y-direction
o	Number of cells in z-direction
dz	Cell spacing in z-direction
dc	Dirichlet coefficients (6x1: left, right, bottom, top, front, back)
nc	Neumann coefficients (6x1: left, right, bottom, top, front, back)
Al	Output: left face modification matrix
Ar	Output: right face modification matrix
Ab	Output: bottom face modification matrix
At	Output: top face modification matrix
Af	Output: front face modification matrix
Ak	Output: back face modification matrix

Definition at line 201 of file addscalarbc.cpp.

                                                        {
    Al.set_size(0,0); Ar.set_size(0,0);
    Ab.set_size(0,0); At.set_size(0,0);
    Af.set_size(0,0); Ak.set_size(0,0);
 
    Real qrl = boundaryNorm(dc, nc, 0, 1);
    Real qbt = boundaryNorm(dc, nc, 2, 3);
    Real qfk = boundaryNorm(dc, nc, 4, 5);
 
    auto makeId = [](u32 sz, Real q, bool excludeCorners) -> sp_mat {
        return (q == 0) ? buildIdentity(sz)
                        : buildIdentity(sz + 2, excludeCorners);
    };
 
    if (qrl > 0) {
        sp_mat Al0, Ar0;
        addScalarBClhs(k, m, dx, {dc(0), dc(1)}, {nc(0), nc(1)}, Al0, Ar0);
 
        sp_mat In = makeId(n, qbt, /*excludeCorners=*/true);
        sp_mat Io = makeId(o, qfk, /*excludeCorners=*/true);
        Al = kron(kron(Io, In), Al0);
        Ar = kron(kron(Io, In), Ar0);
    }
 
    if (qbt > 0) {
        sp_mat Ab0, At0;
        addScalarBClhs(k, n, dy, {dc(2), dc(3)}, {nc(2), nc(3)}, Ab0, At0);
 
        sp_mat Im = makeId(m, qrl, /*excludeCorners=*/false);
        sp_mat Io = makeId(o, qfk, /*excludeCorners=*/true);
        Ab = kron(kron(Io, Ab0), Im);
        At = kron(kron(Io, At0), Im);
    }
 
    if (qfk > 0) {
        sp_mat Af0, Ak0;
        addScalarBClhs(k, o, dz, {dc(4), dc(5)}, {nc(4), nc(5)}, Af0, Ak0);
 
        sp_mat Im = makeId(m, qrl, /*excludeCorners=*/false);
        sp_mat In = makeId(n, qbt, /*excludeCorners=*/false);
        Af = kron(kron(Af0, In), Im);
        Ak = kron(kron(Ak0, In), Im);
    }
}

addScalarBCrhs() [1/3]

void AddScalarBC::addScalarBCrhs	(	vec &	b,
		const vec &	dc,
		const vec &	nc,
		const std::vector< vec > &	v,
		const uvec &	rl,
		const uvec &	rr,
		const uvec &	rb,
		const uvec &	rt )

brief Apply boundary values to the RHS vector for a 2D problem

Parameters

b	Right-hand side vector (modified in place)
dc	Dirichlet coefficients (4x1: left, right, bottom, top)
nc	Neumann coefficients (4x1: left, right, bottom, top)
v	Boundary values (4 vectors: left, right, bottom, top)
rl	Left edge row indices
rr	Right edge row indices
rb	Bottom edge row indices
rt	Top edge row indices

Definition at line 259 of file addscalarbc.cpp.

                                                    {
    const BCPairRhs pairs[] = {
        {0, 1, rl, rr, 0, 1},  // Left  / Right
        {2, 3, rb, rt, 2, 3},  // Bottom / Top
    };
    for (const auto &p : pairs) applyBCPairRhs(b, dc, nc, v, p);
}

addScalarBCrhs() [2/3]

void AddScalarBC::addScalarBCrhs	(	vec &	b,
		const vec &	dc,
		const vec &	nc,
		const std::vector< vec > &	v,
		const uvec &	rl,
		const uvec &	rr,
		const uvec &	rb,
		const uvec &	rt,
		const uvec &	rf,
		const uvec &	rk )

Apply boundary values to the RHS vector for a 3D problem.

Parameters

b	Right-hand side vector (modified in place)
dc	Dirichlet coefficients (6x1: left, right, bottom, top, front, back)
nc	Neumann coefficients (6x1: left, right, bottom, top, front, back)
v	Boundary values (6 vectors: left, right, bottom, top, front, back)
rl	Left face row indices
rr	Right face row indices
rb	Bottom face row indices
rt	Top face row indices
rf	Front face row indices
rk	Back face row indices

Definition at line 270 of file addscalarbc.cpp.

                                                                    {
    const BCPairRhs pairs[] = {
        {0, 1, rl, rr, 0, 1},  // Left  / Right
        {2, 3, rb, rt, 2, 3},  // Bottom / Top
        {4, 5, rf, rk, 4, 5},  // Front  / Back
    };
    for (const auto &p : pairs) applyBCPairRhs(b, dc, nc, v, p);
}

addScalarBCrhs() [3/3]

void AddScalarBC::addScalarBCrhs	(	vec &	b,
		const vec &	v,
		const uvec &	indices )

Apply boundary values to the RHS vector for a 1D problem.

Parameters

b	Right-hand side vector (modified in place)
v	Boundary values (2x1: left, right)
indices	Row indices to update

Definition at line 253 of file addscalarbc.cpp.

                                                               {
    for (uword i = 0; i < indices.n_elem; i++) {
        b(indices(i)) = v(i);
    }
}