#!/usr/bin/env python3
"""
Thermo-mechanical dyke-tip model after Browning & Cortez, "Thermal stress ahead of arrested dyke tips with implications for the reinitiation of dyke propagation" (Bull. Volcanol., VIPS special collection).

Target: FEniCSx / dolfinx 0.9 or 0.10, serial run, PETSc with MUMPS.


Units used throughout: length m, time HOURS, stress MPa, temperature degC.


Stages: 
         python dyke_thermomech_fenicsx.py mesh
         python dyke_thermomech_fenicsx.py run  --model all   # elastic, linear, nonlinear
         python dyke_thermomech_fenicsx.py sens
         python dyke_thermomech_fenicsx.py plots
"""
import argparse
import math
import os


# =============================== CONFIGURATION ======================================
# --- geometry (PAPER: text + Fig. 2) ---
W_DOM, H_DOM = 6000.0, 3000.0        # domain width / depth [m]
XC = 3000.0                           # dyke on the vertical centre line  
Y_TIP = -1250.0                       # top of dyke 1250 m below surface; y=0 is the surface
A_SEMI = 250.0                        # semi-major axis (500 m long)
B_SEMI = 5.0                          # semi-minor axis (10 m wide)
YC = Y_TIP - A_SEMI                   # ellipse centre

# --- thermal boundary / initial conditions ---
GEOTHERM_T0 = 15.0                   
GEOTHERM_GRAD = 30.0                  
                                      
                                     
T_MAGMA = 800.0                      
P0 = 0.2                           

# --- constants, linear model (PAPER Table 1) ---
ALPHA0 = 8e-6                         # 1/degC
CV0 = 820.0                           # J/kg/degC
K0 = 9360.0                           # J/h/m/degC  (= 2.6 W/m/K)
E0 = 40e3                             # MPa (40 GPa)
NU0 = 0.3
RHO = 2700.0                          # kg/m3 
PLANE_STRAIN = True                  
                                      
NU_DEPENDENT = False                  
                                      "kept Poisson's ratio
                                      # constant". Default False; `--nu-dependent` turns the Table 2 law on.
THETA0_IN_KELVIN = True              
                                   

# --- discretisation  ---
DT_H = 0.5                            # time step [h]
T_END_H = 120.0                       
OUT_EVERY_H = 2.0                     
H_TIP, H_WALL, H_FAR = 0.02, 0.2, 100.0   
                                          # near the dyke
                                         
L_GRID = np.arange(0.0, 3.0001, 0.02)  # distance ahead of the tip at which results are probed [m]
SNAPSHOT_H = 24.0             
SENS_TIME_H = 12.0                   
SENS_LEVELS = np.arange(-50, 51, 10) 
INCLUDE_SZZ = False                   


# ============================ MATERIAL LAWS  =========================
class Ops:

    def __init__(self, kind):
        if kind == "np":
            self.exp, self.log, self.maxv = np.exp, np.log, np.maximum
            self.sel = lambda T, thr, a, b: np.where(T <= thr, a, b)
        else:
            import ufl
            self.exp, self.log, self.maxv = ufl.exp, ufl.ln, ufl.max_value
            self.sel = lambda T, thr, a, b: ufl.conditional(ufl.le(T, thr), a, b)


