From b654a2a62bd286ec090d89daf6f6649c7019ce57 Mon Sep 17 00:00:00 2001 From: mariajmellado Date: Tue, 16 Apr 2024 00:13:52 -0400 Subject: [PATCH 1/5] feat: finding best parameters for SE Kernel --- frank/fitExample/AS209_1mm_FrankFit.py | 44 +++++++++++ frank/radial_fitters.py | 5 +- frank/statistical_models.py | 103 ++++++++++++++++++++++++- 3 files changed, 149 insertions(+), 3 deletions(-) create mode 100644 frank/fitExample/AS209_1mm_FrankFit.py diff --git a/frank/fitExample/AS209_1mm_FrankFit.py b/frank/fitExample/AS209_1mm_FrankFit.py new file mode 100644 index 00000000..c7e0e4da --- /dev/null +++ b/frank/fitExample/AS209_1mm_FrankFit.py @@ -0,0 +1,44 @@ +import frank +import numpy as np +import matplotlib.pyplot as plt + +from frank.geometry import SourceGeometry +from frank.radial_fitters import FrankFitter, FourierBesselFitter + +# Huang 2018 +inc = 34.97 +pa = 85.76 +dra = 1.9e-3 +ddec = -2.5e-3 +r_out = 1.9 + +# Frank Parameters +n_pts = 300 +alpha = 1.3 +w_smooth = 1e-1 + +# UVtable AS209 at 1mm with removed visibilities between . +dir = "./" +data_file = dir + 'AS209_continuum_prom_1chan_30s_keepflagsFalse_removed1.txt' + +# Loading data +u, v, Re, Im, Weights = np.loadtxt(data_file, unpack = True, skiprows = 1) +vis = Re + Im*1j + +geom = SourceGeometry(inc= inc, PA= pa, dRA= dra, dDec= ddec) + +" Fitting with frank " +#FF = FrankFitter(r_out, n_pts, geom, alpha = alpha, weights_smooth = w_smooth) +FF = FourierBesselFitter(r_out, n_pts, geom) +sol = FF.fit(u, v, vis, Weights) +#setattr(sol, 'positive', sol.solve_non_negative()) + +fig = plt.figure(num = 1, figsize = (10, 5)) +plt.plot(sol.r, sol.mean / 1e10) +plt.xlabel('Radius ["]', size = 15) +plt.ylabel(r'Brightness profile [$10^{10}$ Jy sr$^{-1}$]', size = 15) +plt.title('Frank Fit AS209 1mm', size = 15) +plt.xlim(0, 1.3) +#plt.savefig('FrankFit_AS209_1mm.jpg', bbox_inches='tight') +plt.show() +plt.close() \ No newline at end of file diff --git a/frank/radial_fitters.py b/frank/radial_fitters.py index 81a0e65c..dfb6f87f 100644 --- a/frank/radial_fitters.py +++ b/frank/radial_fitters.py @@ -510,6 +510,8 @@ def _build_matrices(self, mapping): self._M = mapping['M'] self._j = mapping['j'] + self._V = mapping['V'] + self._Wvalues = mapping['W'] self._H0 = mapping['null_likelihood'] @@ -574,7 +576,8 @@ def fit(self, u, v, V, weights=1): def _fit(self): """Fit step. Computes the best fit given the pre-processed data""" fit = GaussianModel(self._DHT, self._M, self._j, - noise_likelihood=self._H0) + noise_likelihood=self._H0, + Wvalues= self._Wvalues, V = self._V) self._sol = FrankGaussianFit(self._vis_map, fit, self._info, geometry=self._geometry.clone()) diff --git a/frank/statistical_models.py b/frank/statistical_models.py index 46db07b7..183cdbcd 100644 --- a/frank/statistical_models.py +++ b/frank/statistical_models.py @@ -234,6 +234,8 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): 'j' : js[0], 'null_likelihood' : H0, 'hash' : [False, self._DHT, geometry, self._vis_model, self._scale_height], + 'V' : Vs, + 'W' : ws, } def check_hash(self, hash, multi_freq=False, geometry=None): @@ -628,9 +630,12 @@ class GaussianModel: """ def __init__(self, DHT, M, j, p=None, scale=None, guess=None, - Nfields=None, noise_likelihood=0): + Nfields=None, noise_likelihood=0, + Wvalues = None, V = None): self._DHT = DHT + self._Wvalues = Wvalues + self._V = V # Correct shape of design matrix etc. if len(M.shape) == 2: @@ -687,7 +692,19 @@ def __init__(self, DHT, M, j, p=None, scale=None, guess=None, self._Sinv[sn:en, sn:en] += Sj[n] else: - self._Sinv = None + #self._Sinv = None + q_array = self._DHT.q + + def true_squared_exponential_kernel(q, p, l): + + q1, q2 = np.meshgrid(q, q) + p1, p2 = np.meshgrid(p, p) + SE_Kernel = np.sqrt(p1 * p2) * np.exp(-0.5*(q1-q2)**2 / l**2) + return SE_Kernel + + Ykm = self._DHT.coefficients(direction="backward") + # We continue after set M matrix because is needed to calculate + # best parameters for S matrix. # Compute the design matrix self._M = np.zeros([Nr*Nfields, Nr*Nfields], dtype='f8') @@ -707,7 +724,89 @@ def __init__(self, DHT, M, j, p=None, scale=None, guess=None, self._like_noise = noise_likelihood + # M is already defined, so we find best parameters for S matrix and use it. + m, c , l = self.minimizeS() + pI = np.exp(m*np.log(q_array) + c) + S_fspace = true_squared_exponential_kernel(q_array, pI, l) + S_real = np.dot(np.transpose(Ykm), np.dot(S_fspace, Ykm)) + S_real_inv = np.linalg.inv(S_real) + self._Sinv = S_real_inv + self._fit() + + def minimizeS(self): + from scipy.optimize import minimize + from scipy.special import gamma + V = self._V + + def calculate_S(m, c, l): + q_array = self._DHT.q + p_array = c*(q_array**m) + def true_squared_exponential_kernel(q, p, l): + q1, q2 = np.meshgrid(q, q) + p1, p2 = np.meshgrid(p, p) + SE_Kernel = np.sqrt(p1 * p2) * np.exp(-0.5*(q1-q2)**2 / l**2) + return SE_Kernel + + Ykm = self._DHT.coefficients(direction="backward") + S_fspace = true_squared_exponential_kernel(q_array, p_array, l) + S_real = np.dot(np.transpose(Ykm), np.dot(S_fspace, Ykm)) + return S_real + + def calculate_D(S): + S_real_inv = np.linalg.inv(S) + Dinv = self._M + S_real_inv + D = np.linalg.inv(Dinv) + return [Dinv, D] + + def calculate_mu(Dinv): + try: + Dchol = scipy.linalg.cho_factor(Dinv) + mu = scipy.linalg.cho_solve(Dchol, self._j) + + except np.linalg.LinAlgError: + U, s, V = scipy.linalg.svd(Dinv, full_matrices=False) + s1 = np.where(s > 0, 1. / s, 0) + mu = np.dot(V.T, np.multiply(np.dot(U.T, self._j), s1)) + return mu + + def likelihood(param, data): + m, c, l = param + Wvalues = self._Wvalues + N = np.diag(1/Wvalues) + + alpha = 1.3 + l0 = 1e7 + + # Create an Inverse Gamma distribution function + def inv_gamma_function(l, alpha, beta): + return ((gamma(alpha)*beta)**(-1))*((beta/l)**(alpha + 1))*np.exp(-beta/l) + + S = calculate_S(m,c, l) + [Dinv, D] = calculate_D(S) + mu = calculate_mu(Dinv) + logdetS = np.linalg.slogdet(S)[1] + logdetD = np.linalg.slogdet(D)[1] + logdetN = np.linalg.slogdet(N)[1] + factor = np.log(2*np.pi) + + log_likelihood = 2*np.log(np.abs((1/m)*(1/c))) \ + + 2*np.log(inv_gamma_function(l, alpha, l0)) \ + - 0.5*(factor + logdetN) \ + - 0.5*(factor + logdetS) \ + + 0.5*(factor + logdetD) \ + + 0.5*np.dot(np.transpose(self._j), mu) \ + - 0.5*np.dot(np.transpose(data), np.dot(np.diag(Wvalues), data)) + return -log_likelihood + + result = minimize(likelihood, x0=np.array([-5, 60, 1e5]), args=(V,), + bounds=[(-6, 6), (1, 70), (1e4, 1e6)], + method="Nelder-Mead", tol=1e-7, + ) + m, c, l = result.x + print("Result: ", "m: ", m, "c: ", c, "l: ", "{:e}".format(l)) + return [m, c, l] + def _fit(self): """Compute the mean and variance""" From 64a78fb593e9207598149f5844ca26a5a5b24cf8 Mon Sep 17 00:00:00 2001 From: mariajmellado Date: Wed, 29 May 2024 16:51:58 -0400 Subject: [PATCH 2/5] feat: incorporate 2D-DFT to obtain 2D-Frank image --- .../AS209_1mm_FrankFit.py | 0 frank/Examples/DFT_2D_test.ipynb | 203 ++++++++++++++++++ frank/fourier2d.py | 77 +++++++ frank/radial_fitters.py | 7 +- frank/statistical_models.py | 100 ++++----- 5 files changed, 337 insertions(+), 50 deletions(-) rename frank/{fitExample => Examples}/AS209_1mm_FrankFit.py (100%) create mode 100644 frank/Examples/DFT_2D_test.ipynb create mode 100644 frank/fourier2d.py diff --git a/frank/fitExample/AS209_1mm_FrankFit.py b/frank/Examples/AS209_1mm_FrankFit.py similarity index 100% rename from frank/fitExample/AS209_1mm_FrankFit.py rename to frank/Examples/AS209_1mm_FrankFit.py diff --git a/frank/Examples/DFT_2D_test.ipynb b/frank/Examples/DFT_2D_test.ipynb new file mode 100644 index 00000000..f69dc4d7 --- /dev/null +++ b/frank/Examples/DFT_2D_test.ipynb @@ -0,0 +1,203 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d2808daf-7d75-4451-a75f-d6241049b447", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import matplotlib.pyplot as plt\n", + "\n", + "from frank.geometry import SourceGeometry\n", + "from frank.io import load_uvtable\n", + "from frank.radial_fitters import FrankFitter, FourierBesselFitter" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ad28005e-bbd1-467f-918d-ba165010fdcd", + "metadata": {}, + "outputs": [], + "source": [ + "# Data source AS209 1mm visibilities gridded\n", + "\n", + "rad_to_arcsec = 3600 * 180 / np.pi\n", + "\n", + "# Huang 2018 \n", + "inc = 34.97\n", + "pa = 85.76\n", + "dra = 1.9e-3\n", + "ddec = -2.5e-3\n", + "r_out = 1.9\n", + "\n", + "# Frank Parameters\n", + "N = 25\n", + "\n", + "# UVtable AS209 at 1mm.\n", + "dir = \"../data/\"\n", + "data_file = dir +'AS209_continuum_prom_1chan_30s_keepflagsFalse_gridded.txt'\n", + "\n", + " # load data\n", + "u, v, Vis, Weights = np.loadtxt(data_file, unpack = True)\n", + "\n", + "geom = SourceGeometry(inc= inc, PA= pa, dRA= dra, dDec= ddec)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "73f358c0-3cf8-4d59-91f3-0521e4531332", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 1.0607250668108463 minutes ---\n" + ] + } + ], + "source": [ + "#FF = FrankFitter(1.9, 300, geom, alpha = alpha, weights_smooth = w_smooth)\n", + "import time\n", + "start_time = time.time()\n", + "FF = FourierBesselFitter(r_out, N, geom)\n", + "sol_new = FF.fit(u, v, Vis, Weights)\n", + "print(\"--- %s minutes ---\" % (time.time()/60 - start_time/60))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9282d1fc-9737-4220-a98a-a9d8c4b5527f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "625" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(sol_new.mean) # we corroborate the desire output has 25x25 points." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4477675b-c2be-4b9f-98e1-f304651ae07d", + "metadata": {}, + "outputs": [], + "source": [ + "dx = dy = 2*r_out/(N**2*rad_to_arcsec)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f77e0303-e08f-4721-bcb5-00176c97dc13", + "metadata": {}, + "outputs": [], + "source": [ + "I = sol_new.mean.real/(dx*dy)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c02b56ae-29b5-43fe-8bdd-e7040cafec5f", + "metadata": {}, + "outputs": [], + "source": [ + "def reshape(array, N):\n", + " matrix = np.zeros((N, N), dtype=array.dtype)\n", + "\n", + " # Fill the matrix from bottom to top by columns\n", + " for i in range(N):\n", + " matrix[:, i] = array[i * N:(i + 1) * N][::-1]\n", + " return matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a6f7e7c6-5819-44e9-a972-1c03be14e169", + "metadata": {}, + "outputs": [], + "source": [ + "I_reshape = reshape(I, N)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "752cdafd-5775-41f6-a7bd-ad6825cdd767", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 15))\n", + "plt.matshow(I_reshape, cmap=\"magma\")\n", + "cmap = plt.colorbar()\n", + "cmap.set_label(r'I [Jy $sr^{-1}$]', size = 15)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88ed2e6c-5234-420d-a66a-48a5a7425ff5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "PROD_Frank2DVenv", + "language": "python", + "name": "prod_frank2dvenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/frank/fourier2d.py b/frank/fourier2d.py new file mode 100644 index 00000000..08f6332a --- /dev/null +++ b/frank/fourier2d.py @@ -0,0 +1,77 @@ + +import numpy as np + +class DiscreteFourierTransform2D(object): + def __init__(self, Rmax, N, nu=0): + # Remember that now N is to create N**2 points in image plane. + self.Xmax = 2*Rmax # [Rmax] = rad. + self.Ymax = 2*Rmax + self.Nx = N + self.Ny = N + self.N = N**2 # Number of points we want to use in the 2D-DFT. + + # Real space collocation points + x1n = np.linspace(0, self.Xmax, self.Nx) # rad + x2n = np.linspace(0, self.Ymax, self.Ny) # rad + x1n, x2n = np.meshgrid(x1n, x1n, indexing='ij') + # x1n.shape = N**2 X 1, so now, we have N**2 collocation points in the image plane. + x1n, x2n = x1n.reshape(-1), x2n.reshape(-1) # x1n = x_array and x2n = y_array + dx = 2*self.Xmax/self.N + dy = 2*self.Ymax/self.N + + # Frequency space collocation points. + # The [1:] is because to not consider the 0 baseline. But we're missing points. + q1n = np.fft.fftfreq(self.Nx+1, d = dx)[1:] + q2n = np.fft.fftfreq(self.Ny+1, d = dy)[1:] + q1n, q2n = np.meshgrid(q1n, q2n, indexing='ij') + # q1n.shape = N**2 X 1, so now, we have N**2 collocation points. + q1n, q2n = q1n.reshape(-1), q2n.reshape(-1) # q1n = u_array and q2n = v_array + + self.Xn = x1n + self.Yn = x2n + self.Un = q1n + self.Vn = q2n + + def get_collocation_points(self): + return np.array([self.Xn, self.Yn]), np.array([self.Un, self.Vn]) + + def coefficients(self, u = None, v = None, direction="forward"): + if direction == 'forward': + norm = 1 + factor = -2j*np.pi/self.Nx + elif direction == 'backward': + norm = 1 / self.N + factor = 2j*np.pi/self.Nx + else: + raise AttributeError("direction must be one of {}" + "".format(['forward', 'backward'])) + if u is None: + u = self.Un + v = self.Vn + + if direction == "forward": + H = norm * np.exp(factor*(np.outer(u, self.Xn) + np.outer(v, self.Yn))) + else: + H = norm * np.exp(factor*(np.outer(u, self.Xn) + np.outer(v, self.Yn))) + return H + + + def transform(self, f, u, v, direction="forward"): + Y = self.coefficients(u, v, direction=direction) + return np.dot(Y, f) + + + @property + def size(self): + """Number of points used in the 2D-DFT""" + return self.N + + @property + def uv_points(self): + """u and v collocation points""" + return self.Un, self.Vn + + @property + def q(self): + """Frequency points""" + return np.hypot(self.Un, self.Vn) \ No newline at end of file diff --git a/frank/radial_fitters.py b/frank/radial_fitters.py index dfb6f87f..0f606874 100644 --- a/frank/radial_fitters.py +++ b/frank/radial_fitters.py @@ -28,6 +28,7 @@ from frank.constants import rad_to_arcsec from frank.filter import CriticalFilter from frank.hankel import DiscreteHankelTransform +from frank.fourier2d import DiscreteFourierTransform2D from frank.statistical_models import ( GaussianModel, LogNormalMAPModel, VisibilityMapping ) @@ -443,6 +444,7 @@ def __init__(self, Rmax, N, geometry, nu=0, block_data=True, self._geometry = geometry self._DHT = DiscreteHankelTransform(Rmax, N, nu) + self._DFT = DiscreteFourierTransform2D(Rmax, N) if assume_optically_thick: if scale_height is not None: @@ -457,7 +459,8 @@ def __init__(self, Rmax, N, geometry, nu=0, block_data=True, self._vis_map = VisibilityMapping(self._DHT, geometry, model, scale_height=scale_height, block_data=block_data, block_size=block_size, - check_qbounds=False, verbose=verbose) + check_qbounds=False, verbose=verbose, + DFT = self._DFT) self._info = {'Rmax' : self._DHT.Rmax * rad_to_arcsec, 'N' : self._DHT.size @@ -577,7 +580,7 @@ def _fit(self): """Fit step. Computes the best fit given the pre-processed data""" fit = GaussianModel(self._DHT, self._M, self._j, noise_likelihood=self._H0, - Wvalues= self._Wvalues, V = self._V) + Wvalues= self._Wvalues, V = self._V, DFT = self._DFT) self._sol = FrankGaussianFit(self._vis_map, fit, self._info, geometry=self._geometry.clone()) diff --git a/frank/statistical_models.py b/frank/statistical_models.py index 183cdbcd..a1a61f61 100644 --- a/frank/statistical_models.py +++ b/frank/statistical_models.py @@ -66,7 +66,8 @@ class VisibilityMapping: """ def __init__(self, DHT, geometry, vis_model='opt_thick', scale_height=None, block_data=True, - block_size=10 ** 5, check_qbounds=True, verbose=True): + block_size=10 ** 5, check_qbounds=True, verbose=True, + DFT = None): _vis_models = ['opt_thick', 'opt_thin', 'debris'] if vis_model not in _vis_models: @@ -81,6 +82,7 @@ def __init__(self, DHT, geometry, self._chunk_size = block_size self._DHT = DHT + self._DFT = DFT self._geometry = geometry # Check for consistency and report the model choice. @@ -178,8 +180,8 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): frequencies = np.ones_like(V) channels = np.unique(frequencies) - Ms = np.zeros([len(channels), self.size, self.size], dtype='f8') - js = np.zeros([len(channels), self.size], dtype='f8') + Ms = np.zeros([len(channels), self.size, self.size], dtype='c8') + js = np.zeros([len(channels), self.size], dtype='c8') for i, f in enumerate(channels): idx = frequencies == f @@ -199,11 +201,13 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): Ndata = len(Vi) while start < Ndata: qs = qi[start:end] + us = u[start:end] + vs = v[start:end] ks = ki[start:end] ws = wi[start:end] Vs = Vi[start:end] - X = self._get_mapping_coefficients(qs, ks) + X = self._get_mapping_coefficients(qs, ks, us, vs) wXT = np.array(X.T * ws, order='C') @@ -462,7 +466,7 @@ def interpolate(self, f, r, space='Real'): return self._DHT.interpolate(f, r, space) - def _get_mapping_coefficients(self, qs, ks, geometry=None, inverse=False): + def _get_mapping_coefficients(self, qs, ks, u, v, geometry=None, inverse=False): """Get :math:`H(q)`, such that :math:`V(q) = H(q) I_\nu`""" if self._vis_model == 'opt_thick': @@ -486,7 +490,8 @@ def _get_mapping_coefficients(self, qs, ks, geometry=None, inverse=False): else: direction='forward' - H = self._DHT.coefficients(qs, direction=direction) * scale + #H = self._DHT.coefficients(qs, direction=direction) * scale + H = self._DFT.coefficients(u, v, direction=direction) * scale return H @@ -529,7 +534,8 @@ def Rmax(self): @property def q(self): r"""Frequency points, unit = :math:`\lambda`""" - return self._DHT.q + #return self._DHT.q + return self._DFT.q @property def Qmax(self): @@ -539,7 +545,8 @@ def Qmax(self): @property def size(self): """Number of points in reconstruction""" - return self._DHT.size + #return self._DHT.size + return self._DFT.size @property def scale_height(self): @@ -631,9 +638,10 @@ class GaussianModel: def __init__(self, DHT, M, j, p=None, scale=None, guess=None, Nfields=None, noise_likelihood=0, - Wvalues = None, V = None): + Wvalues = None, V = None, DFT = None): self._DHT = DHT + self._DFT = DFT self._Wvalues = Wvalues self._V = V @@ -691,24 +699,13 @@ def __init__(self, DHT, M, j, p=None, scale=None, guess=None, en = (n+1)*Nr self._Sinv[sn:en, sn:en] += Sj[n] - else: + else: # p is None, so we are interested in this case. + " New GP Kernel below" #self._Sinv = None - q_array = self._DHT.q - - def true_squared_exponential_kernel(q, p, l): - - q1, q2 = np.meshgrid(q, q) - p1, p2 = np.meshgrid(p, p) - SE_Kernel = np.sqrt(p1 * p2) * np.exp(-0.5*(q1-q2)**2 / l**2) - return SE_Kernel - - Ykm = self._DHT.coefficients(direction="backward") - # We continue after set M matrix because is needed to calculate - # best parameters for S matrix. # Compute the design matrix - self._M = np.zeros([Nr*Nfields, Nr*Nfields], dtype='f8') - self._j = np.zeros(Nr*Nfields, dtype='f8') + self._M = np.zeros([Nr*Nfields, Nr*Nfields], dtype='c8') + self._j = np.zeros(Nr*Nfields, dtype='c8') for si, Mi, ji in zip(self._scale, M, j): for n in range(0, Nfields): @@ -724,35 +721,42 @@ def true_squared_exponential_kernel(q, p, l): self._like_noise = noise_likelihood - # M is already defined, so we find best parameters for S matrix and use it. - m, c , l = self.minimizeS() - pI = np.exp(m*np.log(q_array) + c) - S_fspace = true_squared_exponential_kernel(q_array, pI, l) - S_real = np.dot(np.transpose(Ykm), np.dot(S_fspace, Ykm)) + " New GP " + self.u, self.v = self._DFT.uv_points + self.Ykm = self._DFT.coefficients(direction="backward") + self.Ykm_f = self._DFT.coefficients(direction="forward") + m, c , l = -4.8, 59.21, 1.21e5 + #m, c, l = self.minimizeS() # Finding best parameters to S matrix. + S_real = self.calculate_S(self.u, self.v, l, m, c) S_real_inv = np.linalg.inv(S_real) self._Sinv = S_real_inv self._fit() + def true_squared_exponential_kernel(self, u, v, l, m, c): + u1, u2 = np.meshgrid(u, u) + v1, v2 = np.meshgrid(v, v) + q1 = np.hypot(u1, v1) + q2 = np.hypot(u2, v2) + + def power_spectrum(q, m, c): + return np.exp(m*np.log(q) + c) + p1 = power_spectrum(q1, m, c) + p2 = power_spectrum(q2, m, c) + + SE_Kernel = np.sqrt(p1 * p2) * np.exp(-0.5*((u1-u2)**2 + (v1-v2)**2)/ l**2) + return SE_Kernel + + def calculate_S(self, u, v, l, m, c): + S_fspace = self.true_squared_exponential_kernel(u, v, l, m, c) + S_real = np.matmul(self.Ykm, np.matmul(S_fspace, self.Ykm_f)) + return S_real + def minimizeS(self): from scipy.optimize import minimize from scipy.special import gamma V = self._V - def calculate_S(m, c, l): - q_array = self._DHT.q - p_array = c*(q_array**m) - def true_squared_exponential_kernel(q, p, l): - q1, q2 = np.meshgrid(q, q) - p1, p2 = np.meshgrid(p, p) - SE_Kernel = np.sqrt(p1 * p2) * np.exp(-0.5*(q1-q2)**2 / l**2) - return SE_Kernel - - Ykm = self._DHT.coefficients(direction="backward") - S_fspace = true_squared_exponential_kernel(q_array, p_array, l) - S_real = np.dot(np.transpose(Ykm), np.dot(S_fspace, Ykm)) - return S_real - def calculate_D(S): S_real_inv = np.linalg.inv(S) Dinv = self._M + S_real_inv @@ -782,7 +786,7 @@ def likelihood(param, data): def inv_gamma_function(l, alpha, beta): return ((gamma(alpha)*beta)**(-1))*((beta/l)**(alpha + 1))*np.exp(-beta/l) - S = calculate_S(m,c, l) + S = self.calculate_S(self.u, self.v, l, m, c) [Dinv, D] = calculate_D(S) mu = calculate_mu(Dinv) logdetS = np.linalg.slogdet(S)[1] @@ -796,7 +800,7 @@ def inv_gamma_function(l, alpha, beta): - 0.5*(factor + logdetS) \ + 0.5*(factor + logdetD) \ + 0.5*np.dot(np.transpose(self._j), mu) \ - - 0.5*np.dot(np.transpose(data), np.dot(np.diag(Wvalues), data)) + - 0.5*np.dot(np.transpose(np.conjugate(data)), np.dot(np.diag(Wvalues), data)) return -log_likelihood result = minimize(likelihood, x0=np.array([-5, 60, 1e5]), args=(V,), @@ -804,10 +808,9 @@ def inv_gamma_function(l, alpha, beta): method="Nelder-Mead", tol=1e-7, ) m, c, l = result.x - print("Result: ", "m: ", m, "c: ", c, "l: ", "{:e}".format(l)) + print("Best parameters: ", "m: ", m, "c: ", c, "l: ", "{:e}".format(l)) return [m, c, l] - def _fit(self): """Compute the mean and variance""" # Compute the inverse prior covariance, S(p)^-1 @@ -980,7 +983,8 @@ def num_fields(self): @property def size(self): """Number of points in reconstruction""" - return self._DHT.size + #return self._DHT.size + return self._DFT.size class LogNormalMAPModel: From 97c6feb9f18228a7c741aa847b5ad45e37380dc0 Mon Sep 17 00:00:00 2001 From: mariajmellado Date: Sun, 16 Jun 2024 18:10:56 -0400 Subject: [PATCH 3/5] feat: Two gaussians test resolution --- frank/Examples/ResolutionTest2Gaussians.ipynb | 488 ++++++++++++++++++ frank/fourier2d.py | 64 ++- frank/radial_fitters.py | 8 +- frank/statistical_models.py | 36 +- 4 files changed, 555 insertions(+), 41 deletions(-) create mode 100644 frank/Examples/ResolutionTest2Gaussians.ipynb diff --git a/frank/Examples/ResolutionTest2Gaussians.ipynb b/frank/Examples/ResolutionTest2Gaussians.ipynb new file mode 100644 index 00000000..d96987cb --- /dev/null +++ b/frank/Examples/ResolutionTest2Gaussians.ipynb @@ -0,0 +1,488 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "469de05e-50e4-4e8d-bf0e-1dade7a54c1c", + "metadata": {}, + "source": [ + "# Real plane" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "0d7bc1bf-bb73-4978-a56d-10f90133510d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Dimensiones de la imagen\n", + "image_width = Nx = 500\n", + "image_height = Ny = 500\n", + "\n", + "# Crear una matriz de píxeles de ejemplo\n", + "image = np.ones((image_height, image_width))\n", + "\n", + "\n", + "def gaussian_parameters(x_center, y_center, cov):\n", + " # Coordenadas donde deseas agregar la función gaussiana\n", + " mean_x = x_center\n", + " mean_y = y_center\n", + " cov = [[50, 0], [00, 50]] # Matriz de covarianza\n", + " # Calcular los valores de la función gaussiana en cada punto de la imagen\n", + " x = np.arange(image_width) - mean_x\n", + " y = np.arange(image_height) - mean_y\n", + " return x, y\n", + " \n", + "def gaussian(x, y, cov):\n", + " # Calcular la función gaussiana en cada punto de la imagen\n", + " gaussian_x = np.exp(-0.5 * (x ** 2 / cov[0][0]))\n", + " gaussian_y = np.exp(-0.5 * (y ** 2 / cov[1][1]))\n", + " gaussian = gaussian_x[:, np.newaxis] * gaussian_y[np.newaxis, :]\n", + " return gaussian\n", + "\n", + "# Definir parámetros de la función que queremos mostrar.\n", + "\"\"\" Gaussian 1\"\"\"\n", + "cov1 = [[100, 0], [0, 100]] \n", + "mx1, my1 = 100, 100\n", + "x1, y1 = gaussian_parameters(mx1, my1, cov1)\n", + "g1 = gaussian(x1, y1, cov1)\n", + "\n", + "\"\"\"Gaussian 2\"\"\"\n", + "cov2 = [[100, 0], [0, 100]] \n", + "mx2, my2 = 400, 400\n", + "x2, y2 = gaussian_parameters(mx2, my2, cov2)\n", + "g2 = gaussian(x2, y2, cov2)\n", + "\n", + "# Normalizar la función gaussiana para que los valores estén en el rango [0, 1]\n", + "g1 /= np.max(g1)\n", + "g2 /= np.max(g2)\n", + "\n", + "# Ajustar la escala de la función gaussiana para que se pueda combinar con la imagen\n", + "g1 *= 0.4e11 # Suponiendo una imagen en escala de grises\n", + "g2 *= 0.4e11 \n", + "\n", + "# la función gaussiana\n", + "imag_asym = image + g1 + g2\n", + "\n", + "# Mostrar la imagen resultante\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(imag_asym, cmap='magma')\n", + "plt.title(\"Two gaussians\")\n", + "plt.colorbar()\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "#plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b9b1ca16-8d12-41ad-bc73-3a8b747298df", + "metadata": {}, + "source": [ + "# Visibility plane" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "01ad35be-1f32-4149-97ff-9572bd5b3672", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Hewlett-Packard\\AppData\\Local\\Temp\\ipykernel_3476\\1821031171.py:4: MatplotlibDeprecationWarning: Auto-removal of overlapping axes is deprecated since 3.6 and will be removed two minor releases later; explicitly call ax.remove() as needed.\n", + " plt.subplot(1,2,1)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fftImagAsym = np.fft.fft2(imag_asym)\n", + "fig, axes = plt.subplots(figsize=(10,4))\n", + "plt.suptitle('The FFT of two gaussians')\n", + "plt.subplot(1,2,1)\n", + "plt.title(\"amplitude\")\n", + "plt.imshow( 10. * np.log10(np.abs(fftImagAsym))) #amplitude (decibels)\n", + "plt.subplot(1,2,2)\n", + "plt.title(\"phase\")\n", + "plt.imshow( np.angle(fftImagAsym)) #phase\n", + "#fig.savefig(\"soccer_fft_gray.png\", bbox_inches='tight', pad_inches=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "12401934-df24-4317-87ad-a4add54570d4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ifftImagAsym = np.fft.ifft2(fftImagAsym)\n", + "plt.figure(figsize=(15, 15))\n", + "plt.matshow(ifftImagAsym.real, cmap='magma')\n", + "plt.colorbar()\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "075c8cc6-a99e-4d50-b9e0-6704e51301f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "54280.21217028851" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xmax = 1.9\n", + "rad_to_arcsec = 3600 * 180 / np.pi\n", + "dx = dy = 2*xmax/(Nx*rad_to_arcsec)\n", + "du = (1/Nx)/dx\n", + "du" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ef6aeb83-066b-404b-81d4-6263fbefd73b", + "metadata": {}, + "outputs": [], + "source": [ + "q1n = np.fft.fftfreq(Nx, d = dx) # is the same as FreqCompCols = np.fft.fftfreq(fftImagAsym.shape[1],d=dy)\n", + "q2n = np.fft.fftfreq(Ny, d = dy) # is the same as FreqCompRows = np.fft.fftfreq(fftImagAsym.shape[0],d=dx)\n", + "q1n, q2n = np.meshgrid(q1n, q2n, indexing='ij') \n", + "u, v = q1n.reshape(-1), q2n.reshape(-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e4e210e1-0ca4-4d7c-871f-09466f56478c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(500, 500)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fftImagAsym.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6e1b318e-dfe8-4c00-aeea-f839b92ade7f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0. , 0. , 0. , ...,\n", + " 0. , 0. , 0. ],\n", + " [ 54280.21217029, 54280.21217029, 54280.21217029, ...,\n", + " 54280.21217029, 54280.21217029, 54280.21217029],\n", + " [ 108560.42434058, 108560.42434058, 108560.42434058, ...,\n", + " 108560.42434058, 108560.42434058, 108560.42434058],\n", + " ...,\n", + " [-162840.63651087, -162840.63651087, -162840.63651087, ...,\n", + " -162840.63651087, -162840.63651087, -162840.63651087],\n", + " [-108560.42434058, -108560.42434058, -108560.42434058, ...,\n", + " -108560.42434058, -108560.42434058, -108560.42434058],\n", + " [ -54280.21217029, -54280.21217029, -54280.21217029, ...,\n", + " -54280.21217029, -54280.21217029, -54280.21217029]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "u.reshape(Nx, Ny)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a1b50514-bf49-4035-b326-cc251a748e6e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0. , 54280.21217029, 108560.42434058, ...,\n", + " -162840.63651087, -108560.42434058, -54280.21217029],\n", + " [ 0. , 54280.21217029, 108560.42434058, ...,\n", + " -162840.63651087, -108560.42434058, -54280.21217029],\n", + " [ 0. , 54280.21217029, 108560.42434058, ...,\n", + " -162840.63651087, -108560.42434058, -54280.21217029],\n", + " ...,\n", + " [ 0. , 54280.21217029, 108560.42434058, ...,\n", + " -162840.63651087, -108560.42434058, -54280.21217029],\n", + " [ 0. , 54280.21217029, 108560.42434058, ...,\n", + " -162840.63651087, -108560.42434058, -54280.21217029],\n", + " [ 0. , 54280.21217029, 108560.42434058, ...,\n", + " -162840.63651087, -108560.42434058, -54280.21217029]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v.reshape(Nx, Ny)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "72a012ad-ef15-416a-b971-4b57e24ed870", + "metadata": {}, + "outputs": [], + "source": [ + "Vis = np.ravel(fftImagAsym)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "173c71c0-3e15-4afd-9df3-c1b69ca4d948", + "metadata": {}, + "outputs": [], + "source": [ + "Re = Vis.real\n", + "Imag = Vis.imag" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "645ac1c3-bb9b-494e-a120-4a64fffd5552", + "metadata": {}, + "outputs": [], + "source": [ + "weights = np.ones(len(Vis))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "95a788c2-4b7f-4808-8e8f-180eafeb5018", + "metadata": {}, + "outputs": [], + "source": [ + "dir_ = \"../data/\"\n", + "#np.savetxt(dir_ + \"two_gaussians_gridded.txt\", np.transpose([u, v, Re, Imag, weights]))" + ] + }, + { + "cell_type": "markdown", + "id": "73d8aaa1-da3b-4575-9bc2-9057067cdc89", + "metadata": {}, + "source": [ + "# Run Frank" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "15683d8c-3629-48c3-8dfa-fcb9eac71a36", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import matplotlib.pyplot as plt\n", + "from frank.geometry import SourceGeometry\n", + "from frank.io import load_uvtable\n", + "from frank.radial_fitters import FrankFitter, FourierBesselFitter" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "aa3444da-3b1e-46cd-89f5-6d309651f012", + "metadata": {}, + "outputs": [], + "source": [ + "# load data\n", + "u, v, Re, Imag, Weights = np.loadtxt(dir_ + \"two_gaussians_gridded.txt\", unpack = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ff6694e9-24a7-48f9-97fd-c6e8771ac649", + "metadata": {}, + "outputs": [], + "source": [ + "Vis = Re + Imag*1j" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "757a26ec-a6a6-4ccb-ab64-8e10dd89e4ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 14.200694981962442 minutes ---\n" + ] + } + ], + "source": [ + "import time\n", + "start_time = time.time()\n", + "N = 50\n", + "r_out = 1.9\n", + "FF = FourierBesselFitter(r_out, N)\n", + "sol_new = FF.fit(u, v, Vis, Weights)\n", + "print(\"--- %s minutes ---\" % (time.time()/60 - start_time/60))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ea569422-aaad-4993-bfd1-d840014d238f", + "metadata": {}, + "outputs": [], + "source": [ + "dx = dy = 2*r_out/(N*rad_to_arcsec)\n", + "I = sol_new.mean.real/(dx*dy)\n", + "I_reshape = I.reshape((N,N))\n", + "r_out_rad = r_out" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "a6fdeefd-7cf1-4812-ba06-96f8d8ade9be", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "plot = ax.imshow(I_reshape, cmap=\"magma\")\n", + "cmap = plt.colorbar(plot)\n", + "cmap.set_label(r'I', size = 15)\n", + "ax.set_title(r'$N^{2}$ points, with N = ' + str(N))\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29581e7f-6576-4dd4-acaa-b069c74f8616", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "PROD_Frank2DVenv", + "language": "python", + "name": "prod_frank2dvenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/frank/fourier2d.py b/frank/fourier2d.py index 08f6332a..54d6e6a0 100644 --- a/frank/fourier2d.py +++ b/frank/fourier2d.py @@ -4,25 +4,25 @@ class DiscreteFourierTransform2D(object): def __init__(self, Rmax, N, nu=0): # Remember that now N is to create N**2 points in image plane. - self.Xmax = 2*Rmax # [Rmax] = rad. - self.Ymax = 2*Rmax + self.Xmax = Rmax #Rad + self.Ymax = Rmax self.Nx = N self.Ny = N - self.N = N**2 # Number of points we want to use in the 2D-DFT. + self.N = self.Nx*self.Ny # Number of points we want to use in the 2D-DFT. # Real space collocation points - x1n = np.linspace(0, self.Xmax, self.Nx) # rad - x2n = np.linspace(0, self.Ymax, self.Ny) # rad - x1n, x2n = np.meshgrid(x1n, x1n, indexing='ij') + x1n = np.linspace(-self.Xmax, self.Xmax, self.Nx, endpoint=False) # rad + x2n = np.linspace(-self.Ymax, self.Ymax, self.Ny, endpoint=False) # rad + x1n, x2n = np.meshgrid(x1n, x2n, indexing='ij') # x1n.shape = N**2 X 1, so now, we have N**2 collocation points in the image plane. x1n, x2n = x1n.reshape(-1), x2n.reshape(-1) # x1n = x_array and x2n = y_array - dx = 2*self.Xmax/self.N - dy = 2*self.Ymax/self.N + self.dx = 2*self.Xmax/self.Nx + self.dy = 2*self.Ymax/self.Ny # Frequency space collocation points. # The [1:] is because to not consider the 0 baseline. But we're missing points. - q1n = np.fft.fftfreq(self.Nx+1, d = dx)[1:] - q2n = np.fft.fftfreq(self.Ny+1, d = dy)[1:] + q1n = np.fft.fftfreq(self.Nx, d = self.dx) + q2n = np.fft.fftfreq(self.Ny, d = self.dy) q1n, q2n = np.meshgrid(q1n, q2n, indexing='ij') # q1n.shape = N**2 X 1, so now, we have N**2 collocation points. q1n, q2n = q1n.reshape(-1), q2n.reshape(-1) # q1n = u_array and q2n = v_array @@ -37,26 +37,34 @@ def get_collocation_points(self): def coefficients(self, u = None, v = None, direction="forward"): if direction == 'forward': - norm = 1 - factor = -2j*np.pi/self.Nx + ## Normalization is dx*dy since we the DFT to be an approximation + ## of the integral (which depends on the area) + norm = 4*self.Xmax*self.Ymax/self.N + factor = -2j*np.pi + + X, Y = self.Xn, self.Yn + if u is None: + u = self.Un + v = self.Vn elif direction == 'backward': - norm = 1 / self.N - factor = 2j*np.pi/self.Nx + ## Correcting for the normalization above 1/N is replaced by this: + norm = 1 / (4*self.Xmax*self.Ymax) + factor = 2j*np.pi + + X, Y = self.Un, self.Vn + if u is None: + u = self.Xn + v = self.Yn else: raise AttributeError("direction must be one of {}" "".format(['forward', 'backward'])) - if u is None: - u = self.Un - v = self.Vn - if direction == "forward": - H = norm * np.exp(factor*(np.outer(u, self.Xn) + np.outer(v, self.Yn))) - else: - H = norm * np.exp(factor*(np.outer(u, self.Xn) + np.outer(v, self.Yn))) + H = norm * np.exp(factor*(np.outer(u, X) + np.outer(v, Y))) + return H - def transform(self, f, u, v, direction="forward"): + def transform(self, f, u=None, v=None, direction="forward"): Y = self.coefficients(u, v, direction=direction) return np.dot(Y, f) @@ -74,4 +82,14 @@ def uv_points(self): @property def q(self): """Frequency points""" - return np.hypot(self.Un, self.Vn) \ No newline at end of file + return np.hypot(self.Un, self.Vn) + + @property + def Rmax(self): + """ Maximum value of the x coordinate in rad""" + return self.Xmax + + @property + def resolution(self): + """ Resolution of the grid in the x coordinate in rad""" + return self.dx \ No newline at end of file diff --git a/frank/radial_fitters.py b/frank/radial_fitters.py index 0f606874..cd021da8 100644 --- a/frank/radial_fitters.py +++ b/frank/radial_fitters.py @@ -430,12 +430,12 @@ class FourierBesselFitter(object): R and H should be in arcsec. Assumes a Gaussian vertical structure. Only works with assume_optically_thick=False block_size : int, default = 10**5 - Size of the matrices if blocking is used + Size of the matrices if blo cking is used verbose : bool, default = False Whether to print notification messages """ - def __init__(self, Rmax, N, geometry, nu=0, block_data=True, + def __init__(self, Rmax, N, geometry=None, nu=0, block_data=True, assume_optically_thick=True, scale_height=None, block_size=10 ** 5, verbose=True): @@ -569,7 +569,7 @@ def fit(self, u, v, V, weights=1): logging.info(' Fitting for brightness profile using' ' {}'.format(self.fit_method())) - self._geometry.fit(u, v, V, weights) + #self._geometry.fit(u, v, V, weights) mapping = self.preprocess_visibilities(u, v, V, weights) self._build_matrices(mapping) @@ -583,7 +583,7 @@ def _fit(self): Wvalues= self._Wvalues, V = self._V, DFT = self._DFT) self._sol = FrankGaussianFit(self._vis_map, fit, self._info, - geometry=self._geometry.clone()) + geometry=None) return self._sol diff --git a/frank/statistical_models.py b/frank/statistical_models.py index a1a61f61..b96218cf 100644 --- a/frank/statistical_models.py +++ b/frank/statistical_models.py @@ -164,7 +164,7 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): logging.info(' Building visibility matrices M and j') # Deproject the visibilities - u, v, k, V = self._geometry.apply_correction(u, v, V, use3D=True) + #u, v, k, V = self._geometry.apply_correction(u, v, V, use3D=True) q = np.hypot(u, v) # Check consistency of the uv points with the model @@ -186,7 +186,7 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): idx = frequencies == f qi = q[idx] - ki = k[idx] + ki = np.ones(len(q[idx]))#k[idx] wi = w[idx] Vi = V[idx] @@ -260,13 +260,13 @@ def check_hash(self, hash, multi_freq=False, geometry=None): passed = ( multi_freq == hash[0] and - self._DHT.Rmax == hash[1].Rmax and - self._DHT.size == hash[1].size and - self._DHT.order == hash[1].order and - geometry.inc == hash[2].inc and - geometry.PA == hash[2].PA and - geometry.dRA == hash[2].dRA and - geometry.dDec == hash[2].dDec and + self._DFT.Rmax == hash[1].Rmax and + self._DFT.size == hash[1].size and + self._DFT.order == hash[1].order and + #geometry.inc == hash[2].inc and + #geometry.PA == hash[2].PA and + #geometry.dRA == hash[2].dRA and + #geometry.dDec == hash[2].dDec and self._vis_model == hash[3] ) @@ -468,7 +468,7 @@ def interpolate(self, f, r, space='Real'): def _get_mapping_coefficients(self, qs, ks, u, v, geometry=None, inverse=False): """Get :math:`H(q)`, such that :math:`V(q) = H(q) I_\nu`""" - + """ if self._vis_model == 'opt_thick': # Optically thick & geometrically thin if geometry is None: @@ -482,7 +482,7 @@ def _get_mapping_coefficients(self, qs, ks, u, v, geometry=None, inverse=False): scale = np.exp(-np.outer(ks*ks, self._H2)) else: raise ValueError("model not supported. Should never occur.") - + """ if inverse: scale = np.atleast_1d(1/scale).reshape(1,-1) qs = qs / rad_to_arcsec @@ -491,7 +491,7 @@ def _get_mapping_coefficients(self, qs, ks, u, v, geometry=None, inverse=False): direction='forward' #H = self._DHT.coefficients(qs, direction=direction) * scale - H = self._DFT.coefficients(u, v, direction=direction) * scale + H = self._DFT.coefficients(u, v, direction=direction) #* scale return H @@ -725,7 +725,7 @@ def __init__(self, DHT, M, j, p=None, scale=None, guess=None, self.u, self.v = self._DFT.uv_points self.Ykm = self._DFT.coefficients(direction="backward") self.Ykm_f = self._DFT.coefficients(direction="forward") - m, c , l = -4.8, 59.21, 1.21e5 + m, c , l = -5, 60, 1e4 #m, c, l = self.minimizeS() # Finding best parameters to S matrix. S_real = self.calculate_S(self.u, self.v, l, m, c) S_real_inv = np.linalg.inv(S_real) @@ -739,8 +739,16 @@ def true_squared_exponential_kernel(self, u, v, l, m, c): q1 = np.hypot(u1, v1) q2 = np.hypot(u2, v2) - def power_spectrum(q, m, c): + def power_spectrum(q, m, c): + indexes = np.where(q == 0)[0] + q_max = np.max(q) + for i in indexes: + q[i] = q_max + q_min = np.min(q) + for i in indexes: + q[i] = q_min return np.exp(m*np.log(q) + c) + p1 = power_spectrum(q1, m, c) p2 = power_spectrum(q2, m, c) From 47dac1dfeeedaba66140689b5a7eb8400d936976 Mon Sep 17 00:00:00 2001 From: mariajmellado Date: Thu, 20 Jun 2024 08:32:04 -0400 Subject: [PATCH 4/5] fix: testing M matrix symmetry --- frank/Examples/TestingMmatrixSymmetry.ipynb | 231 +++++++++++++++++++ frank/fourier2d.py | 14 +- frank/statistical_models.py | 241 ++++++++++++-------- 3 files changed, 389 insertions(+), 97 deletions(-) create mode 100644 frank/Examples/TestingMmatrixSymmetry.ipynb diff --git a/frank/Examples/TestingMmatrixSymmetry.ipynb b/frank/Examples/TestingMmatrixSymmetry.ipynb new file mode 100644 index 00000000..d90dcb25 --- /dev/null +++ b/frank/Examples/TestingMmatrixSymmetry.ipynb @@ -0,0 +1,231 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from frank.geometry import SourceGeometry\n", + "from frank.io import load_uvtable\n", + "from frank.radial_fitters import FrankFitter, FourierBesselFitter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Upload gridded data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Data source AS209 1mm visibilities gridded\n", + "\n", + "rad_to_arcsec = 3600 * 180 / np.pi\n", + "\n", + "# Huang 2018 \n", + "inc = 34.97\n", + "pa = 85.76\n", + "dra = 1.9e-3\n", + "ddec = -2.5e-3\n", + "r_out = 1.9\n", + "\n", + "# Frank Parameters\n", + "n_pts = 300\n", + "alpha = 1.3\n", + "w_smooth = 1e-1\n", + "\n", + "# UVtable used for the simulations on AS209 at 1mm.\n", + "dir = \"../data/\"\n", + "data_file = dir +'AS209_continuum_prom_1chan_30s_keepflagsFalse_gridded.txt'\n", + "\n", + " # load data\n", + "u, v, Vis, Weights = np.loadtxt(data_file, unpack = True)\n", + "\n", + "geom = SourceGeometry(inc= inc, PA= pa, dRA= dra, dDec= ddec)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test exploring 2D-DFT with Frank" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "N = 25" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#FF = FrankFitter(1.9, 300, geom, alpha = alpha, weights_smooth = w_smooth)\n", + "import time\n", + "start_time = time.time()\n", + "FF = FourierBesselFitter(r_out, N, geom)\n", + "sol_new = FF.fit(u, v, Vis, Weights)\n", + "print(\"--- %s minutes ---\" % (time.time()/60 - start_time/60))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "625" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(sol_new.mean)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "dx = dy = 2*r_out/(N**2*rad_to_arcsec)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "I = sol_new.mean.real/(dx*dy)\n", + "#I" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "I_reshape = I.reshape((N,N))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "r_out_rad = r_out" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "plot = ax.imshow(I_reshape, cmap=\"magma\", extent=[-r_out_rad, r_out_rad, -r_out_rad, r_out_rad])\n", + "cmap = plt.colorbar(plot)\n", + "cmap.set_label(r'I [Jy $sr^{-1}$]', size = 15)\n", + "ax.set_title(r'$N^{2}$ points, with N = ' + str(N))\n", + "ax.set_xlabel(\"x ['']\")\n", + "ax.set_ylabel(\"y ['']\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "PROD_Frank2DVenv", + "language": "python", + "name": "prod_frank2dvenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + }, + "nbTranslate": { + "displayLangs": [ + "*" + ], + "hotkey": "alt-t", + "langInMainMenu": true, + "sourceLang": "en", + "targetLang": "fr", + "useGoogleTranslate": true + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/frank/fourier2d.py b/frank/fourier2d.py index 54d6e6a0..b0c73308 100644 --- a/frank/fourier2d.py +++ b/frank/fourier2d.py @@ -1,5 +1,6 @@ import numpy as np +import time class DiscreteFourierTransform2D(object): def __init__(self, Rmax, N, nu=0): @@ -35,7 +36,8 @@ def __init__(self, Rmax, N, nu=0): def get_collocation_points(self): return np.array([self.Xn, self.Yn]), np.array([self.Un, self.Vn]) - def coefficients(self, u = None, v = None, direction="forward"): + def coefficients(self, u = None, v = None, x = None, y = None, direction="forward"): + #start_time = time.time() if direction == 'forward': ## Normalization is dx*dy since we the DFT to be an approximation ## of the integral (which depends on the area) @@ -51,16 +53,16 @@ def coefficients(self, u = None, v = None, direction="forward"): norm = 1 / (4*self.Xmax*self.Ymax) factor = 2j*np.pi - X, Y = self.Un, self.Vn + X, Y = u, v if u is None: - u = self.Xn - v = self.Yn + X, Y = self.Un, self.Vn + u = self.Xn + v = self.Yn else: raise AttributeError("direction must be one of {}" "".format(['forward', 'backward'])) - H = norm * np.exp(factor*(np.outer(u, X) + np.outer(v, Y))) - + #print("--- %s minutes to calculate 2D-DFT coefficients---" % (time.time()/60 - start_time/60)) return H diff --git a/frank/statistical_models.py b/frank/statistical_models.py index b96218cf..8d4ce21f 100644 --- a/frank/statistical_models.py +++ b/frank/statistical_models.py @@ -25,6 +25,7 @@ from frank.constants import rad_to_arcsec, deg_to_rad from frank.minimizer import LineSearch, MinimizeNewton +import time class VisibilityMapping: r"""Builds the mapping between the visibility and image planes. @@ -206,16 +207,40 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): ks = ki[start:end] ws = wi[start:end] Vs = Vi[start:end] - + X = self._get_mapping_coefficients(qs, ks, us, vs) - - wXT = np.array(X.T * ws, order='C') - - Ms[i] += np.dot(wXT, X) - js[i] += np.dot(wXT, Vs) + X_CT = self._get_mapping_coefficients(qs, ks, us, vs, inverse=True) + wXT = np.matmul(X_CT, np.diag(ws)) # this line is the same as below. + #wXT = np.matmul(np.transpose(np.conjugate(X)), np.diag(ws), dtype = "complex64") + Ms[i] += np.matmul(wXT, X, dtype="complex128") + js[i] += np.matmul(wXT, Vs, dtype="complex128") start = end end = min(Ndata, end + Nstep) + + print("M type", Ms[0].dtype) + print("j type", js[0].dtype) + print("M imag-> ", " max: ", np.max(Ms[0].imag), ", min: ", np.min(Ms[0].imag) , ", mean: ", np.mean(Ms[0].imag) ,", median: ", np.median(Ms[0].imag), ", std: ", np.std(Ms[0].imag)) + print("M real-> ", " max: ", np.max(Ms[0].real), ", min: ", np.min(Ms[0].real) , ", mean: ", np.mean(Ms[0].real) ,", median: ", np.median(Ms[0].real), ", std: ", np.std(Ms[0].real)) + tol = 1e-10 + print("with tol: ", tol, ", M is symmetric?", np.allclose(Ms[0].real, Ms[0].T.real, atol=tol)) + # Ms[0] = np.abs(Ms[0]) + # from scipy.linalg import issymmetric + # print(issymmetric(Ms[0]), "that M is a Symmetric Matrix") + + + + import matplotlib.pyplot as plt + plt.matshow(Ms[0].real, cmap="magma", vmax = np.max(Ms[0].real), vmin = np.mean(Ms[0].real)) + plt.colorbar() + plt.title("M matrix, real part") + plt.show() + #import sys + #sys.exit() + + + #Ms[0] = np.loadtxt(r'.\..\Notebooks\M_N75.txt', dtype = 'c8') + #js[0] = np.loadtxt(r'.\..\Notebooks\j_N75.txt', dtype = 'c8') # Compute likelihood normalization H_0, i.e., the # log-likelihood of a source with I=0. @@ -263,10 +288,10 @@ def check_hash(self, hash, multi_freq=False, geometry=None): self._DFT.Rmax == hash[1].Rmax and self._DFT.size == hash[1].size and self._DFT.order == hash[1].order and - #geometry.inc == hash[2].inc and - #geometry.PA == hash[2].PA and - #geometry.dRA == hash[2].dRA and - #geometry.dDec == hash[2].dDec and + geometry.inc == hash[2].inc and + geometry.PA == hash[2].PA and + geometry.dRA == hash[2].dRA and + geometry.dDec == hash[2].dDec and self._vis_model == hash[3] ) @@ -468,7 +493,6 @@ def interpolate(self, f, r, space='Real'): def _get_mapping_coefficients(self, qs, ks, u, v, geometry=None, inverse=False): """Get :math:`H(q)`, such that :math:`V(q) = H(q) I_\nu`""" - """ if self._vis_model == 'opt_thick': # Optically thick & geometrically thin if geometry is None: @@ -482,7 +506,6 @@ def _get_mapping_coefficients(self, qs, ks, u, v, geometry=None, inverse=False): scale = np.exp(-np.outer(ks*ks, self._H2)) else: raise ValueError("model not supported. Should never occur.") - """ if inverse: scale = np.atleast_1d(1/scale).reshape(1,-1) qs = qs / rad_to_arcsec @@ -490,8 +513,7 @@ def _get_mapping_coefficients(self, qs, ks, u, v, geometry=None, inverse=False): else: direction='forward' - #H = self._DHT.coefficients(qs, direction=direction) * scale - H = self._DFT.coefficients(u, v, direction=direction) #* scale + H = self._DFT.coefficients(u, v, direction=direction)*scale return H @@ -725,15 +747,23 @@ def __init__(self, DHT, M, j, p=None, scale=None, guess=None, self.u, self.v = self._DFT.uv_points self.Ykm = self._DFT.coefficients(direction="backward") self.Ykm_f = self._DFT.coefficients(direction="forward") - m, c , l = -5, 60, 1e4 + + m, c , l = -5, 60, 1e4 + #m, c, l = 0.23651345032212925, 60.28747193555951, 1.000389e+05 + #start_time = time.time() #m, c, l = self.minimizeS() # Finding best parameters to S matrix. - S_real = self.calculate_S(self.u, self.v, l, m, c) + #print("--- %s minutes to minimize S---" % (time.time()/60 - start_time/60)) + S_real = self.calculate_S_real(self.u, self.v, l, m, c) + start_time = time.time() S_real_inv = np.linalg.inv(S_real) + print("--- %s minutes to calculate S_real_inv---" % (time.time()/60 - start_time/60)) self._Sinv = S_real_inv - + print(self._Sinv.dtype, " Sinv dtype") + start_time = time.time() self._fit() + print("--- %s minutes to fit---" % (time.time()/60 - start_time/60)) - def true_squared_exponential_kernel(self, u, v, l, m, c): + def true_squared_exponential_kernel(self, u, v, l, m, c): u1, u2 = np.meshgrid(u, u) v1, v2 = np.meshgrid(v, v) q1 = np.hypot(u1, v1) @@ -748,75 +778,106 @@ def power_spectrum(q, m, c): for i in indexes: q[i] = q_min return np.exp(m*np.log(q) + c) - + p1 = power_spectrum(q1, m, c) p2 = power_spectrum(q2, m, c) - SE_Kernel = np.sqrt(p1 * p2) * np.exp(-0.5*((u1-u2)**2 + (v1-v2)**2)/ l**2) return SE_Kernel - - def calculate_S(self, u, v, l, m, c): + + def calculate_S_real(self, u, v, l, m, c): + start_time = time.time() S_fspace = self.true_squared_exponential_kernel(u, v, l, m, c) - S_real = np.matmul(self.Ykm, np.matmul(S_fspace, self.Ykm_f)) + print("--- %s minutes to calculate S---" % (time.time()/60 - start_time/60)) + start_time = time.time() + S_real = np.matmul(self.Ykm, np.matmul(S_fspace, self.Ykm_f), dtype = "complex64") + print("--- %s minutes to calculate S_real---" % (time.time()/60 - start_time/60)) + + print(S_real.dtype, " S_real dtype") + import matplotlib.pyplot as plt + plt.matshow(S_fspace, cmap="magma", vmin = 0, vmax = 1e-3) + plt.colorbar() + plt.title("S real matrix, real part ") + plt.show() + return S_real - + + def calculate_mu_cholesky(self, Dinv): + print("calculate mu with cholesky") + try: + Dchol = scipy.linalg.cho_factor(Dinv) + mu = scipy.linalg.cho_solve(Dchol, self._j) + + except np.linalg.LinAlgError: + U, s, V = scipy.linalg.svd(Dinv, full_matrices=False) + s1 = np.where(s > 0, 1. / s, 0) + mu = np.dot(V.T, np.multiply(np.dot(U.T, self._j), s1)) + return mu + + def calculate_mu_gc(self, Dinv): + from scipy.sparse.linalg import cg, bicg, bicgstab, gmres + method = "BiConjugate Gradient Method" + #from scipy.sparse import csr_matrix, issparse + #is_sparse = issparse(Dinv) + #print("Is Dinv sparse?: ", is_sparse) + start_time = time.time() + mu, exitCode = bicgstab(Dinv, self._j, atol = 0) + print("--- %s minutes to calculate mu---" % (time.time()/60 - start_time/60)) + print("Succesful ", method, "?: ", exitCode == 0) + print("Is the result correct?: ", np.allclose(np.dot(Dinv, mu), self._j)) + return mu + + def likelihood(self, param, data): + from scipy.special import gamma + m, c, l = param + Wvalues = self._Wvalues + N = np.diag(1/Wvalues) + + alpha = 1.3 + l0 = 1e7 + + # Create an Inverse Gamma distribution function + def inv_gamma_function(l, alpha, beta): + return ((gamma(alpha)*beta)**(-1))*((beta/l)**(alpha + 1))*np.exp(-beta/l) + + S_real = self.calculate_S_real(self.u, self.v, l, m, c) + start_time = time.time() + S_real_inv = np.linalg.inv(S_real) + print("--- %s minutes to calculate S_real_inv ---" % (time.time()/60 - start_time/60)) + Dinv = self._M + S_real_inv + start_time = time.time() + D = np.linalg.inv(Dinv) + print("--- %s minutes to calculate D ---" % (time.time()/60 - start_time/60)) + mu = self.calculate_mu_gc(Dinv) + + start_time = time.time() + logdetS = np.linalg.slogdet(S_real)[1] + logdetD = np.linalg.slogdet(D)[1] + logdetN = np.linalg.slogdet(N)[1] + print("--- %s minutes to calculate determinants ---" % (time.time()/60 - start_time/60)) + factor = np.log(2*np.pi) + + start_time = time.time() + log_likelihood = 2*np.log(np.abs((1/m)*(1/c))) \ + + 2*np.log(inv_gamma_function(l, alpha, l0)) \ + - 0.5*(factor + logdetN) \ + - 0.5*(factor + logdetS) \ + + 0.5*(factor + logdetD) \ + + 0.5*np.dot(np.transpose(self._j), mu) \ + - 0.5*np.dot(np.transpose(np.conjugate(data)), np.dot(np.diag(Wvalues), data)) + print("--- %s minutes to calculate log_likelihood ---" % (time.time()/60 - start_time/60)) + return -log_likelihood + def minimizeS(self): from scipy.optimize import minimize - from scipy.special import gamma V = self._V - - def calculate_D(S): - S_real_inv = np.linalg.inv(S) - Dinv = self._M + S_real_inv - D = np.linalg.inv(Dinv) - return [Dinv, D] - - def calculate_mu(Dinv): - try: - Dchol = scipy.linalg.cho_factor(Dinv) - mu = scipy.linalg.cho_solve(Dchol, self._j) - - except np.linalg.LinAlgError: - U, s, V = scipy.linalg.svd(Dinv, full_matrices=False) - s1 = np.where(s > 0, 1. / s, 0) - mu = np.dot(V.T, np.multiply(np.dot(U.T, self._j), s1)) - return mu - - def likelihood(param, data): - m, c, l = param - Wvalues = self._Wvalues - N = np.diag(1/Wvalues) - - alpha = 1.3 - l0 = 1e7 - - # Create an Inverse Gamma distribution function - def inv_gamma_function(l, alpha, beta): - return ((gamma(alpha)*beta)**(-1))*((beta/l)**(alpha + 1))*np.exp(-beta/l) - - S = self.calculate_S(self.u, self.v, l, m, c) - [Dinv, D] = calculate_D(S) - mu = calculate_mu(Dinv) - logdetS = np.linalg.slogdet(S)[1] - logdetD = np.linalg.slogdet(D)[1] - logdetN = np.linalg.slogdet(N)[1] - factor = np.log(2*np.pi) - - log_likelihood = 2*np.log(np.abs((1/m)*(1/c))) \ - + 2*np.log(inv_gamma_function(l, alpha, l0)) \ - - 0.5*(factor + logdetN) \ - - 0.5*(factor + logdetS) \ - + 0.5*(factor + logdetD) \ - + 0.5*np.dot(np.transpose(self._j), mu) \ - - 0.5*np.dot(np.transpose(np.conjugate(data)), np.dot(np.diag(Wvalues), data)) - return -log_likelihood - - result = minimize(likelihood, x0=np.array([-5, 60, 1e5]), args=(V,), - bounds=[(-6, 6), (1, 70), (1e4, 1e6)], - method="Nelder-Mead", tol=1e-7, - ) + print("minimizing") + start_time = time.time() + result = minimize(self.likelihood, x0=np.array([-5, 60, 1e5]), args=(V,), + method="Nelder-Mead", tol=1e-7, + bounds=[(-7, 7), (1, 80), (1e4, 1e5)]) m, c, l = result.x - print("Best parameters: ", "m: ", m, "c: ", c, "l: ", "{:e}".format(l)) + print("--- %s minutes to minimizing ---" % (time.time()/60 - start_time/60)) + print("Result: ", "m: ", m, "c: ", c, "l: ", "{:e}".format(l)) return [m, c, l] def _fit(self): @@ -828,21 +889,19 @@ def _fit(self): Dinv = self._M + Sinv - try: - self._Dchol = scipy.linalg.cho_factor(Dinv) - self._Dsvd = None - - self._mu = scipy.linalg.cho_solve(self._Dchol, self._j) - - except np.linalg.LinAlgError: - U, s, V = scipy.linalg.svd(Dinv, full_matrices=False) - - s1 = np.where(s > 0, 1. / s, 0) - - self._Dchol = None - self._Dsvd = U, s1, V + """ + #import scipy.linalg as sc + def is_pos_def(x): + return np.all(np.linalg.eigvals(x) > 0) + a = sc.issymmetric(Dinv) # necessary condition to be SPD + b = is_pos_def(Dinv) # necessary condition to be SPD + # there is left one condition necessary to be SPD, which is that xT * A * x > 0 for all x != 0. + print("Is symmetric: ", a) + print("Is positive definite: ", b) + """ - self._mu = np.dot(V.T, np.multiply(np.dot(U.T, self._j), s1)) + #self._mu = self.calculate_mu_cholesky(Dinv) + self._mu = self.calculate_mu_gc(Dinv) # Reset the covariance matrix - we will compute it when needed if self._Nfields > 1: From 902a85fc1fea8d9ae6230ee48da062c59f11abdb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mar=C3=ADa=20Jes=C3=BAs?= Date: Tue, 6 Aug 2024 18:15:15 +0100 Subject: [PATCH 5/5] feat: adapted for testing estimated resolution --- frank/Examples/13_July_ResolutionTest.ipynb | 821 ++++++++++++++++++++ frank/fourier2d.py | 15 +- frank/radial_fitters.py | 6 +- frank/statistical_models.py | 104 ++- 4 files changed, 899 insertions(+), 47 deletions(-) create mode 100644 frank/Examples/13_July_ResolutionTest.ipynb diff --git a/frank/Examples/13_July_ResolutionTest.ipynb b/frank/Examples/13_July_ResolutionTest.ipynb new file mode 100644 index 00000000..f59817d1 --- /dev/null +++ b/frank/Examples/13_July_ResolutionTest.ipynb @@ -0,0 +1,821 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dc299b2e-06d4-4588-be06-17959b057e49", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e82117d0-6ec7-4b19-9bd0-74840be46c35", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from frank.geometry import SourceGeometry\n", + "from frank.io import load_uvtable\n", + "from frank.radial_fitters import FrankFitter, FourierBesselFitter\n", + "import frank\n", + "\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "id": "b7fa5fb7-5491-4205-8181-2b247aab9c5b", + "metadata": {}, + "source": [ + "## Constants" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cd7b5850-d2cf-42e8-8891-bac83dbcfeaa", + "metadata": {}, + "outputs": [], + "source": [ + "rad_to_arcsec = 3600 * 180 / np.pi" + ] + }, + { + "cell_type": "markdown", + "id": "d1d949a4-568e-4e80-9fb4-29c128eff501", + "metadata": {}, + "source": [ + "## Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "94dc721b-4d54-4534-84f1-37128a64f187", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_Vis(image, name):\n", + " fftImagAsym = np.fft.fft2(image)\n", + " fftImagAsymshifted = np.fft.fftshift(np.fft.fft2(image))\n", + " fig, axes = plt.subplots(figsize=(10,4))\n", + " plt.clf()\n", + " plt.suptitle('The FFT of ' + name)\n", + " plt.subplot(1,2,1)\n", + " plt.title(\"amplitude\")\n", + " plt.imshow(np.abs(fftImagAsymshifted), cmap='hot') #amplitude (decibels)\n", + " plt.colorbar()\n", + " plt.subplot(1,2,2)\n", + " plt.title(\"phase\")\n", + " plt.imshow(np.angle(fftImagAsymshifted), cmap='hot') #phase\n", + " plt.colorbar()\n", + " return fftImagAsym" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2c3c46de-0941-48d1-a02a-3590f2f08b6c", + "metadata": {}, + "outputs": [], + "source": [ + "def deproject(u, v, Re, Im, inc, pa, dRa, dDec, inverse=False):\n", + " '''\n", + " Deprojects or projects visibilities\n", + " '''\n", + " # Convert to radian\n", + " pa = pa * np.pi / 180.\n", + " inc = inc * np.pi / 180.\n", + " dDec *= np.pi / (180. * 3600)\n", + " dRa *= np.pi / (180. * 3600)\n", + " # Correct the phase position by dRA and dDec\n", + " if not inverse:\n", + " Intensity = (Re + Im * 1j) * np.exp(2j * np.pi * (u * -dRa + v * -dDec))\n", + " # Calculate deprojected arrays\n", + " Rep = np.real(Intensity)\n", + " Imp = np.imag(Intensity)\n", + " # Calculate transformation\n", + " cos_t = np.cos(pa)\n", + " sin_t = np.sin(pa)\n", + " aux = 1.\n", + " if inverse:\n", + " sin_t *= -1.\n", + " aux = 1. / np.cos(inc)\n", + " up = u * aux * cos_t - v * sin_t\n", + " vp = u * aux * sin_t + v * cos_t\n", + " # Deproject\n", + " if not inverse:\n", + " up *= np.cos(inc)\n", + " if inverse:\n", + " Intensity = (Re + Im * 1j) * np.exp(2j * np.pi * (up * -dRa + vp * -dDec))\n", + " # Calculate deprojected arrays\n", + " Rep = np.real(Intensity)\n", + " Imp = np.imag(Intensity)\n", + " # Return\n", + " return up, vp, Rep, Imp\n" + ] + }, + { + "cell_type": "markdown", + "id": "469de05e-50e4-4e8d-bf0e-1dade7a54c1c", + "metadata": {}, + "source": [ + "# Real plane" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a7bbfb9a-48e0-4272-a5c6-2661699d79b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Dimensiones de la imagen\n", + "dim = 900\n", + "image_width = Nx = 900\n", + "image_height = Ny = 900\n", + "\n", + "# Crear una matriz de píxeles de ejemplo\n", + "image = np.ones((image_height, image_width))" + ] + }, + { + "cell_type": "markdown", + "id": "2233754f-8f34-4649-8ed4-c9d664a56d1d", + "metadata": {}, + "source": [ + "## Delta ring" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b1d6c14a-42e8-4c4b-861b-d6220c27a08c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def ring_parameters(center_x, center_y, radius, image_width, image_height):\n", + " # Coordenadas donde deseas agregar el anillo\n", + " x = np.arange(image_width) - center_x\n", + " y = np.arange(image_height) - center_y\n", + " return x, y, radius\n", + "\n", + "def delta_ring(x, y, radius, epsilon):\n", + " # Calcular la distancia radial desde el centro\n", + " R = np.sqrt(x[:, np.newaxis]**2 + y[np.newaxis, :]**2)\n", + " # Aproximar la función delta como una Gaussiana estrecha alrededor de radius\n", + " delta_approx = np.exp(-((R - radius)**2) / (2 * epsilon**2)) / (epsilon * np.sqrt(2 * np.pi))\n", + " return delta_approx\n", + "\n", + "# Definir parámetros del anillo\n", + "center_x, center_y = image_width // 2, image_height // 2\n", + "radius = 100 # Radio del anillo\n", + "epsilon = 1 # Valor pequeño para la aproximación de la delta\n", + "\n", + "# Obtener las coordenadas y el radio del anillo\n", + "x, y, radius = ring_parameters(center_x, center_y, radius, image_width, image_height)\n", + "\n", + "# Calcular el valor del anillo en cada punto de la imagen\n", + "ring = delta_ring(x, y, radius, epsilon)\n", + "\n", + "# Normalizar la función delta aproximada para que los valores estén en el rango [0, 1]\n", + "ring /= np.max(ring)\n", + "\n", + "ring *= 0.4e11 \n", + "\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(ring, extent=(-1, 1, -1, 1), cmap='magma')\n", + "plt.colorbar()\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b9b1ca16-8d12-41ad-bc73-3a8b747298df", + "metadata": {}, + "source": [ + "# Visibility plane" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "10764602-2a57-4a7a-b980-f9a82508881d", + "metadata": {}, + "outputs": [], + "source": [ + "dir = \"../data/\"\n", + "data_file = dir +'AS209_continuum_prom_1chan_30s_keepflagsFalse.txt'\n", + "\n", + " # load data\n", + "u, v, Re, Imag, Weights = np.loadtxt(data_file, unpack = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "348dee41-b489-4aa5-8ebc-80ba44d1f091", + "metadata": {}, + "outputs": [], + "source": [ + "# AS209 - Huang et al. 2018 \n", + "inc = 34.97\n", + "pa = 85.76\n", + "dra = 1.9e-3\n", + "ddec = -2.5e-3\n", + "r_out = 1.9 #arcsecs" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "5557c758-5130-413d-9275-15dca869e471", + "metadata": {}, + "outputs": [], + "source": [ + "# Deprojection\n", + "du, dv, dRe, dIm = deproject(u=u, v=v, Re=Re, Im=Imag,\n", + " inc=inc, pa=pa, dRa=dra, dDec=ddec,\n", + " inverse=False)\n", + "baseline = np.sqrt(du**2 + dv**2)" + ] + }, + { + "cell_type": "markdown", + "id": "c2f2ddbd-cec1-42b6-9d83-476eae6b8018", + "metadata": {}, + "source": [ + "## Delta ring" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ff1ce1af-04b2-44df-b20f-550d895ee0f8", + "metadata": {}, + "outputs": [], + "source": [ + "file_name = 'delta_ring'" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "51c78be4-34fc-4dac-95da-0ff9ab4af727", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.special import j0\n", + "\n", + "ReV = np.median(Re[np.where(baseline<3e4)])*np.real(j0(2.*np.pi*(r_out/rad_to_arcsec/2.)*baseline))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "75d836a7-19ee-440a-8ed4-1ef973d0b29c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-0.02989617, -0.07808702, 0.07037571, ..., -0.02432114,\n", + " -0.016631 , 0.01623501])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ReV" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "7d27cd6d-5d02-4a86-ab5d-bf13ed02f935", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.2510019)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.median(Re[np.where(baseline<3e4)])" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "03c3bce7-8910-48c3-ae92-e57cb0783d69", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.plot(baseline, np.abs(ReV), '.')\n", + "plt.xlabel(\"baseline\")\n", + "plt.ylabel(\"Re [Jy]\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "16be9223-5227-4fc6-8d2a-0a67d3db34a3", + "metadata": {}, + "outputs": [], + "source": [ + "def Vis_delta_ring(u, v, Re, r_out):\n", + " baseline = np.sqrt(u**2 + v**2)\n", + " A0 = np.median(Re[np.where(baseline<3e4)[0]])\n", + " return A0 * np.real(j0(2.*np.pi*(r_out/rad_to_arcsec/2.)*baseline))" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "1b57c68e-7e91-4b4d-9fda-e3775d67b770", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Crear una malla de coordenadas (u, v)\n", + "n = 600\n", + "u_, v_ = np.meshgrid(du[:n], dv[:n])\n", + "u_, v_ = u_.reshape(-1), u_.reshape(-1)\n", + "\n", + "plt.figure(figsize=(2, 2))\n", + "plt.plot(du[:n], dv[:n], 'x')\n", + "plt.xlabel(\"u\")\n", + "plt.ylabel(\"v\")\n", + "plt.show()\n", + "\n", + "image = Vis_delta_ring(u_, v_, dRe, r_out)\n", + "\n", + "ft_image = image.reshape(n, n)\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(ft_image, cmap='viridis')\n", + "plt.colorbar()\n", + "plt.xlabel(\"u\")\n", + "plt.ylabel(\"v\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "7084b991-3d7d-46bc-a7c8-4b9212208565", + "metadata": {}, + "outputs": [], + "source": [ + "u = du\n", + "v = dv\n", + "Re = ReV\n", + "Imag = np.zeros(len(ReV))" + ] + }, + { + "cell_type": "markdown", + "id": "bb7ce9ae-9893-4c54-9683-11960367593b", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## FFT" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "6939d498-983a-4ab8-b976-158a8797596b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fftDelta = plot_Vis(ring, 'delta ring')" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "f587143a-d269-4aa4-8814-c9622692357a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ifftImagAsym = np.fft.ifft2(fftDelta)\n", + "plt.figure(figsize=(15, 15))\n", + "plt.matshow(np.abs(ifftImagAsym), cmap='magma')\n", + "plt.colorbar()\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6b23772b-417b-471a-8558-37b29aea60fb", + "metadata": {}, + "source": [ + "# Save data " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e1831a6e-337c-4843-882a-3a306b6e64dd", + "metadata": {}, + "outputs": [], + "source": [ + "dir_ = \"../data/\"\n", + "np.save(dir_ + file_name, [u, v, Re, Imag, Weights])" + ] + }, + { + "cell_type": "markdown", + "id": "73d8aaa1-da3b-4575-9bc2-9057067cdc89", + "metadata": {}, + "source": [ + "# Run Frank" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "aa3444da-3b1e-46cd-89f5-6d309651f012", + "metadata": {}, + "outputs": [], + "source": [ + "# load data\n", + "u, v, Re, Imag, Weights = np.load(dir_ + file_name + '.npy')" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "ff6694e9-24a7-48f9-97fd-c6e8771ac649", + "metadata": {}, + "outputs": [], + "source": [ + "Vis = Re + Imag*1j" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "id": "5030d0e6-01fe-468f-afc0-9cd6358fcbf7", + "metadata": {}, + "outputs": [], + "source": [ + "N = 30" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "id": "7bfe9c93-aa42-48bb-a605-b3b5ba4a5606", + "metadata": {}, + "outputs": [], + "source": [ + "DFT = frank.fourier2d.DiscreteFourierTransform2D(r_out/frank.constants.rad_to_arcsec, N)" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "id": "599909ad-9d0a-4b0c-8aaa-7d37e33c4cb5", + "metadata": {}, + "outputs": [], + "source": [ + "c = 1.5" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "id": "63ea3cf7-57fc-41e9-861d-938de53386f9", + "metadata": {}, + "outputs": [], + "source": [ + "idx = (np.abs(u) < c*DFT.Un.max()) & (np.abs(v) < c*DFT.Un.max())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "757a26ec-a6a6-4ccb-ab64-8e10dd89e4ab", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "start_time = time.time()\n", + "FF = FourierBesselFitter(1.9, N, geometry_on = False)\n", + "sol_new = FF.fit(u[idx], v[idx], Vis[idx], Weights[idx])\n", + "#sol_new = FF.fit(u, v, Vis, Weights)\n", + "print(\"--- %s minutes ---\" % (time.time()/60 - start_time/60))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ea569422-aaad-4993-bfd1-d840014d238f", + "metadata": {}, + "outputs": [], + "source": [ + "I = sol_new.mean.real\n", + "I_reshape = I.reshape((N,N))\n", + "r_out_arcsec = r_out" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f2cfdf2-cc26-4e91-8e5a-f56e5ca37d27", + "metadata": {}, + "outputs": [], + "source": [ + "def reshape(array, N):\n", + " matrix = np.zeros((N, N), dtype=array.dtype)\n", + "\n", + " # Fill the matrix from bottom to top by columns\n", + " for i in range(N):\n", + " matrix[:, i] = array[i * N:(i + 1) * N][::-1]\n", + " #matrix[:, i] = array[i * N:(i + 1) * N]\n", + " return matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06091671-6488-448e-b32e-ae2feee63f4a", + "metadata": {}, + "outputs": [], + "source": [ + "I_reshape = reshape(I, N)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "55287eb6-1ff0-4fe7-b0de-ad47b29930a1", + "metadata": {}, + "outputs": [], + "source": [ + "x = DFT.Xn*rad_to_arcsec #arcsec\n", + "y = DFT.Yn*rad_to_arcsec #arcsec" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e8956d2-5830-4aa7-82b3-91d80f181d20", + "metadata": {}, + "outputs": [], + "source": [ + "dx = dy = 2*r_out/N" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6fdeefd-7cf1-4812-ba06-96f8d8ade9be", + "metadata": {}, + "outputs": [], + "source": [ + "# Coordenadas del pixel que quieres mostrar\n", + "pixel_x, pixel_y = N//2, N//2\n", + "pixel_value = I_reshape[pixel_y, pixel_x]\n", + "\n", + "# Crear una figura con dos subplots\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5), gridspec_kw={'width_ratios': [3, 1]})\n", + "\n", + "# Primer subplot: la imagen completa\n", + "plot = axs[0].imshow(I_reshape, cmap=\"magma\", extent=[np.min(x), np.max(x), np.min(y), np.max(y)])\n", + "cmap = plt.colorbar(plot, ax=axs[0])\n", + "cmap.set_label(r'I [Jy $sr^{-1}$]', size=15)\n", + "\n", + "axs[0].set_title(r'Delta ring')\n", + "axs[0].set_xlabel(\"x ['']\")\n", + "axs[0].set_ylabel(\"y ['']\")\n", + "axs[0].text(-1.5, -1.7, r' $N^{2}$ pixels, with N = ' + str(N) + ' ', bbox={'facecolor': 'white', 'pad': 1, 'alpha': 0.8})\n", + "axs[0].text(0.3, -1.7, r' FOV: '+ str(2*r_out) +' arcseconds ', bbox={'facecolor': 'white', 'pad': 4, 'alpha': 0.8})\n", + "\n", + "# Segundo subplot: el pixel específico\n", + "# Creamos una matriz de ceros y luego establecemos el valor del píxel deseado en I_reshape[pixel_y, pixel_x]\n", + "pixel_image = np.zeros((1, 1))\n", + "pixel_image[0, 0] = pixel_value\n", + "img = axs[1].imshow(pixel_image, cmap=\"magma\", extent=[0, 1, 0, 1])\n", + "axs[1].set_title(f'Pixel at ({pixel_x}, {pixel_y})')\n", + "axs[1].set_xticks([])\n", + "axs[1].set_yticks([])\n", + "\n", + "# Colorbar para el pixel específico\n", + "cmap_pixel = plt.colorbar(img, ax=axs[1], shrink=0.5)\n", + "cmap_pixel.set_label(r'I [Jy $sr^{-1}$]', size=9)\n", + "\n", + "# Configurar notación científica en la barra de color\n", + "cmap_pixel.formatter.set_powerlimits((-2, 2)) # Limitar la notación científica a potencias entre -3 y 3\n", + "cmap_pixel.update_ticks()\n", + "\n", + "# Mostrar el valor del pixel como leyenda\n", + "axs[1].text(0.5, -0.3, f'Intensity: {pixel_value:.4}', ha='center', va='center', transform=axs[1].transAxes, fontsize=9, bbox={'facecolor': 'white', 'alpha': 0.8, 'pad': 3})\n", + "\n", + "# Agregar indicaciones del largo del pixel en los ejes x y y\n", + "axs[1].annotate('', xy=(0, 0), xytext=(1, 0), arrowprops=dict(arrowstyle='<->', color='black'))\n", + "axs[1].text(0.5, -0.05, f'{dx*1000: .1f} mas', ha='center', va='top', transform=axs[1].transAxes)\n", + "\n", + "axs[1].annotate('', xy=(0, 0), xytext=(0, 1), arrowprops=dict(arrowstyle='<->', color='black'))\n", + "axs[1].text(-0.05, 0.5, f'{dx*1000: .1f} mas', ha='right', va='center', transform=axs[1].transAxes, rotation='vertical')\n", + "\n", + "# Ajustar el tamaño de los subplots\n", + "plt.tight_layout()\n", + "plt.subplots_adjust(wspace=0.2)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db15d7d6-9717-42c0-8078-0fd75ce0575d", + "metadata": {}, + "outputs": [], + "source": [ + "# Calcular las distancias radiales\n", + "\n", + "r = np.sqrt(x**2 + y**2)\n", + "idx = np.argsort(r)\n", + "r = r[idx]\n", + "I = I[idx]\n", + "r_unique, indices = np.unique(r, return_index=True)\n", + "\n", + "I_unique = np.zeros(len(r_unique))\n", + "\n", + "for i in range(len(r_unique)):\n", + " group_r_unique_index = np.where(r == r_unique[i])[0]\n", + " I_unique[i] = np.mean(I[np.array(group_r_unique_index)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f4b4e5e-0862-47dc-8d72-a3acf239cb02", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(r_unique, I_unique)\n", + "plt.ylabel(r'I [Jy/$sr^{-1}$]', size=15)\n", + "plt.xlabel('r [\"]', size = 15)\n", + "plt.title('Radial intensity profile of delta ring')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7dde89e-23d8-48df-a339-655092cb3474", + "metadata": {}, + "outputs": [], + "source": [ + "def gauss(r, sigma):\n", + " return np.exp(-0.5*((r-r_out/2.)/sigma)**2)\n", + "\n", + "from scipy.optimize import curve_fit\n", + "popt, cov = curve_fit(gauss, r_unique, I_unique/np.max(I_unique), p0=[0.09])\n", + "FWHM = popt[0]* 2. *np.sqrt(2.*np.log(2.))\n", + "Error_FWHM = np.sqrt(cov[0][0])* 2. *np.sqrt(2.*np.log(2.)) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60eb5290-c3ac-489c-a64e-a2d44726cc59", + "metadata": {}, + "outputs": [], + "source": [ + "plt.close()\n", + "plt.plot(r_unique, I_unique/np.max(I_unique), color='C0',label= r'Frank Solution, $N^{2}$ pixels with N = ' + str(N))\n", + "plt.plot(r_unique, gauss(r_unique, *popt), color='C1', label='Fit, FWHM=%.1f mas'%(FWHM*1000))\n", + "plt.ylabel(r'I normalized [Jy/$sr^{-1}$]', size=15)\n", + "plt.xlabel('r [\"]', size = 15)\n", + "plt.title('Radial intensity profile of delta ring')\n", + "plt.legend(loc='best', fontsize = 9)\n", + "\n", + "print ('FWHM=', FWHM, '+/-', Error_FWHM, 'arcsec') " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c34b4ec-c503-4954-b341-fc2fe3177e42", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Frank2D_PROD", + "language": "python", + "name": "frank2d_prod" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/frank/fourier2d.py b/frank/fourier2d.py index b0c73308..0c82733a 100644 --- a/frank/fourier2d.py +++ b/frank/fourier2d.py @@ -21,7 +21,6 @@ def __init__(self, Rmax, N, nu=0): self.dy = 2*self.Ymax/self.Ny # Frequency space collocation points. - # The [1:] is because to not consider the 0 baseline. But we're missing points. q1n = np.fft.fftfreq(self.Nx, d = self.dx) q2n = np.fft.fftfreq(self.Ny, d = self.dy) q1n, q2n = np.meshgrid(q1n, q2n, indexing='ij') @@ -53,11 +52,10 @@ def coefficients(self, u = None, v = None, x = None, y = None, direction="forwar norm = 1 / (4*self.Xmax*self.Ymax) factor = 2j*np.pi - X, Y = u, v + X, Y = self.Un, self.Vn if u is None: - X, Y = self.Un, self.Vn - u = self.Xn - v = self.Yn + u = self.Xn + v = self.Yn else: raise AttributeError("direction must be one of {}" "".format(['forward', 'backward'])) @@ -94,4 +92,9 @@ def Rmax(self): @property def resolution(self): """ Resolution of the grid in the x coordinate in rad""" - return self.dx \ No newline at end of file + return self.dx + + @property + def xy_points(self): + """ Collocation points in the image plane""" + return self.Xn, self.Yn \ No newline at end of file diff --git a/frank/radial_fitters.py b/frank/radial_fitters.py index cd021da8..b3eff179 100644 --- a/frank/radial_fitters.py +++ b/frank/radial_fitters.py @@ -168,7 +168,7 @@ def interpolate_brightness(self, Rpts, I=None): ----- The resulting brightness will be consistent with higher-resolution fits as long as the original fit has sufficient resolution. By sufficient - resolution we simply mean that the missing terms in the Fourier-Bessel + we simply mean that the missing terms in the Fourier-Bessel series are negligible, which will typically be the case if the brightness was obtained from a frank fit with 100 points or more. """ @@ -437,7 +437,7 @@ class FourierBesselFitter(object): def __init__(self, Rmax, N, geometry=None, nu=0, block_data=True, assume_optically_thick=True, scale_height=None, - block_size=10 ** 5, verbose=True): + block_size=10 ** 5, verbose=True, geometry_on = True): Rmax /= rad_to_arcsec @@ -457,7 +457,7 @@ def __init__(self, Rmax, N, geometry=None, nu=0, block_data=True, model = 'opt_thin' self._vis_map = VisibilityMapping(self._DHT, geometry, - model, scale_height=scale_height, + model, geometry_on = geometry_on ,scale_height=scale_height, block_data=block_data, block_size=block_size, check_qbounds=False, verbose=verbose, DFT = self._DFT) diff --git a/frank/statistical_models.py b/frank/statistical_models.py index 8d4ce21f..5c4f2391 100644 --- a/frank/statistical_models.py +++ b/frank/statistical_models.py @@ -66,7 +66,7 @@ class VisibilityMapping: Whether to print notification messages """ def __init__(self, DHT, geometry, - vis_model='opt_thick', scale_height=None, block_data=True, + vis_model='opt_thick', geometry_on = True, scale_height=None, block_data=True, block_size=10 ** 5, check_qbounds=True, verbose=True, DFT = None): @@ -78,6 +78,7 @@ def __init__(self, DHT, geometry, self._vis_model = vis_model self.check_qbounds = check_qbounds self._verbose = verbose + self.geometry_on = geometry_on self._chunking = block_data self._chunk_size = block_size @@ -165,7 +166,8 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): logging.info(' Building visibility matrices M and j') # Deproject the visibilities - #u, v, k, V = self._geometry.apply_correction(u, v, V, use3D=True) + if self.geometry_on: + u, v, k, V = self._geometry.apply_correction(u, v, V, use3D=True) q = np.hypot(u, v) # Check consistency of the uv points with the model @@ -179,7 +181,7 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): if frequencies is None: multi_freq = False frequencies = np.ones_like(V) - + start_time = time.time() channels = np.unique(frequencies) Ms = np.zeros([len(channels), self.size, self.size], dtype='c8') js = np.zeros([len(channels), self.size], dtype='c8') @@ -209,15 +211,34 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): Vs = Vi[start:end] X = self._get_mapping_coefficients(qs, ks, us, vs) - X_CT = self._get_mapping_coefficients(qs, ks, us, vs, inverse=True) - wXT = np.matmul(X_CT, np.diag(ws)) # this line is the same as below. - #wXT = np.matmul(np.transpose(np.conjugate(X)), np.diag(ws), dtype = "complex64") - Ms[i] += np.matmul(wXT, X, dtype="complex128") - js[i] += np.matmul(wXT, Vs, dtype="complex128") + wXT = np.matmul(np.transpose(np.conjugate(X)), np.diag(ws), dtype = "complex128") + Ms[i] += np.matmul(wXT, X, dtype="complex128").real + js[i] += np.matmul(wXT, Vs, dtype="complex128").real start = end end = min(Ndata, end + Nstep) - + + import matplotlib.pyplot as plt + + + N = int(np.sqrt(self._DFT.size)) + r"""FRANK 2D: TESTING M + sparcity = ((np.sum(np.abs(Ms[0]) < 0.5e-17))/N**4)*100 + print("M is sparse? ", sparcity) + print(Ms[0]) + + plt.imshow(Ms[0].real, cmap="magma", vmax = np.max(Ms[0].real), vmin = np.mean(Ms[0].real)) + plt.colorbar() + plt.show() + + M = np.diag(np.diag(Ms[0].real)) + num_zeros = ((np.sum(np.abs(M) == 0.0))/N**4)*100 + print("M is sparse? ", num_zeros) + + IFT2 = np.linalg.solve(M, js[0]).real + plt.imshow(IFT2.reshape(N,N).T, cmap="magma") + plt.colorbar() + print("M type", Ms[0].dtype) print("j type", js[0].dtype) print("M imag-> ", " max: ", np.max(Ms[0].imag), ", min: ", np.min(Ms[0].imag) , ", mean: ", np.mean(Ms[0].imag) ,", median: ", np.median(Ms[0].imag), ", std: ", np.std(Ms[0].imag)) @@ -228,8 +249,6 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): # from scipy.linalg import issymmetric # print(issymmetric(Ms[0]), "that M is a Symmetric Matrix") - - import matplotlib.pyplot as plt plt.matshow(Ms[0].real, cmap="magma", vmax = np.max(Ms[0].real), vmin = np.mean(Ms[0].real)) plt.colorbar() @@ -237,10 +256,15 @@ def map_visibilities(self, u, v, V, weights, frequencies=None, geometry=None): plt.show() #import sys #sys.exit() - + """ #Ms[0] = np.loadtxt(r'.\..\Notebooks\M_N75.txt', dtype = 'c8') #js[0] = np.loadtxt(r'.\..\Notebooks\j_N75.txt', dtype = 'c8') + print("--- %s minutes to calculate M and j ---" % (time.time()/60 - start_time/60)) + path = r'/Users/mariajmelladot/Desktop/Frank2D/1_Frank2D_DEV/data/TestingComplexity/' + np.save(path + 'M_N' + str(N) , Ms[0].real) + np.save(path + 'j_N' + str(N) , js[0].real) + # Compute likelihood normalization H_0, i.e., the # log-likelihood of a source with I=0. @@ -288,10 +312,10 @@ def check_hash(self, hash, multi_freq=False, geometry=None): self._DFT.Rmax == hash[1].Rmax and self._DFT.size == hash[1].size and self._DFT.order == hash[1].order and - geometry.inc == hash[2].inc and - geometry.PA == hash[2].PA and - geometry.dRA == hash[2].dRA and - geometry.dDec == hash[2].dDec and + #geometry.inc == hash[2].inc and + #geometry.PA == hash[2].PA and + #geometry.dRA == hash[2].dRA and + #geometry.dDec == hash[2].dDec and self._vis_model == hash[3] ) @@ -496,8 +520,11 @@ def _get_mapping_coefficients(self, qs, ks, u, v, geometry=None, inverse=False): if self._vis_model == 'opt_thick': # Optically thick & geometrically thin if geometry is None: - geometry = self._geometry - scale = np.cos(geometry.inc * deg_to_rad) + if not self.geometry_on: + scale = 1 + else: + geometry = self._geometry + scale = np.cos(geometry.inc * deg_to_rad) elif self._vis_model == 'opt_thin': # Optically thin & geometrically thin scale = 1 @@ -746,7 +773,6 @@ def __init__(self, DHT, M, j, p=None, scale=None, guess=None, " New GP " self.u, self.v = self._DFT.uv_points self.Ykm = self._DFT.coefficients(direction="backward") - self.Ykm_f = self._DFT.coefficients(direction="forward") m, c , l = -5, 60, 1e4 #m, c, l = 0.23651345032212925, 60.28747193555951, 1.000389e+05 @@ -758,10 +784,29 @@ def __init__(self, DHT, M, j, p=None, scale=None, guess=None, S_real_inv = np.linalg.inv(S_real) print("--- %s minutes to calculate S_real_inv---" % (time.time()/60 - start_time/60)) self._Sinv = S_real_inv - print(self._Sinv.dtype, " Sinv dtype") start_time = time.time() self._fit() print("--- %s minutes to fit---" % (time.time()/60 - start_time/60)) + + def calculate_S_real(self, u, v, l, m, c): + start_time = time.time() + S_fspace = self.true_squared_exponential_kernel(u, v, l, m, c) + print("--- %s minutes to calculate S---" % (time.time()/60 - start_time/60)) + start_time = time.time() + S_real = np.matmul(self.Ykm, np.matmul(S_fspace, self.Ykm.conj()), dtype = "complex128").real + print("--- %s minutes to calculate S_real---" % (time.time()/60 - start_time/60)) + + """ + #FRANK 2D: TESTING S_real + print(" S_real") + import matplotlib.pyplot as plt + plt.matshow(S_real, cmap="magma") + plt.colorbar() + plt.title("S matrix, real part ") + plt.show() + """ + + return S_real def true_squared_exponential_kernel(self, u, v, l, m, c): u1, u2 = np.meshgrid(u, u) @@ -784,23 +829,6 @@ def power_spectrum(q, m, c): SE_Kernel = np.sqrt(p1 * p2) * np.exp(-0.5*((u1-u2)**2 + (v1-v2)**2)/ l**2) return SE_Kernel - def calculate_S_real(self, u, v, l, m, c): - start_time = time.time() - S_fspace = self.true_squared_exponential_kernel(u, v, l, m, c) - print("--- %s minutes to calculate S---" % (time.time()/60 - start_time/60)) - start_time = time.time() - S_real = np.matmul(self.Ykm, np.matmul(S_fspace, self.Ykm_f), dtype = "complex64") - print("--- %s minutes to calculate S_real---" % (time.time()/60 - start_time/60)) - - print(S_real.dtype, " S_real dtype") - import matplotlib.pyplot as plt - plt.matshow(S_fspace, cmap="magma", vmin = 0, vmax = 1e-3) - plt.colorbar() - plt.title("S real matrix, real part ") - plt.show() - - return S_real - def calculate_mu_cholesky(self, Dinv): print("calculate mu with cholesky") try: @@ -889,7 +917,7 @@ def _fit(self): Dinv = self._M + Sinv - """ + r""" FRANK 2D: TESTING Dinv #import scipy.linalg as sc def is_pos_def(x): return np.all(np.linalg.eigvals(x) > 0)