solarwindpy 0.0.1.dev0__py3-none-any.whl → 0.1.0__py3-none-any.whl

solarwindpy/fitfunctions/exponentials.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python
+r"""Fit functions for exponential models.
+
+Classes in this module implement exponential decay and related forms
+using the :class:`~solarwindpy.fitfunctions.core.FitFunction` API.
+They provide reasonable starting parameters and formatted LaTeX output
+for visualization.
+"""
+import pdb  # noqa: F401
+import numpy as np
+
+from numbers import Number
+
+from .core import FitFunction
+
+
+class Exponential(FitFunction):
+    def __init__(self, xobs, yobs, **kwargs):
+        """Fit ``A * exp(-c x)`` to the data.
+
+        Parameters
+        ----------
+        xobs : array-like
+            Independent variable values.
+        yobs : array-like
+            Observed dependent variable values.
+        **kwargs
+            Additional options forwarded to :class:`FitFunction`.
+        """
+
+        super().__init__(xobs, yobs, **kwargs)
+
+    @property
+    def function(self):
+        def exp(x, c, A):
+            return A * np.exp(-(c * x))
+
+        return exp
+
+    @property
+    def p0(self):
+        r"""Return initial guesses ``[c, A]`` for the fit."""
+        assert self.sufficient_data
+
+        y = self.observations.used.y
+
+        c = 1.0
+        try:
+            A = y.max()
+        except ValueError as e:
+            chk = (
+                r"zero-size array to reduction operation maximum "
+                "which has no identity"
+            )
+            if e.message.startswith(chk):
+                msg = (
+                    "There is no maximum of a zero-size array. "
+                    "Please check input data."
+                )
+                raise ValueError(msg)
+
+        p0 = [c, A]
+        return p0
+
+    @property
+    def TeX_function(self):
+        TeX = r"f(x)=A \cdot e^{-cx}"
+        return TeX
+
+
+class ExponentialPlusC(FitFunction):
+    def __init__(self, xobs, yobs, **kwargs):
+        """Fit ``A * exp(-c x) + d`` to the data.
+
+        Parameters
+        ----------
+        xobs : array-like
+            Independent variable values.
+        yobs : array-like
+            Observed dependent variable values.
+        **kwargs
+            Additional options forwarded to :class:`FitFunction`.
+        """
+
+        super().__init__(xobs, yobs, **kwargs)
+
+    @property
+    def function(self):
+        def expc(x, c, A, d):
+            return (A * np.exp(-(c * x))) + d
+
+        return expc
+
+    @property
+    def p0(self):
+        r"""Return initial guesses ``[c, A, d]`` for the fit."""
+        assert self.sufficient_data
+
+        y = self.observations.used.y
+
+        c = 1.0
+        d = 0.0
+        try:
+            A = y.max()
+        except ValueError as e:
+            chk = (
+                r"zero-size array to reduction operation maximum "
+                "which has no identity"
+            )
+            if e.message.startswith(chk):
+                msg = (
+                    "There is no maximum of a zero-size array. "
+                    "Please check input data."
+                )
+                raise ValueError(msg)
+
+        p0 = [c, A, d]
+        return p0
+
+    @property
+    def TeX_function(self):
+        TeX = r"f(x)=A \cdot e^{-cx} + d"
+        return TeX
+
+
+class ExponentialCDF(FitFunction):
+    def __init__(self, xobs, yobs, **kwargs):
+        """Fit an exponential cumulative distribution function.
+
+        Parameters
+        ----------
+        xobs : array-like
+            Independent variable values.
+        yobs : array-like
+            Observed cumulative counts.
+        **kwargs
+            Additional options forwarded to :class:`FitFunction`.
+        """
+
+        super().__init__(xobs, yobs, **kwargs)
+
+    @property
+    def function(self):
+        def exp_cdf(x, c):
+            return self.y0 * (1.0 - np.exp(-(c * x)))
+
+        return exp_cdf
+
+    @property
+    def y0(self):
+        r"""Amplitude of the CDF."""
+        return self._y0
+
+    def set_y0(self, new):
+        assert isinstance(new, Number)
+        self._y0 = new
+
+    @property
+    def p0(self):
+        r"""Return initial guess ``[c]`` for the fit."""
+        assert self.sufficient_data
+
+        y = self.observations.used.y
+
+        c = y.mean()
+
+        p0 = [c]
+        return p0
+
+    @property
+    def TeX_function(self):
+        TeX = r"f(x)=A \left(1 - e^{-cx}\right)"
+        return TeX
+
+    def set_TeX_info(self, **kwargs):
+        """Include ``A`` value in the TeX annotation."""
+
+        # HACK: assumes integer A
+        #       If not integer, will need to format float or exp.
+        additional_info = kwargs.pop("additional_info", [])
+        if not isinstance(additional_info, list):
+            additional_info = [additional_info]
+        info_A = r"$A = %s$" % self.y0
+        additional_info = [info_A] + additional_info
+
+        super(ExponentialCDF, self).set_TeX_info(
+            additional_info=additional_info, **kwargs
+        )

