plotastrodata 1.9.11__tar.gz → 1.9.13__tar.gz

{plotastrodata-1.9.11/plotastrodata.egg-info → plotastrodata-1.9.13}/PKG-INFO

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

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

{plotastrodata-1.9.11 → plotastrodata-1.9.13}/plotastrodata/analysis_utils.py

@@ -3,6 +3,7 @@ import warnings
 from dataclasses import dataclass
 from scipy.interpolate import RegularGridInterpolator as RGI
 from scipy.signal import convolve
+from typing import Callable
 
 from plotastrodata import const_utils as cu
 from plotastrodata.coord_utils import coord2xy, rel2abs, xy2coord
@@ -290,7 +291,7 @@ class AstroData():
             self.beam = np.array([bmaj_new, bmin_new, bpa_new])
 
     @_need_multipixels
-    def fit2d(self, model: object, bounds: np.ndarray,
+    def fit2d(self, model: Callable, bounds: np.ndarray,
               progressbar: bool = False,
               kwargs_fit: dict = {}, kwargs_plotcorner: dict = {},
               chan: int | None = None):

{plotastrodata-1.9.11 → plotastrodata-1.9.13}/plotastrodata/fft_utils.py

@@ -1,5 +1,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
+from typing import Callable
 
 from plotastrodata.fits_utils import fits2data
 from plotastrodata.other_utils import close_figure
@@ -11,7 +12,7 @@ def shiftphase(F: np.ndarray, u: np.ndarray,
 
     Args:
         F (np.ndarray): 1D FFT.
-        u (np.ndarray): 1D array. The first frequency coordinate.
+        u (np.ndarray): 1D array. The frequency coordinate.
         xoff (float): From old to new center. Defaults to 0.
 
     Returns:
@@ -27,7 +28,7 @@ def shiftphase2(F: np.ndarray, u: np.ndarray, v: np.ndarray,
     Args:
         F (np.ndarray): 2D FFT.
         u (np.ndarray): 1D or 2D array. The first frequency coordinate.
-        v (np.ndarray): 1D or 2D array. The second frequency coordinate. Defaults to None.
+        v (np.ndarray): 1D or 2D array. The second frequency coordinate.
         xoff (float): From old to new center. Defaults to 0.
         yoff (float): From old to new center. Defaults to 0.
 
@@ -39,7 +40,7 @@ def shiftphase2(F: np.ndarray, u: np.ndarray, v: np.ndarray,
 
 
 def fftcentering(f: np.ndarray, x: np.ndarray | None = None,
-                 xcenter: float = 0
+                 xcenter: float = 0, rfft: bool = False
                  ) -> tuple[np.ndarray, np.ndarray]:
     """FFT with the phase referring to a specific point.
 
@@ -47,6 +48,7 @@ def fftcentering(f: np.ndarray, x: np.ndarray | None = None,
         f (np.ndarray): 1D array for FFT.
         x (np.ndarray, optional): 1D array. The spatial coordinate. Defaults to None.
         xcenter (float, optional): x of phase reference. Defaults to 0.
+        rfft (bool, optional): True means using rFFT. Defaults to False.
 
     Returns:
         tuple: (F, u). F is FFT of f. u is a 1D array of the frequency coordinate.
@@ -56,15 +58,19 @@ def fftcentering(f: np.ndarray, x: np.ndarray | None = None,
         x = np.arange(nx)
     X = x[0, :] if np.ndim(x) == 2 else x
     dx = X[1] - X[0]
-    u = np.fft.fftshift(np.fft.fftfreq(nx, d=dx))
-    F = np.fft.fftshift(np.fft.fft(f))
+    if rfft:
+        u = np.fft.rfftfreq(nx, d=dx)
+        F = np.fft.rfft(f)
+    else:
+        u = np.fft.fftshift(np.fft.fftfreq(nx, d=dx))
+        F = np.fft.fftshift(np.fft.fft(f))
     F = shiftphase(F, u=u, xoff=xcenter - X[0])
     return F, u
 
 
 def fftcentering2(f: np.ndarray,
                   x: np.ndarray | None = None, y: np.ndarray | None = None,
-                  xcenter: float = 0, ycenter: float = 0
+                  xcenter: float = 0, ycenter: float = 0, rfft: bool = False
                   ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """FFT with the phase referring to a specific point.
 
@@ -74,6 +80,7 @@ def fftcentering2(f: np.ndarray,
         y (np.ndarray, optional): 1D or 2D array. The second spatial coordinate. Defaults to None.
         xcenter (float, optional): x of phase reference. Defaults to 0.
         ycenter (float, optional): y of phase reference. Defaults to 0.
+        rfft (bool, optional): True means using rFFT. Defaults to False.
 
     Returns:
         tuple: (F, u, v). F is FFT of f. u and v are 1D arrays of the frequency coordinates.
@@ -85,39 +92,60 @@ def fftcentering2(f: np.ndarray,
         y = np.arange(ny)
     X = x[0, :] if np.ndim(x) == 2 else x
     Y = y[:, 0] if np.ndim(y) == 2 else y
-    dx, dy = X[1] - X[0], Y[1] - Y[0]
-    u = np.fft.fftshift(np.fft.fftfreq(nx, d=dx))
-    v = np.fft.fftshift(np.fft.fftfreq(ny, d=dy))
-    F = np.fft.fftshift(np.fft.fft2(f))
+    dx = X[1] - X[0]
+    dy = Y[1] - Y[0]
+    if rfft:
+        u = np.fft.rfftfreq(nx, d=dx)
+        v = np.fft.fftshift(np.fft.fftfreq(ny, d=dy))
+        F = np.fft.fftshift(np.fft.rfft2(f), axes=0)
+    else:
+        u = np.fft.fftshift(np.fft.fftfreq(nx, d=dx))
+        v = np.fft.fftshift(np.fft.fftfreq(ny, d=dy))
+        F = np.fft.fftshift(np.fft.fft2(f))
     F = shiftphase2(F, u, v, xcenter - X[0], ycenter - Y[0])
     return F, u, v
 
 
 def ifftcentering(F: np.ndarray, u: np.ndarray | None = None,
-                  xcenter: float = 0,
-                  x0: float = None,
-                  outreal: bool = True
+                  xcenter: float = 0, x0: float = None,
+                  dx: float = 1,
+                  outreal: bool = False, rfft: bool = False
                   ) -> tuple[np.ndarray, np.ndarray]:
     """inverse FFT with the phase referring to a specific point.
 
     Args:
-        F (np.ndarray): 1D array. A result of FFT.
+        F (np.ndarray): 1D array. An FFT result in the frequency domain.
         u (np.ndarray, optional): 1D array. The frequency coordinate. Defaults to None.
         xcenter (float, optional): x of phase reference (used in fftcentering). Defaults to 0.
         x0 (float, optional): spatial coordinate of x[0]. Defaults to None.
-        outreal (bool, optional): whether output only the real part. Defaults to True.
+        dx (float, optional): spatial interval. Defaults to 1.
+        outreal (bool, optional): whether output only the real part. Defaults to False.
+        rfft (bool, optional): True means using rFFT. Defaults to False.
 
     Returns:
         tuple: (f, x). f is iFFT of F. x is a 1D array of the spatial coordinate.
     """
     nx = np.shape(F)[0]
     if u is None:
-        u = np.fft.fftshift(np.fft.fftfreq(nx, d=1))
+        if rfft:
+            nx = 2 * (nx - 1)  # Follow numpy.fft.irfft behavior.
+            u = np.fft.rfftfreq(nx, d=dx)
+        else:
+            u = np.fft.fftshift(np.fft.fftfreq(nx, d=dx))
+    else:
+        if rfft:
+            if np.isclose(u[-1], 1 / (2 * dx)):
+                nx = 2 * (nx - 1)
+            else:
+                nx = 2 * (nx - 1) + 1
     x = (np.arange(nx) - (nx-1)/2.) / (u[1]-u[0]) / nx + xcenter
     if x0 is not None:
         x = x - x[0] + x0
     F = shiftphase(F, u=u, xoff=x[0] - xcenter)
-    f = np.fft.ifft(np.fft.ifftshift(F))
+    if rfft:
+        f = np.fft.irfft(F, n=nx)
+    else:
+        f = np.fft.ifft(np.fft.ifftshift(F))
     if outreal:
         f = np.real(f)
     return f, x
@@ -127,28 +155,42 @@ def ifftcentering2(F: np.ndarray,
                    u: np.ndarray | None = None, v: np.ndarray | None = None,
                    xcenter: float = 0, ycenter: float = 0,
                    x0: float | None = None, y0: float | None = None,
-                   outreal: bool = True
+                   dx: float = 1, dy: float = 1,
+                   outreal: bool = False, rfft: bool = False
                    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """inverse FFT with the phase referring to a specific point.
 
     Args:
-        F (np.ndarray): 2D array. A result of FFT.
+        F (np.ndarray): 2D array. An FFT result in the frequency domain.
         u (np.ndarray, optional): 1D or 2D array. The first frequency coordinate. Defaults to None.
         v (np.ndarray, optional): 1D or 2D array. The second frequency cooridnate. Defaults to None.
         xcenter (float, optional): x of phase reference (used in fftcentering2). Defaults to 0.
         ycenter (float, optional): y of phase reference (used in fftcentering2). Defaults to 0.
         x0 (float, optional): spatial coordinate of x[0]. Defaults to None.
         y0 (float, optional): spatial coordinate of y[0]. Defaults to None.
-        outreal (bool, optional): whether output only the real part. Defaults to True.
+        dx (float, optional): spatial interval. Defaults to 1.
+        dy (float, optional): spatial interval. Defaults to 1.
+        outreal (bool, optional): whether output only the real part. Defaults to False.
+        rfft (bool, optional): True means using rFFT. Defaults to False.
 
     Returns:
         tuple: (f, x, y). f is iFFT of F. x and y are 1D arrays of the spatial coordinates.
     """
     ny, nx = np.shape(F)
     if u is None:
-        u = np.fft.fftshift(np.fft.fftfreq(nx, d=1))
+        if rfft:
+            nx = 2 * (nx - 1)  # Follow numpy.fft.irfft behavior.
+            u = np.fft.rfftfreq(nx, d=dx)
+        else:
+            u = np.fft.fftshift(np.fft.fftfreq(nx, d=dy))
+    else:
+        if rfft:
+            if np.isclose(u[-1], 1 / (2 * dx)):
+                nx = 2 * (nx - 1)
+            else:
+                nx = 2 * (nx - 1) + 1
     if v is None:
-        v = np.fft.fftshift(np.fft.fftfreq(ny, d=1))
+        v = np.fft.fftshift(np.fft.fftfreq(ny, d=dy))
     x = (np.arange(nx) - (nx-1)/2.) / (u[1]-u[0]) / nx + xcenter
     y = (np.arange(ny) - (ny-1)/2.) / (v[1]-v[0]) / ny + ycenter
     if x0 is not None:
@@ -156,12 +198,110 @@ def ifftcentering2(F: np.ndarray,
     if y0 is not None:
         y = y - y[0] + y0
     F = shiftphase2(F, u, v, x[0] - xcenter, y[0] - ycenter)
-    f = np.fft.ifft2(np.fft.ifftshift(F))
+    if rfft:
+        f = np.fft.irfft2(np.fft.ifftshift(F, axes=0), s=(ny, nx))
+    else:
+        f = np.fft.ifft2(np.fft.ifftshift(F))
     if outreal:
         f = np.real(f)
     return f, x, y
 
 
+class FftCentering():
+    """Set FFT conditions and functions.
+
+    Args:
+        x (np.ndarray): 1D array.
+        y (np.ndarray, optional): 1D array. Defaults to None.
+        xcenter (float, optional): x of phase reference. Defaults to 0.
+        ycenter (float, optional): y of phase reference. Defaults to 0.
+        rfft (bool, optional): True means using rFFT. Defaults to False.
+    """
+    def __init__(self, x: np.ndarray,
+                 y: np.ndarray | None = None,
+                 xcenter: float = 0,
+                 ycenter: float = 0,
+                 rfft: bool = False):
+        nx = len(x)
+        self.x = x
+        self.dx = dx = x[1] - x[0]
+        self.xcenter = xcenter
+        self.ndim = 2 if isinstance(y, np.ndarray) else 1
+        self.rfft = rfft
+        if rfft:
+            u = np.fft.rfftfreq(nx, d=dx)
+        else:
+            u = np.fft.fftshift(np.fft.fftfreq(nx, d=dx))
+        self.u = u
+        if self.ndim == 2:
+            ny = len(y)
+            self.y = y
+            self.dy = dy = y[1] - y[0]
+            self.ycenter = ycenter
+            v = np.fft.fftshift(np.fft.fftfreq(ny, d=dy))
+            self.v = v
+
+    def fft(self, f: np.ndarray | None = None
+            ) -> np.ndarray | Callable:
+        """FFT calculation done by considering 1D/2D and fft/rfft.
+
+        Args:
+            f (np.ndarray | None, optional): 1D or 2D array. Defaults to None.
+
+        Returns:
+            np.ndarray: FFT result. When f is None, the return is the FFT function.
+        """
+        if self.ndim == 1:
+            def func(f: np.ndarray):
+                F, _ = fftcentering(f=f, x=self.x,
+                                    xcenter=self.xcenter,
+                                    rfft=self.rfft)
+                return F
+
+        else:
+            def func(f: np.ndarray):
+                F, _, _ = fftcentering2(f=f, x=self.x, y=self.y,
+                                        xcenter=self.xcenter,
+                                        ycenter=self.ycenter,
+                                        rfft=self.rfft)
+                return F
+
+        return func if f is None else func(f)
+
+    def ifft(self, F: np.ndarray | None = None, outreal: bool = False
+             ) -> np.ndarray | Callable:
+        """iFFT calculation done by considering 1D/2D and fft/rfft.
+
+        Args:
+            F (np.ndarray | None, optional): An FFT result. Defaults to None.
+
+        Returns:
+            np.ndarray: iFFT result. When F is None, the return is the iFFT function.
+        """
+        if self.ndim == 1:
+            def func(F: np.ndarray):
+                f, _ = ifftcentering(F=F, u=self.u,
+                                     xcenter=self.xcenter,
+                                     x0=self.x[0],
+                                     dx=self.dx,
+                                     outreal=outreal,
+                                     rfft=self.rfft)
+                return f
+
+        else:
+            def func(F: np.ndarray):
+                f, _, _ = ifftcentering2(F=F, u=self.u, v=self.v,
+                                         xcenter=self.xcenter,
+                                         ycenter=self.ycenter,
+                                         x0=self.x[0], y0=self.y[0],
+                                         dx=self.dx, dy=self.dy,
+                                         outreal=outreal,
+                                         rfft=self.rfft)
+                return f
+
+        return func if F is None else func(F)
+
+
 def zeropadding(f: np.ndarray, x: np.ndarray, y: np.ndarray,
                 xlim: list, ylim: list
                 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:

{plotastrodata-1.9.11 → plotastrodata-1.9.13}/plotastrodata/fitting_utils.py

@@ -7,6 +7,7 @@ import warnings
 from dynesty import DynamicNestedSampler as DNS
 from multiprocessing import Pool
 from tqdm import tqdm
+from typing import Callable
 
 from plotastrodata.matrix_utils import Mrot, dot2d
 from plotastrodata.other_utils import close_figure
@@ -63,8 +64,8 @@ def _check_GR(samples: np.ndarray, nwalkers: int, ndata: int, dim: int,
 class EmceeCorner():
     warnings.simplefilter('ignore', RuntimeWarning)
 
-    def __init__(self, bounds: np.ndarray, logl: object | None = None,
-                 model: object | None = None,
+    def __init__(self, bounds: np.ndarray, logl: Callable | None = None,
+                 model: Callable | None = None,
                  xdata: np.ndarray | None = None,
                  ydata: np.ndarray | None = None,
                  sigma: np.ndarray = 1, progressbar: bool = False,
@@ -111,7 +112,8 @@ class EmceeCorner():
 
     def _run_sampler(self, pos0: np.ndarray, pt: bool,
                      ncores: int, ntemps: int,
-                     nsteps: int, nwalkers: int) -> object:
+                     nsteps: int, nwalkers: int
+                     ) -> ptemcee.Sampler | emcee.EnsembleSampler:
         """Create and run the sampler, then return it."""
         if pt:
             sampler_cls = ptemcee.Sampler

{plotastrodata-1.9.11 → plotastrodata-1.9.13}/plotastrodata/noise_utils.py

@@ -215,6 +215,6 @@ def estimate_rms(data: np.ndarray,
         ave = n.m0
         noise = n.s0
     if np.abs(ave) > 0.2 * noise:
-        s = 'Mean > 0.2 x standard deviation.'
+        s = '|mean| > 0.2sigma.'
         warnings.warn(s, UserWarning)
     return noise

{plotastrodata-1.9.11 → plotastrodata-1.9.13}/plotastrodata/other_utils.py

@@ -3,6 +3,7 @@ import numbers
 import numpy as np
 import warnings
 from scipy.interpolate import RegularGridInterpolator as RGI
+from typing import Callable
 
 
 def listing(*args) -> list:
@@ -217,7 +218,7 @@ def reform_data(c: np.ndarray, v_in: np.ndarray | None,
 
 def RGIxy(y: np.ndarray, x: np.ndarray, data: np.ndarray,
           yxnew: tuple[np.ndarray, np.ndarray] | None = None,
-          **kwargs) -> object | np.ndarray:
+          **kwargs) -> Callable | np.ndarray:
     """RGI for x and y at each channel.
 
     Args:
@@ -252,7 +253,7 @@ def RGIxy(y: np.ndarray, x: np.ndarray, data: np.ndarray,
 
 def RGIxyv(v: np.ndarray, y: np.ndarray, x: np.ndarray, data: np.ndarray,
            vyxnew: tuple[np.ndarray, np.ndarray, np.ndarray] | None = None,
-           **kwargs) -> object | np.ndarray:
+           **kwargs) -> Callable | np.ndarray:
     """RGI in the x-y-v space.
 
     Args:

{plotastrodata-1.9.11 → plotastrodata-1.9.13}/plotastrodata/plot_utils.py

@@ -3,7 +3,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 from dataclasses import dataclass
 from matplotlib.patches import Ellipse, Rectangle
-from typing import TypeVar
+from typing import TypeVar, Callable
 
 from plotastrodata.analysis_utils import AstroData, AstroFrame
 from plotastrodata.coord_utils import (coord2xy, xy2coord,
@@ -162,13 +162,13 @@ def _get_v(p, v: np.ndarray | None = None,
     return v
 
 
-def _get_nij2ch(nrows: int = 1, ncols: int = 1) -> object:
+def _get_nij2ch(nrows: int = 1, ncols: int = 1) -> Callable:
     def nij2ch(n: int, i: int, j: int) -> int:
         return n*nrows*ncols + i*ncols + j
     return nij2ch
 
 
-def _get_ch2nij(nrows: int = 1, ncols: int = 1) -> object:
+def _get_ch2nij(nrows: int = 1, ncols: int = 1) -> Callable:
     def ch2nij(ch: int) -> tuple[int, int, int]:
         n = ch // (nrows*ncols)
         i = (ch - n*nrows*ncols) // ncols
@@ -178,7 +178,7 @@ def _get_ch2nij(nrows: int = 1, ncols: int = 1) -> object:
 
 
 def _get_vskipfill(nv: float, v_org: np.ndarray, vskip: int,
-                   channelnumber: int) -> object:
+                   channelnumber: int) -> Callable:
     def vskipfill(c: np.ndarray, v_in: np.ndarray) -> np.ndarray:
         c = reform_data(c=c, v_in=v_in, nv=nv, v_org=v_org, vskip=vskip)
         if isinstance(channelnumber, int):

{plotastrodata-1.9.11 → plotastrodata-1.9.13/plotastrodata.egg-info}/PKG-INFO

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