plotastrodata 1.3.2__tar.gz → 1.4.1__tar.gz

{plotastrodata-1.3.2 → plotastrodata-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plotastrodata
-Version: 1.3.2
+Version: 1.4.1
 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.3.2 → plotastrodata-1.4.1}/plotastrodata/__init__.py

@@ -1,4 +1,4 @@
 import warnings
 
 warnings.simplefilter('ignore', UserWarning)
-__version__ = '1.3.2'
+__version__ = '1.4.1'

{plotastrodata-1.3.2 → plotastrodata-1.4.1}/plotastrodata/analysis_utils.py

@@ -4,31 +4,16 @@ from scipy.interpolate import RegularGridInterpolator as RGI
 from scipy.optimize import curve_fit
 from scipy.signal import convolve
 
-from plotastrodata.other_utils import (coord2xy, rel2abs, estimate_rms, trim,
-                                       isdeg, Mfac, Mrot, dot2d, gaussian2d)
+from plotastrodata.coord_utils import coord2xy, rel2abs
+from plotastrodata.matrix_utils import Mfac, Mrot, dot2d
+from plotastrodata.other_utils import (estimate_rms, trim,
+                                       gaussian2d, isdeg,
+                                       RGIxy, RGIxyv, to4dim)
 from plotastrodata.fits_utils import FitsData, data2fits, Jy2K
 from plotastrodata import const_utils as cu
 from plotastrodata.fitting_utils import EmceeCorner
 
 
-def to4dim(data: np.ndarray) -> np.ndarray:
-    """Change a 2D, 3D, or 4D array to a 4D array.
-
-    Args:
-        data (np.ndarray): Input data. 2D, 3D, or 4D.
-
-    Returns:
-        np.ndarray: Output 4D array.
-    """
-    if np.ndim(data) == 2:
-        d = np.array([[data]])
-    elif np.ndim(data) == 3:
-        d = np.array([data])
-    else:
-        d = np.array(data)
-    return d
-
-
 def quadrantmean(data: np.ndarray, x: np.ndarray, y: np.ndarray,
                  quadrants: str = '13') -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Take mean between 1st and 3rd (or 2nd and 4th) quadrants.
@@ -62,74 +47,6 @@ def quadrantmean(data: np.ndarray, x: np.ndarray, y: np.ndarray,
     return datanew[ny:, nx:], xnew[nx:], ynew[ny:]
 
 
-def RGIxy(y: np.ndarray, x: np.ndarray, data: np.ndarray,
-          yxnew: tuple[np.ndarray, np.ndarray] | None = None,
-          **kwargs) -> object | np.ndarray:
-    """RGI for x and y at each channel.
-
-    Args:
-        y (np.ndarray): 1D array. Second coordinate.
-        x (np.ndarray): 1D array. First coordinate.
-        data (np.ndarray): 2D, 3D, or 4D array.
-        yxnew (tuple, optional): (ynew, xnew), where ynew and xnew are 1D or 2D arrays. Defaults to None.
-
-    Returns:
-        np.ndarray: The RGI function or the interpolated array.
-    """
-    if not np.ndim(data) in [2, 3, 4]:
-        print('data must be 2D, 3D, or 4D.')
-        return
-
-    _kw = {'bounds_error': False, 'fill_value': np.nan,
-           'method': 'linear'}
-    _kw.update(kwargs)
-    c4d = to4dim(data)
-    c4d[np.isnan(c4d)] = 0
-    f = [[RGI((y, x), c2d, **_kw)
-          for c2d in c3d] for c3d in c4d]
-    if yxnew is None:
-        if len(f) == 1:
-            f = f[0]
-        if len(f) == 1:
-            f = f[0]
-        return f
-    else:
-        return np.squeeze([[f2d(tuple(yxnew)) for f2d in f3d] for f3d in f])
-
-
-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:
-    """RGI in the x-y-v space.
-
-    Args:
-        v (np.ndarray): 1D array. Third coordinate.
-        y (np.ndarray): 1D array. Second coordinate.
-        x (np.ndarray): 1D array. First coordinate.
-        data (np.ndarray): 3D or 4D array.
-        vyxnew (tuple, optional): (vnew, ynew, xnew), where vnew, ynew, and xnew are 1D or 2D arrays. Defaults to None.
-
-    Returns:
-        np.ndarray: The RGI function or the interpolated array.
-    """
-    if not np.ndim(data) in [3, 4]:
-        print('data must be 3D or 4D.')
-        return
-
-    _kw = {'bounds_error': False, 'fill_value': np.nan,
-           'method': 'linear'}
-    _kw.update(kwargs)
-    c4d = to4dim(data)
-    c4d[np.isnan(c4d)] = 0
-    f = [RGI((v, y, x), c3d, **_kw) for c3d in c4d]
-    if vyxnew is None:
-        if len(f) == 1:
-            f = f[0]
-        return f
-    else:
-        return np.squeeze([f3d(tuple(vyxnew)) for f3d in f])
-
-
 def filled2d(data: np.ndarray, x: np.ndarray, y: np.ndarray, n: int = 1,
              **kwargs) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Fill 2D data, 1D x, and 1D y by a factor of n using RGI.
@@ -580,7 +497,7 @@ class AstroData():
                 h['BMAJ'] = self.beam_org[0] / 3600
                 h['BMIN'] = self.beam_org[1] / 3600
                 h['BPA'] = self.beam_org[2]
-            else:    
+            else:
                 h['BMAJ'] = self.beam[0] / 3600
                 h['BMIN'] = self.beam[1] / 3600
                 h['BPA'] = self.beam[2]
@@ -750,6 +667,8 @@ class AstroFrame():
                 grid = fd.get_grid(center=d.center[i], dist=self.dist,
                                    restfreq=d.restfreq[i], vsys=self.vsys,
                                    pv=self.pv)
+                if fd.wcsrot:
+                    d.center[i] = fd.get_center()  # for WCS rotation
                 d.beam[i] = fd.get_beam(dist=self.dist)
                 d.bunit[i] = fd.get_header('BUNIT')
             if d.data[i] is not None:
@@ -788,8 +707,8 @@ class AstroFrame():
                               'CUNIT1': 'DEG',
                               'RESTFREQ': d.restfreq[i]}
                     if None not in d.beam[i]:
-                        header['BMAJ'] = d.beam[i][0] / 3600
-                        header['BMIN'] = d.beam[i][1] / 3600
+                        header['BMAJ'] = d.beam[i][0] / 3600 / self.dist
+                        header['BMIN'] = d.beam[i][1] / 3600 / self.dist
                     d.data[i] = d.data[i] * Jy2K(header=header)
                     d.sigma[i] = d.sigma[i] * Jy2K(header=header)
                 if self.pv and None not in d.beam[i]:

