plotastrodata 1.8.14__tar.gz → 1.8.16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.8.14
+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.14 → plotastrodata-1.8.16}/plotastrodata/__init__.py

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

{plotastrodata-1.8.14 → 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.14 → 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.14 → 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.14 → plotastrodata-1.8.16}/plotastrodata/plot_utils.py

@@ -357,6 +357,8 @@ def kwargs2instance(cls: type[T], kw: dict) -> T:
         exkeys = {'fitsimage', 'center'}
     elif cls == Stretcher:
         exkeys = {'vmin', 'vmax'}
+    elif cls == Beam:
+        exkeys = {'beam'}
     keys = vars(cls(**kw0)).keys()
     tmp = {k: kw[k] for k in keys if k in kw}
     for k in keys - exkeys:
@@ -607,19 +609,13 @@ class PlotAstroData(AstroFrame):
                       angle=angle * self.xdir, **_kw)
                 axnow.add_patch(p)
 
-    def add_beam(self, show_beam: bool = True,
-                 beam: list[float | None] = [None] * 3,
-                 beamcolor: str = 'gray',
-                 beampos: list[float, float] | None = None,
-                 **kwargs) -> None:
-        """Use add_region(). All the arguments may be a list of each format.
-
-        Args:
-            show_beam (bool, optional): Defaults to True.
-            beam (list, optional): [bmaj, bmin, bpa]. This may be a list of list. Defaults to [None, None, None].
-            beamcolor (str, optional): matplotlib color. This may be a list of str. Defaults to 'gray'.
-            beampos (list, optional): Relative position. This may be a list of list or a list of None. Defaults to None.
+    def add_beam(self, **kwargs) -> None:
+        """Use add_region(). kwargs may include the arguments of Beam, except for beam_kwargs, to specify the beam apparance. Those arguments may be a list of each format.
         """
+        b = kwargs2instance(Beam, kwargs)
+        show_beam, beamcolor, beampos = b.show_beam, b.beamcolor, b.beampos
+        beam = b.beam
+        del kwargs['beam']
         if not show_beam:
             return
 
@@ -826,7 +822,7 @@ class PlotAstroData(AstroFrame):
                   cbticklabels: list[str] | None = None,
                   cblocation: str = 'right',
                   **kwargs) -> None:
-        """Use Axes.pcolormesh of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include the arguments for Stretcher (stretch, stretchscale, and stretchpower) to specify the stretch parameters. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail. kwargs may include xskiip and yskip.
+        """Use Axes.pcolormesh of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include the arguments for Stretcher (stretch, stretchscale, and stretchpower) to specify the stretch parameters. kwargs may include arguments of Beam; a dict of beam_kwargs specifies the beam patch in more detail. kwargs may include xskiip and yskip.
 
         Args:
             show_cbar (bool, optional): Show color bar. Defaults to True.
@@ -866,7 +862,7 @@ class PlotAstroData(AstroFrame):
     def add_contour(self,
                     levels: list[float] = [-12, -6, -3, 3, 6, 12, 24, 48, 96, 192, 384],
                     **kwargs) -> None:
-        """Use Axes.contour of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail. kwargs may include xskiip and yskip.
+        """Use Axes.contour of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. kwargs may include arguments of Beam; a dict of beam_kwargs specifies the beam patch in more detail. kwargs may include xskiip and yskip.
 
         Args:
             levels (list, optional): Contour levels in the unit of sigma. Defaults to [-12,-6,-3,3,6,12,24,48,96,192,384].
@@ -894,7 +890,7 @@ class PlotAstroData(AstroFrame):
                     rotation: float = 0.,
                     cutoff: float = 3.,
                     **kwargs) -> None:
-        """Use Axes.quiver of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. fitsimage = [ampfits, angfits, Ufits, Qfits]. data = [amp, ang, stU, stQ]. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail. kwargs may include xskiip and yskip.
+        """Use Axes.quiver of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. fitsimage = [ampfits, angfits, Ufits, Qfits]. data = [amp, ang, stU, stQ]. kwargs may include arguments of Beam; a dict of beam_kwargs specifies the beam patch in more detail. kwargs may include xskiip and yskip.
 
         Args:
             ampfits (str, optional): In put fits name. Length of segment. Defaults to None.
@@ -943,23 +939,15 @@ class PlotAstroData(AstroFrame):
         for axnow, unow, vnow in zip(self.ax, U, V):
             axnow.quiver(x, y, unow, vnow, **_kw)
 
-    def add_rgb(self,
-                stretch: list[str] = ['linear'] * 3,
-                stretchscale: list[float | None] = [None] * 3,
-                stretchpower: list[float] = [0.5] * 3,
-                **kwargs) -> None:
-        """Use PIL.Image and imshow of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. A three-element array ([red, green, blue]) is supposed for all arguments, except for xskip, yskip and show_beam, including vmax and vmin. kwargs may include the arguments for Stretcher (stretch, stretchscale, and stretchpower; three-element array for each) to specify the stretch parameters. kwargs may include arguments for add_beam() and a dict of beam_kwargs to specify the beam patch in more detail. kwargs may include xskiip and yskip.
-
-        Args:
-            stretch (str, optional): 'log', 'asinh', 'power', or 'linear'. Any other means 'linear'. 'log' means the mapped data are logarithmic. 'asinh' means the mapped data are arc sin hyperbolic. 'power' means the mapped data are power-law (see also stretchpower). Defaults to 'linear'.
-            stretchscale (float, optional): Color scale is asinh(data / stretchscale). Defaults to None.
-            stretchpower (float, optional): Color scale is data**stretchpower / stretchpower. 1 means the linear scale, while 0 means the logarithmic scale. Defaults to 0.5.
+    def add_rgb(self, **kwargs) -> None:
+        """Use PIL.Image and imshow of matplotlib. kwargs must include the arguments of AstroData to specify the data to be plotted. A three-element array ([red, green, blue]) is supposed for all arguments, including vmax and vmin, except for xskip, yskip and show_beam. kwargs may include the arguments for Stretcher (stretch, stretchscale, and stretchpower; three-element array for each) to specify the stretch parameters. kwargs may include arguments of Beam (three-element arrays); a single dict of beam_kwargs specifies the beam patch in more detail. kwargs may include xskiip and yskip.
         """
         from PIL import Image
 
         self._kw = {'vmin': [None] * 3, 'vmax': [None] * 3,
-                    'stretch': stretch, 'stretchscale': stretchscale,
-                    'stretchpower': stretchpower}
+                    'stretch': ['linear'] * 3,
+                    'stretchscale': [None] * 3,
+                    'stretchpower': [0.5] * 3}
         c, x, y, v, _, _, _kw, singlepix = self._map_init(kwargs)
         if singlepix:
             print('No pixel size. Skip add_rgb.')

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotastrodata
-Version: 1.8.14
+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