solarwindpy/fitfunctions/gaussians.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python
+r"""Gaussian-based fit functions.
+
+The classes here implement standard Gaussian shapes and common
+variations used throughout the package.  Each class inherits from
+:class:`~solarwindpy.fitfunctions.core.FitFunction` and defines the
+target function, initial parameter estimates, and LaTeX output helpers.
+"""
+import pdb  # noqa: F401
+import numpy as np
+
+from .core import FitFunction
+
+
+class Gaussian(FitFunction):
+    def __init__(self, xobs, yobs, **kwargs):
+        """Fit a standard Gaussian profile."""
+
+        super().__init__(xobs, yobs, **kwargs)
+
+    @property
+    def function(self):
+        def gaussian(x, mu, sigma, A):
+            arg = -0.5 * (((x - mu) / sigma) ** 2.0)
+            return A * np.exp(arg)
+
+        return gaussian
+
+    @property
+    def p0(self):
+        r"""Return initial guesses ``[mu, sigma, A]`` for the fit."""
+        assert self.sufficient_data
+
+        x, y = self.observations.used.x, self.observations.used.y
+        mean = (x * y).sum() / y.sum()
+        std = np.sqrt(((x - mean) ** 2.0 * y).sum() / y.sum())
+
+        try:
+            peak = y.max()
+        except ValueError as e:
+            chk = (
+                r"zero-size array to reduction operation maximum "
+                "which has no identity"
+            )
+            if e.message.startswith(chk):
+                msg = (
+                    "There is no maximum of a zero-size array. "
+                    "Please check input data."
+                )
+                raise ValueError(msg)
+
+        p0 = [mean, std, peak]
+        return p0
+
+    @property
+    def TeX_function(self):
+        #         TeX = r"f(x)=\frac{1}{\sqrt{2 \pi} \sigma} A\cdot e^{-\frac{1}{2} (\frac{x-\mu}{\sigma})^2}"
+        TeX = r"f(x)=A \cdot e^{-\frac{1}{2} \left(\frac{x-\mu}{\sigma}\right)^2}"
+        return TeX
+
+    def make_fit(self, *args, **kwargs):
+        super().make_fit(*args, **kwargs)
+        try:
+            self.TeX_info.set_TeX_argnames(mu=r"\mu", sigma=r"\sigma")
+        except AttributeError:  # Fit failed
+            pass
+
+
+class GaussianNormalized(FitFunction):
+    def __init__(self, xobs, yobs, **kwargs):
+        """Fit a normalized Gaussian where the integral equals ``n``."""
+
+        super().__init__(xobs, yobs, **kwargs)
+
+    @property
+    def function(self):
+        def gaussian_normalized(x, mu, sigma, n):
+            arg = -0.5 * (((x - mu) / sigma) ** 2.0)
+            A = n / (np.sqrt(2 * np.pi) * sigma)
+            return A * np.exp(arg)
+
+        return gaussian_normalized
+
+    @property
+    def p0(self):
+        r"""Return initial guesses ``[mu, sigma, n]`` for the fit."""
+        assert self.sufficient_data
+
+        x, y = self.observations.used.x, self.observations.used.y
+        mean = (x * y).sum() / y.sum()
+        std = np.sqrt(((x - mean) ** 2.0 * y).sum() / y.sum())
+
+        try:
+            peak = y.max()
+        except ValueError as e:
+            chk = (
+                r"zero-size array to reduction operation maximum "
+                "which has no identity"
+            )
+            if e.message.startswith(chk):
+                msg = (
+                    "There is no maximum of a zero-size array. "
+                    "Please check input data."
+                )
+                raise ValueError(msg)
+
+        n = peak * std * np.sqrt(2 * np.pi)
+        p0 = [mean, std, n]
+        return p0
+
+    @property
+    def TeX_function(self):
+        TeX = r"f(x)=\frac{n}{\sqrt{2 \pi} \sigma} e^{-\frac{1}{2} \left(\frac{x-\mu}{\sigma}\right)^2}"
+        #         TeX = r"f(x)=A \cdot e^{-\frac{1}{2} (\frac{x-\mu}{\sigma})^2}"
+        return TeX
+
+    def make_fit(self, *args, **kwargs):
+        super().make_fit(*args, **kwargs)
+        try:
+            self.TeX_info.set_TeX_argnames(mu=r"\mu", sigma=r"\sigma")
+        except AttributeError:  # Fit failed
+            pass
+
+
+class GaussianLn(FitFunction):
+    r"""Gaussian where taking :math:`\ln(x)`.
+
+    [1] https://mathworld.wolfram.com/LogNormalDistribution.html
+    """
+
+    def __init__(self, xobs, yobs, **kwargs):
+        """Fit a Gaussian in logarithmic space."""
+
+        super().__init__(xobs, yobs, **kwargs)
+        self.set_TeX_report_normal_parameters(False)
+
+    @property
+    def function(self):
+        #         def gaussian_ln(x, m, s, A):
+        #             x = np.log(x)
+        #             coeff = (np.sqrt(2.0 * np.pi) * s) ** (-1.0)
+        #             arg = -0.5 * (((x - m) / s) ** 2.0)
+        #             return A * coeff * np.exp(arg)
+
+        def gaussian_ln(x, m, s, A):
+            lnx = np.log(x)
+
+            coeff = A
+            #             coeff *= (np.sqrt(2.0 * np.pi) * s * x) ** (-1.0)
+
+            arg = -0.5 * (((lnx - m) / s) ** 2.0)
+
+            return coeff * np.exp(arg)
+
+        #         def gaussian_ln(x, m, s, A):
+        #             arg = m + (s * x)
+        #             return A * np.exp(arg)
+
+        return gaussian_ln
+
+    @property
+    def p0(self):
+        r"""Return initial guesses ``[ln(mu), ln(sigma), ln(A)]``."""
+        assert self.sufficient_data
+
+        x, y = self.observations.used.x, self.observations.used.y
+
+        mean = (x * y).sum() / y.sum()
+        std = ((x - mean) ** 2.0 * y).sum() / y.sum()
+
+        try:
+            peak = y.max()
+        except ValueError as e:
+            chk = (
+                r"zero-size array to reduction operation maximum "
+                "which has no identity"
+            )
+            if e.message.startswith(chk):
+                msg = (
+                    "There is no maximum of a zero-size array. "
+                    "Please check input data."
+                )
+                raise ValueError(msg)
+
+        p0 = [mean, std, peak]
+        p0 = [np.log(x) for x in p0]
+        return p0
+
+    @property
+    def TeX_function(self):
+        TeX = (
+            r"f(x) = A \cdot  "
+            r"\mathrm{exp}\left[-\frac{1}{2}  "
+            r"(\frac{\mathrm{ln}(x)-m}{s})^2\right]"
+        )
+        TeX = (
+            r"f(x) ="
+            r"A \cdot"
+            #                r"\frac{1}{\sqrt{2\pi} s x}"
+            r"\exp\left["
+            r"\frac{\left(\ln x - m\right)^2}{2 s^2}"
+            r"\right]"
+        )
+        return TeX
+
+    @property
+    def normal_parameters(self):
+        r"""Calculate the normal parameters from log-normal parameters.
+
+        .. math::
+
+            \mu = \exp[m + (s^2)/2]
+            \sigma = \sqrt{\exp[s^2 + 2m] (\exp[s^2] - 1)}
+        """
+        m = self.popt["m"]
+        s = self.popt["s"]
+
+        mu = np.exp(m + ((s**2.0) / 2.0))
+        sigma = np.exp(s**2.0 + 2.0 * m)
+        sigma *= np.exp(s**2.0) - 1.0
+        sigma = np.sqrt(sigma)
+
+        return dict(mu=mu, sigma=sigma)
+
+    @property
+    def TeX_report_normal_parameters(self):
+        r"""Report normal parameters, not log-normal parameters in the TeX info."""
+        try:
+            return self._use_normal_parameters
+        except AttributeError:
+            return False
+
+    def set_TeX_report_normal_parameters(self, new):
+        new = bool(new)
+        self._use_normal_parameters = new
+
+    @property
+    def TeX_popt(self):
+        r"""Create a dictionary with ``(k, v)`` pairs corresponding to parameter values.
+
+        ``(self.argnames, :math:`p_{\mathrm{opt}} \pm \sigma_p`)`` with the
+        appropriate uncertainty.
+
+        See ``set_TeX_trans_argnames`` to translate the argnames for TeX.
+        """
+        TeX_popt = super(GaussianLn, self).TeX_popt
+
+        if self.TeX_report_normal_parameters:
+            # psigma = self.psigma
+            popt = self.normal_parameters.items()
+            # use -9999 to indicate fill value that hasn't been set.
+            # I need to figure out how to calculate the transformation
+            # of the uncertainty of log normal to normal.
+            normal_popt = {k: self.val_uncert_2_string(v, np.nan) for k, v in popt}
+            normal_popt = {k: v.split(r" \pm")[0] for k, v in normal_popt.items()}
+
+            translate = dict(mu=r"\mu", sigma=r"\sigma")
+            for k0, k1 in translate.items():
+                normal_popt[k1] = normal_popt[k0]
+                del normal_popt[k0]
+
+            TeX_popt.update(normal_popt)
+
+        return TeX_popt

