path: root/fg21sim/extragalactic/clusters/solver.py

# Copyright (c) 2017 Weitian LI <weitian@aaronly.me>
# MIT license

"""
Solve the Fokker-Planck equation to derive the time evolution
of the electron spectrum (or number density distribution).

References
----------
.. [park1996]
   Park & Petrosian 1996, ApJS, 103, 255
   http://adsabs.harvard.edu/abs/1996ApJS..103..255P
.. [donnert2014]
   Donnert & Brunetti 2014, MNRAS, 443, 3564
   http://adsabs.harvard.edu/abs/2014MNRAS.443.3564D
"""

import logging

import numpy as np


logger = logging.getLogger(__name__)


def TDMAsolver(a, b, c, d):
    """
    Tri-diagonal matrix algorithm (a.k.a Thomas algorithm) solver,
    which is much faster than the generic Gaussian elimination algorithm.

    a[i]*x[i-1] + b[i]*x[i] + c[i]*x[i+1] = d[i],
    where: a[0] = c[N-1] = 0

    Example
    -------
    >>> A = np.array([[10,  2, 0, 0],
                      [ 3, 10, 4, 0],
                      [ 0,  1, 7, 5],
                      [ 0,  0, 3, 4]], dtype=float)
    >>> a = np.array([     3, 1, 3], dtype=float)
    >>> b = np.array([10, 10, 7, 4], dtype=float)
    >>> c = np.array([ 2,  4, 5   ], dtype=float)
    >>> d = np.array([ 3,  4, 5, 6], dtype=float)
    >>> print(TDMAsolver(a, b, c, d))
    [ 0.14877589  0.75612053 -1.00188324  2.25141243]
    # compare against numpy linear algebra library
    >>> print(np.linalg.solve(A, d))
    [ 0.14877589  0.75612053 -1.00188324  2.25141243]

    References
    ----------
    [1] http://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm

    Credit
    ------
    [1] https://gist.github.com/cbellei/8ab3ab8551b8dfc8b081c518ccd9ada9
    """
    # Number of equations
    nf = len(d)
    # Copy the input arrays
    ac, bc, cc, dc = map(np.array, (a, b, c, d))
    for it in range(1, nf):
        mc = ac[it-1] / bc[it-1]
        bc[it] -= mc*cc[it-1]
        dc[it] -= mc*dc[it-1]

    xc = bc
    xc[-1] = dc[-1] / bc[-1]

    for il in range(nf-2, -1, -1):
        xc[il] = (dc[il] - cc[il]*xc[il+1]) / bc[il]

    return xc


