vsh-tools 0.1.0__py3-none-any.whl

vsh_tools/basis.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File name: basis.py
+"""
+Vector Spherical Harmonics (VSH) basis projections.
+
+Reference
+---------
+F. Mignard & S. Klioner, A&A 547, A59 (2012).
+DOI: 10.1051/0004-6361/201219927.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy import sqrt, pi, sin, cos
+from math import factorial
+from typing import Tuple
+
+__all__ = ["vec_sph_harm_proj", "real_vec_sph_harm_proj"]
+
+# -----------------------------  FUNCTIONS -----------------------------
+
+
+def vec_sph_harm_proj(
+    l_max: int,
+    ra: np.ndarray,
+    dc: np.ndarray,
+    sph_type: str = "T",
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Compute complex VSH projections T_lm (or S_lm) onto (e_ra, e_dec) at (ra, dec).
+
+    Parameters
+    ----------
+    l_max : int
+        Maximum degree of the harmonics (>= 1).
+    ra, dc : array_like of float (radians)
+        Right ascension and declination arrays of equal length.
+    sph_type : {"T","S"}, optional
+        Return toroidal ("T") or spheroidal ("S") projections. Default "T".
+
+    Returns
+    -------
+    T_ra_mat, T_dc_mat : complex ndarray, shape (l_max+1, l_max+1, N)
+        For each (l, m), the projection of the vector harmonic onto e_ra and e_dec.
+
+    Notes
+    -----
+    - m runs 0..l; entries where 0 <= m <= l are filled, others remain zero.
+    - S_lm is obtained from T_lm via (S_ra, S_dc) = (-T_dc, T_ra).
+    """
+
+    # Basic checks / normalization
+    try:
+        l_max = int(l_max)
+    except Exception as e:
+        raise ValueError("l_max must be convertible to int.") from e
+    if l_max < 1:
+        raise ValueError("l_max must be >= 1.")
+
+    ra = np.asarray(ra, dtype=float)
+    dc = np.asarray(dc, dtype=float)
+    if ra.shape != dc.shape:
+        raise ValueError("ra and dc must have the same shape.")
+    N = ra.size
+
+    x = sin(dc)
+    # Guard against tiny negative values from rounding (near poles)
+    fac_pol = np.sqrt(np.clip(1.0 - x * x, 0.0, 1.0))
+
+    # A_lm and B_lm recursion buffers
+    A_mat = np.zeros((l_max + 1, l_max + 1, N), dtype=float)
+    B_mat = np.zeros((l_max + 1, l_max + 1, N), dtype=float)
+    B_mat[1, 1, :] = 1.0  # seed
+    B_mat[1, 0, :] = 0.0
+
+    # Output buffers (complex)
+    T_ra_mat = np.zeros((l_max + 1, l_max + 1, N), dtype=complex)
+    T_dc_mat = np.zeros((l_max + 1, l_max + 1, N), dtype=complex)
+
+    # Build B_lm (Eqs. B.13–B.17)
+    for l in range(2, l_max + 1):
+        for m in range(l, -1, -1):  # m = l, l-1, ..., 0
+            if m == 0:
+                B_mat[l, 0, :] = 0.0
+            elif l == m:
+                # (2m-1) * m/(m-1) * sqrt(1-x^2) * B_{m-1,m-1}
+                B_mat[l, m, :] = fac_pol * \
+                    (2 * m - 1) * (m / (m - 1)) * B_mat[m - 1, m - 1, :]
+            elif l == m + 1:
+                # (2m+1) * x * B_{m,m}
+                B_mat[l, m, :] = (2 * m + 1) * x * B_mat[m, m, :]
+            else:
+                # ((2l-1)x B_{l-1,m} - (l-1+m) B_{l-2,m}) / (l-m)
+                B_mat[l, m, :] = ((2 * l - 1) * x * B_mat[l - 1, m, :] -
+                                  (l - 1 + m) * B_mat[l - 2, m, :]) / (l - m)
+
+    # Build A_lm (Eqs. B.18–B.19)
+    for l in range(1, l_max + 1):
+        for m in range(0, l + 1):
+            if m == 0:
+                A_mat[l, 0, :] = fac_pol * B_mat[l, 1, :]
+            else:
+                # (-x*l*B_{l,m} + (l+m)B_{l-1,m}) / m
+                A_mat[l, m, :] = (-x * l * B_mat[l, m, :] +
+                                  (l + m) * B_mat[l - 1, m, :]) / m
+
+    # Project to e_ra, e_dec (Eqs. B.9–B.10)
+    for l in range(1, l_max + 1):
+        for m in range(0, l + 1):
+            # Normalization coefficient
+            c = (2 * l + 1) / (l * (l + 1)) / (4 * pi) * \
+                factorial(l - m) / factorial(l + m)
+            c = (-1) ** m * sqrt(c) * (cos(m * ra) + 1j * sin(m * ra))
+
+            T_ra_mat[l, m, :] = c * A_mat[l, m, :]
+            T_dc_mat[l, m, :] = c * B_mat[l, m, :] * (-1j)
+
+    if sph_type == "T":
+        return T_ra_mat, T_dc_mat
+    elif sph_type == "S":
+        # S = (-T_dc, T_ra)
+        return -T_dc_mat, T_ra_mat
+    else:
+        raise ValueError("sph_type must be 'T' or 'S'.")
+
+
+def real_vec_sph_harm_proj(
+    l: int,
+    m: int,
+    T_ra_mat: np.ndarray,
+    T_dc_mat: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Real-valued VSH components for given (l, m) from complex T_lm projections.
+
+    Parameters
+    ----------
+    l, m : int
+        Degree and order (with 0 <= m <= l).
+    T_ra_mat, T_dc_mat : complex ndarray
+        Outputs of `vec_sph_harm_proj(...)`.
+
+    Returns
+    -------
+    T_ra_r, T_dc_r, T_ra_i, T_dc_i : float ndarray
+        Real and imaginary parts (with the conventional sign: imag parts negated
+        compared to the raw complex imag) as used in real expansions.
+        If m == 0, returns (real(T_ra), real(T_dc), zeros, zeros).
+    """
+    if not (0 <= m <= l):
+        raise ValueError("Require 0 <= m <= l.")
+
+    T_ra = T_ra_mat[l, m, :]
+    T_dc = T_dc_mat[l, m, :]
+
+    if m == 0:
+        # Only the "real" component is used for m = 0
+        return np.real(T_ra), np.real(T_dc), np.zeros_like(T_ra, dtype=float), np.zeros_like(T_dc, dtype=float)
+
+    # For m > 0, real basis uses:
+    # real part unchanged, imag part with opposite sign and factor 2
+    T_ra_r = 2.0 * np.real(T_ra)
+    T_dc_r = 2.0 * np.real(T_dc)
+    T_ra_i = -2.0 * np.imag(T_ra)
+    T_dc_i = -2.0 * np.imag(T_dc)
+
+    return T_ra_r, T_dc_r, T_ra_i, T_dc_i

vsh_tools/bootstrap.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File name: bootstrap.py
+"""
+Nonparametric bootstrap for VSH parameter uncertainties.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .outliers import extract_data
+from .linalg import nor_eq_sol
+from .transforms import convert_ts_to_rgq
+
+
+# ----------------------------- utilities -----------------------------
+def bs_freq(x_or_n=None) -> int:
+    """
+    Bootstrap resampling frequency N ≈ n * ln(n)^2.
+
+    Accepts either an array (length n) or an integer n.
+    Falls back to N=1000 if None given.
+    """
+    print("Decide the frequency of bootstrap resamplings")
+    if x_or_n is None:
+        print("Since no sample is given, using the default value (1000).")
+        return 1000
+
+    n = int(x_or_n if np.isscalar(x_or_n) else len(x_or_n))
+    if n <= 1:
+        return 1000
+    N = int(n * (np.log(n) ** 2))
+    print(f"Sample size n={n}, resampling frequency N ≈ n * ln(n)^2 = {N}")
+    return max(N, 1)
+
+
+def bs_formal_error(x, xi):
+    """
+    Estimate mean, std of bootstrap draws, and RMS around the original x.
+    """
+    xi = np.asarray(xi, dtype=float)
+    xi_mean = float(np.mean(xi))
+    xi_std = float(np.std(xi, ddof=1)) if xi.size > 1 else 0.0
+    denom = max(xi.size - 1, 1)
+    xi_rms = float(np.sqrt(np.sum((xi - x) ** 2) / denom))
+    return xi_mean, xi_std, xi_rms
+
+
+def bs_resampling(X, Y, samp_size=None):
+    """
+    Bootstrap resample paired arrays X, Y with replacement.
+    """
+    X = np.asarray(X)
+    Y = np.asarray(Y)
+    if X.shape[0] != Y.shape[0]:
+        raise ValueError("X and Y must have the same length.")
+    n = X.shape[0]
+    m = int(n if samp_size is None else samp_size)
+    idx = np.random.choice(n, size=m, replace=True)
+    return X[idx], Y[idx]
+
+
+def bs_resampling_indx(X, samp_size=None):
+    """
+    Return bootstrap indices for X (size given or len(X)), with replacement.
+    """
+    n = len(X)
+    m = int(n if samp_size is None else samp_size)
+    return np.random.choice(n, size=m, replace=True)
+
+
+# ----------------------------- main -----------------------------
+def bootstrap_resample_4_err(
+    mask,
+    dra,
+    ddc,
+    dra_err,
+    ddc_err,
+    ra_rad,
+    dc_rad,
+    ra_dc_cor,
+    l_max,
+    fit_type,
+    num_iter,
+    output,
+):
+    """
+    Estimate formal uncertainty via nonparametric bootstrap.
+
+    Returns
+    -------
+    output : dict
+        Updated with bootstrap summaries for VSH coeffs and RGQ terms.
+    """
+    # Clean sample (if a mask was applied)
+    if not np.all(mask):
+        dra, ddc, dra_err, ddc_err, ra_rad, dc_rad, ra_dc_cor = extract_data(
+            mask, dra, ddc, dra_err, ddc_err, ra_rad, dc_rad, ra_dc_cor
+        )
+
+    # Current estimates (baseline)
+    pmt = np.asarray(output["pmt"])
+    if "pmt1" in output:
+        pmt1 = np.asarray(output["pmt1"])
+        degree_key = "pmt1"
+    else:
+        pmt1 = np.asarray(output["pmt2"])
+        degree_key = "pmt2"
+
+    # Bootstrap sizes
+    N_samp = len(dra)
+    N_resamp = bs_freq(N_samp)
+    N_pmt = pmt.size
+    N_pmt1 = pmt1.size
+
+    pmt_ts_array = np.zeros((N_resamp, N_pmt))    # VSH coeffs
+    # RGQ terms (length depends on l_max & fit_type)
+    pmt_rgq_array = np.zeros((N_resamp, N_pmt1))
+
+    for i in range(N_resamp):
+        # Indices for a bootstrap sample
+        new_idx = bs_resampling_indx(dra)
+
+        # Slice all arrays consistently (extract_data accepts index arrays too)
+        dra1, ddc1, dra_err1, ddc_err1, ra_rad1, dc_rad1, ra_dc_cor1 = extract_data(
+            new_idx, dra, ddc, dra_err, ddc_err, ra_rad, dc_rad, ra_dc_cor
+        )
+
+        # Refit on the resampled data
+        pmti, sigi, cor_mati, _, _ = nor_eq_sol(
+            dra1, ddc1, dra_err1, ddc_err1, ra_rad1, dc_rad1,
+            ra_dc_cor=ra_dc_cor1, l_max=l_max, fit_type=fit_type,
+            num_iter=num_iter, calc_res=True
+        )
+        pmt_ts_array[i, :] = pmti
+
+        # Convert to rotation/glide/quadrupolar terms
+        conv = convert_ts_to_rgq(pmti, sigi, cor_mati, l_max, fit_type)
+        rgq = np.asarray(conv["pmt1"] if "pmt1" in conv else conv["pmt2"])
+        if rgq.size != N_pmt1:
+            # If the pipeline later changes lengths, keep it robust:
+            rgq = rgq[:N_pmt1]
+        pmt_rgq_array[i, :] = rgq
+
+    # Bootstrap summaries for VSH coeffs
+    pmt_ts_mean = np.zeros(N_pmt)
+    pmt_ts_std = np.zeros(N_pmt)
+    pmt_ts_rms = np.zeros(N_pmt)
+    for i in range(N_pmt):
+        meani, stdi, rmsi = bs_formal_error(pmt[i], pmt_ts_array[:, i])
+        pmt_ts_mean[i], pmt_ts_std[i], pmt_ts_rms[i] = meani, stdi, rmsi
+
+    # Bootstrap summaries for RGQ terms
+    pmt_rgq_mean = np.zeros(N_pmt1)
+    pmt_rgq_std = np.zeros(N_pmt1)
+    pmt_rgq_rms = np.zeros(N_pmt1)
+    for i in range(N_pmt1):
+        meani, stdi, rmsi = bs_formal_error(pmt1[i], pmt_rgq_array[:, i])
+        pmt_rgq_mean[i], pmt_rgq_std[i], pmt_rgq_rms[i] = meani, stdi, rmsi
+
+    # Store results
+    output["pmt_bs_mean"] = pmt_ts_mean
+    output["pmt_bs_std"] = pmt_ts_std
+    output["pmt_bs_rms"] = pmt_ts_rms
+
+    output[f"{degree_key}_bs_mean"] = pmt_rgq_mean
+    output[f"{degree_key}_bs_std"] = pmt_rgq_std
+    output[f"{degree_key}_bs_rms"] = pmt_rgq_rms
+
+    # Notes (keep as a list; caller can print if needed)
+    output["note"] = output.get("note", []) + [
+        "pmt_bs_mean/std/rms: VSH coefficients from bootstrap sampling",
+        f"{degree_key}_bs_mean/std/rms: glide+rotation(+quadrupolar) from bootstrap sampling",
+    ]
+
+    return output
+
+
+def main():
+    print("Have a nice day!")
+
+
+if __name__ == "__main__":
+    main()

vsh_tools/deprecated/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env ipython
+# -*- coding: utf-8 -*-
+# File name: __init__.py
+"""
+Created on Mon Feb  7 14:52:46 2022
+
+@author: Neo(niu.liu@nju.edu.cn)
+"""

vsh_tools/deprecated/auto_elim.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File name: auto_elim.py
+"""
+Created on Thu Dec 24 10:35:28 2020
+
+@author: Neo(niu.liu@nju.edu.cn)
+
+This script contains code for auto-elimination.
+"""
+
+import numpy as np
+
+# My progs
+from .stats_func import calc_nor_sep
+from .matrix_calc import (nor_eq_sol_from_cache, nor_eq_sol,
+                          residual_calc_from_cache,
+                          cache_mat_calc, rm_cache_mat)
+
+
+# ----------------------------- Function -----------------------------
+def extract_data(mask, dra, ddc, dra_err, ddc_err, ra_rad, dc_rad, ra_dc_cor=None):
+    """Get a clean sample based on mask
+
+    Parameters
+    ----------
+    mask : array of boolean
+        mask for extract data
+    dra/ddc : array of float
+        R.A.(*cos(Dec.))/Dec. differences
+    dra_err/ddc_err : array of float
+        formal uncertainty of dra(*cos(dc_rad))/ddc
+    ra_rad/dc_rad : array of float
+        Right ascension/Declination in radian
+
+    Returns
+    ----------
+    dra_new/ddc_new: array of float
+        R.A.(*cos(Dec.))/Dec for the clean sample. differences
+    dra_err_new/ddc_err_new: array of float
+        formal uncertainty of dra(*cos(dc_rad))/ddc for the clean sample
+    ra_rad_new/dc_rad_new: array of float
+        Right ascension/Declination in radian for the clean sample
+    ra_dc_cor_new: array of float
+        covariance/correlation coefficient between dra and ddc for the clean sample
+    """
+
+    # Extract the clean sample
+    dra_new, ddc_new = dra[mask], ddc[mask]
+    dra_err_new, ddc_err_new = dra_err[mask], ddc_err[mask]
+    ra_rad_new, dc_rad_new = ra_rad[mask], dc_rad[mask]
+
+    if ra_dc_cor is None:
+        ra_dc_cor_new = ra_dc_cor
+    else:
+        ra_dc_cor_new = ra_dc_cor[mask]
+
+    return dra_new, ddc_new, dra_err_new, ddc_err_new, ra_rad_new, dc_rad_new, ra_dc_cor_new
+
+
+def elim_on_nor_sep(clip_limit, dra, ddc, dra_err, ddc_err, ra_dc_cor=None):
+    """Get a clean sample based on normalized separation
+
+    Parameters
+    ----------
+    dra/ddc: array of float
+        R.A.(*cos(Dec.))/Dec. differences
+    dra_err/ddc_err: array of float
+        formal uncertainty of dra(*cos(dc_rad))/ddc
+    ra_rad/dc_rad: array of float
+        Right ascension/Declination in radian
+    clip_limit: int ot float
+        maximum normalized separation for clipping data
+    ra_dc_cor: array of float
+        correlation coefficient between dra and ddc, default is None
+
+    Returns
+    ----------
+    dra_new/ddc_new: array of float
+        R.A.(*cos(Dec.))/Dec for the clean sample. differences
+    dra_err_new/ddc_err_new: array of float
+        formal uncertainty of dra(*cos(dc_rad))/ddc for the clean sample
+    ra_rad_new/dc_rad_new: array of float
+        Right ascension/Declination in radian for the clean sample
+    ra_dc_cor_new: array of float
+        covariance/correlation coefficient between dra and ddc for the clean sample
+    """
+
+    # Calculate normalized separation
+    nor_sep = calc_nor_sep(dra, dra_err, ddc, ddc_err, ra_dc_cor)
+    med_nor_sep = np.median(nor_sep)
+    max_nor_sep = clip_limit * med_nor_sep
+
+    # Constraint on normalized separation
+    mask = (nor_sep <= max_nor_sep)
+
+    return max_nor_sep, mask
+
+
+def auto_elim_vsh_fit(clip_limit, dra, ddc, dra_err, ddc_err, ra_rad, dc_rad,
+                      ra_dc_cor=None, l_max=1, fit_type="full", num_iter=100):
+    """ Fit the VSH parameters with auto-elimination
+
+    Parameters
+    ----------
+    clip_limit: float
+        thershold on normalized separation for auto-elimination
+    dra/ddc: array of float
+        R.A.(*cos(Dec.))/Dec. differences
+    dra_err/ddc_err: array of float
+        formal uncertainty of dra(*cos(dc_rad))/ddc
+    ra_rad/dc_rad: array of float
+        Right ascension/Declination in radian
+    ra_dc_cor: array of float
+        correlation coefficient between dra and ddc, default is None
+    l_max: int
+        maximum degree
+    fit_type: string
+        flag to determine which parameters to be fitted
+        full for T - and S-vectors both
+        T for T-vectors only
+        S for S-vectors only
+    pos_in_rad: Boolean
+        tell if positions are given in radian, mostly False
+    num_iter: int
+        number of source once processed. 100 should be fine
+
+    Returns
+    ----------
+    pmt: array of float
+        estimation of(d1, d2, d3, r1, r2, r3)
+    sig: array of float
+        uncertainty of x
+    cor_mat: matrix
+        matrix of correlation coefficient.
+    """
+
+    print("==================== Auto-elimination ====================")
+    print("    Nb_iteration    Nb_sources    Nb_outliers    Threshold")
+    print("    {:11d}    {:9d}    {:9d}    {:9.3f}".format(0, len(dra), 0, 0))
+
+    # mask1 = All True
+    mask1 = np.full(len(dra), True)
+    iter_count = 0
+
+    # first elimination
+    max_nor_sep2, mask2 = elim_on_nor_sep(
+        clip_limit, dra, ddc, dra_err, ddc_err, ra_dc_cor)
+
+    # Generate cache matrix
+    suffix_array = cache_mat_calc(
+        dra, ddc, dra_err, ddc_err, ra_rad, dc_rad,
+        ra_dc_cor=ra_dc_cor, l_max=l_max, fit_type=fit_type, num_iter=num_iter)
+
+    while np.any(mask1 != mask2):
+        # Renew the flags
+        max_nor_sep1, mask1 = max_nor_sep2, mask2
+
+        # Generate a clean sample
+        [dra1, ddc1, dra_err1, ddc_err1, ra_rad1, dc_rad1, ra_dc_cor1] = extract_data(
+            mask1, dra, ddc, dra_err, ddc_err, ra_rad, dc_rad, ra_dc_cor)
+
+        iter_count += 1
+        print("    {:11d}    {:9d}    {:9d}    {:9.3f}".format(
+            iter_count, len(dra1), len(dra)-len(dra1), max_nor_sep1))
+
+        pmt, sig, cor_mat = nor_eq_sol(
+            dra1, ddc1, dra_err1, ddc_err1, ra_rad1, dc_rad1,
+            ra_dc_cor=ra_dc_cor1, l_max=l_max, fit_type=fit_type,
+            num_iter=num_iter, calc_res=False)
+
+        # Calculate residuals for all sources
+        dra_r, ddc_r = residual_calc_from_cache(
+            dra, ddc, pmt, suffix_array)
+
+        # Re-eliminate the data
+        max_nor_sep2, mask2 = elim_on_nor_sep(
+            clip_limit, dra_r, ddc_r, dra_err, ddc_err, ra_dc_cor)
+
+    # Record the mask
+    mask = mask1
+
+    # If no source is classified as outlier
+    if iter_count == 0:
+        pmt, sig, cor_mat, dra_r, ddc_r = nor_eq_sol_from_cache(
+            dra, ddc, suffix_array, num_iter=num_iter)
+
+    # Remove cache file
+    rm_cache_mat(suffix_array)
+
+    return pmt, sig, cor_mat, dra_r, ddc_r, mask
+
+
+def std_elim_vsh_fit(x_limit, dra, ddc, dra_err, ddc_err, ra_rad, dc_rad,
+                     ra_dc_cor=None, l_max=1, fit_type="full", num_iter=100):
+    """Fit the VSH parameters with standard-elimination
+
+    Parameters
+    ----------
+    x_limit: float
+        thershold on normalized separation for std-elimination
+    dra/ddc: array of float
+        R.A.(*cos(Dec.))/Dec. differences
+    dra_err/ddc_err: array of float
+        formal uncertainty of dra(*cos(dc_rad))/ddc
+    ra_rad/dc_rad: array of float
+        Right ascension/Declination in radian
+    ra_dc_cor: array of float
+        correlation coefficient between dra and ddc, default is None
+    l_max: int
+        maximum degree
+    fit_type: string
+        flag to determine which parameters to be fitted
+        full for T - and S-vectors both
+        T for T-vectors only
+        S for S-vectors only
+    pos_in_rad: Boolean
+        tell if positions are given in radian, mostly False
+    num_iter: int
+        number of source once processed. 100 should be fine
+
+    Returns
+    ----------
+    pmt: array of float
+        estimation of(d1, d2, d3, r1, r2, r3)
+    sig: array of float
+        uncertainty of x
+    cor_mat : matrix
+        matrix of correlation coefficient.
+    mask : array-like of boolean
+        flag for the clean sample
+    """
+
+    # Generate cache matrix
+    suffix_array = cache_mat_calc(
+        dra, ddc, dra_err, ddc_err, ra_rad, dc_rad,
+        ra_dc_cor=ra_dc_cor, l_max=l_max, fit_type=fit_type, num_iter=num_iter)
+
+    # Calculate normalized separation
+    nor_sep = calc_nor_sep(dra, dra_err, ddc, ddc_err, ra_dc_cor)
+    mask = (nor_sep <= x_limit)
+
+    # Generate a clean sample
+    [dra1, ddc1, dra_err1, ddc_err1, ra_rad1, dc_rad1, ra_dc_cor1] = extract_data(
+        mask, dra, ddc, dra_err, ddc_err, ra_rad, dc_rad, ra_dc_cor)
+
+    print("==================== Standard-elimination ====================")
+    print("    Nb_sources    Nb_outliers    Threshold")
+    print("    {:9d}    {:9d}    {:9.3f}".format(
+        len(dra1), len(dra)-len(dra1), x_limit))
+
+    pmt, sig, cor_mat = nor_eq_sol(
+        dra1, ddc1, dra_err1, ddc_err1, ra_rad1, dc_rad1,
+        ra_dc_cor=ra_dc_cor1, l_max=l_max, fit_type=fit_type,
+        num_iter=num_iter, calc_res=False)
+
+    # Calculate residuals for all sources
+    dra_r, ddc_r = residual_calc_from_cache(
+        dra, ddc, pmt, suffix_array)
+
+    # Remove cache file
+    rm_cache_mat(suffix_array)
+
+    return pmt, sig, cor_mat, dra_r, ddc_r, mask
+
+
+def main():
+    """Maybe add some tests here
+    """
+
+    print("Have a nice day!")
+
+
+if __name__ == "__main__":
+    main()
+# --------------------------------- END --------------------------------