solarwindpy/fitfunctions/lines.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+r"""Simple linear fit functions.
+
+This module defines :class:`~solarwindpy.fitfunctions.core.FitFunction`
+subclasses for straight-line models.  They are primarily used for
+quick trend estimation and serve as basic examples of the
+FitFunction interface.
+"""
+import pdb  # noqa: F401
+import numpy as np
+
+from .core import FitFunction
+
+
+class Line(FitFunction):
+    def __init__(self, xobs, yobs, **kwargs):
+        """Create a line fit to ``(xobs, yobs)`` data."""
+        super().__init__(xobs, yobs, **kwargs)
+
+    @property
+    def function(self):
+        def line(x, m, b):
+            return (m * x) + b
+
+        return line
+
+    @property
+    def p0(self):
+        r"""Calculate the initial guess for the line parameters.
+
+        If this fails, return :py:meth:`curve_fit`'s default value `None`.
+
+        Return
+        ------
+        p0 : list
+            The initial guesses as [m, b].
+        """
+        assert self.sufficient_data
+
+        x = self.observations.used.x
+        y = self.observations.used.y
+        dy, dx = np.ediff1d(y), np.ediff1d(x)
+
+        m = dy / dx
+        m = np.median(m)
+        b = (m * x) - y
+        b = np.median(b)
+
+        p0 = [m, b]
+
+        if not (np.all(np.isfinite(dx)) and (np.all(np.abs(dx) > 0))):
+            self.logger.warning(f"Slope estimate failed (dx = {dx}).\nReturning None.")
+            p0 = None
+
+        return p0
+
+    @property
+    def TeX_function(self):
+        TeX = r"f(x)=m \cdot x + b"
+        return TeX
+
+    @property
+    def x_intercept(self):
+        return -self.popt["b"] / self.popt["m"]
+
+
+class LineXintercept(FitFunction):
+    def __init__(self, xobs, yobs, **kwargs):
+        super().__init__(xobs, yobs, **kwargs)
+
+    @property
+    def function(self):
+        def line(x, m, x0):
+            return m * (x - x0)
+
+        return line
+
+    @property
+    def p0(self):
+        r"""Calculate the initial guess for the line parameters.
+
+        If this fails, return :py:meth:`curve_fit`'s default value `None`.
+
+        Return
+        ------
+        p0 : list
+            The initial guesses as [m, b].
+        """
+        assert self.sufficient_data
+
+        x = self.observations.used.x
+        y = self.observations.used.y
+        dy, dx = np.ediff1d(y), np.ediff1d(x)
+
+        m = dy / dx
+        m = np.median(m)
+        b = (m * x) - y
+        b = np.median(b)
+
+        x0 = -b / m
+        p0 = [m, x0]
+
+        if not (np.all(np.isfinite(dx)) and (np.all(np.abs(dx) > 0))):
+            self.logger.warning(f"Slope estimate failed (dx = {dx}).\nReturning None.")
+            p0 = None
+
+        return p0
+
+    @property
+    def TeX_function(self):
+        TeX = r"f(x)=m \cdot (x - x_0)"
+        return TeX
+
+    @property
+    def y_intercept(self):
+        return -self.popt["x0"] * self.popt["m"]