class Props:
    """Properties as functions of absolute temperature T [degC]. Units: MPa, m, h, degC."""

    def __init__(self, ops, model, nu_dependent=False, scale=None):
        self.o, self.model, self.nu_dep = ops, model, nu_dependent
        self.s = dict(E=1.0, nu=1.0, alpha=1.0, cv=1.0, k=1.0)
        self.s.update(scale or {})

    @property
    def nl(self):
        return self.model == "nonlinear"

    def alpha(self, T):
        o, s = self.o, self.s["alpha"]
        if not self.nl:
            return s * ALPHA0
        a1 = o.maxv(0.8383 - 0.00142 * T, 1e-6) ** (-1.0 / 1.7085)
        a2 = o.maxv(-5.4160 + 0.0095 * T, 1e-6) ** (-1.0 / 1.5719)
        return s * ALPHA0 * o.sel(T, 573.0, a1, o.sel(T, 625.0, a2, 1.5131))

    def cv(self, T):                                   # J/kg/degC
        o, s = self.o, self.s["cv"]
        if not self.nl:
            return s * CV0
        return s * CV0 * o.sel(T, 575.0, 0.957 + 6.59e-4 * T, 1.173 + 1.238e-4 * T)

    def k(self, T):                                    # J/h/m/degC
        o, s = self.o, self.s["k"]
        if not self.nl:
            return s * K0
        return s * K0 * (-5.8126 + 6.8485 * o.exp(T * math.log(0.9995)) + 0.002172 * T)

    def E(self, T):                                    # MPa
        o, s = self.o, self.s["E"]
        if not self.nl:
            return s * E0
        e1 = 1.2665 * E0 / (1.0 + o.exp(-1.43 + 0.0034 * T))
        e2 = E0 / (-109.953 + 17.542 * o.log(o.maxv(T, 1.0)))
        return s * o.sel(T, 600.0, e1, e2)

    def nu(self, T):
        o, s = self.o, self.s["nu"]
        if not (self.nl and self.nu_dep):
            return s * NU0
        n1 = NU0 * (1.0052 - 7e-4 * T)
        n2 = 2.24 * NU0 / (1.0 + o.exp(13.11 - 0.02 * T))
        return s * o.sel(T, 600.0, n1, n2)

    # derived (Eqs 5, 6 and kappa = alpha(3 lambda + 2 mu) = alpha E / (1-2 nu))
    def lam(self, T):
        E, n = self.E(T), self.nu(T)
        return E * n / ((1 + n) * (1 - 2 * n))

    def mu(self, T):
        return self.E(T) / (2 * (1 + self.nu(T)))

    def kappa(self, T):
        return self.alpha(T) * (3 * self.lam(T) + 2 * self.mu(T))

    def rho_cv(self, T):                               # MPa/degC
        return RHO * self.cv(T) / 1e6

    def k_mpa(self, T):                                # MPa m2 /h /degC
        return self.k(T) / 1e6


def geotherm(y):
    """Background temperature [degC] at (negative-down) coordinate y [m]."""
    return GEOTHERM_T0 + GEOTHERM_GRAD * (-y) / 1000.0

# ================================= MESH =============================================
def stage_mesh(outdir, h_tip, h_wall, h_far):
    import gmsh
    gmsh.initialize()
    gmsh.option.setNumber("General.Terminal", 1)
    gmsh.model.add("dyke")
    occ = gmsh.model.occ
    rect = occ.addRectangle(0.0, -H_DOM, 0.0, W_DOM, H_DOM)
    ell = occ.addDisk(XC, YC, 0.0, B_SEMI, A_SEMI)          # rx = 5 (x), ry = 250 (y)
    cut, _ = occ.cut([(2, rect)], [(2, ell)])
    occ.synchronize()
    surf = [t for d, t in cut if d == 2]
    bnd = gmsh.model.getBoundary([(2, s) for s in surf], oriented=False, recursive=False)
    groups = {1: [], 2: [], 3: [], 4: [], 5: []}              # left,right,bottom,top,cavity
    eps = 1e-3
    for d, t in bnd:
        x0, y0, _, x1, y1, _ = gmsh.model.getBoundingBox(d, t)
        if x1 < eps:
            groups[1].append(t)
        elif x0 > W_DOM - eps:
            groups[2].append(t)
        elif y1 < -H_DOM + eps:
            groups[3].append(t)
        elif y0 > -eps:
            groups[4].append(t)
        else:
            groups[5].append(t)
    for g, tags in groups.items():
        gmsh.model.addPhysicalGroup(1, tags, g)
    gmsh.model.addPhysicalGroup(2, surf, 1)

    F = gmsh.model.mesh.field
    f1 = F.add("Distance"); F.setNumbers(f1, "CurvesList", groups[5]); F.setNumber(f1, "Sampling", 5000)
    f2 = F.add("Threshold"); F.setNumber(f2, "InField", f1)
    F.setNumber(f2, "SizeMin", h_wall); F.setNumber(f2, "SizeMax", h_far)
    F.setNumber(f2, "DistMin", 2.0); F.setNumber(f2, "DistMax", 1500.0)
    f3 = F.add("MathEval")
    F.setString(f3, "F", "Sqrt((x-%g)^2+(y-%g)^2)" % (XC, Y_TIP))
    f4 = F.add("Threshold"); F.setNumber(f4, "InField", f3)
    F.setNumber(f4, "SizeMin", h_tip); F.setNumber(f4, "SizeMax", h_wall)
    F.setNumber(f4, "DistMin", 1.0); F.setNumber(f4, "DistMax", 8.0)
    f5 = F.add("Min"); F.setNumbers(f5, "FieldsList", [f2, f4])
    F.setAsBackgroundMesh(f5)
    for opt in ("Mesh.MeshSizeExtendFromBoundary", "Mesh.MeshSizeFromPoints", "Mesh.MeshSizeFromCurvature"):
        gmsh.option.setNumber(opt, 0)
    gmsh.model.mesh.generate(2)
    path = os.path.join(outdir, "dyke.msh")
    gmsh.write(path)
    n = len(gmsh.model.mesh.getNodes()[0])
    gmsh.finalize()
    print("mesh written:", path, "nodes:", n)


