plotastrodata 1.8.15__tar.gz → 1.8.16__tar.gz

{plotastrodata-1.8.15/plotastrodata.egg-info → plotastrodata-1.8.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.8.15
+Version: 1.8.16
 Summary: plotastrodata is a tool for astronomers to create figures from FITS files and perform fundamental data analyses with ease.
 Home-page: https://github.com/yusukeaso-astron/plotastrodata
 Download-URL: https://github.com/yusukeaso-astron/plotastrodata

{plotastrodata-1.8.15 → plotastrodata-1.8.16}/plotastrodata/__init__.py

@@ -1,4 +1,4 @@
 import warnings
 
 warnings.simplefilter('ignore', FutureWarning)
-__version__ = '1.8.15'
+__version__ = '1.8.16'

{plotastrodata-1.8.15 → plotastrodata-1.8.16}/plotastrodata/analysis_utils.py

@@ -2,17 +2,16 @@ import numpy as np
 import warnings
 from dataclasses import dataclass
 from scipy.interpolate import RegularGridInterpolator as RGI
-from scipy.optimize import curve_fit
 from scipy.signal import convolve
 
 from plotastrodata import const_utils as cu
 from plotastrodata.coord_utils import coord2xy, rel2abs, xy2coord
 from plotastrodata.fits_utils import data2fits, FitsData, Jy2K
-from plotastrodata.fitting_utils import EmceeCorner, gaussfit1d
+from plotastrodata.fitting_utils import (EmceeCorner, gaussian2d,
+                                         gaussfit1d, gaussfit2d)
 from plotastrodata.matrix_utils import dot2d, Mfac, Mrot
 from plotastrodata.noise_utils import estimate_rms
-from plotastrodata.other_utils import (gaussian2d, isdeg,
-                                       RGIxy, RGIxyv, to4dim, trim)
+from plotastrodata.other_utils import isdeg, RGIxy, RGIxyv, to4dim, trim
 
 
 def quadrantmean(data: np.ndarray, x: np.ndarray, y: np.ndarray,
@@ -106,7 +105,7 @@ class AstroData():
     beam: np.ndarray | tuple[None] = (None, None, None)
     fitsimage: str | None = None
     Tb: bool = False
-    sigma: str = 'hist'
+    sigma: str | float | None = 'hist'
     center: str = 'common'
     restfreq: float | None = None
     cfactor: float = 1
@@ -333,47 +332,32 @@ class AstroData():
 
     @_need_multipixels
     def gaussfit2d(self, chan: int | None = None) -> dict:
-        """Fit a 2D Gaussian function to self.data.
+        """Fit a 2D Gaussian function to self.data using fitting_utils.gaussfit2d().
 
         Args:
             chan (int): The channel number where the 2D Gaussian is fitted. Defaults to None.
 
         Returns:
-            dict: The best parameter set (popt), the covariance set (pcov), the best 2D Gaussian array (model), the residual from the model (residual), and the coordinates of the best-fit center (center).
+            dict: The best parameter set (popt), the error set (perr), the best 2D Gaussian array (model), the residual from the model (residual), and the coordinates of the best-fit center (center).
         """
-        d = self.data if chan is None else self.data[chan]
-        x = self.x
-        y = self.y
-        ds = np.min([np.abs(self.dx), np.abs(self.dy)])
-        p0 = (np.max(d), np.median(x), np.median(y), 5 * ds, 5 * ds, 0)
-        amax = np.max(np.abs(d))
-        xmin = np.min(x)
-        xmax = np.max(x)
-        ymin = np.min(y)
-        ymax = np.max(y)
-        smax = np.max([xmax - xmin, ymax - ymin])
-        bounds = [[-amax, xmin, ymin, ds, ds, -90],
-                  [amax, xmax, ymax, smax, smax, 90]]
-        x, y = np.meshgrid(x, y)
+        z = self.data if chan is None else self.data[chan]
         Omega = np.pi * self.beam[0] * self.beam[1] / 4 / np.log(2)
         pixelperbeam = Omega / np.abs(self.dx * self.dy)
         s = 'sigma is multiplied by sqrt(pixel-per-beam)' \
             + ' to consider the noise correlation in a beam.' \
             + ' This correction is relatively conservative.'
         warnings.warn(s, UserWarning)
-        popt, pcov = curve_fit(gaussian2d,
-                               (x.ravel(), y.ravel()), d.ravel(),
-                               p0=p0, bounds=bounds,
-                               sigma=self.sigma * np.sqrt(pixelperbeam),
-                               absolute_sigma=True)
-        model = gaussian2d((x, y), *popt)
-        residual = d - model
-        if (center := self.center) is not None:
-            xy = popt[1:3] / 3600
-            newcenter = xy2coord(xy, coordorg=center)
+        res = gaussfit2d(xdata=self.x, ydata=self.y, zdata=z,
+                         sigma=self.sigma * np.sqrt(pixelperbeam),
+                         show=False, nwalkersperdim=4)
+        popt, perr = res['popt'], res['perr']
+        model = gaussian2d(np.meshgrid(self.x, self.y), *popt)
+        residual = z - model
+        if self.center is not None:
+            newcenter = xy2coord(popt[1:3] / 3600, coordorg=self.center)
         else:
             newcenter = None
-        return {'popt': popt, 'pcov': pcov,
+        return {'popt': popt, 'perr': perr,
                 'model': model, 'residual': residual,
                 'center': newcenter}
 
@@ -468,7 +452,8 @@ class AstroData():
             res = [None] * nprof
             for i in range(nprof):
                 res[i] = gaussfit1d(xdata=v, ydata=prof[i],
-                                    sigma=None, show=True)
+                                    sigma=None, show=True,
+                                    nwalkersperdim=8)
             gfitres['best'] = [a['popt'][:3] for a in res]
             gfitres['error'] = [a['perr'][:3] for a in res]
         return v, prof, gfitres

{plotastrodata-1.8.15 → plotastrodata-1.8.16}/plotastrodata/fitting_utils.py

@@ -8,6 +8,7 @@ from dynesty import DynamicNestedSampler as DNS
 from multiprocessing import Pool
 from tqdm import tqdm
 
+from plotastrodata.matrix_utils import Mrot, dot2d
 from plotastrodata.other_utils import close_figure
 
 
@@ -395,6 +396,47 @@ class EmceeCorner():
         return {'evidence': evidence, 'error': error}
 
 
+def gaussian1d(x: np.ndarray | float,
+               amplitude: float, xo: float, fwhm: float,
+               ) -> np.ndarray:
+    """One dimensional Gaussian function.
+
+    Args:
+        x (np.ndarray): Variable of the Gaussian function.
+        amplitude (float): Peak value.
+        xo (float): Offset in the x direction.
+        fwhm (float): Full width at half maximum.
+
+    Returns:
+        g (np.ndarray): 1D numpy array.
+    """
+    g = amplitude * np.exp2(-4 * (((x - xo) / fwhm)**2))
+    return g
+
+
+def gaussian2d(xy: np.ndarray,
+               amplitude: float, xo: float, yo: float,
+               fwhm_major: float, fwhm_minor: float, pa: float
+               ) -> np.ndarray:
+    """Two dimensional Gaussian function.
+
+    Args:
+        xy (np.ndarray): A pair of (x, y).
+        amplitude (float): Peak value.
+        xo (float): Offset in the x direction.
+        yo (float): Offset in the y direction.
+        fwhm_major (float): Full width at half maximum in the major axis (but can be shorter than the minor axis).
+        fwhm_minor (float): Full width at half maximum in the minor axis (but can be longer then the major axis).
+        pa (float): Position angle of the major axis from the +y axis to the +x axis in the unit of degree.
+
+    Returns:
+        g (np.ndarray): Output array in the same shape as xy.
+    """
+    s, t = dot2d(Mrot(-pa), [xy[1] - yo, xy[0] - xo])
+    g = amplitude * np.exp2(-4 * ((s / fwhm_major)**2 + (t / fwhm_minor)**2))
+    return g
+
+
 def gaussfit1d(xdata: np.ndarray, ydata: np.ndarray,
                sigma: float | np.ndarray | None,
                show: bool = False, **kwargs) -> dict:
@@ -403,43 +445,90 @@ def gaussfit1d(xdata: np.ndarray, ydata: np.ndarray,
     Args:
         xdata (np.ndarray): ydata is compared with Gauss(xdata).
         ydata (np.ndarray): ydata is compared with Gauss(xdata).
-        sigma (float | np.ndarray | None): Noise level of ydata. If None is given, sigma is also a free parameter. Defaults to None.
+        sigma (float | np.ndarray | None): Noise level of ydata. If None is given, sigma is estimated by a temporary fitting. Defaults to None.
         show (bool, optional): True means to show the best-fit parameters and uncertainties. Defaults to False.
 
     Returns:
-        dict: _description_
+        dict: The keys are popt, perr, and sigma.
     """
-    if sigma is not None and np.shape(sigma) == ():
-        sigma = [sigma] * len(xdata)
     xmin, xmax = np.min(xdata), np.max(xdata)
     ymin, ymax = np.min(ydata), np.max(ydata)
+    xw = xmax - xmin
+    yw = ymax - ymin
     dx = np.abs(xdata[1] - xdata[0])
-    bounds = [[ymin, ymax], [xmin, xmax], [dx, xmax - xmin]]
-    if sigma is None:
-        bounds.append([np.log(ymax * 1e-6), np.log(ymax)])
-
-    def g(x, p):
-        a, c, w = p
-        return a * np.exp(-4. * np.log(2.) * ((x - c) / w)**2)
-
-    if sigma is None:
-        def logl(p):
-            sigmdl = np.exp(p[3])
-            chi2 = np.sum(((ydata - g(xdata, p[:3])) / sigmdl)**2)
-            return -0.5 * chi2 - p[3]
-    else:
-        def logl(p):
-            chi2 = np.sum(((ydata - g(xdata, p)) / sigma)**2)
-            return -0.5 * chi2
-
-    fitter = EmceeCorner(bounds=bounds, logl=logl)
-    fitter.fit(**kwargs)
+    bounds = [[ymin - yw * 10, ymax + yw * 10], [xmin, xmax], [dx, xw]]
+    sigtmp = sigma or max(np.abs(ymin), np.abs(ymax)) * 0.01
+    for i in range(2 if sigma is None else 1):
+        fitter = EmceeCorner(bounds=bounds, model=gaussian1d,
+                             sigma=sigtmp, xdata=xdata, ydata=ydata)
+        fitter.fit(**kwargs)
+        if i == 0:
+            sigtmp = np.std(ydata - gaussian1d(xdata, *fitter.popt))
     popt = fitter.popt
     plow = fitter.plow
     phigh = fitter.phigh
     perr = (phigh - plow) / 2
-    pars = 'peak, center, FWHM' + (', lnsigma' if sigma is None else '')
     if show:
-        print(f'Gauss ({pars}):', popt)
+        print('Gauss (peak, center, FWHM):', popt)
+        print('Gauss uncertainties:', perr)
+        if sigma is None:
+            print('Estimated sigma: ', sigtmp)
+    return {'popt': popt, 'perr': perr, 'sigma': sigtmp}
+
+
+def gaussfit2d(xdata: np.ndarray, ydata: np.ndarray, zdata: np.ndarray,
+               sigma: float | np.ndarray | None,
+               show: bool = False, **kwargs) -> dict:
+    """Gaussian fitting to a pair of 1D arrays.
+
+    Args:
+        xdata (np.ndarray): zdata is compared with Gauss(xdata, ydata).
+        ydata (np.ndarray): zdata is compared with Gauss(xdata, ydata).
+        zdata (np.ndarray): zdata is compared with Gauss(xdata, ydata).
+        sigma (float | np.ndarray | None): Noise level of ydata. If None is given, sigma is estimated by a temporary fitting. Defaults to None.
+        show (bool, optional): True means to show the best-fit parameters and uncertainties. Defaults to False.
+
+    Returns:
+        dict: The keys are popt, perr, and sigma.
+    """
+    xmin, xmax = np.min(xdata), np.max(xdata)
+    ymin, ymax = np.min(ydata), np.max(ydata)
+    zmin, zmax = np.min(zdata), np.max(zdata)
+    xw = xmax - xmin
+    yw = ymax - ymin
+    zw = zmax - zmin
+    dx = min(np.abs(xdata[1] - xdata[0]), np.abs(ydata[1] - ydata[0]))
+    xw = max(xw, yw)
+    xy = np.meshgrid(xdata, ydata)
+    sigtmp = sigma or max(np.abs(zmin), np.abs(zmax)) * 0.01
+
+    def model(xy, a, cx, cy, wmaj, wmin, pa):
+        if wmaj < wmin:
+            return np.inf
+        else:
+            return gaussian2d(xy, a, cx, cy, wmaj, wmin, pa)
+
+    bounds = [[zmin - zw * 10, zmax + zw * 10],
+              [xmin, xmax], [ymin, ymax],
+              [dx, xw], [dx, xw], [-90, 90]]
+    for i in range(2):
+        fitter = EmceeCorner(bounds=bounds, model=model,
+                             sigma=sigtmp, xdata=xy, ydata=zdata)
+        fitter.fit(**kwargs)
+        a, cx, cy, wmaj, wmin, pa = fitter.popt
+        wmax = max(wmaj, wmin)
+        bounds = [sorted([a / 2, a * 2]),
+                  [cx - wmax, cx + wmax], [cy - wmax, cy + wmax],
+                  [wmaj / 2, wmaj * 2], [wmin / 2, wmin * 2],
+                  [pa - 45, pa + 45]]
+        if i == 0 and sigma is None:
+            sigtmp = np.std(ydata - gaussian2d(xy, *fitter.popt))
+    popt = fitter.popt
+    popt[-1] = (popt[-1] + 90) % 180 - 90
+    perr = (fitter.phigh - fitter.plow) / 2
+    if show:
+        print('Gauss (peak, center, FWHM):', popt)
         print('Gauss uncertainties:', perr)
-    return {'popt': popt, 'perr': perr}
+        if sigma is None:
+            print('Estimated sigma: ', sigtmp)
+    return {'popt': popt, 'perr': perr, 'sigma': sigtmp}

{plotastrodata-1.8.15 → plotastrodata-1.8.16}/plotastrodata/other_utils.py

@@ -2,8 +2,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 from scipy.interpolate import RegularGridInterpolator as RGI
 
-from plotastrodata.matrix_utils import Mrot, dot2d
-
 
 def listing(*args) -> list:
     """Output a list of the input when the input is string or number.
@@ -176,29 +174,6 @@ def RGIxyv(v: np.ndarray, y: np.ndarray, x: np.ndarray, data: np.ndarray,
         return np.squeeze([f3d(tuple(vyxnew)) for f3d in f])
 
 
-def gaussian2d(xy: np.ndarray,
-               amplitude: float, xo: float, yo: float,
-               fwhm_major: float, fwhm_minor: float, pa: float
-               ) -> np.ndarray:
-    """Two dimensional Gaussian function.
-
-    Args:
-        xy (np.ndarray): A pair of (x, y).
-        amplitude (float): Peak value.
-        xo (float): Offset in the x direction.
-        yo (float): Offset in the y direction.
-        fwhm_major (float): Full width at half maximum in the major axis (but can be shorter than the minor axis).
-        fwhm_minor (float): Full width at half maximum in the minor axis (but can be longer then the major axis).
-        pa (float): Position angle of the major axis from the +y axis to the +x axis in the unit of degree.
-
-    Returns:
-        g (np.ndarray): 2D numpy array.
-    """
-    s, t = dot2d(Mrot(-pa), [xy[1] - yo, xy[0] - xo])
-    g = amplitude * np.exp2(-4 * ((s / fwhm_major)**2 + (t / fwhm_minor)**2))
-    return g
-
-
 def close_figure(fig: object, savefig: dict | str | None = None,
                  show: bool = False, tight: bool = True) -> None:
     """Save, show, and close the figure.

{plotastrodata-1.8.15 → plotastrodata-1.8.16/plotastrodata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.8.15
+Version: 1.8.16
 Summary: plotastrodata is a tool for astronomers to create figures from FITS files and perform fundamental data analyses with ease.
 Home-page: https://github.com/yusukeaso-astron/plotastrodata
 Download-URL: https://github.com/yusukeaso-astron/plotastrodata