plotastrodata 1.9.10__tar.gz → 1.9.12__tar.gz

{plotastrodata-1.9.10/plotastrodata.egg-info → plotastrodata-1.9.12}/PKG-INFO

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

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

{plotastrodata-1.9.10 → plotastrodata-1.9.12}/plotastrodata/analysis_utils.py

@@ -33,18 +33,19 @@ def quadrantmean(data: np.ndarray, x: np.ndarray, y: np.ndarray,
         print('data must be 2D.')
         return
 
-    dx, dy = x[1] - x[0], y[1] - y[0]
-    nx = int(np.floor(max(np.abs(x[0]), np.abs(x[-1])) / dx))
-    ny = int(np.floor(max(np.abs(y[0]), np.abs(y[-1])) / dy))
-    xnew = np.linspace(-nx * dx, nx * dx, 2 * nx + 1)
-    ynew = np.linspace(-ny * dy, ny * dy, 2 * ny + 1)
-    Xnew, Ynew = np.meshgrid(xnew, ynew)
-    if quadrants in ['13', '24']:
-        s = 1 if quadrants == '13' else -1
-        f = RGI((y, s * x), data, bounds_error=False, fill_value=np.nan)
-        datanew = f((Ynew, Xnew))
-    else:
-        print('quadrants must be \'13\' or \'24\'.')
+    if quadrants not in ['13', '24']:
+        print("quadrants must be '13' or '24'.")
+        return
+
+    dx = x[1] - x[0]
+    dy = y[1] - y[0]
+    nx = int(np.ceil(np.max(np.abs(x)) / dx))
+    ny = int(np.ceil(np.max(np.abs(y)) / dy))
+    xnew = np.linspace(-nx, nx, 2 * nx + 1) * dx
+    ynew = np.linspace(-ny, ny, 2 * ny + 1) * dy
+    s = 1 if quadrants == '13' else -1
+    f = RGI((y, s * x), data, bounds_error=False, fill_value=np.nan)
+    datanew = f(np.meshgrid(ynew, xnew, indexing='ij'))
     datanew = (datanew + datanew[::-1, ::-1]) / 2.
     return datanew[ny:, nx:], xnew[nx:], ynew[ny:]
 
@@ -70,12 +71,12 @@ def filled2d(data: np.ndarray, x: np.ndarray, y: np.ndarray, n: int = 1,
 
 
 def _need_multipixels(method):
-    def wrapper(self, *args, **kwargs):
-        singlepixel = self.dx is None or self.dy is None
+    def wrapper(cls, *args, **kwargs):
+        singlepixel = cls.dx is None or cls.dy is None
         if singlepixel:
             print('No pixel size.')
             return
-        return method(self, *args, **kwargs)
+        return method(cls, *args, **kwargs)
     return wrapper
 
 
@@ -140,57 +141,60 @@ class AstroData():
         self.beam_org = None
         self.fitsheader = None
 
-    def binning(self, width: list[int, int, int] = [1, 1, 1]):
+    def _binning_one(self, t: str, width: float):
+        grid = getattr(self, t)
+        if width == 1 or grid is None:
+            return
+
+        dt = f'd{t}'
+        sep = getattr(self, dt)
+        if sep is None:
+            s = f'Skip binning in the {t}-axis because {dt} is None.'
+            warnings.warn(s, UserWarning)
+            return
+
+        i = {'v': 1, 'y': 2, 'x': 3}[t]
+        sizenew = self.size[i] // width
+        self.size[i] = sizenew
+        data = np.moveaxis(self.data, i, 0)
+        datanew = np.moveaxis(np.zeros(self.size), i, 0)
+        gridnew = np.zeros(sizenew)
+        for start in range(width):
+            stop = start + sizenew * width
+            datanew += data[start:stop:width]
+            gridnew += grid[start:stop:width]
+        self.data = np.moveaxis(datanew, 0, i) / width
+        setattr(self, t, gridnew / width)
+        setattr(self, dt, sep * width)
+
+    def binning(self, width: list[int] = [1, 1, 1]):
         """Binning up neighboring pixels in the v, y, and x domain.
 
         Args:
             width (list, optional): Number of channels, y-pixels, and x-pixels for binning. Defaults to [1, 1, 1].
         """
-        w = [1] * (4 - len(width)) + list(width)
+        w = np.array([1] * (3 - len(width)) + list(width), dtype=int)
         if self.pv:
-            w[2] = max(w[1], w[2])
-            w[1] = 1
-        d = to4dim(self.data)
-        size = np.array(np.shape(d))
-        w = np.array(w, dtype=int)
-        if np.any(w > size):
-            w = np.minimum(w, size)
-            ws = ', '.join([f'{s:d}' for s in w[1:]])
+            w[1] = max(w[0], w[1])
+            w[2] = 1
+        self.data = to4dim(self.data)
+        size = np.array(np.shape(self.data))
+        if np.any(w > size[1:]):
+            w = np.minimum(w, size[1:])
+            ws = ', '.join([f'{s:d}' for s in w])
             print(f'width was changed to [{ws}].')
-        newsize = size // w
-        if (not self.pv and w[1] > 1) or (self.pv and w[2] > 1):
-            width_v = w[2] if self.pv else w[1]
+        if (not self.pv and w[0] > 1) or (self.pv and w[1] > 1):
+            width_v = w[1] if self.pv else w[0]
             print(f'sigma has been divided by sqrt({width_v:d})'
                   + ' because of binning in the v-axis.')
             self.sigma = self.sigma / np.sqrt(width_v)
-        if (not self.pv and w[2] > 1) or w[3] > 1:
+        if (not self.pv and w[1] > 1) or w[2] > 1:
             print('Binning in the x- or y-axis does not update sigma.')
-        grid = [None, self.v, self.y, self.x]
-        dgrid = [None, self.dv, self.dy, self.dx]
-        for n in range(1, 4):
-            if w[n] == 1 or grid[n] is None:
-                continue
-            if dgrid[n] is None:
-                t = ['v', 'y', 'x'][n - 1]
-                s = f'Skip binning in the {t}-axis' \
-                    + f' because d{t} is None.'
-                warnings.warn(s, UserWarning)
-                continue
-            size[n] = newsize[n]
-            olddata = np.moveaxis(d, n, 0)
-            newdata = np.moveaxis(np.zeros(size), n, 0)
-            t = np.zeros(newsize[n])
-            for i in range(w[n]):
-                i_stop = i + newsize[n] * w[n]
-                i_step = w[n]
-                t += grid[n][i:i_stop:i_step]
-                newdata += olddata[i:i_stop:i_step]
-            grid[n] = t / w[n]
-            dgrid[n] = dgrid[n] * w[n]
-            d = np.moveaxis(newdata, 0, n) / w[n]
-        self.data = np.squeeze(d)
-        _, self.v, self.y, self.x = grid
-        _, self.dv, self.dy, self.dx = dgrid
+        self.size = size
+        for t, ww in zip(['v', 'y', 'x'], w):
+            self._binning_one(t, ww)
+        self.data = np.squeeze(self.data)
+        del self.size
         if self.pv:
             self.v = self.y
             self.dv = self.dy
@@ -245,16 +249,14 @@ class AstroData():
         nx = len(self.x) if len(self.x) % 2 == 1 else len(self.x) - 1
         ny = len(self.y) if len(self.y) % 2 == 1 else len(self.y) - 1
         y = np.linspace(-(ny-1) / 2, (ny-1) / 2, ny) * np.abs(self.dy)
-        g1 = np.exp(-4*np.log(2) * y**2 / (bmaj**2 - bmin**2))
+        g1 = np.exp(-4 * np.log(2) * y**2 / (bmaj**2 - bmin**2))
         e = np.sqrt(1 - bmin**2 / bmaj**2)
         g1 /= np.sqrt(np.pi / 4 / np.log(2) * bmin * e)
         g = np.zeros((ny, nx))
         g[:, (nx - 1) // 2] = g1
         d = self.data.copy()
         d[np.isnan(d)] = 0
-        d = to4dim(d)
-        d = [[convolve(c, g, mode='same') for c in cc] for cc in d]
-        self.data = np.squeeze(d)
+        self.data = np.squeeze(convolve(to4dim(d), [[g]], mode='same'))
         self.rotate(bpa)
         self.beam[1] = self.beam[0]
         self.beam[2] = 0
@@ -272,8 +274,10 @@ class AstroData():
         self.data = RGIxy(self.y, self.x, self.data, yxnew, **kwargs)
         if None not in self.beam:
             bmaj, bmin, bpa = self.beam
-            a, b = np.linalg.multi_dot([Mfac(1/bmaj, 1/bmin), Mrot(pa-bpa),
-                                        Mfac(1, ci), Mrot(-pa)]).T
+            a, b = np.linalg.multi_dot([Mfac(1 / bmaj, 1 / bmin),
+                                        Mrot(pa - bpa),
+                                        Mfac(1, ci),
+                                        Mrot(-pa)]).T
             alpha = (np.dot(a, a) + np.dot(b, b)) / 2
             beta = np.dot(a, b)
             gamma = (np.dot(a, a) - np.dot(b, b)) / 2
@@ -406,6 +410,21 @@ class AstroData():
         if len(excludepix) == 2:
             self.data[(excludepix[0] < mask) * (mask < excludepix[1])] = np.nan
 
+    def _gfit_profile(self, prof: list, gaussfit: bool):
+        if not gaussfit:
+            return {}
+
+        gfitres = {}
+        nprof = len(prof)
+        res = [None] * nprof
+        for i in range(nprof):
+            res[i] = gaussfit1d(xdata=self.v, ydata=prof[i],
+                                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 gfitres
+
     def profile(self, coords: list[str] = [],
                 xlist: list[float] = [], ylist: list[float] = [],
                 ellipse: list[float, float, float] | None = None,
@@ -430,13 +449,12 @@ class AstroData():
             print('Data must be 3D with the v, y, and x axes.')
             return
 
-        v = self.v
         data, xf, yf = filled2d(self.data, self.x, self.y, ninterp)
         x, y = np.meshgrid(xf, yf)
         if len(coords) > 0:
             xlist, ylist = coord2xy(coords, self.center) * 3600.
         nprof = len(xlist)
-        prof = np.empty((nprof, len(v)))
+        prof = np.empty((nprof, len(self.v)))
         ellipse = ellipse or [[0, 0, 0]] * nprof
         calc = np.sum if flux else np.mean
         for i, (xc, yc, e) in enumerate(zip(xlist, ylist, ellipse)):
@@ -455,16 +473,8 @@ class AstroData():
             else:
                 Omega = np.pi * self.beam[0] * self.beam[1] / 4. / np.log(2.)
                 prof *= np.abs(self.dx * self.dy) / Omega
-        gfitres = {}
-        if gaussfit:
-            res = [None] * nprof
-            for i in range(nprof):
-                res[i] = gaussfit1d(xdata=v, ydata=prof[i],
-                                    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
+        gfitres = self._gfit_profile(prof, gaussfit)
+        return self.v, prof, gfitres
 
     def rotate(self, pa: float = 0, **kwargs):
         """Counter clockwise rotation with respect to the center.
@@ -515,6 +525,31 @@ class AstroData():
              'bunit': self.bunit}
         return d
 
+    def _put_header(self, h: dict, t: str, crpix: int, crval: float,
+                    cdelt: float | None = None) -> None:
+        fhd = self.fitsheader
+        axis = {'x': 1, 'y': 2, 'v': 2 if self.pv else 3}[t]
+        u = f'CUNIT{axis}'
+        indeg = fhd is None or u not in fhd or isdeg(fhd[u])
+        h[f'NAXIS{axis}'] = len(getattr(self, t))
+        h[f'CRPIX{axis}'] = int(crpix)
+        h[f'CRVAL{axis}'] = float(crval)
+        if cdelt is None:
+            cdelt = getattr(self, f'd{t}') / (3600 if indeg else 1)
+        h[f'CDELT{axis}'] = float(cdelt)
+
+    def _get_cvdv_in_freq(self, ck: int) -> tuple[float, float]:
+        cv = self.v[ck]
+        dv = self.dv
+        if self.restfreq is None or self.restfreq == 0:
+            s = 'No valid restfreq. The velocity axis is saved as is.'
+            warnings.warn(s, UserWarning)
+            return cv, dv
+
+        cv = (1 - cv / cu.c_kms) * self.restfreq
+        dv = -dv / cu.c_kms * self.restfreq
+        return cv, dv
+
     @_need_multipixels
     def writetofits(self, fitsimage: str = 'out.fits',
                     header: dict = {}) -> None:
@@ -524,7 +559,6 @@ class AstroData():
             fitsimage (str, optional): Output FITS file name. Defaults to 'out.fits'.
             header (dict, optional): Header dictionary. Defaults to {}.
         """
-        fhd = self.fitsheader
         h = {}
         ci = nearest_index(self.x)
         cx = 0
@@ -536,35 +570,13 @@ class AstroData():
                 xy = [self.x[ci] / 3600, self.y[cj] / 3600]
                 cx, cy = coord2xy(xy2coord(xy, self.center))
 
-        def indeg(s):
-            u = f'CUNIT{s}'
-            return fhd is None or u not in fhd or isdeg(fhd[u])
-
-        h['NAXIS1'] = len(self.x)
-        h['CRPIX1'] = int(ci + 1)
-        h['CRVAL1'] = float(cx)
-        h['CDELT1'] = float(self.dx / (3600 if indeg('1') else 1))
+        self._put_header(h, 'x', crpix=ci + 1, crval=cx)
+        if not self.pv:
+            self._put_header(h, 'y', crpix=cj + 1, crval=cy)
         if self.dv is not None:
-            vaxis = '2' if self.pv else '3'
             ck = nearest_index(self.v)
-            cv = self.v[ck]
-            dv = self.dv
-            if self.restfreq is None or self.restfreq == 0:
-                s = 'No valid restfreq.' \
-                    + f' Axis {vaxis} is saved as is.'
-                warnings.warn(s, UserWarning)
-            else:
-                cv = (1 - cv / cu.c_kms) * self.restfreq
-                dv = -dv / cu.c_kms * self.restfreq
-            h[f'NAXIS{vaxis}'] = len(self.v)
-            h[f'CRPIX{vaxis}'] = int(ck + 1)
-            h[f'CRVAL{vaxis}'] = float(cv)
-            h[f'CDELT{vaxis}'] = float(dv)
-        if not self.pv:
-            h['NAXIS2'] = len(self.y)
-            h['CRPIX2'] = int(cj + 1)
-            h['CRVAL2'] = float(cy)
-            h['CDELT2'] = float(self.dy / (3600 if indeg('2') else 1))
+            cv, dv = self._get_cvdv_in_freq(ck)
+            self._put_header(h, 'v', crpix=ck + 1, crval=cv, cdelt=dv)
         if None not in self.beam:
             beam = self.beam_org if self.pv else self.beam
             h['BMAJ'] = float(beam[0] / 3600)

{plotastrodata-1.9.10 → plotastrodata-1.9.12}/plotastrodata/coord_utils.py

@@ -3,7 +3,7 @@ from astropy import units
 from astropy.coordinates import FK4, FK5, SkyCoord
 
 
-def _updateframe(frame: str) -> str:
+def _updateframe(frame: str | None) -> str:
     """Internal function to str frame to astropy frame.
 
     Args:

{plotastrodata-1.9.10 → plotastrodata-1.9.12}/plotastrodata/fft_utils.py

@@ -11,7 +11,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 +27,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 +39,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 +47,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 +57,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 +79,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 +91,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 +154,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,7 +197,10 @@ 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

{plotastrodata-1.9.10 → plotastrodata-1.9.12}/plotastrodata/fits_utils.py

@@ -376,7 +376,7 @@ def fits2data(fitsimage: str, Tb: bool = False, log: bool = False,
               restfreq: float | None = None, center: str | None = None,
               vsys: float = 0., pv: bool = False, **kwargs
               ) -> tuple[np.ndarray, tuple[np.ndarray, np.ndarray, np.ndarray],
-                         tuple[float, float, float], float, float]:
+                         np.ndarray, str, float]:
     """Extract data from a fits file. kwargs are arguments of FitsData.trim().
 
     Args:

{plotastrodata-1.9.10 → plotastrodata-1.9.12}/plotastrodata/fitting_utils.py

@@ -281,6 +281,29 @@ class EmceeCorner():
                 ax.set_xlabel('Step')
         close_figure(fig, savefig, show)
 
+    def _set_results_posteriorongrid(self) -> None:
+        p = self.p
+        p1d = self.p1d
+        pargrid = self.pargrid
+        if np.all(p == 0):
+            print('All posterior is below pcut.')
+            self.popt = np.full(self.dim, np.nan)
+            self.plow = np.full(self.dim, np.nan)
+            self.pmid = np.full(self.dim, np.nan)
+            self.phigh = np.full(self.dim, np.nan)
+        else:
+            i_max = np.unravel_index(np.argmax(p), np.shape(p))[::-1]
+            self.popt = np.array([p[i] for p, i in zip(pargrid, i_max)])
+
+            def getpercentile(percent: float):
+                a = [np.percentile(g, percent, method='inverted_cdf', weights=p)
+                     for g, p in zip(pargrid, p1d)]
+                return np.array(a)
+
+            self.plow = getpercentile(self.percent[0])
+            self.pmid = getpercentile(50)
+            self.phigh = getpercentile(self.percent[1])
+
     def posteriorongrid(self, ngrid: list[int] | int = 100,
                         log: list[bool] | bool = False, pcut: float = 0):
         """Calculate the posterior on a grid of ngrid x ngrid x ... x ngrid.
@@ -297,8 +320,8 @@ class EmceeCorner():
         pargrid = []
         inzip = [self.bounds[:, 0], self.bounds[:, 1], ngrid, log]
         for start, stop, num, uselog in zip(*inzip):
-            args = [start, stop, num]
-            pargrid.append(np.geomspace(*args) if uselog else np.linspace(*args))
+            spacer = np.geomspace if uselog else np.linspace
+            pargrid.append(spacer(start, stop, num))
         p = np.exp(self.logl(np.meshgrid(*pargrid[::-1], indexing='ij')[::-1]))
         p[p < pcut] = 0
         dpar = []
@@ -309,33 +332,74 @@ class EmceeCorner():
             else:
                 dpar.append(pg * 0 + pg[1] - pg[0])
         vol = np.prod(np.meshgrid(*dpar[::-1], indexing='ij')[::-1], axis=0)
-        adim = np.arange(self.dim)
-        axlist = [tuple(np.delete(adim, i)) for i in adim[::-1]]  # adim[::-1] is becuase the 0th parameter is the innermost axis.
+        arrdim = np.arange(self.dim)
+        arrdim_r = arrdim[::-1]
+        # arrdim[::-1] is becuase the 0th parameter is the innermost axis.
+        axlist = [tuple(np.delete(arrdim, i)) for i in arrdim_r]
         p1d = [np.sum(p * vol, axis=a) / np.sum(vol, axis=a) for a in axlist]
         evidence = np.sum(p * vol) / np.sum(vol)
-        if np.all(p == 0):
-            print('All posterior is below pcut.')
-            self.popt = np.full(self.dim, np.nan)
-            self.plow = np.full(self.dim, np.nan)
-            self.pmid = np.full(self.dim, np.nan)
-            self.phigh = np.full(self.dim, np.nan)
-        else:
-            i_max = np.unravel_index(np.argmax(p), np.shape(p))[::-1]
-            self.popt = np.array([p[i] for p, i in zip(pargrid, i_max)])
-
-            def getpercentile(percent: float):
-                a = [np.percentile(g, percent, method='inverted_cdf', weights=p)
-                     for g, p in zip(pargrid, p1d)]
-                return np.array(a)
-
-            self.plow = getpercentile(self.percent[0])
-            self.pmid = getpercentile(50)
-            self.phigh = getpercentile(self.percent[1])
         self.p = p
         self.p1d = p1d
         self.pargrid = pargrid
         self.vol = vol
         self.evidence = evidence
+        self.arrdim = arrdim
+        self.arrdim_r = arrdim_r
+        self._set_results_posteriorongrid()
+
+    def _i_eq_j(self, fig, ax, i: int, k: int) -> None:
+        x = self.pargrid
+        y = self.p1d
+        s0 = self.pmid[i]
+        s1 = self.phigh[i] - self.pmid[i]
+        s2 = self.pmid[i] - self.plow[i]
+        s0 = f'{s0:.2f}'
+        s1 = '^{+' + f'{s1:.2f}' + '}'
+        s2 = '_{-' + f'{s2:.2f}' + '}'
+        s0 = s0 + s1 + s2
+        ax[k] = fig.add_subplot(self.dim, self.dim, k + 1)
+        ax[k].plot(x[i], y[i], 'k-', drawstyle='steps-mid')
+        ax[k].axvline(self.popt[i])
+        ax[k].axvline(self.plow[i], linestyle='--', color='k')
+        ax[k].axvline(self.pmid[i], linestyle='--', color='k')
+        ax[k].axvline(self.phigh[i], linestyle='--', color='k')
+        ax[k].set_title(rf'{self.labels[i]}=${s0}$')
+        ax[k].set_xlim(self.cornerrange[i])
+        ax[k].set_ylim([0, np.max(y[i]) * 1.2])
+        ax[k].set_yticks([])
+        if i == self.dim - 1:
+            plt.setp(ax[k].get_xticklabels(), rotation=45)
+            ax[k].set_xlabel(self.labels[i])
+        else:
+            plt.setp(ax[k].get_xticklabels(), visible=False)
+
+    def _i_neq_j(self, fig, ax, i: int, j: int, k: int) -> None:
+        x = self.pargrid
+        sharex = ax[self.dim * (i - 1) + j]
+        sharey = ax[self.dim * i + (j - 1)] if j > 1 else None
+        ax[k] = fig.add_subplot(self.dim, self.dim, k + 1,
+                                sharex=sharex, sharey=sharey)
+        axis = tuple(np.delete(self.arrdim_r, [i, j]))
+        yy = np.sum(self.p * self.vol, axis=axis) \
+            / np.sum(self.vol, axis=axis)
+        ax[k].pcolormesh(x[j], x[i], yy, cmap=self.cmap)
+        ax[k].contour(x[j], x[i], yy, colors='k',
+                      levels=self.levels * np.nanmax(yy))
+        ax[k].plot(self.popt[j], self.popt[i], 'o')
+        ax[k].axvline(self.popt[j])
+        ax[k].axhline(self.popt[i])
+        ax[k].set_xlim(self.cornerrange[j])
+        ax[k].set_ylim(self.cornerrange[i])
+        if j == 0:
+            ax[k].set_ylabel(self.labels[i])
+            plt.setp(ax[k].get_yticklabels(), rotation=45)
+        else:
+            plt.setp(ax[k].get_yticklabels(), visible=False)
+        if i == self.dim - 1:
+            ax[k].set_xlabel(self.labels[j])
+            plt.setp(ax[k].get_xticklabels(), rotation=45)
+        else:
+            plt.setp(ax[k].get_xticklabels(), visible=False)
 
     def plotongrid(self, show: bool = False, savefig: str | None = None,
                    labels: list[str] = None,
@@ -352,70 +416,30 @@ class EmceeCorner():
             cmap: (str, optional): cmap for matplotlib.pyplot.plt.pcolormesh(). Defaults to 'binary'.
             levels: (list, optional): levels for matplotlib.pyplot.plt.contour() relative to the peak. Defaults to [exp(-0.5*3^2), exp(-0.5*2^2), exp(-0.5*1^2)].
         """
-        adim = np.arange(self.dim)
         if labels is None:
-            labels = [f'Par {i:d}' for i in adim]
+            labels = [f'Par {i:d}' for i in self.arrdim]
         if cornerrange is None:
             cornerrange = self.bounds
-        x = self.pargrid
-        y = self.p1d
+        self.labels = labels
+        self.cornerrange = cornerrange
+        self.cmap = cmap
+        self.levels = np.array(levels)
         fig = plt.figure(figsize=(2 * self.dim * 1.2, 2 * self.dim * 1.2))
         fig.subplots_adjust(hspace=0.05, wspace=0.05, top=0.87, right=0.87)
         ax = np.empty(self.dim * self.dim, dtype='object')
-        for i in adim:
-            for j in adim:
+        for i in self.arrdim:
+            for j in self.arrdim:
                 if i < j:
                     continue
                 k = self.dim * i + j
                 if i == j:
-                    s0 = self.pmid[i]
-                    s1 = self.phigh[i] - self.pmid[i]
-                    s2 = self.pmid[i] - self.plow[i]
-                    s0 = f'{s0:.2f}'
-                    s1 = '^{+' + f'{s1:.2f}' + '}'
-                    s2 = '_{-' + f'{s2:.2f}' + '}'
-                    s0 = s0 + s1 + s2
-                    ax[k] = fig.add_subplot(self.dim, self.dim, k + 1)
-                    ax[k].plot(x[i], y[i], 'k-', drawstyle='steps-mid')
-                    ax[k].axvline(self.popt[i])
-                    ax[k].axvline(self.plow[i], linestyle='--', color='k')
-                    ax[k].axvline(self.pmid[i], linestyle='--', color='k')
-                    ax[k].axvline(self.phigh[i], linestyle='--', color='k')
-                    ax[k].set_title(rf'{labels[i]}=${s0}$')
-                    ax[k].set_xlim(cornerrange[i])
-                    ax[k].set_ylim([0, np.max(y[i]) * 1.2])
-                    ax[k].set_yticks([])
-                    if i == self.dim - 1:
-                        plt.setp(ax[k].get_xticklabels(), rotation=45)
-                        ax[k].set_xlabel(labels[i])
-                    else:
-                        plt.setp(ax[k].get_xticklabels(), visible=False)
+                    self._i_eq_j(fig, ax, i, k)
                 else:
-                    sharex = ax[self.dim * (i - 1) + j]
-                    sharey = ax[self.dim * i + (j - 1)] if j > 1 else None
-                    ax[k] = fig.add_subplot(self.dim, self.dim, k + 1,
-                                            sharex=sharex, sharey=sharey)
-                    axis = tuple(np.delete(adim[::-1], [i, j]))
-                    yy = np.sum(self.p * self.vol, axis=axis) \
-                        / np.sum(self.vol, axis=axis)
-                    ax[k].pcolormesh(x[j], x[i], yy, cmap=cmap)
-                    ax[k].contour(x[j], x[i], yy, colors='k',
-                                  levels=np.array(levels) * np.nanmax(yy))
-                    ax[k].plot(self.popt[j], self.popt[i], 'o')
-                    ax[k].axvline(self.popt[j])
-                    ax[k].axhline(self.popt[i])
-                    ax[k].set_xlim(cornerrange[j])
-                    ax[k].set_ylim(cornerrange[i])
-                    if j == 0:
-                        ax[k].set_ylabel(labels[i])
-                        plt.setp(ax[k].get_yticklabels(), rotation=45)
-                    else:
-                        plt.setp(ax[k].get_yticklabels(), visible=False)
-                    if i == self.dim - 1:
-                        ax[k].set_xlabel(labels[j])
-                        plt.setp(ax[k].get_xticklabels(), rotation=45)
-                    else:
-                        plt.setp(ax[k].get_xticklabels(), visible=False)
+                    self._i_neq_j(fig, ax, i, j, k)
+        del self.labels
+        del self.cornerrange
+        del self.cmap
+        del self.levels
         close_figure(fig, savefig, show, tight=False)
 
     def getDNSevidence(self, **kwargs):

{plotastrodata-1.9.10 → plotastrodata-1.9.12}/plotastrodata/noise_utils.py

@@ -74,7 +74,7 @@ def select_noise(data: np.ndarray, sigma: str) -> np.ndarray:
     Returns:
         np.ndarray: 1D array that includes only the selected pixels.
     """
-    n = np.array(data) * 1
+    n = np.array(data).copy()
     if 'edge' in sigma:
         if np.ndim(n) <= 2:
             print('\'edge\' is ignored because ndim <= 2.')
@@ -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.10 → plotastrodata-1.9.12/plotastrodata.egg-info}/PKG-INFO

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