# =============================== FEM SOLVER =========================================
def _load_mesh(path):
    import gmsh
    from mpi4py import MPI
    from dolfinx.io import gmsh as dgmsh
    gmsh.initialize()
    gmsh.open(path)
    res = dgmsh.model_to_mesh(gmsh.model, MPI.COMM_WORLD, 0, gdim=2)
    gmsh.finalize()
    if hasattr(res, "mesh"):                 # dolfinx >= 0.10 returns a MeshData object
        return res.mesh, res.cell_tags, res.facet_tags
    return res[0], res[1], res[2]


def _ipts(space):
    p = space.element.interpolation_points
    return p() if callable(p) else p


def run_model(model, mesh_path, dt=DT_H, t_end=T_END_H, scale=None, nu_dependent=NU_DEPENDENT,
              l_grid=L_GRID, snapshot=None, quiet=False):
    """Solve one model. model in {'elastic','linear','nonlinear'}. Returns dict of probe arrays."""
    import ufl
    import dolfinx
    import basix.ufl
    from mpi4py import MPI
    from dolfinx import fem, geometry, plot
    from dolfinx.fem.petsc import NonlinearProblem

    msh, _, ft = _load_mesh(mesh_path)
    tdim, fdim = msh.topology.dim, msh.topology.dim - 1
    msh.topology.create_connectivity(fdim, tdim)

    Pu = basix.ufl.element("Lagrange", msh.basix_cell(), 2, shape=(2,))
    Pt = basix.ufl.element("Lagrange", msh.basix_cell(), 1)
    W = fem.functionspace(msh, basix.ufl.mixed_element([Pu, Pt]))

    w, w_n = fem.Function(W), fem.Function(W)
    u, T = ufl.split(w)
    u_n, T_n = ufl.split(w_n)
    v, q = ufl.TestFunctions(W)
    x = ufl.SpatialCoordinate(msh)

    pr = Props(Ops("ufl"), model, nu_dependent, scale)
    T0 = GEOTHERM_T0 + GEOTHERM_GRAD * (-x[1]) / 1000.0             # background theta_0(z)
    T0_coup = T0 + 273.15 if THETA0_IN_KELVIN else T0

    def sigma(u_, T_):                                              # Eq. 3 (tension-positive, plane strain)
        eps = ufl.sym(ufl.grad(u_))
        return (pr.lam(T_) * ufl.tr(eps) * ufl.Identity(2) + 2 * pr.mu(T_) * eps
                - pr.kappa(T_) * (T_ - T0) * ufl.Identity(2))

    n = ufl.FacetNormal(msh)
    ds = ufl.Measure("ds", domain=msh, subdomain_data=ft)
    dx = ufl.Measure("dx", domain=msh)
    dt_c = fem.Constant(msh, dolfinx.default_scalar_type(dt))

    F_mech = ufl.inner(sigma(u, T), ufl.sym(ufl.grad(v))) * dx + P0 * ufl.inner(n, v) * ds(5)
    F_heat = (pr.rho_cv(T) * (T - T_n) / dt_c * q
              + pr.kappa(T) * T0_coup * ufl.div(u - u_n) / dt_c * q          # Eq. 1 coupling term
              + pr.k_mpa(T) * ufl.inner(ufl.grad(T), ufl.grad(q))) * dx      # (sign: see report, Eq. 1 typo)
    F = F_mech + F_heat

    # ---- boundary conditions ----
    Wu0, _ = W.sub(0).sub(0).collapse()
    Wt, _ = W.sub(1).collapse()
    g = fem.Function(Wt)
    g.interpolate(lambda xx: geotherm(xx[1]))
    f = {i: ft.find(i) for i in range(1, 6)}
    zero = dolfinx.default_scalar_type(0.0)
    bcs = []
    for i in (1, 2):                                                 # lateral: u_x = 0
        d = fem.locate_dofs_topological(W.sub(0).sub(0), fdim, f[i])
        bcs.append(fem.dirichletbc(zero, d, W.sub(0).sub(0)))
    d = fem.locate_dofs_topological(W.sub(0), fdim, f[3])            # bottom: u = 0
    bcs.append(fem.dirichletbc(np.zeros(2, dtype=dolfinx.default_scalar_type), d, W.sub(0)))
    for i in (1, 2, 3, 4):                                           # outer edges: theta = geotherm
        d = fem.locate_dofs_topological((W.sub(1), Wt), fdim, f[i])
        bcs.append(fem.dirichletbc(g, d, W.sub(1)))
    if model == "elastic":                                           # no thermal load: theta == theta_0 everywhere
        d = fem.locate_dofs_topological((W.sub(1), Wt), fdim, f[5])
        bcs.append(fem.dirichletbc(g, d, W.sub(1)))
    else:
        d = fem.locate_dofs_topological(W.sub(1), fdim, f[5])
        bcs.append(fem.dirichletbc(dolfinx.default_scalar_type(T_MAGMA), d, W.sub(1)))

    # ---- initial condition ----
    w_n.sub(1).interpolate(lambda xx: geotherm(xx[1]))
    w.x.array[:] = w_n.x.array

    # ---- Newton solver (API differs between dolfinx 0.9 and 0.10) ----
    J = ufl.derivative(F, w, ufl.TrialFunction(W))
    ver = tuple(int(p) for p in dolfinx.__version__.split(".")[:2])
    if ver >= (0, 10):
        problem = NonlinearProblem(F, w, bcs=bcs, J=J, petsc_options_prefix="tm_", petsc_options={
            "snes_type": "newtonls", "snes_linesearch_type": "none", "snes_rtol": 1e-8,
            "snes_atol": 1e-10, "snes_max_it": 30, "ksp_type": "preonly", "pc_type": "lu",
            "pc_factor_mat_solver_type": "mumps"})

        def newton():
            problem.solve()
            return problem.solver.getConvergedReason() > 0
    else:
        from dolfinx.nls.petsc import NewtonSolver
        from petsc4py import PETSc
        problem = NonlinearProblem(F, w, bcs=bcs, J=J)
        solver = NewtonSolver(MPI.COMM_WORLD, problem)
        solver.convergence_criterion = "incremental"
        solver.rtol, solver.atol, solver.max_it = 1e-8, 1e-10, 30
        ksp = solver.krylov_solver
        opts, pre = PETSc.Options(), solver.krylov_solver.getOptionsPrefix()
        opts[pre + "ksp_type"] = "preonly"
        opts[pre + "pc_type"] = "lu"
        opts[pre + "pc_factor_mat_solver_type"] = "mumps"
        ksp.setFromOptions()

        def newton():
            return solver.solve(w)[1]

    # ---- post-processing machinery ----
    S = fem.functionspace(msh, ("DG", 1))
    V1 = fem.functionspace(msh, ("Lagrange", 1))
    sg = sigma(u, T)
    szz = pr.lam(T) * ufl.tr(ufl.sym(ufl.grad(u))) - pr.kappa(T) * (T - T0)
    exprs = dict(sxx=sg[0, 0], syy=sg[1, 1], sxy=sg[0, 1], szz=szz, th=T, dth=T - T0)
    dg_exprs = {k: fem.Expression(e, _ipts(S)) for k, e in exprs.items()}
    dg_funcs = {k: fem.Function(S) for k in exprs}

    L = np.asarray(l_grid, float)
    pts = np.zeros((len(L), 3))
    pts[:, 0], pts[:, 1] = XC, Y_TIP + np.maximum(L, 1e-3)          # 1 mm inside the rock at L = 0
    tree = geometry.bb_tree(msh, tdim)
    coll = geometry.compute_colliding_cells(msh, geometry.compute_collisions_points(tree, pts), pts)
    ok = [i for i in range(len(L)) if len(coll.links(i)) > 0]
    cells = [coll.links(i)[0] for i in ok]

    def probe():
        out = {}
        for k in exprs:
            dg_funcs[k].interpolate(dg_exprs[k])
            arr = np.full(len(L), np.nan)
            arr[ok] = dg_funcs[k].eval(pts[ok], cells)[:, 0]
            out[k] = arr
        sxx, syy, sxy = out["sxx"], out["syy"], out["sxy"]
        mean, R = 0.5 * (sxx + syy), np.sqrt((0.5 * (sxx - syy)) ** 2 + sxy ** 2)
        ev = np.stack([mean + R, mean - R] + ([out["szz"]] if INCLUDE_SZZ else []))
        # compression-positive (paper convention): sigma1 = most compressive, sigma3 = least compressive
        return -ev.min(axis=0), -ev.max(axis=0), out["th"], out["dth"]

    def p1_snapshot():
        res = {}
        topo, _, geom = plot.vtk_mesh(V1)
        res["tri"], res["x"], res["y"] = topo.reshape(-1, 4)[:, 1:], geom[:, 0], geom[:, 1]
        h = {}
        for k, e in (("th", T), ("dth", T - T0)):
            fn = fem.Function(V1); fn.interpolate(fem.Expression(e, _ipts(V1))); h[k] = fn.x.array.copy()
        sxx, syy, sxy = sg[0, 0], sg[1, 1], sg[0, 1]
        mean, R = 0.5 * (sxx + syy), ufl.sqrt((0.5 * (sxx - syy)) ** 2 + sxy ** 2 + 1e-12)
        for k, e in (("s1", -(mean - R)), ("s3", -(mean + R))):
            fn = fem.Function(V1); fn.interpolate(fem.Expression(e, _ipts(V1))); h[k] = fn.x.array.copy()
        res.update(h)
        return res

    # ---- time loop ----
    times, S1, S3, TH, DT_ = [], [], [], [], []
    snap = None
    if model == "elastic":                                           # a single static solve
        dt_c.value = 1.0
        assert newton(), "Newton failed (elastic)"
        s1, s3, th, dth = probe()
        times, S1, S3, TH, DT_ = [0.0], [s1], [s3], [th], [dth]
        if snapshot is not None:
            snap = p1_snapshot()
    else:
        t, next_out = 0.0, OUT_EVERY_H
        nsteps = int(round(t_end / dt))
        for step in range(nsteps):
            t += dt
            w_n.x.array[:] = w.x.array
            if not newton():
                raise RuntimeError("Newton did not converge at t=%.2f h (model=%s)" % (t, model))
            if abs(t - next_out) < 1e-9:
                s1, s3, th, dth = probe()
                times.append(t); S1.append(s1); S3.append(s3); TH.append(th); DT_.append(dth)
                next_out += OUT_EVERY_H
                if snapshot is not None and abs(t - snapshot) < 1e-9:
                    snap = p1_snapshot()
                if not quiet:
                    print("%s  t=%6.1f h  max dth(L<=1m)=%.0f" % (model, t, np.nanmax(dth[L <= 1.0])))
    return dict(t=np.array(times), L=L, sig1=np.array(S1), sig3=np.array(S3),
                th=np.array(TH), dth=np.array(DT_), snap=snap)


