plotastrodata 1.9.9__tar.gz → 1.9.11__tar.gz

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

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

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

{plotastrodata-1.9.9 → plotastrodata-1.9.11}/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
 
 
@@ -117,7 +118,7 @@ class AstroData():
     def __post_init__(self):
         n = 0
         if self.fitsimage is not None:
-            if type(self.fitsimage) is not list:
+            if not isinstance(self.fitsimage, list):
                 n = 1
             elif any(a is not None for a in self.fitsimage):
                 n = len(self.fitsimage)
@@ -126,7 +127,7 @@ class AstroData():
             if n > 0:
                 self.data = None
         if self.data is not None:
-            if type(self.data) is not list:
+            if not isinstance(self.data, list):
                 n = 1
             elif any(a is not None for a in self.data):
                 n = len(self.data)
@@ -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)
@@ -590,9 +602,9 @@ def _get_gridsep(axis: np.ndarray | None):
     return axis[1] - axis[0] if axis is not None and len(axis) > 1 else None
 
 
-ASTRODATA_ARGS = ["fitsimage", "data", "Tb", "sigma", "center", "restfreq",
-                  "cfactor", "bunit", "fitsimage_org", "sigma_org",
-                  "beam_org", "fitsheader", "pv", "pvpa"]
+ASTRODATA_ARGS = ['fitsimage', 'data', 'Tb', 'sigma', 'center', 'restfreq',
+                  'cfactor', 'bunit', 'fitsimage_org', 'sigma_org',
+                  'beam_org', 'fitsheader', 'pv', 'pvpa']
 
 
 @dataclass