class FokkerPlanckSolver:
    """
    Solve the Fokker-Planck equation:

    ∂u(x,t)   ∂  /                ∂u(x) \            u(x,t)
    ------- = -- | B(x)u(x) + C(x)----- | + Q(x,t) - ------
       ∂t     ∂x \                  ∂x  /            T(x,t)

    u(x,t) : distribution/spectrum w.r.t. x at different times
    B(x,t) : advection coefficient
    C(x,t) : diffusion coefficient (>0)
    Q(x,t) : injection coefficient (>=0)
    T(x,t) : escape coefficient

    NOTE
    ----
    The no-flux boundary condition is used, and optional boundary fix
    may be applied.

    Parameters
    ----------
    xmin, xmax : float
        The minimum and maximum bounds of the X (spatial/momentum) axis.
    x_np : int
        Number of (logarithmic grid) points/cells along the X axis
    tstep : float
        Specify to use the constant time step for solving the equation.
    f_advection : function
        Function f(x,t) to calculate the advection coefficient B(x,t)
    f_diffusion : function
        Function f(x,t) to calculate the diffusion coefficient C(x,t)
    f_injection : function
        Function f(x,t) to calculate the injection coefficient Q(x,t)
    f_escape : function, optional
        Function f(x,t) to calculate the escape coefficient T(x,t)
    buffer_np : int, optional
        Number of grid points taking as the buffer region near the lower
        boundary.  The densities within this buffer region will be replaced
        by extrapolating an power law to avoid unphysical accumulations.
        This fix is ignored if this parameter is not specified.
        (This parameter is suggested to be about 5%-10% of ``x_np``.)

    NOTE
    ----
    All above functions should accept two parameters: ``(x, t)``,
    where ``x`` is an 1D float `~numpy.ndarray` representing the adopted
    logarithmic grid points along the spatial/energy axis, ``t`` is the
    time of each solving step.

    NOTE
    ----
    The diffusion coefficients (i.e., calculated by ``f_diffusion()``)
    should be *positive* (i.e., C(x) > 0), otherwise unstable or wrong
    results may occur, due to the current numerical scheme/algorithm
    adopted.
    """

    def __init__(self, xmin, xmax, x_np, tstep,
                 f_advection, f_diffusion, f_injection,
                 f_escape=None, buffer_np=None):
        self.xmin = xmin
        self.xmax = xmax
        self.x_np = x_np
        self.tstep = tstep
        self.f_advection = f_advection
        self.f_diffusion = f_diffusion
        self.f_injection = f_injection
        self.f_escape = f_escape
        self.buffer_np = buffer_np

    @property
    def x(self):
        """
        X values of the adopted logarithmic grid.
        """
        grid = np.logspace(np.log10(self.xmin), np.log10(self.xmax),
                           num=self.x_np)
        return grid

    @property
    def dx(self):
        """
        Values of dx[i] on the grid.

        dx[i] = (x[i+1] - x[i-1]) / 2

        NOTE
        ----
        Extrapolate the X grid by 1 point beyond each side, therefore
        avoid NaN for the first and last element of dx[i].
        Otherwise, the subsequent calculation of tridiagonal coefficients
        may be invalid for the boundary elements.

        References: Ref.[park1996],Eq.(8)
        """
        x = self.x  # log scale
        # Extrapolate the x grid by 1 point beyond each side
        ratio = x[1] / x[0]
        x2 = np.concatenate([[x[0]/ratio], x, [x[-1]*ratio]])
        dx_ = (x2[2:] - x2[:-2]) / 2
        return dx_

    @property
    def dx_phalf(self):
        """
        Values of dx[i+1/2] on the grid.

        dx[i+1/2] = x[i+1] - x[i]
        Thus the last element is NaN.

        References: Ref.[park1996],Eq.(8)
        """
        x = self.x
        dx_ = x[1:] - x[:-1]
        grid = np.concatenate([dx_, [np.nan]])
        return grid

    @property
    def dx_mhalf(self):
        """
        Values of dx[i-1/2] on the grid.

        dx[i-1/2] = x[i] - x[i-1]
        Thus the first element is NaN.
        """
        x = self.x
        dx_ = x[1:] - x[:-1]
        grid = np.concatenate([[np.nan], dx_])
        return grid

    @staticmethod
    def X_phalf(X):
        """
        Calculate the values at midpoints (+1/2) for the given quantity.

        X[i+1/2] = (X[i] + X[i+1]) / 2
        Thus the last element is NaN.

        References: Ref.[park1996],Eq.(10)
        """
        Xmid = (X[1:] + X[:-1]) / 2
        return np.concatenate([Xmid, [np.nan]])

    @staticmethod
    def X_mhalf(X):
        """
        Calculate the values at midpoints (-1/2) for the given quantity.

        X[i-1/2] = (X[i-1] + X[i]) / 2
        Thus the first element is NaN.
        """
        Xmid = (X[1:] + X[:-1]) / 2
        return np.concatenate([[np.nan], Xmid])

    @staticmethod
    def W(w):
        # References: Ref.[park1996],Eqs.(27,35)
        w = np.asarray(w)
        with np.errstate(invalid="ignore"):
            # Ignore NaN's
            w = np.abs(w)
            mask = (w < 0.1)  # Comparison on NaN gives False, as expected
        W = np.zeros(w.shape) * np.nan
        W[mask] = 1.0 / (1 + w[mask]**2/24 + w[mask]**4/1920)
        W[~mask] = (w[~mask] * np.exp(-w[~mask]/2) /
                    (1 - np.exp(-w[~mask])))
        return W

    @staticmethod
    def bound_w(w, wmin=1e-8, wmax=1e3):
        """
        Bound the absolute values of ``w`` within [wmin, wmax], to avoid
        the underflow/overflow during later W/Wplus/Wminus calculations.
        """
        ww = np.array(w)
        with np.errstate(invalid="ignore"):
            # Ignore NaN's
            m1 = (np.abs(ww) < wmin)
            m2 = (np.abs(ww) > wmax)
        ww[m1] = wmin * np.sign(ww[m1])
        ww[m2] = wmax * np.sign(ww[m2])
        return ww

    def Wplus(self, w):
        # References: Ref.[park1996],Eq.(32)
        ww = self.bound_w(w)
        W = self.W(ww)
        Wplus = W * np.exp(ww/2)
        return Wplus

    def Wminus(self, w):
        # References: Ref.[park1996],Eq.(32)
        ww = self.bound_w(w)
        W = self.W(ww)
        Wminus = W * np.exp(-ww/2)
        return Wminus

    def tridiagonal_coefs(self, uc, tc, tstep):
        """
        Calculate the coefficients for the tridiagonal system of linear
        equations corresponding to the original Fokker-Planck equation.

        -a[i]*u[i-1] + b[i]*u[i] - c[i]*u[i+1] = r[i],
        where: a[0] = c[N-1] = 0

        NOTE
        ----
        When i=0 or i=N-1, b[i] is invalid due to X[-1/2] or X[N-1/2] are
        invalid. Therefore, b[0] and b[N-1] should be alternatively
        calculated with (e.g., no-flux) boundary condition considered.

        References: Ref.[park1996],Eqs.(16,18,34)
        """
        dt = tstep
        x = self.x
        dx = self.dx
        dx_phalf = self.dx_phalf
        dx_mhalf = self.dx_mhalf
        B = self.f_advection(x, tc)
        C = self.f_diffusion(x, tc)
        Q = self.f_injection(x, tc)
        #
        B_phalf = self.X_phalf(B)
        B_mhalf = self.X_mhalf(B)
        C_phalf = self.X_phalf(C)
        C_mhalf = self.X_mhalf(C)
        w_phalf = dx_phalf * B_phalf / C_phalf
        w_mhalf = dx_mhalf * B_mhalf / C_mhalf
        Wplus_phalf = self.Wplus(w_phalf)
        Wplus_mhalf = self.Wplus(w_mhalf)
        Wminus_phalf = self.Wminus(w_phalf)
        Wminus_mhalf = self.Wminus(w_mhalf)
        #
        a = (dt/dx) * (C_mhalf/dx_mhalf) * Wminus_mhalf
        a[0] = 0.0  # Fix a[0] which is NaN
        c = (dt/dx) * (C_phalf/dx_phalf) * Wplus_phalf
        c[-1] = 0.0  # Fix c[-1] which is NaN
        b = 1 + (dt/dx) * ((C_mhalf/dx_mhalf) * Wplus_mhalf +
                           (C_phalf/dx_phalf) * Wminus_phalf)
        # Calculate b[0] & b[-1], considering the no-flux boundary condition
        b[0] = 1 + (dt/dx[0]) * (C_phalf[0]/dx_phalf[0])*Wminus_phalf[0]
        b[-1] = 1 + (dt/dx[-1]) * (C_mhalf[-1]/dx_mhalf[-1])*Wplus_mhalf[-1]
        # Escape from the system
        if self.f_escape is not None:
            T = self.f_escape(x, tc)
            b += dt / T
        # Right-hand side
        r = dt * Q + uc
        return (a, b, c, r)

    def fix_boundary(self, uc):
        """
        Due to the no-flux boundary condition adopted, particles may
        unphysically pile up near the lower boundary.  Therefore, a
        buffer region spanning ``self.buffer_np`` cells is chosen, within
        which the densities are replaced by extrapolating from the upper
        density distribution as a power law, and the power-law index
        is determined by fitting to the data points of ``self.buffer_np``
        cells on the upper side of the buffer region.

        NOTE
        ----
        * Also fix the upper boundary in the same way.
        * Fix the boundaries only when the particles are piling up at the
          boundaries.

        References: Ref.[donnert2014],Sec.(3.3)
        """
        if self.buffer_np is None:
            return uc
        if (uc <= 0.0).sum() > 0:
            logger.warning("solved density has zero/negative values!")
            return uc

        x = self.x
        # Lower boundary
        ybuf = uc[:self.buffer_np]
        if ybuf[0] > ybuf[1]:
            # Particles are piling up at the lower boundary, to fix it...
            #
            # Power-law fit
            xp = x[self.buffer_np:(self.buffer_np*2)]
            yp = uc[self.buffer_np:(self.buffer_np*2)]
            pfit = np.polyfit(np.log(xp), np.log(yp), deg=1)
            xbuf = x[:self.buffer_np]
            ybuf = np.exp(np.polyval(pfit, np.log(xbuf)))
            uc[:self.buffer_np] = ybuf

        # Upper boundary
        ybuf = uc[(-self.buffer_np):]
        if ybuf[-1] > ybuf[-2]:
            # Particles are piling up at the upper boundary, to fix it...
            xp = x[(-self.buffer_np*2):(-self.buffer_np)]
            yp = uc[(-self.buffer_np*2):(-self.buffer_np)]
            pfit = np.polyfit(np.log(xp), np.log(yp), deg=1)
            xbuf = x[(-self.buffer_np):]
            ybuf = np.exp(np.polyval(pfit, np.log(xbuf)))
            uc[(-self.buffer_np):] = ybuf

        return uc

    def time_step(self):
        """
        Adaptively determine the time step for solving the equation.

        TODO/XXX
        """
        pass

    def solve_step(self, uc, tc, tstep=None):
        """
        Solve the Fokker-Planck equation by a single step.
        """
        if tstep is None:
            tstep = self.tstep
        a, b, c, r = self.tridiagonal_coefs(uc=uc, tc=tc, tstep=tstep)
        TDM_a = -a[1:]  # Also drop the first element
        TDM_b = b
        TDM_c = -c[:-1]  # Also drop the last element
        TDM_rhs = r
        t2 = tc + tstep
        u2 = TDMAsolver(TDM_a, TDM_b, TDM_c, TDM_rhs)
        u2 = self.fix_boundary(u2)
        return (u2, t2)

    def solve(self, u0, tstart, tstop):
        """
        Solve the Fokker-Planck equation from ``tstart`` to ``tstop``,
        with initial spectrum/distribution ``u0``.
        """
        uc = u0
        tc = tstart
        tstep = self.tstep
        logger.debug("Solving Fokker-Planck equation: " +
                     "time: %.3f - %.3f" % (tstart, tstop))
        nstep = int((tstop - tc) / tstep)
        logger.debug("Constant time step: %.3f (#%d steps)" % (tstep, nstep))
        i = 0
        while tc+tstep < tstop:
            i += 1
            logger.debug("[%d/%d] t=%.3f ..." % (i, nstep, tc))
            uc, tc = self.solve_step(uc=uc, tc=tc, tstep=tstep)
        # Last step
        tstep = tstop - tc
        logger.debug("Last step: t=%.3f (tstep=%.3f) ..." % (tc, tstep))
        uc, __ = self.solve_step(uc=uc, tc=tc, tstep=tstep)
        return uc