def stage_run(outdir, models, args):
    for m in models:
        r = run_model(m, os.path.join(outdir, "dyke.msh"), dt=args.dt, t_end=args.t_end,
                      nu_dependent=args.nu_dependent, snapshot=SNAPSHOT_H)
        np.savez(os.path.join(outdir, "res_%s.npz" % m), **{k: v for k, v in r.items() if k != "snap"})
        if r["snap"] is not None:
            np.savez(os.path.join(outdir, "fields_%s.npz" % m), **r["snap"])
        print("saved", m)


def stage_sens(outdir, args):
    """Fig. 9: perturb one input at a time by -50..+50 % of the NON-LINEAR model (reference choice ASSUMED)."""
    Lp = np.array([0.0, 0.25, 0.5, 1.0])
    mp = os.path.join(outdir, "dyke.msh")
    ref = run_model("nonlinear", mp, dt=args.dt, t_end=SENS_TIME_H, nu_dependent=args.nu_dependent,
                    l_grid=Lp, quiet=True)
    s_ref, d_ref = ref["sig3"][-1], ref["dth"][-1]
    print("reference d_theta at L=%s: %s  (paper Fig. 9: 748, 167, 46, 4)" % (Lp, np.round(d_ref)))
    out = {"L": Lp, "levels": SENS_LEVELS, "dth_ref": d_ref}
    for name in ("E", "alpha", "nu", "cv", "k"):
        rows = []
        for p in SENS_LEVELS:
            if p == 0:
                rows.append(np.zeros(len(Lp))); continue
            r = run_model("nonlinear", mp, dt=args.dt, t_end=SENS_TIME_H, scale={name: 1 + p / 100.0},
                          nu_dependent=args.nu_dependent, l_grid=Lp, quiet=True)
            s = r["sig3"][-1]
            rows.append(100.0 * (np.abs(s) - np.abs(s_ref)) / np.abs(s_ref))     # |sigma3| change, see report
        out[name] = np.array(rows)
        print("done", name)
    np.savez(os.path.join(outdir, "sens.npz"), **out)


