warwick-sciml 2026.1.0__tar.gz

warwick_sciml-2026.1.0/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv run --python 3.12 --extra test pytest -q
+
+  publish:
+    # Publish to PyPI when a version tag (e.g. v2026.1.0) is pushed, via trusted publishing
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: test
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Check tag matches package version
+        run: test "v$(uv version --short)" = "${GITHUB_REF_NAME}"
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

warwick_sciml-2026.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.egg-info/
+.venv/
+dist/
+.pytest_cache/
+*.log

warwick_sciml-2026.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 James Kermode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

warwick_sciml-2026.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.5
+Name: warwick-sciml
+Version: 2026.1.0
+Summary: Support modules for the Warwick PX914/ES98E Predictive Modelling, UQ and Scientific Machine Learning module
+Project-URL: Repository, https://github.com/HetSys/warwick-sciml
+Author: James Kermode
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Provides-Extra: atomistic
+Requires-Dist: ase; extra == 'atomistic'
+Requires-Dist: atomistica; extra == 'atomistic'
+Requires-Dist: jax; extra == 'atomistic'
+Requires-Dist: matscipy; extra == 'atomistic'
+Provides-Extra: gp
+Requires-Dist: jax; extra == 'gp'
+Requires-Dist: tinygp; extra == 'gp'
+Provides-Extra: test
+Requires-Dist: ase; extra == 'test'
+Requires-Dist: atomistica; extra == 'test'
+Requires-Dist: jax; extra == 'test'
+Requires-Dist: matscipy; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: tinygp; extra == 'test'
+Description-Content-Type: text/markdown
+
+# warwick-sciml
+
+Support modules for the University of Warwick module on Predictive Modelling,
+Uncertainty Quantification and Scientific Machine Learning (PX914 / ES98E).
+
+```bash
+pip install warwick-sciml              # core: BLR, sensitivity analysis, fluid/FE solvers
+pip install "warwick-sciml[gp]"        # + Gaussian process utilities (JAX, tinygp)
+pip install "warwick-sciml[atomistic]" # + atomistic examples (ASE, atomistica, matscipy, JAX)
+```
+
+In a marimo notebook, add it to the PEP 723 header instead, e.g.
+
+```python
+# /// script
+# dependencies = ["warwick-sciml[atomistic]>=2026.1", "marimo>=0.25"]
+# ///
+```
+
+then `from sciml.blr import design_matrix`, `from sciml import tersoff_jax`, etc.
+
+| Module | Contents |
+|---|---|
+| `sciml.blr` | Bayesian linear regression: basis functions, design matrices, posteriors |
+| `sciml.sensitivity` | finite-difference sensitivities and Taylor expansions |
+| `sciml.fluidsolvers` | Poiseuille flow solvers |
+| `sciml.femsolvers` | 2D plane-stress finite element solver |
+| `sciml.gputils` | Gaussian process fitting and plotting (extra `gp`) |
+| `sciml.atomistic` | Tersoff calculators, vacancy formation energies (extra `atomistic`) |
+| `sciml.tersoff_jax` | differentiable Tersoff potential in JAX (extra `atomistic`) |
+| `sciml.progress` | tqdm wrappers for lecture notebooks |
+
+Versions follow the academic year (`2026.x` for 2026/27).
+
+## Development
+
+```bash
+uv run --extra test pytest
+```

warwick_sciml-2026.1.0/README.md