plotastrodata-1.4.1/plotastrodata/coord_utils.py

@@ -0,0 +1,149 @@
+import numpy as np
+from astropy.coordinates import SkyCoord, FK5, FK4
+from astropy import units
+
+
+def _getframe(coord: str, s: str = '') -> tuple:
+    """Internal function to pick up the frame name from the coordinates.
+
+    Args:
+        coord (str): something like "J2000 01h23m45.6s 01d23m45.6s"
+        s (str, optional): To distinguish coord and coordorg. Defaults to ''.
+
+    Returns:
+        tuple: updated coord and frame. frame is FK5(equinox='J2000), FK4(equinox='B1950'), or 'icrs'.
+    """
+    if len(c := coord.split()) == 3:
+        coord = f'{c[1]} {c[2]}'
+        if 'J2000' in c[0]:
+            frame = FK5(equinox='J2000')
+        elif 'FK5' in c[0]:
+            frame = FK5(equinox='J2000')
+        elif 'B1950' in c[0]:
+            frame = FK4(equinox='B1950')
+        elif 'FK4' in c[0]:
+            frame = FK4(equinox='B1950')
+        elif 'ICRS' in c[0]:
+            frame = 'icrs'
+        else:
+            print(f'Unknown equinox found in coord{s}. ICRS is used')
+            frame = 'icrs'
+    else:
+        frame = None
+    return coord, frame
+
+
+def _updateframe(frame: str) -> str:
+    """Internal function to str frame to astropy frame.
+
+    Args:
+        frame (str): _description_
+
+    Returns:
+        str: frame as is, FK5(equinox='J2000'), FK4(equinox='B1950'), or 'icrs'.
+    """
+    if 'ICRS' in frame:
+        a = 'icrs'
+    elif 'J2000' in frame or 'FK5' in frame:
+        a = FK5(equinox='J2000')
+    elif 'B1950' in frame or 'FK4' in frame:
+        a = FK4(equinox='B1950')
+    else:
+        a = frame
+    return a
+
+
+def coord2xy(coords: str | list, coordorg: str = '00h00m00s 00d00m00s',
+             frame: str | None = None, frameorg: str | None = None,
+             ) -> np.ndarray:
+    """Transform R.A.-Dec. to relative (deg, deg).
+
+    Args:
+        coords (str, list): something like '01h23m45.6s 01d23m45.6s'. The input can be a list of str in an arbitrary shape.
+        coordorg (str, optional): something like '01h23m45.6s 01d23m45.6s'. The origin of the relative (deg, deg). Defaults to '00h00m00s 00d00m00s'.
+        frame (str, optional): coordinate frame. Defaults to None.
+        frameorg (str, optional): coordinate frame of the origin. Defaults to None.
+
+    Returns:
+        np.ndarray: [(array of) alphas, (array of) deltas] in degree. The shape of alphas and deltas is the input shape. With a single input, the output is [alpha0, delta0].
+    """
+    coordorg, frameorg_c = _getframe(coordorg, 'org')
+    frameorg = frameorg_c if frameorg is None else _updateframe(frameorg)
+    if type(coords) is list:
+        for i in range(len(coords)):
+            coords[i], frame_c = _getframe(coords[i])
+    else:
+        coords, frame_c = _getframe(coords)
+    frame = frame_c if frame is None else _updateframe(frame)
+    if frame is None and frameorg is not None:
+        frame = frameorg
+    if frame is not None and frameorg is None:
+        frameorg = frame
+    if frame is None and frameorg is None:
+        frame = frameorg = 'icrs'
+    clist = SkyCoord(coords, frame=frame)
+    c0 = SkyCoord(coordorg, frame=frameorg)
+    c0 = c0.transform_to(frame=frame)
+    xy = c0.spherical_offsets_to(clist)
+    return np.array([xy[0].degree, xy[1].degree])
+
+
+def xy2coord(xy: list, coordorg: str = '00h00m00s 00d00m00s',
+             frame: str | None = None, frameorg: str | None = None,
+             ) -> str:
+    """Transform relative (deg, deg) to R.A.-Dec.
+
+    Args:
+        xy (list): [(array of) alphas, (array of) deltas] in degree. alphas and deltas can have an arbitrary shape.
+        coordorg (str): something like '01h23m45.6s 01d23m45.6s'. The origin of the relative (deg, deg). Defaults to '00h00m00s 00d00m00s'.
+        frame (str): coordinate frame. Defaults to None.
+        frameorg (str): coordinate frame of the origin. Defaults to None.
+
+    Returns:
+        str: something like '01h23m45.6s 01d23m45.6s'. With multiple inputs, the output has the input shape.
+    """
+    coordorg, frameorg_c = _getframe(coordorg, 'org')
+    frameorg = frameorg_c if frameorg is None else _updateframe(frameorg)
+    if frameorg is None:
+        frameorg = 'icrs'
+    frame = frameorg if frame is None else _updateframe(frame)
+    c0 = SkyCoord(coordorg, frame=frameorg)
+    coords = c0.spherical_offsets_by(*xy * units.degree)
+    coords = coords.transform_to(frame=frame)
+    return coords.to_string('hmsdms')
+
+
+def rel2abs(xrel: float, yrel: float,
+            x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    """Transform relative coordinates to absolute ones.
+
+    Args:
+        xrel (float): 0 <= xrel <= 1. 0 and 1 correspond to x[0] and x[-1], respectively. Arbitrary shape.
+        yrel (float): same as xrel.
+        x (np.ndarray): [x0, x0+dx, x0+2dx, ...]
+        y (np.ndarray): [y0, y0+dy, y0+2dy, ...]
+
+    Returns:
+        np.ndarray: [xabs, yabs]. Each has the input's shape.
+    """
+    xabs = (1. - xrel)*x[0] + xrel*x[-1]
+    yabs = (1. - yrel)*y[0] + yrel*y[-1]
+    return np.array([xabs, yabs])
+
+
+def abs2rel(xabs: float, yabs: float,
+            x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    """Transform absolute coordinates to relative ones.
+
+    Args:
+        xabs (float): In the same frame of x.
+        yabs (float): In the same frame of y.
+        x (np.ndarray): [x0, x0+dx, x0+2dx, ...]
+        y (np.ndarray): [y0, y0+dy, y0+2dy, ...]
+
+    Returns:
+        ndarray: [xrel, yrel]. Each has the input's shape. 0 <= xrel, yrel <= 1. 0 and 1 correspond to x[0] and x[-1], respectively.
+    """
+    xrel = (xabs - x[0]) / (x[-1] - x[0])
+    yrel = (yabs - y[0]) / (y[-1] - y[0])
+    return np.array([xrel, yrel])

plotastrodata-1.4.1/plotastrodata/ext_utils.py

@@ -0,0 +1,49 @@
+import subprocess
+import shlex
+import numpy as np
+
+from plotastrodata import const_utils as cu
+
+
+def terminal(cmd: str, **kwargs) -> None:
+    """Run a terminal command through subprocess.run.
+
+    Args:
+        cmd (str): Terminal command.
+    """
+    subprocess.run(shlex.split(cmd), **kwargs)
+
+
+def runpython(filename: str, **kwargs) -> None:
+    """Run a python file.
+
+    Args:
+        filename (str): Python file name.
+    """
+    terminal(f'python {filename}', **kwargs)
+
+
+def BnuT(T: float = 30, nu: float = 230e9) -> float:
+    """Planck function.
+
+    Args:
+        T (float, optional): Temperature in the unit of K. Defaults to 30.
+        nu (float, optional): Frequency in the unit of Hz. Defaults to 230e9.
+
+    Returns:
+        float: Planck function in the SI units.
+    """
+    return 2 * cu.h * nu**3 / cu.c**2 / (np.exp(cu.h * nu / cu.k_B / T) - 1)
+
+
+def JnuT(T: float = 30, nu: float = 230e9) -> float:
+    """Brightness templerature from the Planck function.
+
+    Args:
+        T (float, optional): Temperature in the unit of K. Defaults to 30.
+        nu (float, optional): Frequency in the unit of Hz. Defaults to 230e9.
+
+    Returns:
+        float: Brightness temperature of Planck function in the unit of K.
+    """
+    return cu.h * nu / cu.k_B / (np.exp(cu.h * nu / cu.k_B / T) - 1)

{plotastrodata-1.3.2 → plotastrodata-1.4.1}/plotastrodata/fits_utils.py

@@ -2,8 +2,10 @@ import numpy as np
 from astropy.io import fits
 from astropy import units, wcs
 
-from plotastrodata.other_utils import (coord2xy, xy2coord,
-                                       estimate_rms, trim, isdeg)
+from plotastrodata.coord_utils import coord2xy, xy2coord
+from plotastrodata.matrix_utils import dot2d
+from plotastrodata.other_utils import (estimate_rms, trim, isdeg,
+                                       RGIxy)
 from plotastrodata import const_utils as cu
 
 
@@ -204,6 +206,28 @@ class FitsData:
                 restfreq = h['RESTFREQ']
         self.x, self.y, self.v = None, None, None
         self.dx, self.dy, self.dv = None, None, None
+        # WCS rotation (Calabretta & Greisen 2002, Astronomy & Astrophysics, 395, 1077)
+        self.wcsrot = False
+        cdij = ['CD1_1', 'CD1_2', 'CD2_1', 'CD2_2']
+        if np.all([s in list(h.keys()) for s in cdij]):
+            self.wcsrot = True
+            cd11, cd12, cd21, cd22 = [h[s] for s in cdij]
+            cdelt1cdelt2 = cd11 * cd22 - cd12 * cd21
+            sin_2rho = 2 * cd21 * cd22 / cdelt1cdelt2
+            cos_2rho = (cd11 * cd22 + cd12 * cd21) / cdelt1cdelt2
+            crota2 = np.arctan2(sin_2rho, cos_2rho) / 2.
+            sin_rho = np.sin(crota2)
+            cos_rho = np.cos(crota2)
+            cdelt1 = cd11 * cos_rho + cd21 * sin_rho
+            cdelt2 = -cd12 * sin_rho + cd22 * cos_rho
+            crota2 = np.degrees(crota2)
+            h['CDELT1'] = cdelt1
+            h['CDELT2'] = cdelt2
+            del h['CD1_1']
+            del h['CD1_2']
+            del h['CD2_1']
+            del h['CD2_2']
+            print(f'WCS rotation was found (CROTA2 = {crota2:f} deg).')
 
         def get_list(i: int, crval=False) -> np.ndarray:
             s = np.arange(h[f'NAXIS{i:d}'])
@@ -271,6 +295,30 @@ class FitsData:
         if h['NAXIS'] > 2 and h['NAXIS3'] > 1:
             gen_v(get_list(3, True))
 
+        if self.wcsrot:
+            data = self.get_data()
+            self.header['CRPIX1'] = ic = len(self.x) // 2
+            self.header['CRPIX2'] = jc = len(self.y) // 2
+            xc = self.x[ic] / self.dx
+            yc = self.y[jc] / self.dy
+            Mcd = [[cd11, cd12], [cd21, cd22]]
+            xc, yc = dot2d(Mcd, [xc, yc])
+            newcenter = xy2coord(xy=[xc, yc], coordorg=self.get_center())
+            xc, yc = coord2xy(coords=newcenter, coordorg='00h00m00s 00d00m00s')
+            self.header['CRVAL1'] = xc
+            self.header['CRVAL2'] = yc
+            self.x = self.x - self.x[ic]
+            self.y = self.y - self.y[jc]
+            x = self.x / (3600 if isdeg(h['CUNIT1']) else 1)
+            y = self.y / (3600 if isdeg(h['CUNIT2']) else 1)
+            X, Y = np.meshgrid(x, y)
+            cdinv = np.linalg.inv([[cd11, cd12], [cd21, cd22]])
+            xnew, ynew = dot2d(cdinv, [X, Y])
+            datanew = RGIxy(self.y / self.dy, self.x / self.dx,
+                            data, (ynew, xnew))
+            self.data = datanew
+            print('Data values were interpolated for WCS rotation.')
+
     def get_grid(self, **kwargs) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """Output the grids, [x, y, v]. This method can take the arguments of gen_grid().
 

{plotastrodata-1.3.2 → plotastrodata-1.4.1}/plotastrodata/los_utils.py

@@ -1,35 +1,6 @@
 import numpy as np
 
-
-def Mrot3d(t: float, axis: int = 3) -> np.ndarray:
-    """3D rotation matrix around a specified axis.
-
-    This function creates a 3x3 rotation matrix for rotating coordinates around
-    the x-axis (axis=1), y-axis (axis=2), or z-axis (axis=3) by t degrees.
-
-    Args:
-        t (float): Rotation angle in degrees.
-        axis (int, optional): Axis to rotate around - 1 for x-axis, 2 for y-axis, 3 for z-axis. Defaults to 3.
-
-    Returns:
-        np.ndarray: 3x3 rotation matrix that rotates coordinates around the specified axis by t degrees.
-    """
-    cos_t = np.cos(np.radians(t))
-    sin_t = np.sin(np.radians(t))
-    match axis:
-        case  1:
-            m = [[1, 0, 0],
-                 [0, cos_t, -sin_t],
-                 [0, sin_t, cos_t]]
-        case 2:
-            m = [[cos_t, 0, sin_t],
-                 [0, 1, 0],
-                 [-sin_t, 0, cos_t]]
-        case 3:
-            m = [[cos_t, -sin_t, 0],
-                 [sin_t, cos_t, 0],
-                 [0, 0, 1]]
-    return m
+from plotastrodata.matrix_utils import Mrot3d
 
 
 def obs2sys(xobs: np.ndarray, yobs: np.ndarray, zobs: np.ndarray,

plotastrodata-1.4.1/plotastrodata/matrix_utils.py

@@ -0,0 +1,74 @@
+import numpy as np
+
+
+def Mfac(f0: float = 1, f1: float = 1) -> np.ndarray:
+    """2 x 2 matrix for (x,y) --> (f0 * x, f1 * y).
+
+    Args:
+        f0 (float, optional): Defaults to 1.
+        f1 (float, optional): Defaults to 1.
+
+    Returns:
+        np.ndarray: Matrix for the multiplication.
+    """
+    return np.array([[f0, 0], [0, f1]])
+
+
+def Mrot(pa: float = 0) -> np.ndarray:
+    """2 x 2 matrix for rotation.
+
+    Args:
+        pa (float, optional): How many degrees are the image rotated by. Defaults to 0.
+
+    Returns:
+        np.ndarray: Matrix for the rotation.
+    """
+    p = np.radians(pa)
+    return np.array([[np.cos(p), -np.sin(p)], [np.sin(p),  np.cos(p)]])
+
+
+def dot2d(M: np.ndarray = [[1, 0], [0, 1]],
+          a: np.ndarray = [0, 0]) -> np.ndarray:
+    """To maltiply a 2 x 2 matrix to (x,y) with arrays of x and y.
+
+    Args:
+        M (np.ndarray, optional): 2 x 2 matrix. Defaults to [[1, 0], [0, 1]].
+        a (np.ndarray, optional): 2D vector (of 1D arrays). Defaults to [0].
+
+    Returns:
+        np.ndarray: The 2D vector after the matrix multiplied.
+    """
+    x = M[0][0] * np.array(a[0]) + M[0][1] * np.array(a[1])
+    y = M[1][0] * np.array(a[0]) + M[1][1] * np.array(a[1])
+    return np.array([x, y])
+
+
+def Mrot3d(t: float, axis: int = 3) -> np.ndarray:
+    """3D rotation matrix around a specified axis.
+
+    This function creates a 3x3 rotation matrix for rotating coordinates around
+    the x-axis (axis=1), y-axis (axis=2), or z-axis (axis=3) by t degrees.
+
+    Args:
+        t (float): Rotation angle in degrees.
+        axis (int, optional): Axis to rotate around - 1 for x-axis, 2 for y-axis, 3 for z-axis. Defaults to 3.
+
+    Returns:
+        np.ndarray: 3x3 rotation matrix that rotates coordinates around the specified axis by t degrees.
+    """
+    cos_t = np.cos(np.radians(t))
+    sin_t = np.sin(np.radians(t))
+    match axis:
+        case  1:
+            m = [[1, 0, 0],
+                 [0, cos_t, -sin_t],
+                 [0, sin_t, cos_t]]
+        case 2:
+            m = [[cos_t, 0, sin_t],
+                 [0, 1, 0],
+                 [-sin_t, 0, cos_t]]
+        case 3:
+            m = [[cos_t, -sin_t, 0],
+                 [sin_t, cos_t, 0],
+                 [0, 0, 1]]
+    return m

plotastrodata-1.4.1/plotastrodata/other_utils.py

@@ -0,0 +1,290 @@
+import numpy as np
+from scipy.optimize import curve_fit
+from scipy.special import erf
+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.
+
+    Returns:
+        list: With a single non-list input, the output is a list like ['a'], rather than [['a']].
+    """
+    nums = [float, int, np.float64, np.int64, np.float32, np.int32]
+    b = [None] * len(args)
+    for i, a in enumerate(args):
+        b[i] = [a] if type(a) in (nums + [str]) else a
+    if len(args) == 1:
+        b = b[0]
+    return b
+
+
+def isdeg(s: str) -> bool:
+    """Whether the given string means degree.
+
+    Args:
+        s (str): The string to be checked.
+
+    Returns:
+        bool: Whether the given string means degree.
+    """
+    if type(s) is str:
+        return s.strip() in ['deg', 'DEG', 'degree', 'DEGREE']
+    else:
+        return False
+
+
+def estimate_rms(data: np.ndarray, sigma: float | str | None = 'hist') -> float:
+    """Estimate a noise level of a N-D array.
+       When a float number or None is given, this function just outputs it.
+       Following methos are acceptable.
+       'edge': use data[0] and data[-1].
+       'neg': use only negative values.
+       'med': use the median of data^2 assuming Gaussian.
+       'iter': exclude outliers.
+       'out': exclude inner 60% about axes=-2 and -1.
+       'hist': fit histgram with Gaussian.
+       'hist-pbcor': fit histgram with PB-corrected Gaussian.
+
+    Args:
+        data (np.ndarray): N-D array.
+        sigma (float or str): One of the methods above. Defaults to 'hist'.
+
+    Returns:
+        float: the estimated root mean square of noise.
+    """
+    if sigma is None:
+        return None
+
+    nums = [float, int, np.float64, np.int64, np.float32, np.int32]
+    if type(sigma) in nums:
+        noise = sigma
+    elif np.ndim(np.squeeze(data)) == 0:
+        print('sigma cannot be estimated from only one pixel.')
+        noise = 0.0
+    elif sigma == 'edge':
+        ave = np.nanmean(data[::len(data) - 1])
+        noise = np.nanstd(data[::len(data) - 1])
+        if np.abs(ave) > 0.2 * noise:
+            print('Warning: The intensity offset is larger than 0.2 sigma.')
+    elif sigma == 'neg':
+        noise = np.sqrt(np.nanmean(data[data < 0]**2))
+    elif sigma == 'med':
+        noise = np.sqrt(np.nanmedian(data**2) / 0.454936)
+    elif sigma == 'iter':
+        n = data.copy()
+        for _ in range(5):
+            ave, sig = np.nanmean(n), np.nanstd(n)
+            n = n - ave
+            n = n[np.abs(n) < 3.5 * sig]
+        ave = np.nanmean(n)
+        noise = np.nanstd(n)
+        if np.abs(ave) > 0.2 * noise:
+            print('Warning: The intensity offset is larger than 0.2 sigma.')
+    elif sigma == 'out':
+        n, n0, n1 = data.copy(), len(data), len(data[0])
+        n = np.moveaxis(n, [-2, -1], [0, 1])
+        n[n0//5: n0*4//5, n1//5: n1*4//5] = np.nan
+        if np.all(np.isnan(n)):
+            print('sigma=\'neg\' instead of \'out\' because'
+                  + ' the outer region is filled with nan.')
+            noise = np.sqrt(np.nanmean(data[data < 0]**2))
+        else:
+            ave = np.nanmean(n)
+            noise = np.nanstd(n)
+            if np.abs(ave) > 0.2 * noise:
+                print('Warning: The intensity offset is larger than 0.2 sigma.')
+    elif sigma[:4] == 'hist':
+        m0, s0 = np.nanmean(data), np.nanstd(data)
+        hist, hbin = np.histogram(data[~np.isnan(data)],
+                                  bins=100, density=True,
+                                  range=(m0 - s0 * 5, m0 + s0 * 5))
+        hist, hbin = hist * s0, (hbin[:-1] + hbin[1:]) / 2 / s0
+        if sigma[4:] == '-pbcor':
+            def g(x, s, c, R):
+                xn = (x - c) / np.sqrt(2) / s
+                return (erf(xn) - erf(xn * np.exp(-R**2))) / (2 * (x-c) * R**2)
+        else:
+            def g(x, s, c, R):
+                return np.exp(-((x-c)/s)**2 / 2) / np.sqrt(2*np.pi) / s
+        popt, _ = curve_fit(g, hbin, hist, p0=[1, 0, 1])
+        ave = popt[1]
+        noise = popt[0]
+        if np.abs(ave) > 0.2 * noise:
+            print('Warning: The intensity offset is larger than 0.2 sigma.')
+        noise = noise * s0
+    return noise
+
+
+def trim(data: np.ndarray | None = None, x: np.ndarray | None = None,
+         y: np.ndarray | None = None, v: np.ndarray | None = None,
+         xlim: list[float, float] | None = None,
+         ylim: list[float, float] | None = None,
+         vlim: list[float, float] | None = None,
+         pv: bool = False) -> tuple[np.ndarray, list[np.ndarray, np.ndarray, np.ndarray]]:
+    """Trim 2D or 3D data by given coordinates and their limits.
+
+    Args:
+        data (np.ndarray, optional): 2D or 3D array. Defaults to None.
+        x (np.ndarray, optional): 1D array. Defaults to None.
+        y (np.ndarray, optional): 1D array. Defaults to None.
+        v (np.ndarray, optional): 1D array. Defaults to None.
+        xlim (list, optional): [xmin, xmax]. Defaults to None.
+        ylim (list, optional): [ymin, ymax]. Defaults to None.
+        vlim (list, optional): [vmin, vmax]. Defaults to None.
+
+    Returns:
+        tuple: Trimmed (data, [x,y,v]).
+    """
+    xout, yout, vout, dataout = x, y, v, data
+    i0 = j0 = k0 = 0
+    i1 = j1 = k1 = 100000
+    if not (x is None or xlim is None):
+        if not (None in xlim):
+            x0 = np.max([np.min(x), xlim[0]])
+            x1 = np.min([np.max(x), xlim[1]])
+            i0 = np.argmin(np.abs(x - x0))
+            i1 = np.argmin(np.abs(x - x1))
+            i0, i1 = sorted([i0, i1])
+            xout = x[i0:i1+1]
+    if not (y is None or ylim is None):
+        if not (None in ylim):
+            y0 = np.max([np.min(y), ylim[0]])
+            y1 = np.min([np.max(y), ylim[1]])
+            j0 = np.argmin(np.abs(y - y0))
+            j1 = np.argmin(np.abs(y - y1))
+            j0, j1 = sorted([j0, j1])
+            yout = y[j0:j1+1]
+    if not (v is None or vlim is None):
+        if not (None in vlim):
+            v0 = np.max([np.min(v), vlim[0]])
+            v1 = np.min([np.max(v), vlim[1]])
+            k0 = np.argmin(np.abs(v - v0))
+            k1 = np.argmin(np.abs(v - v1))
+            k0, k1 = sorted([k0, k1])
+            vout = v[k0:k1+1]
+    if data is not None:
+        d = np.squeeze(data)
+        if np.ndim(d) == 0:
+            print('data has only one pixel.')
+            d = data
+        if np.ndim(d) == 2:
+            if pv:
+                j0, j1 = k0, k1
+            dataout = d[j0:j1+1, i0:i1+1]
+        else:
+            d = np.moveaxis(d, [-3, -2, -1], [0, 1, 2])
+            d = d[k0:k1+1, j0:j1+1, i0:i1+1]
+            d = np.moveaxis(d, [0, 1, 2], [-3, -2, -1])
+            dataout = d
+    return dataout, [xout, yout, vout]
+
+
+def to4dim(data: np.ndarray) -> np.ndarray:
+    """Change a 2D, 3D, or 4D array to a 4D array.
+
+    Args:
+        data (np.ndarray): Input data. 2D, 3D, or 4D.
+
+    Returns:
+        np.ndarray: Output 4D array.
+    """
+    if np.ndim(data) == 2:
+        d = np.array([[data]])
+    elif np.ndim(data) == 3:
+        d = np.array([data])
+    else:
+        d = np.array(data)
+    return d
+
+
+def RGIxy(y: np.ndarray, x: np.ndarray, data: np.ndarray,
+          yxnew: tuple[np.ndarray, np.ndarray] | None = None,
+          **kwargs) -> object | np.ndarray:
+    """RGI for x and y at each channel.
+
+    Args:
+        y (np.ndarray): 1D array. Second coordinate.
+        x (np.ndarray): 1D array. First coordinate.
+        data (np.ndarray): 2D, 3D, or 4D array.
+        yxnew (tuple, optional): (ynew, xnew), where ynew and xnew are 1D or 2D arrays. Defaults to None.
+
+    Returns:
+        np.ndarray: The RGI function or the interpolated array.
+    """
+    if not np.ndim(data) in [2, 3, 4]:
+        print('data must be 2D, 3D, or 4D.')
+        return
+
+    _kw = {'bounds_error': False, 'fill_value': np.nan,
+           'method': 'linear'}
+    _kw.update(kwargs)
+    c4d = to4dim(data)
+    c4d[np.isnan(c4d)] = 0
+    f = [[RGI((y, x), c2d, **_kw)
+          for c2d in c3d] for c3d in c4d]
+    if yxnew is None:
+        if len(f) == 1:
+            f = f[0]
+        if len(f) == 1:
+            f = f[0]
+        return f
+    else:
+        return np.squeeze([[f2d(tuple(yxnew)) for f2d in f3d] for f3d in f])
+
+
+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:
+    """RGI in the x-y-v space.
+
+    Args:
+        v (np.ndarray): 1D array. Third coordinate.
+        y (np.ndarray): 1D array. Second coordinate.
+        x (np.ndarray): 1D array. First coordinate.
+        data (np.ndarray): 3D or 4D array.
+        vyxnew (tuple, optional): (vnew, ynew, xnew), where vnew, ynew, and xnew are 1D or 2D arrays. Defaults to None.
+
+    Returns:
+        np.ndarray: The RGI function or the interpolated array.
+    """
+    if not np.ndim(data) in [3, 4]:
+        print('data must be 3D or 4D.')
+        return
+
+    _kw = {'bounds_error': False, 'fill_value': np.nan,
+           'method': 'linear'}
+    _kw.update(kwargs)
+    c4d = to4dim(data)
+    c4d[np.isnan(c4d)] = 0
+    f = [RGI((v, y, x), c3d, **_kw) for c3d in c4d]
+    if vyxnew is None:
+        if len(f) == 1:
+            f = f[0]
+        return f
+    else:
+        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

{plotastrodata-1.3.2 → plotastrodata-1.4.1}/plotastrodata/plot_utils.py

@@ -4,7 +4,8 @@ import matplotlib.pyplot as plt
 from matplotlib.patches import Ellipse, Rectangle
 from dataclasses import dataclass
 
-from plotastrodata.other_utils import coord2xy, xy2coord, listing, estimate_rms
+from plotastrodata.coord_utils import coord2xy, xy2coord
+from plotastrodata.other_utils import listing, estimate_rms
 from plotastrodata.analysis_utils import AstroData, AstroFrame
 
 

{plotastrodata-1.3.2 → plotastrodata-1.4.1}/plotastrodata.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plotastrodata
-Version: 1.3.2
+Version: 1.4.1
 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.3.2 → plotastrodata-1.4.1}/plotastrodata.egg-info/SOURCES.txt

@@ -5,10 +5,13 @@ setup.py
 plotastrodata/__init__.py
 plotastrodata/analysis_utils.py
 plotastrodata/const_utils.py
+plotastrodata/coord_utils.py
+plotastrodata/ext_utils.py
 plotastrodata/fft_utils.py
 plotastrodata/fits_utils.py
 plotastrodata/fitting_utils.py
 plotastrodata/los_utils.py
+plotastrodata/matrix_utils.py
 plotastrodata/other_utils.py
 plotastrodata/plot_utils.py
 plotastrodata.egg-info/PKG-INFO

plotastrodata-1.3.2/plotastrodata/other_utils.py

@@ -1,439 +0,0 @@
-import subprocess
-import shlex
-import numpy as np
-from astropy.coordinates import SkyCoord, FK5, FK4
-from astropy import units
-from scipy.optimize import curve_fit
-from scipy.special import erf
-
-from plotastrodata import const_utils as cu
-
-
-def terminal(cmd: str, **kwargs) -> None:
-    """Run a terminal command through subprocess.run.
-
-    Args:
-        cmd (str): Terminal command.
-    """
-    subprocess.run(shlex.split(cmd), **kwargs)
-
-
-def runpython(filename: str, **kwargs) -> None:
-    """Run a python file.
-
-    Args:
-        filename (str): Python file name.
-    """
-    terminal(f'python {filename}', **kwargs)
-
-
-def listing(*args) -> list:
-    """Output a list of the input when the input is string or number.
-
-    Returns:
-        list: With a single non-list input, the output is a list like ['a'], rather than [['a']].
-    """
-    nums = [float, int, np.float64, np.int64, np.float32, np.int32]
-    b = [None] * len(args)
-    for i, a in enumerate(args):
-        b[i] = [a] if type(a) in (nums + [str]) else a
-    if len(args) == 1:
-        b = b[0]
-    return b
-
-
-def isdeg(s: str) -> bool:
-    """Whether the given string means degree.
-
-    Args:
-        s (str): The string to be checked.
-
-    Returns:
-        bool: Whether the given string means degree.
-    """
-    if type(s) is str:
-        return s.strip() in ['deg', 'DEG', 'degree', 'DEGREE']
-    else:
-        return False
-
-
-def _getframe(coord: str, s: str = '') -> tuple:
-    """Internal function to pick up the frame name from the coordinates.
-
-    Args:
-        coord (str): something like "J2000 01h23m45.6s 01d23m45.6s"
-        s (str, optional): To distinguish coord and coordorg. Defaults to ''.
-
-    Returns:
-        tuple: updated coord and frame. frame is FK5(equinox='J2000), FK4(equinox='B1950'), or 'icrs'.
-    """
-    if len(c := coord.split()) == 3:
-        coord = f'{c[1]} {c[2]}'
-        if 'J2000' in c[0]:
-            frame = FK5(equinox='J2000')
-        elif 'FK5' in c[0]:
-            frame = FK5(equinox='J2000')
-        elif 'B1950' in c[0]:
-            frame = FK4(equinox='B1950')
-        elif 'FK4' in c[0]:
-            frame = FK4(equinox='B1950')
-        elif 'ICRS' in c[0]:
-            frame = 'icrs'
-        else:
-            print(f'Unknown equinox found in coord{s}. ICRS is used')
-            frame = 'icrs'
-    else:
-        frame = None
-    return coord, frame
-
-
-def _updateframe(frame: str) -> str:
-    """Internal function to str frame to astropy frame.
-
-    Args:
-        frame (str): _description_
-
-    Returns:
-        str: frame as is, FK5(equinox='J2000'), FK4(equinox='B1950'), or 'icrs'.
-    """
-    if 'ICRS' in frame:
-        a = 'icrs'
-    elif 'J2000' in frame or 'FK5' in frame:
-        a = FK5(equinox='J2000')
-    elif 'B1950' in frame or 'FK4' in frame:
-        a = FK4(equinox='B1950')
-    else:
-        a = frame
-    return a
-
-
-def coord2xy(coords: str | list, coordorg: str = '00h00m00s 00d00m00s',
-             frame: str | None = None, frameorg: str | None = None,
-             ) -> np.ndarray:
-    """Transform R.A.-Dec. to relative (deg, deg).
-
-    Args:
-        coords (str, list): something like '01h23m45.6s 01d23m45.6s'. The input can be a list of str in an arbitrary shape.
-        coordorg (str, optional): something like '01h23m45.6s 01d23m45.6s'. The origin of the relative (deg, deg). Defaults to '00h00m00s 00d00m00s'.
-        frame (str, optional): coordinate frame. Defaults to None.
-        frameorg (str, optional): coordinate frame of the origin. Defaults to None.
-
-    Returns:
-        np.ndarray: [(array of) alphas, (array of) deltas] in degree. The shape of alphas and deltas is the input shape. With a single input, the output is [alpha0, delta0].
-    """
-    coordorg, frameorg_c = _getframe(coordorg, 'org')
-    frameorg = frameorg_c if frameorg is None else _updateframe(frameorg)
-    if type(coords) is list:
-        for i in range(len(coords)):
-            coords[i], frame_c = _getframe(coords[i])
-    else:
-        coords, frame_c = _getframe(coords)
-    frame = frame_c if frame is None else _updateframe(frame)
-    if frame is None and frameorg is not None:
-        frame = frameorg
-    if frame is not None and frameorg is None:
-        frameorg = frame
-    if frame is None and frameorg is None:
-        frame = frameorg = 'icrs'
-    clist = SkyCoord(coords, frame=frame)
-    c0 = SkyCoord(coordorg, frame=frameorg)
-    c0 = c0.transform_to(frame=frame)
-    xy = c0.spherical_offsets_to(clist)
-    return np.array([xy[0].degree, xy[1].degree])
-
-
-def xy2coord(xy: list, coordorg: str = '00h00m00s 00d00m00s',
-             frame: str | None = None, frameorg: str | None = None,
-             ) -> str:
-    """Transform relative (deg, deg) to R.A.-Dec.
-
-    Args:
-        xy (list): [(array of) alphas, (array of) deltas] in degree. alphas and deltas can have an arbitrary shape.
-        coordorg (str): something like '01h23m45.6s 01d23m45.6s'. The origin of the relative (deg, deg). Defaults to '00h00m00s 00d00m00s'.
-        frame (str): coordinate frame. Defaults to None.
-        frameorg (str): coordinate frame of the origin. Defaults to None.
-
-    Returns:
-        str: something like '01h23m45.6s 01d23m45.6s'. With multiple inputs, the output has the input shape.
-    """
-    coordorg, frameorg_c = _getframe(coordorg, 'org')
-    frameorg = frameorg_c if frameorg is None else _updateframe(frameorg)
-    if frameorg is None:
-        frameorg = 'icrs'
-    frame = frameorg if frame is None else _updateframe(frame)
-    c0 = SkyCoord(coordorg, frame=frameorg)
-    coords = c0.spherical_offsets_by(*xy * units.degree)
-    coords = coords.transform_to(frame=frame)
-    return coords.to_string('hmsdms')
-
-
-def rel2abs(xrel: float, yrel: float,
-            x: np.ndarray, y: np.ndarray) -> np.ndarray:
-    """Transform relative coordinates to absolute ones.
-
-    Args:
-        xrel (float): 0 <= xrel <= 1. 0 and 1 correspond to x[0] and x[-1], respectively. Arbitrary shape.
-        yrel (float): same as xrel.
-        x (np.ndarray): [x0, x0+dx, x0+2dx, ...]
-        y (np.ndarray): [y0, y0+dy, y0+2dy, ...]
-
-    Returns:
-        np.ndarray: [xabs, yabs]. Each has the input's shape.
-    """
-    xabs = (1. - xrel)*x[0] + xrel*x[-1]
-    yabs = (1. - yrel)*y[0] + yrel*y[-1]
-    return np.array([xabs, yabs])
-
-
-def abs2rel(xabs: float, yabs: float,
-            x: np.ndarray, y: np.ndarray) -> np.ndarray:
-    """Transform absolute coordinates to relative ones.
-
-    Args:
-        xabs (float): In the same frame of x.
-        yabs (float): In the same frame of y.
-        x (np.ndarray): [x0, x0+dx, x0+2dx, ...]
-        y (np.ndarray): [y0, y0+dy, y0+2dy, ...]
-
-    Returns:
-        ndarray: [xrel, yrel]. Each has the input's shape. 0 <= xrel, yrel <= 1. 0 and 1 correspond to x[0] and x[-1], respectively.
-    """
-    xrel = (xabs - x[0]) / (x[-1] - x[0])
-    yrel = (yabs - y[0]) / (y[-1] - y[0])
-    return np.array([xrel, yrel])
-
-
-def estimate_rms(data: np.ndarray, sigma: float | str | None = 'hist') -> float:
-    """Estimate a noise level of a N-D array.
-       When a float number or None is given, this function just outputs it.
-       Following methos are acceptable.
-       'edge': use data[0] and data[-1].
-       'neg': use only negative values.
-       'med': use the median of data^2 assuming Gaussian.
-       'iter': exclude outliers.
-       'out': exclude inner 60% about axes=-2 and -1.
-       'hist': fit histgram with Gaussian.
-       'hist-pbcor': fit histgram with PB-corrected Gaussian.
-
-    Args:
-        data (np.ndarray): N-D array.
-        sigma (float or str): One of the methods above. Defaults to 'hist'.
-
-    Returns:
-        float: the estimated root mean square of noise.
-    """
-    if sigma is None:
-        return None
-
-    nums = [float, int, np.float64, np.int64, np.float32, np.int32]
-    if type(sigma) in nums:
-        noise = sigma
-    elif np.ndim(np.squeeze(data)) == 0:
-        print('sigma cannot be estimated from only one pixel.')
-        noise = 0.0
-    elif sigma == 'edge':
-        ave = np.nanmean(data[::len(data) - 1])
-        noise = np.nanstd(data[::len(data) - 1])
-        if np.abs(ave) > 0.2 * noise:
-            print('Warning: The intensity offset is larger than 0.2 sigma.')
-    elif sigma == 'neg':
-        noise = np.sqrt(np.nanmean(data[data < 0]**2))
-    elif sigma == 'med':
-        noise = np.sqrt(np.nanmedian(data**2) / 0.454936)
-    elif sigma == 'iter':
-        n = data.copy()
-        for _ in range(5):
-            ave, sig = np.nanmean(n), np.nanstd(n)
-            n = n - ave
-            n = n[np.abs(n) < 3.5 * sig]
-        ave = np.nanmean(n)
-        noise = np.nanstd(n)
-        if np.abs(ave) > 0.2 * noise:
-            print('Warning: The intensity offset is larger than 0.2 sigma.')
-    elif sigma == 'out':
-        n, n0, n1 = data.copy(), len(data), len(data[0])
-        n = np.moveaxis(n, [-2, -1], [0, 1])
-        n[n0//5: n0*4//5, n1//5: n1*4//5] = np.nan
-        if np.all(np.isnan(n)):
-            print('sigma=\'neg\' instead of \'out\' because'
-                  + ' the outer region is filled with nan.')
-            noise = np.sqrt(np.nanmean(data[data < 0]**2))
-        else:
-            ave = np.nanmean(n)
-            noise = np.nanstd(n)
-            if np.abs(ave) > 0.2 * noise:
-                print('Warning: The intensity offset is larger than 0.2 sigma.')
-    elif sigma[:4] == 'hist':
-        m0, s0 = np.nanmean(data), np.nanstd(data)
-        hist, hbin = np.histogram(data[~np.isnan(data)],
-                                  bins=100, density=True,
-                                  range=(m0 - s0 * 5, m0 + s0 * 5))
-        hist, hbin = hist * s0, (hbin[:-1] + hbin[1:]) / 2 / s0
-        if sigma[4:] == '-pbcor':
-            def g(x, s, c, R):
-                xn = (x - c) / np.sqrt(2) / s
-                return (erf(xn) - erf(xn * np.exp(-R**2))) / (2 * (x-c) * R**2)
-        else:
-            def g(x, s, c, R):
-                return np.exp(-((x-c)/s)**2 / 2) / np.sqrt(2*np.pi) / s
-        popt, _ = curve_fit(g, hbin, hist, p0=[1, 0, 1])
-        ave = popt[1]
-        noise = popt[0]
-        if np.abs(ave) > 0.2 * noise:
-            print('Warning: The intensity offset is larger than 0.2 sigma.')
-        noise = noise * s0
-    return noise
-
-
-def trim(data: np.ndarray | None = None, x: np.ndarray | None = None,
-         y: np.ndarray | None = None, v: np.ndarray | None = None,
-         xlim: list[float, float] | None = None,
-         ylim: list[float, float] | None = None,
-         vlim: list[float, float] | None = None,
-         pv: bool = False) -> tuple[np.ndarray, list[np.ndarray, np.ndarray, np.ndarray]]:
-    """Trim 2D or 3D data by given coordinates and their limits.
-
-    Args:
-        data (np.ndarray, optional): 2D or 3D array. Defaults to None.
-        x (np.ndarray, optional): 1D array. Defaults to None.
-        y (np.ndarray, optional): 1D array. Defaults to None.
-        v (np.ndarray, optional): 1D array. Defaults to None.
-        xlim (list, optional): [xmin, xmax]. Defaults to None.
-        ylim (list, optional): [ymin, ymax]. Defaults to None.
-        vlim (list, optional): [vmin, vmax]. Defaults to None.
-
-    Returns:
-        tuple: Trimmed (data, [x,y,v]).
-    """
-    xout, yout, vout, dataout = x, y, v, data
-    i0 = j0 = k0 = 0
-    i1 = j1 = k1 = 100000
-    if not (x is None or xlim is None):
-        if not (None in xlim):
-            x0 = np.max([np.min(x), xlim[0]])
-            x1 = np.min([np.max(x), xlim[1]])
-            i0 = np.argmin(np.abs(x - x0))
-            i1 = np.argmin(np.abs(x - x1))
-            i0, i1 = sorted([i0, i1])
-            xout = x[i0:i1+1]
-    if not (y is None or ylim is None):
-        if not (None in ylim):
-            y0 = np.max([np.min(y), ylim[0]])
-            y1 = np.min([np.max(y), ylim[1]])
-            j0 = np.argmin(np.abs(y - y0))
-            j1 = np.argmin(np.abs(y - y1))
-            j0, j1 = sorted([j0, j1])
-            yout = y[j0:j1+1]
-    if not (v is None or vlim is None):
-        if not (None in vlim):
-            v0 = np.max([np.min(v), vlim[0]])
-            v1 = np.min([np.max(v), vlim[1]])
-            k0 = np.argmin(np.abs(v - v0))
-            k1 = np.argmin(np.abs(v - v1))
-            k0, k1 = sorted([k0, k1])
-            vout = v[k0:k1+1]
-    if data is not None:
-        d = np.squeeze(data)
-        if np.ndim(d) == 0:
-            print('data has only one pixel.')
-            d = data
-        if np.ndim(d) == 2:
-            if pv:
-                j0, j1 = k0, k1
-            dataout = d[j0:j1+1, i0:i1+1]
-        else:
-            d = np.moveaxis(d, [-3, -2, -1], [0, 1, 2])
-            d = d[k0:k1+1, j0:j1+1, i0:i1+1]
-            d = np.moveaxis(d, [0, 1, 2], [-3, -2, -1])
-            dataout = d
-    return dataout, [xout, yout, vout]
-
-
-def Mfac(f0: float = 1, f1: float = 1) -> np.ndarray:
-    """2 x 2 matrix for (x,y) --> (f0 * x, f1 * y).
-
-    Args:
-        f0 (float, optional): Defaults to 1.
-        f1 (float, optional): Defaults to 1.
-
-    Returns:
-        np.ndarray: Matrix for the multiplication.
-    """
-    return np.array([[f0, 0], [0, f1]])
-
-
-def Mrot(pa: float = 0) -> np.ndarray:
-    """2 x 2 matrix for rotation.
-
-    Args:
-        pa (float, optional): How many degrees are the image rotated by. Defaults to 0.
-
-    Returns:
-        np.ndarray: Matrix for the rotation.
-    """
-    p = np.radians(pa)
-    return np.array([[np.cos(p), -np.sin(p)], [np.sin(p),  np.cos(p)]])
-
-
-def dot2d(M: np.ndarray = [[1, 0], [0, 1]],
-          a: np.ndarray = [0, 0]) -> np.ndarray:
-    """To maltiply a 2 x 2 matrix to (x,y) with arrays of x and y.
-
-    Args:
-        M (np.ndarray, optional): 2 x 2 matrix. Defaults to [[1, 0], [0, 1]].
-        a (np.ndarray, optional): 2D vector (of 1D arrays). Defaults to [0].
-
-    Returns:
-        np.ndarray: The 2D vector after the matrix multiplied.
-    """
-    x = M[0, 0] * np.array(a[0]) + M[0, 1] * np.array(a[1])
-    y = M[1, 0] * np.array(a[0]) + M[1, 1] * np.array(a[1])
-    return np.array([x, y])
-
-
-def BnuT(T: float = 30, nu: float = 230e9) -> float:
-    """Planck function.
-
-    Args:
-        T (float, optional): Temperature in the unit of K. Defaults to 30.
-        nu (float, optional): Frequency in the unit of Hz. Defaults to 230e9.
-
-    Returns:
-        float: Planck function in the SI units.
-    """
-    return 2 * cu.h * nu**3 / cu.c**2 / (np.exp(cu.h * nu / cu.k_B / T) - 1)
-
-
-def JnuT(T: float = 30, nu: float = 230e9) -> float:
-    """Brightness templerature from the Planck function.
-
-    Args:
-        T (float, optional): Temperature in the unit of K. Defaults to 30.
-        nu (float, optional): Frequency in the unit of Hz. Defaults to 230e9.
-
-    Returns:
-        float: Brightness temperature of Planck function in the unit of K.
-    """
-    return cu.h * nu / cu.k_B / (np.exp(cu.h * nu / cu.k_B / T) - 1)
-
-
-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