# ================================== PLOTS ===========================================
DRED, LRED, GREY, TAN = "darkred", "indianred", "grey", "tan"


def _load(outdir, m):
    p = os.path.join(outdir, "res_%s.npz" % m)
    return dict(np.load(p)) if os.path.exists(p) else None


def stage_plots(outdir):
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    import matplotlib.tri as mtri
    nl, li, el = _load(outdir, "nonlinear"), _load(outdir, "linear"), _load(outdir, "elastic")
    L = nl["L"]
    i24 = int(np.argmin(np.abs(nl["t"] - SNAPSHOT_H)))

    # ---- Fig. 3 ----
    fp = os.path.join(outdir, "fields_nonlinear.npz")
    if os.path.exists(fp):
        d = np.load(fp)
        tri_all = mtri.Triangulation(d["x"], d["y"], d["tri"])
        fig = plt.figure(figsize=(9, 10))
        ax = fig.add_subplot(3, 1, 1)
        m = ax.tripcolor(tri_all, d["th"], cmap="afmhot", vmin=0, vmax=100, shading="gouraud")
        ax.set_aspect("equal"); ax.set_title("A) θ (°C), full domain"); plt.colorbar(m, ax=ax)
        cx = d["x"][d["tri"]].mean(1); cy = d["y"][d["tri"]].mean(1)
        sel = (np.abs(cx - XC) < 15) & (cy > Y_TIP - 25) & (cy < Y_TIP + 8)
        tri_z = mtri.Triangulation(d["x"], d["y"], d["tri"][sel])
        axs = [fig.add_subplot(3, 2, 3 + i) for i in range(4)]
        for a, (key, ttl, cm) in zip(axs, [("th", "B) θ (°C)", "hot"), ("dth", "C) θ-θ0 (°C)", "jet"),
                                           ("s3", "D) σ3 (MPa)", "jet"), ("s1", "E) σ1 (MPa)", "jet")]):
            mm = a.tripcolor(tri_z, d[key], cmap=cm, shading="gouraud")
            a.set_aspect("equal"); a.set_title(ttl); plt.colorbar(mm, ax=a)
            a.set_xlim(XC - 15, XC + 15); a.set_ylim(Y_TIP - 25, Y_TIP + 8)
        fig.savefig(os.path.join(outdir, "fig3.png"), dpi=200, bbox_inches="tight"); plt.close(fig)

    # ---- Fig. 4 ----
    fig, axs = plt.subplots(2, 1, figsize=(6.5, 9))
    for ax, key, lab in ((axs[0], "sig3", "Minimum Principal Stress σ3 (MPa)"),
                         (axs[1], "sig1", "Maximum Principal Stress σ1 (MPa)")):
        ax.plot(L, nl[key][i24], "k", lw=2, label="Non-Linear Model")
        ax.plot(L, li[key][i24], color=GREY, lw=2, label="Lineal Model")
        if el is not None:
            ax.plot(L, el[key][0], color=TAN, lw=2, label="Pure Elasticity")
        ax.set_xlim(-0.05, 1.0); ax.set_xlabel("Distance ahead dyke tip, L (m)"); ax.set_ylabel(lab)
        ax.legend(loc="upper right", fontsize=8)
        a2 = ax.twinx(); a2.plot(L, nl["dth"][i24], color=DRED); a2.set_ylabel("Temperature Variation, θ-θ0 (°C)", color=DRED)
        if key == "sig3":
            ax.axhline(0, ls="--", color="k", lw=0.8)
    fig.savefig(os.path.join(outdir, "fig4.png"), dpi=200, bbox_inches="tight"); plt.close(fig)

    # ---- Fig. 5 ----
    fig, axs = plt.subplots(2, 1, figsize=(6.5, 9))
    for ax, Lq in zip(axs, (0.25, 1.0)):
        j = int(np.argmin(np.abs(L - Lq)))
        ax.plot(nl["t"], nl["sig3"][:, j], "k", lw=2, label="Non-linear Model")
        ax.plot(li["t"], li["sig3"][:, j], color=GREY, lw=2, label="Linear Model")
        ax.set_ylabel("Tensile Stress, σ3 (MPa)"); ax.legend(loc="upper left", fontsize=8)
        a2 = ax.twinx(); a2.plot(nl["t"], nl["dth"][:, j], color=DRED); a2.plot(li["t"], li["dth"][:, j], "--", color=DRED, lw=0.8)
        a2.set_ylabel("Temperature Variation, θ-θ0 (°C)", color=DRED)
    axs[1].set_xlabel("Time (Hours)")
    fig.savefig(os.path.join(outdir, "fig5.png"), dpi=200, bbox_inches="tight"); plt.close(fig)

    # ---- Fig. 6 (which points are plotted is not stated: here every probe point, every output time) ----
    fig, ax = plt.subplots(figsize=(7, 5.5))
    ax.scatter(li["dth"].ravel(), li["sig3"].ravel(), s=6, color=LRED, label="Linear Model")
    ax.scatter(nl["dth"].ravel(), nl["sig3"].ravel(), s=6, color=DRED, label="Non-linear Model")
    ax.axhline(0, ls="--", color="k"); ax.axvline(110, ls="--", color="grey", lw=1)
    ax.set_xlabel("Temperature Variation, θ-θ0 (°C)"); ax.set_ylabel("Tensile Stress, σ3 (MPa)"); ax.legend()
    fig.savefig(os.path.join(outdir, "fig6.png"), dpi=200, bbox_inches="tight"); plt.close(fig)

    # ---- Fig. 7: first grid point (0.02 m spacing) where theta-theta0 has dropped below the isotherm ----
    fig, ax = plt.subplots(figsize=(7, 5.5))
    for thr in (110.0, 510.0):
        dist = np.array([L[np.argmax(row < thr)] if np.any(row < thr) else np.nan for row in nl["dth"]])
        ax.plot(nl["t"], dist, color=DRED, lw=2)
        m = nl["t"] >= 30
        slope = np.polyfit(nl["t"][m], dist[m], 1)[0]
        ax.plot(nl["t"][m], np.polyval(np.polyfit(nl["t"][m], dist[m], 1), nl["t"][m]), "k")
        ax.text(nl["t"][-1], dist[-1], " Δθ=%d°C  v≈%.4f m/h" % (thr, slope))
        print("isotherm %d C: v = %.4f m/h (paper: %s)" % (thr, slope, "0.01" if thr == 110 else "0.001"))
    ax.set_xlabel("Time (Hours)"); ax.set_ylabel("Distance (m)")
    fig.savefig(os.path.join(outdir, "fig7.png"), dpi=200, bbox_inches="tight"); plt.close(fig)

    # ---- Fig. 9 ----
    sp = os.path.join(outdir, "sens.npz")
    if os.path.exists(sp):
        s = np.load(sp)
        fig, axs = plt.subplots(2, 2, figsize=(10, 8), sharex=True, sharey=True)
        names = ["Dyke's tip", "0.25 m ahead dyke's tip", "0.5 m ahead dyke's tip", "1 m ahead dyke's tip"]
        for i, ax in enumerate(axs.ravel()):
            ax.plot(s["levels"], s["E"][:, i], "k", lw=2, label="E and α")
            ax.plot(s["levels"], s["nu"][:, i], color=DRED, lw=2, label="ν")
            ax.plot(s["levels"], s["cv"][:, i], color=LRED, lw=2, label="$c_v$")
            ax.plot(s["levels"], s["k"][:, i], color="silver", lw=2, label="k")
            ax.set_ylim(-75, 75); ax.set_title("%s (Δθ=%.0f°C)" % (names[i], s["dth_ref"][i]), fontsize=9)
            ax.legend(loc="lower right", fontsize=7)
        for ax in axs[1]:
            ax.set_xlabel("Percentage Change in Input Variables (%)")
        for ax in axs[:, 0]:
            ax.set_ylabel("Δσ3 (%)")
        fig.savefig(os.path.join(outdir, "fig9.png"), dpi=200, bbox_inches="tight"); plt.close(fig)
    print("plots written to", outdir)