class FokkerPlanckTests:
    """
    Several Fokker-Planck equation test cases that have analytical solutions
    (hard-sphere approximation) to validate the above solver implementation.
    """
    xmin, xmax = 1e-4, 1e4
    x_np = 200
    x = np.logspace(np.log10(xmin), np.log10(xmax), x_np)
    tstep = 1e-3
    buffer_np = 20
    # Particle injection position/energy
    x_inj = 0.1

    def _f_injection(self, x, t):
        """
        Q(x,t) injection coefficient
        """
        idx = (self.x < self.x_inj).sum()
        dx = self.x[idx] - self.x[idx-1]
        sigma = dx / 2

        x = np.asarray(x)
        mu = (x - self.x_inj) / sigma
        coef = 1 / np.sqrt(2*np.pi * sigma**2)
        y = coef * np.exp(-0.5 * mu**2)
        return y

    def test1(self):
        """
        Fokker-Planck equation test case 1.

        WARNING
        -------
        The equations given by [park1996] and [donnert2014] both have a
        sign error about the advection term B(x).

        Usage
        -----
        >>> fpsolver = test1()
        >>> x = fpsolver.x
        >>> ts = [0, 0.2, 0.4, 0.7, 1.4, 2.7, 5.2, 10.0]
        >>> us = [None]*len(ts)
        >>> us[0] = np.zeros(x.shape)
        >>> for i, t in enumerate(ts[1:]):
        ...     tstart = ts[i]
        ...     tstop = ts[i+1]
        ...     print("* time: %.1f -> %.1f @ step: %.1e" %
        ...           (tstart, tstop, fpsolver.tstep))
        ...     us[i+1] = fpsolver.solve(u0=us[i], tstart=tstart, tstop=tstop)

        References
        ----------
        * [park1996], Eq.(22), Fig.(4)
        * [donnert2014], Eq.(34), Fig.(1:top-left)
        """
        def f_advection(x, t):
            # WARNING:
            # Both [park1996] and [donnert2014] got a "-1" for this term,
            # which should be "+1".
            return -x+1

        def f_diffusion(x, t):
            return x*x

        def f_injection(x, t):
            if t >= 0:
                return self._f_injection(x, t)
            else:
                return 0

        def f_escape(x, t):
            return 1

        fpsolver = FokkerPlanckSolver(xmin=self.xmin, xmax=self.xmax,
                                      x_np=self.x_np, tstep=self.tstep,
                                      f_advection=f_advection,
                                      f_diffusion=f_diffusion,
                                      f_injection=f_injection,
                                      f_escape=f_escape,
                                      buffer_np=self.buffer_np)
        return fpsolver

    def test2(self):
        """
        Fokker-Planck equation test case 2.

        References
        ----------
        * [park1996], Eq.(23), Fig.(2)
        * [donnert2014], Eq.(39), Fig.(1:bottom-left)
        """
        def f_advection(x, t):
            return -x

        def f_diffusion(x, t):
            return x*x

        def f_injection(x, t):
            if t >= 0:
                return self._f_injection(x, t)
            else:
                return 0

        def f_escape(x, t):
            return x

        fpsolver = FokkerPlanckSolver(xmin=self.xmin, xmax=self.xmax,
                                      x_np=self.x_np, tstep=self.tstep,
                                      f_advection=f_advection,
                                      f_diffusion=f_diffusion,
                                      f_injection=f_injection,
                                      f_escape=f_escape,
                                      buffer_np=self.buffer_np)
        return fpsolver

    def test3(self):
        """
        Fokker-Planck equation test case 3.

        References
        ----------
        * [park1996], Eq.(24), Fig.(3)
        * [donnert2014], Eq.(43), Fig.(1:bottom-right)
        """
        def f_advection(x, t):
            return -x**2

        def f_diffusion(x, t):
            return x**3

        def f_injection(x, t):
            if t == 0:
                return self._f_injection(x, 0) / self.tstep
            else:
                return 0

        def f_escape(x, t):
            return 1

        fpsolver = FokkerPlanckSolver(xmin=self.xmin, xmax=self.xmax,
                                      x_np=self.x_np, tstep=self.tstep,
                                      f_advection=f_advection,
                                      f_diffusion=f_diffusion,
                                      f_injection=f_injection,
                                      f_escape=f_escape,
                                      buffer_np=self.buffer_np)
        return fpsolver