solarwindpy/fitfunctions/moyal.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+r""":py:mod:`Gaussian` and related `FitFunction` sublcasses."""
+import pdb  # noqa: F401
+import numpy as np
+
+from .core import FitFunction
+
+
+class Moyal(FitFunction):
+    def __init__(self, sigma, xobs, yobs, **kwargs):
+        super().__init__(xobs, yobs, **kwargs)
+
+    #         self._sigma = float(sigma)
+
+    @property
+    def function(self):
+        def moyal(x, mu, sigma, A):
+            center = x - mu
+            #             sigma = self.sigma
+            ms_sq = (center / sigma) ** 2
+            arg0 = 0.5 * (ms_sq - np.exp(ms_sq))
+            arg1 = np.exp(arg0)
+            out = A * (np.exp(arg1) - 1)
+            return out
+
+        return moyal
+
+    @property
+    def sigma(self):
+        r"""Initial guess for mean value."""
+        return self._sigma
+
+    @property
+    def p0(self):
+        r"""Calculate the initial guess for the Gaussian parameters.
+
+        Return
+        ------
+        p0 : list
+            The initial guesses as [mu, sigma, A].
+        """
+        assert self.sufficient_data
+
+        x, y = self.observations.used.x, self.observations.used.y
+        mean = (x * y).sum() / y.sum()
+        std = np.sqrt(((x - mean) ** 2.0 * y).sum() / y.sum())
+        #         std = self.sigma
+
+        try:
+            peak = y.max()
+        except ValueError as e:
+            chk = (
+                r"zero-size array to reduction operation maximum "
+                "which has no identity"
+            )
+            if e.message.startswith(chk):
+                msg = (
+                    "There is no maximum of a zero-size array. "
+                    "Please check input data."
+                )
+                raise ValueError(msg)
+
+        p0 = [mean, std, peak]
+        return p0
+
+    @property
+    def TeX_function(self):
+        #         TeX = r"f(x)=\frac{1}{\sqrt{2 \pi} \sigma} A\cdot e^{-\frac{1}{2} (\frac{x-\mu}{\sigma})^2}"
+        TeX = r"f(x)=A \cdot e^{-\frac{1}{2} (\frac{x-\mu}{\sigma})^2 - e^{\frac{x-\mu}{\sigma}}^2}"
+        TeX = "lala"
+        return TeX