# =================================== MAIN ===========================================
def main():
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("stage", choices=["fig8", "mesh", "run", "sens", "plots"])
    ap.add_argument("--outdir", default="out")
    ap.add_argument("--model", default="all", choices=["all", "elastic", "linear", "nonlinear"])
    ap.add_argument("--dt", type=float, default=DT_H)
    ap.add_argument("--t-end", type=float, default=T_END_H)
    ap.add_argument("--h-tip", type=float, default=H_TIP)
    ap.add_argument("--h-wall", type=float, default=H_WALL)
    ap.add_argument("--h-far", type=float, default=H_FAR)
    ap.add_argument("--nu-dependent", action="store_true", default=NU_DEPENDENT)
    args = ap.parse_args()
    os.makedirs(args.outdir, exist_ok=True)
    if args.stage == "fig8":
        stage_fig8(args.outdir)
    elif args.stage == "mesh":
        stage_mesh(args.outdir, args.h_tip, args.h_wall, args.h_far)
    elif args.stage == "run":
        stage_run(args.outdir, ["elastic", "linear", "nonlinear"] if args.model == "all" else [args.model], args)
    elif args.stage == "sens":
        stage_sens(args.outdir, args)
    else:
        stage_plots(args.outdir)


if __name__ == "__main__":
    main()