@@ -675,12 +687,12 @@ class AstroFrame():
          Returns:
             np.ndarray: absolute coordinates.
          """
-        onexy = np.shape(poslist) == (2,) and type(poslist[0]) is not str
+        onexy = np.shape(poslist) == (2,) and not isinstance(poslist[0], str)
         if np.shape(poslist) == () or onexy:
             poslist = [poslist]
         x, y = [None] * len(poslist), [None] * len(poslist)
         for i, p in enumerate(poslist):
-            if type(p) is str:
+            if isinstance(p, str):
                 x[i], y[i] = coord2xy(p, self.center) * 3600.
             else:
                 x[i], y[i] = rel2abs(*p, self.Xlim, self.Ylim)
@@ -688,12 +700,12 @@ class AstroFrame():
 
     def _get_restfreq(self, header: dict):
         """Extract rest frequency from FITS header."""
-        if "RESTFRQ" in header:
-            return header["RESTFRQ"]
-        if "RESTFREQ" in header:
-            return header["RESTFREQ"]
-        if "NAXIS3" in header and header["NAXIS3"] == 1 and not self.pv:
-            return header["CRVAL3"]
+        if 'RESTFRQ' in header:
+            return header['RESTFRQ']
+        if 'RESTFREQ' in header:
+            return header['RESTFREQ']
+        if 'NAXIS3' in header and header['NAXIS3'] == 1 and not self.pv:
+            return header['CRVAL3']
         return None
 
     def _read_fitsimage(self, d: AstroData, i: int, grid: list) -> list:
@@ -715,7 +727,7 @@ class AstroFrame():
         if fd.wcsrot:
             d.center[i] = fd.get_center()
         d.beam[i] = fd.get_beam(dist=self.dist)
-        d.bunit[i] = fd.get_header("BUNIT")
+        d.bunit[i] = fd.get_header('BUNIT')
         return grid
 
     def _shift_center(self, d: AstroData, i: int, grid: list) -> list:
@@ -758,7 +770,7 @@ class AstroFrame():
         if self.pv:
             d.v = d.y
         for axis in ['x', 'y', 'v']:
-            setattr(d, f"d{axis}", _get_gridsep(getattr(d, axis)))
+            setattr(d, f'd{axis}', _get_gridsep(getattr(d, axis)))
 
     def _convert_to_Tb(self, d: AstroData, i: int):
         """Convert Jy/beam data to brightness temperature if requested."""
@@ -766,12 +778,12 @@ class AstroFrame():
             return
 
         dx = d.dy if self.swapxy else d.dx
-        header = {"CDELT1": dx / 3600,
-                  "CUNIT1": "DEG",
-                  "RESTFREQ": d.restfreq[i]}
+        header = {'CDELT1': dx / 3600,
+                  'CUNIT1': 'deg',
+                  'RESTFREQ': d.restfreq[i]}
         if None not in d.beam[i]:
-            header["BMAJ"] = d.beam[i][0] / 3600 / self.dist
-            header["BMIN"] = d.beam[i][1] / 3600 / self.dist
+            header['BMAJ'] = d.beam[i][0] / 3600 / self.dist
+            header['BMIN'] = d.beam[i][1] / 3600 / self.dist
         factor = Jy2K(header=header)
         d.data[i] = d.data[i] * factor
         if d.sigma[i] is not None:
@@ -785,7 +797,7 @@ class AstroFrame():
         bmaj, bmin, bpa = d.beam_org[i] = d.beam[i]
         if d.pvpa[i] is None:
             d.pvpa[i] = bpa
-            print("pvpa is not specified. pvpa=bpa is assumed.")
+            print('pvpa is not specified. pvpa=bpa is assumed.')
         angle = np.radians(bpa - d.pvpa[i])
         beam_incut = 1 / np.hypot(np.cos(angle) / bmaj, np.sin(angle) / bmin)
         d.beam[i] = np.array([np.abs(d.dv), beam_incut, 0])
@@ -827,5 +839,5 @@ class AstroFrame():
         d.beam = _as_list(d.beam, d.n, isbeam=True)
         for i in range(d.n):
             self._read_one(d, i)
-        for name in ASTRODATA_ARGS + ["beam"]:
+        for name in ASTRODATA_ARGS + ['beam']:
             setattr(d, name, _scalar_if_single(getattr(d, name), d.n))

{plotastrodata-1.9.9 → plotastrodata-1.9.11}/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:
@@ -18,7 +18,7 @@ def _updateframe(frame: str) -> str:
         a = FK5(equinox='J2000')
     elif 'B1950' in frame or 'FK4' in frame:
         a = FK4(equinox='B1950')
-    elif type(frame) is str:
+    elif isinstance(frame, str):
         print(f'Unknown frame ({frame}) was found. Use ICRS instead.')
         a = 'icrs'
     else:
@@ -26,7 +26,7 @@ def _updateframe(frame: str) -> str:
     return a
 
 
-def _getframe(coord: str) -> tuple:
+def _getframe(coord: str | list) -> tuple:
     """Internal function to pick up the frame name from the coordinates. When coord is a list, frame and framename are picked up from the first element.
 
     Args:
@@ -43,7 +43,7 @@ def _getframe(coord: str) -> tuple:
         framename = c[0] if hasframe else None
         return hmsdms, frame, framename
 
-    if type(coord) is str:
+    if isinstance(coord, str):
         return getframe_single(coord)
     else:
         outlist = [getframe_single(c) for c in coord]