@@ -0,0 +1,39 @@
+# warwick-sciml
+
+Support modules for the University of Warwick module on Predictive Modelling,
+Uncertainty Quantification and Scientific Machine Learning (PX914 / ES98E).
+
+```bash
+pip install warwick-sciml              # core: BLR, sensitivity analysis, fluid/FE solvers
+pip install "warwick-sciml[gp]"        # + Gaussian process utilities (JAX, tinygp)
+pip install "warwick-sciml[atomistic]" # + atomistic examples (ASE, atomistica, matscipy, JAX)
+```
+
+In a marimo notebook, add it to the PEP 723 header instead, e.g.
+
+```python
+# /// script
+# dependencies = ["warwick-sciml[atomistic]>=2026.1", "marimo>=0.25"]
+# ///
+```
+
+then `from sciml.blr import design_matrix`, `from sciml import tersoff_jax`, etc.
+
+| Module | Contents |
+|---|---|
+| `sciml.blr` | Bayesian linear regression: basis functions, design matrices, posteriors |
+| `sciml.sensitivity` | finite-difference sensitivities and Taylor expansions |
+| `sciml.fluidsolvers` | Poiseuille flow solvers |
+| `sciml.femsolvers` | 2D plane-stress finite element solver |
+| `sciml.gputils` | Gaussian process fitting and plotting (extra `gp`) |
+| `sciml.atomistic` | Tersoff calculators, vacancy formation energies (extra `atomistic`) |
+| `sciml.tersoff_jax` | differentiable Tersoff potential in JAX (extra `atomistic`) |
+| `sciml.progress` | tqdm wrappers for lecture notebooks |
+
+Versions follow the academic year (`2026.x` for 2026/27).
+
+## Development
+
+```bash
+uv run --extra test pytest
+```

warwick_sciml-2026.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "warwick-sciml"
+version = "2026.1.0"
+description = "Support modules for the Warwick PX914/ES98E Predictive Modelling, UQ and Scientific Machine Learning module"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "James Kermode" }]
+
+dependencies = [
+    "numpy",
+    "scipy",
+    "matplotlib",
+    "pandas",
+    "tqdm",
+]
+
+[project.urls]
+Repository = "https://github.com/HetSys/warwick-sciml"
+
+[project.optional-dependencies]
+# Gaussian process utilities (sciml.gputils)
+gp = ["jax", "tinygp"]
+# Atomistic examples (sciml.atomistic, sciml.tersoff_jax)
+atomistic = ["ase", "atomistica", "matscipy", "jax"]
+test = ["pytest", "warwick-sciml[gp,atomistic]"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sciml"]
+
+[tool.pytest.ini_options]
+filterwarnings = ["ignore::DeprecationWarning"]

warwick_sciml-2026.1.0/src/sciml/__init__.py

@@ -0,0 +1,16 @@
+"""Support modules for the Warwick PX914/ES98E module on Predictive Modelling,
+Uncertainty Quantification and Scientific Machine Learning.
+
+Submodules (import them explicitly, e.g. ``from sciml.blr import design_matrix``):
+
+- ``sciml.blr``           Bayesian linear regression: basis functions, design matrices, posteriors
+- ``sciml.sensitivity``   finite-difference sensitivities and Taylor expansions
+- ``sciml.fluidsolvers``  Poiseuille flow solvers
+- ``sciml.femsolvers``    2D plane-stress finite element solver
+- ``sciml.gputils``       Gaussian process fitting and plotting with JAX/tinygp   [extra: gp]
+- ``sciml.atomistic``     Tersoff calculators and vacancy formation energies       [extra: atomistic]
+- ``sciml.tersoff_jax``   differentiable Tersoff potential in JAX                  [extra: atomistic]
+- ``sciml.progress``      tqdm wrappers suited to lecture notebooks
+"""
+
+__version__ = "2026.1.0"

warwick_sciml-2026.1.0/src/sciml/atomistic.py

@@ -0,0 +1,88 @@
+import sys
+
+import numpy as np
+
+from ase.build import bulk
+from ase.optimize.precon import PreconLBFGS
+from atomistica import Tersoff, Tersoff_PRB_39_5566_Si_C
+
+Tersoff_parameter_names = list(Tersoff_PRB_39_5566_Si_C.keys())[2:]
+del Tersoff_parameter_names[Tersoff_parameter_names.index('m')]
+del Tersoff_parameter_names[Tersoff_parameter_names.index('mubo')]
+
+Tersoff_parameter_values = np.array([Tersoff_PRB_39_5566_Si_C[key][-1] for key in Tersoff_parameter_names])
+
+def tersoff_calculator(parameters):
+    # build a dictionary of parameters using values passed in
+    param_dict = { 'el': 'Si', 'm': 1 } # fixed parameters
+    param_dict.update(dict(zip(Tersoff_parameter_names, parameters)))
+    calc = Tersoff(**param_dict)
+    return calc
+
+def vacancy_cell(Ncell=3, rattle=0.0):
+    """
+    Build an Ncell x Ncell x Ncell cubic Si supercell and a copy with a vacancy.
+
+    The atom nearest the cell midpoint is removed. Positions in the vacancy cell
+    are optionally rattled (standard deviation `rattle`, in Angstrom) before the
+    atom is deleted.
+
+    Returns
+    -------
+    at_sup:   perfect supercell
+    at_vac:   supercell with the vacancy
+    vac_pos:  position of the removed atom
+    """
+    at_sup = bulk('Si', cubic=True) * Ncell
+    at_vac = at_sup.copy()
+    if rattle:
+        at_vac.rattle(rattle)
+    cell_midpoint = np.diag(at_vac.cell) * 0.5
+    vac_atom = ((at_vac.positions - cell_midpoint)**2).sum(axis=1).argmin()
+    vac_pos = at_vac.positions[vac_atom].copy()
+    del at_vac[vac_atom]
+    return at_sup, at_vac, vac_pos
+
+
+def vacancy_formation_energy(parameters, Ncell=3, relax=False, fmax=1e-4, logfile=None):
+    """
+    Compute vacancy formation energy for a Ncell x Ncell x Ncell Si system
+
+    Modified to use given values of the Tersoff parameters
+
+    Arguments
+    ---------
+
+    parameters: vector of the Tersoff parameters to be used
+    Ncell:      number of unit cells (default 3)
+    relax:      if true, rattle the atoms slightly and perform a geometry
+                   optimisation before computing the vacancy formation energy
+    fmax:       the maximum force tolerance to use when `relax=True`
+
+    Returns
+    -------
+
+    e_vac       Vacancy formation energy, in eV
+
+    """
+    at_sup, at_vac, _ = vacancy_cell(Ncell, rattle=0.01 if relax else 0.0)
+
+    calc = tersoff_calculator(parameters)
+    at_sup.calc = calc
+    e_bulk_per_atom = at_sup.get_potential_energy() / len(at_sup)
+
+    at_vac.calc = calc
+    if relax:
+        opt = PreconLBFGS(at_vac, logfile=logfile)
+        opt.run(fmax=fmax)
+    return at_vac.get_potential_energy() - e_bulk_per_atom * len(at_vac)
+
+
+def vacancy_formation_energy_first5(x):
+    X = Tersoff_parameter_values.copy()
+    X[:5] = x
+    _stdout = sys.stdout
+    sys.stdout = None # suppress output
+    Ef = vacancy_formation_energy(X, relax=True)
+    sys.stdout = _stdout
+    return Ef

warwick_sciml-2026.1.0/src/sciml/blr.py

@@ -0,0 +1,133 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def design_matrix(X, phi):
+    """
+    Arguments:
+
+    X   -  The observed inputs
+    phi -  The basis functions
+    """
+    num_observations = X.shape[0]
+    num_basis = phi.num_basis
+    Phi = np.zeros((num_observations, num_basis))
+    for i in range(num_observations):
+        Phi[i, :] = phi(X[i, :])
+    return Phi
+
+
+class LinearBasis:
+    """
+    Represents a 1D linear basis.
+    """
+
+    def __init__(self):
+        self.num_basis = 2  # The number of basis functions
+
+    def __call__(self, x):
+        """
+        ``x`` should be a 1D array of inputs
+        """
+        return [1.0, x[0]]
+
+
+class PolynomialBasis:
+    """
+    A set of polynomial basis functions.
+
+    Arguments:
+    degree  -  The degree of the polynomial.
+    """
+
+    def __init__(self, degree):
+        self.degree = degree
+        self.num_basis = degree + 1
+
+    def __call__(self, x):
+        return np.array([x[0] ** i for i in range(self.degree + 1)])
+
+
+class RadialBasisFunctions:
+    """
+    A set of linear basis functions.
+
+    Arguments:
+    X   -  The centers of the radial basis functions.
+    ell -  The assumed lengthscale.
+    """
+
+    def __init__(self, X, ell):
+        self.X = X
+        self.ell = ell
+        self.num_basis = X.shape[0]
+
+    def __call__(self, x):
+        return np.exp(-0.5 * (x - self.X) ** 2 / self.ell**2).flatten()
+
+
+def least_squares_MLE(X, y):
+    """Compute maximum likelihood estimate of mean and standard deviation of weights"""
+    w_MLE, res_MLE, _, _ = np.linalg.lstsq(X, y, rcond=None)
+    sigma_MLE = np.sqrt(res_MLE / X.shape[0])
+    return w_MLE, sigma_MLE
+
+
+def prior(alpha, N):
+    """Compute mean and covariance matrices of the weight prior"""
+    m0 = np.zeros(N)
+    S0 = 1.0 / alpha * np.eye(N)
+    return m0, S0
+
+
+def posterior(Phi, y, alpha, beta, return_inverse=False):
+    """Computes mean and covariance matrix of the posterior distribution."""
+    S_N_inv = alpha * np.eye(Phi.shape[1]) + beta * Phi.T.dot(Phi)
+    S_N = np.linalg.inv(S_N_inv)
+    m_N = beta * S_N.dot(Phi.T).dot(y)
+    m_N = m_N
+    if return_inverse:
+        return m_N, S_N, S_N_inv
+    else:
+        return m_N, S_N
+
+
+def posterior_predictive(Phi_test, m_N, S_N, beta):
+    """Computes mean and variances of the posterior predictive distribution."""
+    y = Phi_test.dot(m_N).ravel()
+    # Only compute variances (diagonal elements of covariance matrix)
+    y_epi = np.sum(Phi_test.dot(S_N) * Phi_test, axis=1)
+    y_var = 1 / beta + y_epi
+    return y, y_epi, y_var
+
+
+def plot_data(X, y):
+    plt.plot(X[:, 0], y[:, 0], "kx", ms=10)
+
+
+def plot_truth(X, y, label="Truth"):
+    plt.plot(X[:, 0], y[:, 0], "k--", label=label)
+
+
+def plot_posterior_samples(X, y):
+    plt.plot(X, y, "r-")
+    plt.axis("equal")
+
+
+def plot_predictive(X, y, y_epi, y_var):
+    sigma_epi = np.sqrt(y_epi)  # epistemitic uncertainty
+    sigma_tot = np.sqrt(y_var)  # total uncertainty
+
+    y_el = y - 2 * sigma_epi
+    y_tl = y - 2 * sigma_tot
+    y_eu = y + 2 * sigma_epi
+    y_tu = y + 2 * sigma_tot
+
+    plt.plot(X[:, 0], y, "b-", label="Prediction")
+    plt.fill_between(
+        X[:, 0], y_el, y_eu, color="C2", label="Epistemic uncertainty", alpha=0.3
+    )
+    plt.fill_between(
+        X[:, 0], y_tl, y_el, color="C1", label="Total uncertainty", alpha=0.3
+    )
+    plt.fill_between(X[:, 0], y_eu, y_tu, color="C1", alpha=0.3)

warwick_sciml-2026.1.0/src/sciml/femsolvers.py

@@ -0,0 +1,118 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+def plot_mesh(XYZ, c='k', ls='--'):
+    wrap = list(range(len(XYZ))) + [0]
+    plt.plot(XYZ[wrap, 0], XYZ[wrap, 1], 's'+c+ls)
+    plt.xlabel("$x_1$")
+    # Set y axis label.
+    plt.ylabel("$x_2$")
+
+def plane_stress(E,nu):
+    C = np.zeros((3,3))
+    De = np.array([[1,nu,0],
+                   [nu,1,0], [0,0,(1-nu)/2]])
+    De1 = E/(1-nu**2)
+    C = np.dot(De1,De)
+    return C
+
+def dispstrain_B(xyze, xi, eta):
+    natcoord = np.array([[-1, 1, 1, -1],[-1, -1, 1, 1]]) #natural nodal coordinates of a quad element
+
+    # derivatives of shape functions w.r.t. natural coordinates
+    dNdnat = np.zeros((2,4))
+    dNdnat[0,:]=(1/4)*natcoord[0,:]*(1+natcoord[1,:]*eta)
+    dNdnat[1,:]=(1/4)*natcoord[1,:]*(1+natcoord[0,:]*xi)
+
+    # element Jacobian matrix
+    Jmat = np.dot(dNdnat,xyze)                      # [2x2 matrix]
+    J = np.linalg.det(Jmat)                         # determinant of the Jacobian
+
+    JmatInv = np.linalg.inv(Jmat)                   # inverse of the Jacobian matrix
+    dNdx = np.dot(JmatInv, dNdnat)                  # effectively: Jmat^-1 * dNdna
+
+    #displacement-strain matrix
+    #linear QUAD element
+    dsB = np.zeros((3,8))                            # [3 strain components X 8 DOFs]
+    dsB[0, 0::2] = dNdx[0, :]
+    dsB[1, 1::2] = dNdx[1, :]
+    dsB[2, 0::2] = dNdx[1, :]
+    dsB[2, 1::2] = dNdx[0, :]
+
+    return dsB, J
+
+def keval(xyze, Ce, th):
+    ke=np.zeros((8,8))                                # create element stiffness matrix (ndof x ndof)
+
+    a = 1/(np.sqrt(3))                                # location of Gauss points (in natural coordinates)
+    w = 1                                             # weights
+    Gauss = np.array([[-a, a, a, -a],[-a, -a, a, a]]) # Gauss points matrix
+
+    for i in range(4):                                # introduce natural coordinates
+        xi=Gauss[0,i]                                 # natural coordinate - horizontal
+        eta=Gauss[1,i]                                # natural coordinate - vertical
+
+        dsB, J = dispstrain_B(xyze,xi,eta)           # evaluate dsB matrix and Jacobian
+
+        dsBT=dsB.transpose()
+        dot1=np.dot(dsBT,Ce)
+        dot2=np.dot(dot1,dsB)
+        ke=ke+dot2*J*th*w                             # evaluate element stiffness matrix
+
+    return ke
+
+def sigma_vector(XYZ, C, de):
+    a=1/np.sqrt(3)                                       # location of Gauss points (in parent coordinates)
+    w=1                                                  # weights
+    Gauss = np.array([[-a, a, a, -a],[-a, -a, a, a]])    # Gauss points matrix
+    sigma = np.zeros(3)                                  # stress (Voigt notation)
+
+    for j in range(4):                                   # loop over element integration points
+        xi=Gauss[0,j]                                    # natural coordinate - horizontal
+        eta=Gauss[1,j]                                   # natural coordinate - vertical
+        dsB, J = dispstrain_B(XYZ,xi,eta)                # evaluate dsB matrix and Jacobian
+        sG1 = np.dot(dsB,de)                             # strain vector (Voigt notation)
+        sG2 = sG1
+        sigmaGauss = np.dot(C, sG2)                      # stresses at j-th Gauss point within parent element
+        sigma = sigma + sigmaGauss*J*w                   # sum of the stresses over all Gauss points within physical element
+
+    return sigma
+
+def quad_solver(x, plot=False):
+    """
+    Wrapper around simple linear FE solver for trapezoidal geometry from PX912
+
+    Arguments:
+        x - vector containing [E (Pa), nu (dimensionless), t (m), fext_top (N)]
+        plot - if True, plot mesh before and after applying load
+
+    Returns:
+        stress - array of length 3 containing [sigma_xx, sigma_yy, sigma_xy] in units of Pa
+    """
+    E, nu, th, fext_top = x # unpack inputs
+
+    XYZ = np.array([[0,1],[0,0],[2,0.5],[2,1]])    # nodal coordinates
+
+    ndof = XYZ.size
+    BC = np.ones(ndof, dtype=int)
+
+    BC[[0, 1, 2, 3]] = 0
+    BCid = BC.nonzero()[0]
+
+    # Applied loads - define the RHS load vector
+    rhs = np.zeros(ndof)
+    rhs[[1, 7]] = fext_top
+    rhs = rhs[BCid]
+
+    C = plane_stress(E,nu)
+    ke = keval(XYZ, C, th)
+    ke = ke[np.ix_(BCid,BCid)]
+    ue = np.linalg.solve(ke, rhs)
+    de = np.zeros(XYZ.size)
+    de[BCid] = ue
+    if plot:
+        sdef=10000                                     # scale deformation
+        plot_mesh(XYZ)
+        plot_mesh(XYZ + sdef*de.reshape(XYZ.shape), c='r', ls='-')
+    sigma = sigma_vector(XYZ, C, de)
+    return sigma

warwick_sciml-2026.1.0/src/sciml/fluidsolvers.py

@@ -0,0 +1,94 @@
+import numpy as np
+import scipy.sparse as sparse
+import scipy.sparse.linalg as linalg
+
+def poiseuille_solver_1(x, N=1000, return_all=False):
+    F, W = x # unpack parameters
+    F = F*np.ones(N) # vector for RHS
+    F[0] = F[-1] = 0  # enforce boundary conditions on RHS
+    h = 2*W/(N-1)
+    A = sparse.dia_matrix((N, N)) # assemble matrix A
+
+    # Build diagonals with boundary condition modifications
+    main_dia = np.ones(N) * 2/h**2
+    main_dia[0] = main_dia[-1] = 1  # enforce u[0] = u[-1] = 0
+    upper_dia = np.ones(N-1) * -1/h**2
+    upper_dia[0] = 0  # no coupling at left boundary
+    lower_dia = np.ones(N-1) * -1/h**2
+    lower_dia[-1] = 0  # no coupling at right boundary
+
+    A.setdiag(main_dia)
+    A.setdiag(upper_dia,  1)
+    A.setdiag(lower_dia, -1)
+    A = A.tocsc() # convert to CSC storage for efficient solve
+    u = linalg.spsolve(A, F)
+    Q = np.sum(u)*h
+    if return_all:
+        return u, F, Q
+    else:
+        return Q
+
+def poiseuille_solver_2(x, N=1000, return_all=False):
+    F_l, F_h, W = x # unpack parameters
+
+    # build vector for F used for RHS of linear system
+    y = np.linspace(-W, W, N)
+    F = np.where((y > 0) & (y < W/2), F_l, F_h)
+    F[0] = F[-1] = 0  # enforce boundary conditions on RHS
+
+    h = 2*W/(N-1)
+    A = sparse.dia_matrix((N, N)) # assemble matrix A
+
+    # Build diagonals with boundary condition modifications
+    main_dia = np.ones(N) * 2/h**2
+    main_dia[0] = main_dia[-1] = 1  # enforce u[0] = u[-1] = 0
+    upper_dia = np.ones(N-1) * -1/h**2
+    upper_dia[0] = 0  # no coupling at left boundary
+    lower_dia = np.ones(N-1) * -1/h**2
+    lower_dia[-1] = 0  # no coupling at right boundary
+
+    A.setdiag(main_dia)
+    A.setdiag(upper_dia,  1)
+    A.setdiag(lower_dia, -1)
+    A = A.tocsc() # convert to CSC storage for efficient solve
+    u = linalg.spsolve(A, F)
+    Q = np.sum(u)*h
+
+    if return_all:
+        return u, F, Q
+    else:
+        return Q
+
+def poiseuille_solver_3(F, W=2, return_all=False):
+    N = len(F)
+    F = F.copy()  # avoid modifying input
+    F[0] = F[-1] = 0  # enforce boundary conditions on RHS
+    h = 2*W/(N-1)
+    A = sparse.dia_matrix((N, N)) # assemble matrix A
+
+    # Build diagonals with boundary condition modifications
+    main_dia = np.ones(N) * 2/h**2
+    main_dia[0] = main_dia[-1] = 1  # enforce u[0] = u[-1] = 0
+    upper_dia = np.ones(N-1) * -1/h**2
+    upper_dia[0] = 0  # no coupling at left boundary
+    lower_dia = np.ones(N-1) * -1/h**2
+    lower_dia[-1] = 0  # no coupling at right boundary
+
+    A.setdiag(main_dia)
+    A.setdiag(upper_dia,  1)
+    A.setdiag(lower_dia, -1)
+    A = A.tocsc() # convert to CSC storage for efficient solve
+    u = linalg.spsolve(A, F) # parameter vector specifies RHS
+    Q = np.sum(u)*h
+    if return_all:
+        return u, F, Q
+    else:
+        return Q
+
+
+# +
+def u_analytic(y, F, W):
+    return F / 2 * (W ** 2 - y ** 2)
+
+def Q_analytic(F, W):
+    return 2 * W ** 3 * F / 3