from IPython.display import Code
Code(filename='linewave/linewave.py')

"""Solve the 1D wave equation using the leap-frog scheme"""
import argparse

import numpy as np
import matplotlib.pyplot as plt


c = 1.0  # Wave speed


def sinus(x, t):
    """Return the analytical solution of the 1D wave equation"""
    return np.sin(2 * np.pi * (x - c * t))


def compute_wave(L=1.0, T=100.0, CFL=0.99, N=40):
    """Compute the solution of the 1D wave equation using the leap-frog scheme"""
    # Discretization
    x, dx = np.linspace(0, L, N, endpoint=False, retstep=True)
    dt = CFL * dx / c  # Time step

    # Initialize arrays
    un = np.empty_like(x)
    unm1 = np.empty_like(x)
    unp1 = np.empty_like(x)

    # Set initial solution
    un = sinus(x, 0.0)
    unm1 = sinus(x, -dt)

    # Leap-frog scheme

    t = 0.0
    while t < T:
        t += dt
        unp1 = -unm1 + 2 * un + CFL**2 * (np.roll(un, 1) - 2 * un + np.roll(un, -1))
        # Exchange array references for avoiding a copy
        unm1, un, unp1 = un, unp1, unm1

    return t, x, un


def L2_error(t, x, u):
    """Compute the L2 error norm"""
    return np.linalg.norm(u - sinus(x, t)) / np.linalg.norm(sinus(x, t))


def plot(t, x, u):
    """Plot the solution"""
    plt.plot(x, u, "o", label=f"t = {t:.2f}")
    plt.plot(x, sinus(x, t), label="Analytical")
    plt.title(f"Leap-frog solution with N = {len(x)}")
    plt.xlabel("x")
    plt.ylabel("u")
    plt.legend()
    plt.show()


def main():
    """Main function with CLI"""
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )
    parser.add_argument("--L", type=float, default=1.0, help="Length of the domain")
    parser.add_argument("--T", type=float, default=100.0, help="Final time")
    parser.add_argument("--CFL", type=float, default=0.99, help="CFL number")
    parser.add_argument("--N", type=int, default=40, help="Number of grid points")
    args = parser.parse_args()
    t, x, u = compute_wave(**vars(args))
    plot(t, x, u)
    print(f"L2 error norm: {L2_error(t, x, u):.3e}")


if __name__ == "__main__":
    main()

%run linewave/linewave.py --help

usage: linewave.py [-h] [--L L] [--T T] [--CFL CFL] [--N N]

Solve the 1D wave equation using the leap-frog scheme

options:
  -h, --help  show this help message and exit
  --L L       Length of the domain (default: 1.0)
  --T T       Final time (default: 100.0)
  --CFL CFL   CFL number (default: 0.99)
  --N N       Number of grid points (default: 40)

%run linewave/linewave.py

L2 error norm: 1.289e-02

%run linewave/linewave.py --T 1000 --N 20

L2 error norm: 5.134e-01

%run linewave/linewave.py --T 1000 --N 20 --CFL 1.

L2 error norm: 2.273e-09

Code(filename='test_linewave.py')

from linewave import linewave


def test_linewave():
    t, x, u = linewave.compute_wave(T=50, N=80, L=2.)
    assert x.max() == 2. - 2. / 80
    assert t >= 50
    assert linewave.L2_error(t, x, u) < 0.01

!pytest test_linewave.py

============================= test session starts ==============================
platform darwin -- Python 3.11.7, pytest-8.1.1, pluggy-1.4.0
rootdir: /Users/boileau/Documents/Conf/2024/Infomath/script2paquet
plugins: anyio-4.3.0
collected 1 item                                                               

test_linewave.py .                                                       [100%]

============================== 1 passed in 0.21s ===============================

cookiecutter https://plmlab.math.cnrs.fr/mboileau/cookiecutter.git --directory python

!cp linewave/linewave.py ../linewave/src/linewave/
!cp test_linewave.py ../linewave/tests/

pip install -e .

pip install -e ".[test]"

docs
├── Makefile  # pour construire sous Linux
├── make.bat  # pour construire sous Windows
└── source
    ├── conf.py  # la configuration de sphinx
    ├── index.md  # la page d'accueil de la doc
    └── installation.md  # une page d'installation

pip install -e ".[doc]"

pip install git+ssh://git@plmlab.math.cnrs.fr/mboileau/linewave.git@v0.1.0

Mon code python sur PLMLab : du script au paquet installable¶

Situation banale d'un laboratoire de mathématiques¶

L'escalier de la compétence¶

Exemple : un notebook qui calcule la propagation d'une onde linéaire en 1D¶

Première étape : découpage en fonctions et CLI¶

Tests unitaires avec pytest¶

GitLab & Co¶

Ce qu'il reste à faire¶

Installation¶

Exécution des tests unitaires¶

Doc avec sphinx¶

Première release sur GitLab¶

Conclusion¶

Les dernières marches à gravir¶