@@ -108,7 +108,7 @@ def xy2coord(xy: list, coordorg: str = '00h00m00s 00d00m00s',
         coords = coords.transform_to(frame=frame)
     coords = coords.to_string('hmsdms')
     if framename is not None:
-        if type(coords) is str:
+        if isinstance(coords, str):
             coords = f'{framename} {coords}'
         else:
             coords = np.array([f'{framename} {s}' for s in coords])

{plotastrodata-1.9.9 → plotastrodata-1.9.11}/plotastrodata/fits_utils.py

@@ -241,23 +241,23 @@ class FitsData:
         h = self.header
         cxy = (0, 0)
         if center is not None and not self.wcsrot:
-            coordorg = xy2coord([h["CRVAL1"], h["CRVAL2"]])
-            if (radesys := h.get("RADESYS")) is not None:
-                coordorg = f"{radesys}  {coordorg}"
+            coordorg = xy2coord([h['CRVAL1'], h['CRVAL2']])
+            if (radesys := h.get('RADESYS')) is not None:
+                coordorg = f'{radesys}  {coordorg}'
             cxy = coord2xy(center, coordorg)
-        slabel = ["x", "y"]
+        slabel = ['x', 'y']
 
         def wrapper(i: int):
             def gen_s(s_in: np.ndarray | None) -> None:
-                if h.get(f"NAXIS{i+1}") is None or s_in is None:
+                if h.get(f'NAXIS{i+1}') is None or s_in is None:
                     s, ds = None, None
                 else:
                     s = (s_in - cxy[i]) * dist
-                    if isdeg(h[f"CUNIT{i+1}"]):
+                    if isdeg(h[f'CUNIT{i+1}']):
                         s *= 3600.
                     ds = None if len(s) == 0 else s[1] - s[0]
-                setattr(self, f"{slabel[i]}", s)
-                setattr(self, f"d{slabel[i]}", ds)
+                setattr(self, f'{slabel[i]}', s)
+                setattr(self, f'd{slabel[i]}', ds)
             return gen_s
 
         return wrapper(0), wrapper(1)
@@ -266,29 +266,29 @@ class FitsData:
         h = self.header
 
         def gen_v(v_in: np.ndarray) -> None:
-            vaxis = "2" if pv else "3"
-            if h.get(f"NAXIS{vaxis}") is None or v_in is None:
+            vaxis = '2' if pv else '3'
+            if h.get(f'NAXIS{vaxis}') is None or v_in is None:
                 self.v, self.dv = None, None
                 return
 
             if restfreq is None:
                 freq = np.mean(v_in)
-                print("restfreq is assumed to be the center.")
+                print('restfreq is assumed to be the center.')
             else:
                 freq = restfreq
-            v = v_in + h[f"CRVAL{vaxis}"]
+            v = v_in + h[f'CRVAL{vaxis}']
             key = f'CUNIT{vaxis}'
             cunitv = h[key].strip()
             match cunitv:
-                case "Hz" | "HZ":
+                case 'Hz' | 'HZ':
                     if freq == 0:
-                        print("v is read as is, because restfreq=0.")
+                        print('v is read as is, because restfreq=0.')
                     else:
                         v = (1 - v / freq) * cu.c_kms - vsys
-                case "m/s" | "M/S":
+                case 'm/s' | 'M/S':
                     print(f'{key}={cunitv} found.')
                     v = v * 1e-3 - vsys
-                case 'km/s' | "KM/S":
+                case 'km/s' | 'KM/S':
                     print(f'{key}={cunitv} found.')
                     v = v - vsys
                 case _:
@@ -301,11 +301,11 @@ class FitsData:
 
     def _get_array(self, i: int) -> np.ndarray:
         h = self.header
-        n = h.get(f"NAXIS{i:d}")
+        n = h.get(f'NAXIS{i:d}')
         if n is None:
             return None
 
-        s = (np.arange(n) - h[f"CRPIX{i:d}"] + 1) * h[f"CDELT{i:d}"]
+        s = (np.arange(n) - h[f'CRPIX{i:d}'] + 1) * h[f'CDELT{i:d}']
         return s
 
     def gen_grid(self, center: str | None = None, dist: float = 1.,
@@ -343,7 +343,7 @@ class FitsData:
         Returns:
             tuple: (x, y, v).
         """
-        if not np.all([hasattr(self, s) for s in ["x", "y", "v"]]):
+        if not np.all([hasattr(self, s) for s in ['x', 'y', 'v']]):
             self.gen_grid(**kwargs)
         return self.x, self.y, self.v
 
@@ -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: