{ "cells": [ { "cell_type": "markdown", "id": "dc62ab54", "metadata": {}, "source": [ "## Detection of the Sun Center through Polarimetric Observations\n", "\n", "By Alessandro Liberatore (alessandro.liberatore@inaf.it)\n", "\n", "[This script was last tested and confirmed to run correctly on August 5, 2025]" ] }, { "cell_type": "markdown", "id": "8cd0a690", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "id": "83476a8d", "metadata": {}, "source": [ "In both coronagraphic and total solar eclipse observations, the solar disk is not directly visible. Blocking direct light from the photosphere is essential to observe the solar atmosphere, which is thousands of times dimmer than the solar disk. This lack of direct observation of the solar disk introduces uncertainty in determining the Sun’s center behind the occulter or the Moon. \n", "\n", "A common approach for detecting the Sun’s center is based on astrometry, which measures the precise positions of the Sun, looking at the position and movements of other celestial bodies like stars and planets. Methods such as astrometry are applicable only when stars are present in the field of view, which is not always the case due to several limiting factors. For instance, a low signal-to-noise ratio may prevent the detection of background stars, especially in highly scattered or noisy observations. Similarly, a small field of view can reduce or completely exclude the presence of reference stars, making astrometric measurements unfeasible. Additional challenges include instrumental limitations, exposure time constraints, and the brightness of the observed target, which can overpower faint background sources. These factors collectively restrict the applicability of astrometric techniques in certain observational conditions, necessitating alternative methods for precise positional measurements. \n", "\n", "In this notebook, we present a novel method for determining the center of the solar disk using polarimetric observations of the solar corona. The polarized component of the solar corona (K-corona) is the brightest component of the solar corona. The K-corona is due to Thomson diffusion of photospheric radiation by free coronal electrons and results linearly polarized with a polarization angle tangent to the solar limb. In particular, we will make use of the Angle of Linear Polarization ($AoLP$) maps, defined as:\n", "\n", "$$ AoLP = \\frac{1}{2} \\arctan{\\left(\\frac{U}{Q}\\right)}$$\n", "\n", "where $Q$ and $U$ are the second and third elements of the stokes vector $\\mathbf{S} = [S_0, S_1, S_2] = [I , Q, U]$." ] }, { "cell_type": "markdown", "id": "aba9f27a", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "id": "f4425998", "metadata": {}, "source": [ "Python packages necessary to run the code:" ] }, { "cell_type": "code", "execution_count": 1, "id": "0bfaf9cc", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/aliberatore/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:35: NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", " warnings.warn(\n" ] } ], "source": [ "%matplotlib ipympl\n", "#%matplotlib notebook\n", "#%matplotlib inline\n", "\n", "import glob\n", "import sys\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib import cm\n", "from mpl_toolkits.mplot3d import Axes3D\n", "from matplotlib.ticker import MaxNLocator\n", "\n", "from sunpy.sun import constants as con\n", "import sunpy.map\n", "import sunpy_soar\n", "from sunpy.net import Fido, attrs as a\n", "\n", "import astropy.units as u\n", "from astropy.io import fits\n", "from astropy.wcs import WCS\n", "from astropy.visualization import ImageNormalize, PowerStretch" ] }, { "cell_type": "markdown", "id": "bef272b5", "metadata": {}, "source": [ "Download Metis $AoLP$ map:" ] }, { "cell_type": "code", "execution_count": 2, "id": "01357482-1ed6-46d7-93c0-19d78964f52d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "#################### AoLP ####################\n", "Results from 1 Provider:\n", "\n", "4 Results from the SOARClient:\n", "\n", "Instrument Data product ... Filesize SOOP Name \n", " ... Mbyte \n", "---------- ------------------ ... -------- ---------------------------------\n", " METIS metis-vl-pol-angle ... 12.64 L_FULL_HRES_HCAD_Coronal-Dynamics\n", " METIS metis-vl-pol-angle ... 12.64 L_FULL_HRES_HCAD_Coronal-Dynamics\n", " METIS metis-vl-pol-angle ... 12.64 L_FULL_HRES_HCAD_Coronal-Dynamics\n", " METIS metis-vl-pol-angle ... 12.64 L_FULL_HRES_HCAD_Coronal-Dynamics\n", "\n", "\n" ] } ], "source": [ "# Select the instrument (e.g., METIS)\n", "instrument = a.Instrument(\"METIS\")\n", "\n", "# Set the time range of interest\n", "time = a.Time(\"2022-03-24 00:00:00\", \"2022-03-24 02:00:00\")\n", "\n", "# Select the product\n", "product_AoLP = a.soar.Product(\"metis-vl-pol-angle\")\n", "\n", "# Select the level (0, 1, 2)\n", "level = a.Level(2)\n", "\n", "# Show the available data\n", "result_AoLP = Fido.search(instrument & time & product_AoLP & level)\n", "\n", "print(f\"{'#' * 20} AoLP {'#' * 20}\\n{result_AoLP}\")" ] }, { "cell_type": "code", "execution_count": 3, "id": "46c443d9-6113-45eb-8c4d-f88bd9469e55", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "425b7ce85d7e499a8c022ca99e351d80", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Files Downloaded: 0%| | 0/4 [00:00\n", "
\n", " Figure\n", "
\n", " \n", " \n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "i = 0 # image you want to plot (0 <= i < Number of images)\n", "extension = 0 # fits extension you want to plot\n", "\n", "AoLP_map = sunpy.map.Map(all_data[i])[extension]\n", "AoLP_map.plot_settings['norm'] = ImageNormalize(vmin=-90, vmax=+90)\n", "\n", "fig = plt.figure(figsize=(5, 5))\n", "\n", "axes = [fig.add_subplot(1, 1, i+1, projection=m.wcs) for i, m in enumerate([AoLP_map])]\n", "\n", "for ax, m in zip(axes, [AoLP_map]):\n", " im = m.plot(axes=ax)\n", " m.draw_limb(axes=ax)\n", " m.draw_grid(axes=ax)\n", " plt.colorbar(im, ax=ax, orientation='horizontal', fraction=0.04, pad=0.14)\n", " \n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "ffabe54b", "metadata": {}, "source": [ "The method presented in this notebook for determining the center of the Sun behind the occulter requires selecting two angles ($\\alpha$ and $\\beta$) and drawing two lines. Each line passes through one of the angles and its opposite angle (i.e., one line passes through $\\alpha$ and $\\alpha + 180^\\circ$, and the other one between $\\beta$ and $\\beta + 180^\\circ$). Once these two lines are obtained, their intersection must be determined. This intersection will indicate the position of the Sun's center. \n", "\n", "The following function, returns the intersection point (x, y) given the endpoints of the two lines: " ] }, { "cell_type": "code", "execution_count": 5, "id": "174b5f63-8a32-481e-919b-94c9807d099a", "metadata": {}, "outputs": [], "source": [ "def line_intersection(line1, line2):\n", " xdiff = (line1[0][0] - line1[1][0], line2[0][0] - line2[1][0])\n", " ydiff = (line1[0][1] - line1[1][1], line2[0][1] - line2[1][1])\n", "\n", " def det(a, b):\n", " return a[0] * b[1] - a[1] * b[0]\n", "\n", " div = det(xdiff, ydiff)\n", " if div == 0:\n", " raise Exception('Lines do not intersect!')\n", "\n", " d = (det(*line1), det(*line2))\n", " x = det(d, xdiff) / div\n", " y = det(d, ydiff) / div\n", " \n", " return x, y" ] }, { "cell_type": "markdown", "id": "d338f97d", "metadata": {}, "source": [ "To determine the value of the Sun's center to compare with the actual value reported in the FITS file header, we will iterate the procedure (i.e., angles selection and evaluation of the intersection of the lines passing through them) for various angles $\\varphi$, and then compute the average. \n", "\n", "Since we are dealing with two lines, we have a range that can vary between 0 and 180 degrees for each line at most." ] }, { "cell_type": "markdown", "id": "e4ffe2ff", "metadata": {}, "source": [ "The core of the code consist of evaluating the endpoints of the lines required to execute `line_intersection()`. The position of the endpoints are obtained as the average of the position of all pixels in regions of interest (ROIs)." ] }, { "cell_type": "markdown", "id": "c7ab90fc", "metadata": {}, "source": [ "Each element of `dist_vec` is a distance between the real Sun Center (from FITS header) and the obtained one (from the lines intersection) at fixed $\\varphi$ for a single $AoLP$ map. \n", "\n", "The average of all the element of `dist_vec` (i.e., an average distance obtained considering all the $\\varphi$) is an element of vector `dist_vecALL`. Thus, `dist_vecALL` contains a number of elements equal to the number of $AoLP$ maps considered." ] }, { "cell_type": "code", "execution_count": 6, "id": "a9f7b3ad-9356-461e-b287-c65ab2294d7a", "metadata": {}, "outputs": [], "source": [ "# Limits on the considered angular range\n", "phi_istart, phi_istop, phi_istep = 30., 61., 1. # [deg] -default angular range-\n", "rho_limIN, rho_limOUT = 30., 100. # [pixels] -default radial range-\n", "\n", "# Flags\n", "NBIN_val = 2 # set the NBIN values of the images you want to consider (for Metis: NBIN_val = 1, 2, 4)\n", "plotFig, savePNG = False, False # set True if you want to see plots or save PNG (plotFig must be set 'True' as well in this case)\n", "verbose = False # set True if you wish to print\n", "excluded_values = []\n", "\n", "if plotFig:\n", " plt.ion()\n", "else:\n", " plt.ioff()" ] }, { "cell_type": "code", "execution_count": 7, "id": "c1e265c8-4462-40c5-aeb4-284cf61a57ac", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Img n.: 0 / 3\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "WARNING: FITSFixedWarning: CROTA = 3.95190364417 / [deg] rotation angle \n", "keyword looks very much like CROTAn but isn't. [astropy.wcs.wcs]\n", "WARNING: FITSFixedWarning: 'datfix' made the change 'Set MJD-OBS to 59662.000709 from DATE-OBS.\n", "Set MJD-BEG to 59662.000709 from DATE-BEG.\n", "Set MJD-AVG to 59662.010687 from DATE-AVG.\n", "Set MJD-END to 59662.020664 from DATE-END'. [astropy.wcs.wcs]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Img n.: 1 / 3\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "WARNING: FITSFixedWarning: CROTA = 3.95561790589 / [deg] rotation angle \n", "keyword looks very much like CROTAn but isn't. [astropy.wcs.wcs]\n", "WARNING: FITSFixedWarning: 'datfix' made the change 'Set MJD-OBS to 59662.021542 from DATE-OBS.\n", "Set MJD-BEG to 59662.021542 from DATE-BEG.\n", "Set MJD-AVG to 59662.031520 from DATE-AVG.\n", "Set MJD-END to 59662.041498 from DATE-END'. [astropy.wcs.wcs]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Img n.: 2 / 3\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "WARNING: FITSFixedWarning: CROTA = 3.95912887568 / [deg] rotation angle \n", "keyword looks very much like CROTAn but isn't. [astropy.wcs.wcs]\n", "WARNING: FITSFixedWarning: 'datfix' made the change 'Set MJD-OBS to 59662.042376 from DATE-OBS.\n", "Set MJD-BEG to 59662.042376 from DATE-BEG.\n", "Set MJD-AVG to 59662.052353 from DATE-AVG.\n", "Set MJD-END to 59662.062331 from DATE-END'. [astropy.wcs.wcs]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Img n.: 3 / 3\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "WARNING: FITSFixedWarning: CROTA = 3.96279374514 / [deg] rotation angle \n", "keyword looks very much like CROTAn but isn't. [astropy.wcs.wcs]\n", "WARNING: FITSFixedWarning: 'datfix' made the change 'Set MJD-OBS to 59662.063209 from DATE-OBS.\n", "Set MJD-BEG to 59662.063209 from DATE-BEG.\n", "Set MJD-AVG to 59662.073187 from DATE-AVG.\n", "Set MJD-END to 59662.083164 from DATE-END'. [astropy.wcs.wcs]\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# List containing the distances between the real Sun center and the ones obtained from the lines' intersection (\"polarimetric Sun center\" hereafter) for different Sun-Spacecraft distances (in Astronomical Units)\n", "dist_vecALL = []\n", "dist_vecALL_best = []\n", "sigma_vecALL = []\n", "sigma_vecALL_best = []\n", "AUvec = []\n", "\n", "# List containing information on the ROIs (e.g., number of pixels and width)\n", "LEN_ROIsector_vec_avg = []\n", "mean_std_ROI_vec = []\n", "mean_phi_iocen_vec_TRTLBLBR_vec = []\n", "std_phi_iocen_vec_TRTLBLBR_vec = []\n", "\n", "# Lists containing the average of the AoLP ROI to evaluate the error on the angle\n", "AoLP_vs_radial_img = []\n", "AoLP_vs_radial_img_fig = []\n", "AoLP_vs_radial_vecsimg = []\n", "AoLP_vs_radial_vecsimg_fig = []\n", "\n", "# Values set in the cycles\n", "delta_phi_min = 0.1 # after several tests, a deltaPhi of 0.1 is the minimum value to ensure a non-empty array in the dataset considered\n", "\n", "# Image reading\n", "AoLPimg_vec = [fits.open(all_data[i])[0] for i in range(len(all_data))]\n", "phi_i_vec = [phi_i for phi_i in np.arange(phi_istart, phi_istop, phi_istep)] # list of considered phi\n", "\n", "# Cycle on the list of considered images (as test, set: 271, 272)\n", "from_AoLPimg = 0 # first image to consider\n", "to_AoLPimg = len(AoLPimg_vec) # last image to consider\n", "\n", "for AoLPimg in range(from_AoLPimg, to_AoLPimg):\n", " \n", " print(\"Img n.:\", AoLPimg, \"/\", len(AoLPimg_vec)-1)\n", " \n", " if AoLPimg not in excluded_values: \n", "\n", " # Initialization of used list ##############\n", " \n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec = []\n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_min = []\n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_max = []\n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_mean = []\n", " x_inters_vec = []\n", " y_inters_vec = []\n", " dist_vec = []\n", " LEN_ROIsector_vec = []\n", " std_ROI_vec = []\n", " phi_iocen_vec_TRTLBLBR_vec = []\n", " \n", " # ########################################## \n", " \n", " \n", " \n", " # Image under consideration ################\n", " \n", " hdu_AoLP = AoLPimg_vec[AoLPimg]\n", " \n", " # Instrument features **********************\n", " dataMap_deg = True # set 'True' if the data maps are in degree. Set 'False' if in radians.\n", " Number_of_bin = hdu_AoLP.header['NBIN1'] # considered binning factor (axis 1 = axis 2)\n", " imageID = \"SESS_NUM: {0} | FILENAME: {1}\".format(hdu_AoLP.header['SESS_NUM'], hdu_AoLP.header['FILENAME']) # ID of the considered image\n", " imageDATE = hdu_AoLP.header['DATE-AVG'] # time of observation \n", " pixel_scale_arcsec_axis1 = hdu_AoLP.header['CDELT1'] # pixel scale along axis 1 [arcsec] \n", " pixel_scale_arcsec_axis2 = hdu_AoLP.header['CDELT2'] # pixel scale along axis 2 [arcsec] \n", " imageINFOV = hdu_AoLP.header['INN_FOV'] # inner FoV [deg]\n", " imageOUTFOV = hdu_AoLP.header['OUT_FOV'] # outer FoV [deg]\n", " dim_axis1 = hdu_AoLP.header['PXEND1'] # last pixel read out in dimension 1 (i.e., dim of axis 1) [pixel]\n", " dim_axis2 = hdu_AoLP.header['PXEND2'] # last pixel read out in dimension 1 (i.e., dim of axis 2) [pixel]\n", " rsun_arcsec = hdu_AoLP.header['RSUN_ARC'] # solar radius in arcsecond\n", " image_IOcen = (hdu_AoLP.header['IO_XCEN'], hdu_AoLP.header['IO_YCEN']) # Internal Occulter center coordinate [pixel]\n", " image_SUNcen = (hdu_AoLP.header['SUN_XCEN'], hdu_AoLP.header['SUN_YCEN']) # Sun center coordinate [pixel]\n", " image_CROTA = hdu_AoLP.header['CROTA'] # rotation angle [deg]\n", " shift_AoLP = 49 # angle wrt reference axis\n", " \n", " if shift_AoLP <= 0:\n", " lim360 = 360+shift_AoLP\n", " else:\n", " lim360 = shift_AoLP\n", " # ******************************************\n", "\n", " if dataMap_deg:\n", " my_map = sunpy.map.Map(hdu_AoLP.data, hdu_AoLP.header)\n", " else:\n", " hdu_AoLP.data = hdu_AoLP.data*180/np.pi\n", " my_map = sunpy.map.Map(hdu_AoLP.data, hdu_AoLP.header)\n", " \n", " # ########################################## \n", " \n", " \n", " if Number_of_bin == NBIN_val:\n", " \n", " # Image Name, WCS and Obs. time ********\n", " if verbose:\n", " print(imageID)\n", " wcs_Metis = WCS(hdu_AoLP.header)\n", " DATE_AVG_AoLP = imageDATE\n", " # ************************************** \n", " \n", " \n", " \n", " # Instrument Field of View (FoV) *******\n", " fov1 = imageINFOV*3600/pixel_scale_arcsec_axis1 # internal FoV [pixel]\n", " fov2 = imageOUTFOV*3600/pixel_scale_arcsec_axis2 # external FoV [pixel]\n", " # ************************************** \n", " \n", " \n", " \n", " # Polar Maps and Masks *****************\n", " x = np.arange(dim_axis1)\n", " y = np.arange(dim_axis2)\n", " xx, yy = np.meshgrid(x, y, sparse = False)\n", " rho_iocen = np.sqrt((xx-image_IOcen[0])**2 + (yy-image_IOcen[1])**2) # Map of distance from IO center [pixel]\n", " phi_iocen = (np.arctan2((yy-image_IOcen[1]), (xx-image_IOcen[0]))*(180/np.pi)+360)%360 # Map of angle from IO center [deg]\n", " phi_suncen = (np.arctan2((yy-image_SUNcen[1]), (xx-image_SUNcen[0]))*(180/np.pi)+360)%360 # Map of angle from Sun center [deg]\n", " \n", " hdu_AoLP.data[rho_iocen < fov1] = 0. # Internal Occulter mask\n", " hdu_AoLP.data[rho_iocen > fov2-10] = np.nan # Field Stop mask\n", " \n", " Rsun_m = con.constants['radius'].value # Solar Radius in meters\n", " R_Sun_pixel = rsun_arcsec/pixel_scale_arcsec_axis1 # Solar Radius in pixel\n", " if pixel_scale_arcsec_axis1 == pixel_scale_arcsec_axis2:\n", " platescale = pixel_scale_arcsec_axis1 # Instrument platescale [arcsec/pixel]\n", " else:\n", " platescale = pixel_scale_arcsec_axis1 # Instrument platescale [arcsec/pixel]\n", " print(\"ATTENTION! DIFFERENT PLATESCALES ALONG X AND Y! - TBD. Same platescale is considered.\")\n", " R_Sun_arcsec = R_Sun_pixel * platescale # Solar radius in arcsec\n", " AU_m = con.constants['mean distance'].value # Astronomical Unit in meters\n", " \n", " distance = Rsun_m/np.tan(rsun_arcsec/60/60*np.pi/180) / AU_m # Sun-Spacecraft distance in Astronomical Units [AU]\n", " if verbose:\n", " print(\"Sun-S/C distance:\", distance)\n", " AUvec.append(distance)\n", " \n", " rho_IO_Rsun = np.sqrt(((xx-image_IOcen[0]) * platescale / R_Sun_arcsec)**2 + ((yy-image_IOcen[1]) * platescale / R_Sun_arcsec)**2) # Map of distance from IO center [R_sun]\n", " rho_Sun_Rsun = np.sqrt(((xx-image_SUNcen[0]) * platescale / R_Sun_arcsec)**2 + ((yy-image_SUNcen[1]) * platescale / R_Sun_arcsec)**2) # Map of distance from Sun center [R_sun]\n", " # **************************************\n", " \n", " \n", " \n", " # About angle tangentiality ************\n", " height, width = my_map.data.shape[0], my_map.data.shape[1]\n", " x, y = np.meshgrid(np.arange(width), np.arange(height))\n", " sun_y = image_SUNcen[1]\n", " sun_x = image_SUNcen[0]\n", " rad_angle = np.arctan2(y - sun_y, x - sun_x)\n", " rad_angle = rad_angle % np.pi\n", " tan_angle = rad_angle - 0.5*np.pi\n", " tan_angle_deg_rotated = sunpy.map.Map(tan_angle*(180/np.pi), hdu_AoLP.header)\n", " \n", " #if plotFig:\n", " if False:\n", " fig = plt.figure(figsize=(14., 2.5))\n", " \n", " ax0 = fig.add_subplot(1, 3, 1, projection = tan_angle_deg_rotated)\n", " #ax0.imshow(tan_angle_deg_rotated, cmap = \"jet\", origin='lower', vmin = 0, vmax = 360)\n", " tan_angle_deg_rotated.plot(cmap = \"jet\", vmin = 0, vmax = 360)\n", " tan_angle_deg_rotated.draw_limb()\n", " tan_angle_deg_rotated.draw_grid()\n", " lon, lat = ax0.coords\n", " lon.set_major_formatter('d.dd')\n", " lat.set_major_formatter('d.dd')\n", "\n", " ax1 = fig.add_subplot(1, 3, 2, projection = my_map)\n", " my_map.plot(cmap = \"jet\", vmin = -90, vmax = 90)\n", " my_map.draw_limb()\n", " my_map.draw_grid()\n", " lon, lat = ax1.coords\n", " lon.set_major_formatter('d.dd')\n", " lat.set_major_formatter('d.dd')\n", " ax1.coords.grid(True, color = 'white', ls = 'dotted', alpha = 0.5)\n", " plt.colorbar(label = \"AoLP [deg]\", shrink = 1.00, pad = 0.07)\n", " \n", " img_difference = hdu_AoLP.data-tan_angle_deg_rotated.data\n", " img_difference[img_difference>90] = img_difference[img_difference>90]-180\n", " img_difference[img_difference<-90] = img_difference[img_difference<-90]+180\n", " \n", " img_difference -= shift_AoLP\n", " hdu_AoLPdata_vs_theta_map = sunpy.map.Map(img_difference, hdu_AoLP.header) \n", " \n", " #if plotFig:\n", " if False:\n", " ax2 = fig.add_subplot(1, 3, 3, projection = my_map)\n", " hdu_AoLPdata_vs_theta_map.plot(cmap = \"jet\", vmin = 0, vmax = 10)\n", " hdu_AoLPdata_vs_theta_map.draw_limb()\n", " hdu_AoLPdata_vs_theta_map.draw_grid()\n", " lon, lat = ax2.coords\n", " lon.set_major_formatter('d.dd')\n", " lat.set_major_formatter('d.dd')\n", " ax2.coords.grid(True, color = 'white', ls = 'dotted', alpha = 0.5)\n", " plt.colorbar(label = r\"(AoLP-$\\theta$)-90 [deg]\", shrink = 1.00, pad = 0.07)\n", " \n", " #if plotFig:\n", " if False:\n", " img_difference[rho_iocen < fov1] = np.nan # Internal Occulter mask\n", " \n", " angles = np.array(img_difference).flatten()\n", " mean = np.nanmean(angles)\n", " \n", " fig, (ax_img, ax_hist) = plt.subplots(1, 2, figsize=(10, 4), dpi = 100, gridspec_kw={'width_ratios': [1, 1.2]})\n", " \n", " im = ax_img.imshow(img_difference, origin = \"lower\", cmap='viridis', vmin=-5, vmax=5)\n", " ax_img.set_title(\"Map\")\n", " ax_img.axis('on')\n", " ax_img.set_xlabel(\"x [pixel]\")\n", " ax_img.set_ylabel(\"y [pixel]\")\n", " fig.colorbar(im, ax=ax_img, fraction=0.046, pad=0.04, label=\"Dev. from tan. [deg]\")\n", " \n", " \n", " # n = len(angles)\n", " # nbin = int(np.ceil(np.log2(n) + 1))\n", " nbin = 1000\n", " ax_hist.hist(angles, bins=nbin, range=(-30, 30), edgecolor='black', color='cornflowerblue')\n", " ax_hist.set_title(\"Hist\")\n", " ax_hist.set_xlabel(r\"$\\varphi$ [deg]\")\n", " ax_hist.set_ylabel(\"Counts [#]\")\n", " ax_hist.axvline(mean, color='red', linestyle='--', label=f\"Mean = {mean:.2f}°\")\n", " ax_hist.legend()\n", " \n", " freq, bin_edges = np.histogram(angles, bins=nbin, range=(0, 90))\n", " index_peak = np.argmax(freq)\n", " center_peack = 0.5 * (bin_edges[index_peak] + bin_edges[index_peak + 1])\n", " \n", " print(f\"Hist Mean: {mean:.2f}°\")\n", " print(f\"Hist Peak: {center_peack:.2f}° with {freq[index_peak]} pixels\")\n", " \n", " plt.tight_layout()\n", " \n", " # if savePNG:\n", " if False:\n", " plt.savefig(path+\"/output/IMG{0}_MetisSunDist_{1:.3f}AU_ObsTime_{2:}.png\".format(AoLPimg, distance, DATE_AVG_AoLP))\n", " # **************************************\n", " \n", " \n", " \n", " # Absolute value of AoLP maps **********\n", " hdu_AoLP.data = np.abs(hdu_AoLP.data)\n", " # **************************************\n", " \n", " \n", " \n", " # Cycle on the radial distances ********\n", " for r_i in np.arange(1, 2, 1):\n", " \n", " # Image reading\n", " AoLPimg_vec = [fits.open(all_data[i])[0] for i in range(len(all_data))]\n", " \n", " # Cycle on the considered angles\n", " for phi_i in np.arange(phi_istart, phi_istop, phi_istep):\n", " \n", " # Region of Interest (ROI) -------------\n", " \n", " # Radial ROI\n", " ROIrho = np.logical_and(rho_iocen > fov1+rho_limIN, rho_iocen < fov1+rho_limOUT*r_i)\n", " \n", " # Angular ROI\n", " ROIphi = np.logical_and(hdu_AoLP.data >= phi_i-delta_phi_min, hdu_AoLP.data <= phi_i+delta_phi_min) \n", " \n", " # Total ROI (i.e., Radial + Angular)\n", " ROI = np.logical_and(ROIrho, ROIphi)\n", " hdu_AoLP.data = np.where(ROI, np.nan, hdu_AoLP.data)\n", " \n", " # Top-Right ROI \n", " ROI_sectorTR = np.logical_and(ROI, np.logical_and(phi_iocen > 0+shift_AoLP, phi_iocen < 90+shift_AoLP))\n", " AoLP_vs_radial_TR = hdu_AoLPdata_vs_theta_map.data[ROI_sectorTR]\n", " \n", " # Top-Left ROI \n", " ROI_sectorTL = np.logical_and(ROI, np.logical_and(phi_iocen > 90+shift_AoLP, phi_iocen < 180+shift_AoLP))\n", " AoLP_vs_radial_TL = hdu_AoLPdata_vs_theta_map.data[ROI_sectorTL]\n", " \n", " # Bottom-Left ROI \n", " ROI_sectorBL = np.logical_and(ROI, np.logical_and(phi_iocen > 180+shift_AoLP, phi_iocen < 270+shift_AoLP))\n", " AoLP_vs_radial_BL = hdu_AoLPdata_vs_theta_map.data[ROI_sectorBL]\n", " \n", " # Bottom-Right ROI \n", " ROI_sectorBR = np.logical_and(ROI, np.logical_or(phi_iocen > 270+shift_AoLP, phi_iocen < lim360))\n", " AoLP_vs_radial_BR = hdu_AoLPdata_vs_theta_map.data[ROI_sectorBR]\n", " \n", " # Number of pixels considered (average of all ROIs)\n", " LEN_ROIsector = (len(AoLP_vs_radial_TR)+len(AoLP_vs_radial_TL)+len(AoLP_vs_radial_BL)+len(AoLP_vs_radial_BR))/4\n", " LEN_ROIsector_vec.append(LEN_ROIsector)\n", " \n", " if verbose:\n", " print(\"Magenta:\", np.mean(AoLP_vs_radial_TR)) # Average value of AoLP in ROI1\n", " print(\"Cyan:\", np.mean(AoLP_vs_radial_TL)) # Average value of AoLP in ROI2\n", " print(\"Orange:\", np.mean(AoLP_vs_radial_BL)) # Average value of AoLP in ROI3\n", " print(\"Lime:\", np.mean(AoLP_vs_radial_BR)) # Average value of AoLP in ROI4\n", " print(\"LEN_ROIsector:\", LEN_ROIsector) # average number of pixels in the ROIs\n", " \n", " AoLP_vs_radial_ROIsector_AVG = (np.nanmean(AoLP_vs_radial_TR)+np.nanmean(AoLP_vs_radial_TL)+np.nanmean(AoLP_vs_radial_BL)+np.nanmean(AoLP_vs_radial_BR))/4\n", " AoLP_vs_radial_norm_val = np.max([np.nanmean(AoLP_vs_radial_TR), np.nanmean(AoLP_vs_radial_TL), np.nanmean(AoLP_vs_radial_BL), np.nanmean(AoLP_vs_radial_BR)])\n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec.append(AoLP_vs_radial_norm_val)\n", "\n", " if verbose:\n", " print(\"Angle: {0}\".format(phi_i), [np.nanmean(AoLP_vs_radial_TR), np.nanmean(AoLP_vs_radial_TL), np.nanmean(AoLP_vs_radial_BL), np.nanmean(AoLP_vs_radial_BR)])\n", " print(\"AoLP_vs_radial_ROIsector average all colors:\", AoLP_vs_radial_ROIsector_AVG)\n", " # --------------------------------------\n", " \n", " \n", " \n", " # Plot AoLP map and intersection -------\n", " my_map = sunpy.map.Map(hdu_AoLP.data, hdu_AoLP.header) \n", " considered_angles = [ROI]\n", " \n", " #plotFig = True \n", " if plotFig:\n", " plt.figure(figsize = [7, 7], dpi = 250)\n", " ax = plt.subplot(1, 1, 1, projection = my_map)\n", " \n", " x_vecTL, x_vecBL, x_vecTR, x_vecBR = [], [], [], [] # T, B, L, R = Top, Bottom, Left, Right\n", " y_vecTL, y_vecBL, y_vecTR, y_vecBR = [], [], [], [] # T, B, L, R = Top, Bottom, Left, Right\n", " phi_iocen_vec_TR, phi_iocen_vec_TL, phi_iocen_vec_BL, phi_iocen_vec_BR = [], [], [], []\n", " \n", " for i in range(len(considered_angles)):\n", " index = np.where(considered_angles[i])\n", " index_yx = zip(index[0], index[1])\n", " \n", " for y, x in index_yx:\n", " # There is a shift of 45deg in the standard cartesian sectors due to the 45deg shift between polar angle and AoLP\n", " if phi_iocen[y][x] > 0+shift_AoLP and phi_iocen[y][x] < 90+shift_AoLP: # = phi_iocen > 0 and phi_iocen < 90\n", " x_vecTR.append(x)\n", " y_vecTR.append(y)\n", " if plotFig:\n", " ax.plot(x, y, '.', color='magenta')\n", " phi_iocen_vec_TR.append(phi_iocen[y][x])\n", " elif phi_iocen[y][x] > 90+shift_AoLP and phi_iocen[y][x] < 180+shift_AoLP: # = phi_iocen > 90 and phi_iocen < 180\n", " x_vecTL.append(x)\n", " y_vecTL.append(y)\n", " if plotFig:\n", " ax.plot(x, y, '.', color='cyan')\n", " phi_iocen_vec_TL.append(phi_iocen[y][x])\n", " elif phi_iocen[y][x] > 180+shift_AoLP and phi_iocen[y][x] < 270+shift_AoLP: # = phi_iocen > 180 and phi_iocen < 270\n", " x_vecBL.append(x)\n", " y_vecBL.append(y)\n", " if plotFig:\n", " ax.plot(x, y, '.', color='orange')\n", " phi_iocen_vec_BL.append(phi_iocen[y][x])\n", " elif phi_iocen[y][x] > 270+shift_AoLP or phi_iocen[y][x] < lim360: # = phi_iocen > 270 and phi_iocen < 360\n", " x_vecBR.append(x)\n", " y_vecBR.append(y)\n", " if plotFig:\n", " ax.plot(x, y, '.', color='lime')\n", " if phi_iocen[y][x] < shift_AoLP:\n", " phi_iocen_vec_BR.append(phi_iocen[y][x]+360)\n", " else:\n", " phi_iocen_vec_BR.append(phi_iocen[y][x])\n", " else:\n", " sys.exit(\"ERROR\")\n", " \n", " # ROIs' half-width\n", " phi_iocen_vec_TR = np.max( [np.abs(np.mean(phi_iocen_vec_TR)-phi_iocen_vec_TR[i]) for i in range(len(phi_iocen_vec_TR))] )\n", " phi_iocen_vec_TL = np.max( [np.abs(np.mean(phi_iocen_vec_TL)-phi_iocen_vec_TL[i]) for i in range(len(phi_iocen_vec_TL))] )\n", " phi_iocen_vec_BL = np.max( [np.abs(np.mean(phi_iocen_vec_BL)-phi_iocen_vec_BL[i]) for i in range(len(phi_iocen_vec_BL))] )\n", " phi_iocen_vec_BR = np.max( [np.abs(np.mean(phi_iocen_vec_BR)-phi_iocen_vec_BR[i]) for i in range(len(phi_iocen_vec_BR))] )\n", " \n", " if verbose:\n", " print(\"phi_iocen_vec_TR:\", phi_iocen_vec_TR)\n", " print(\"phi_iocen_vec_TL:\", phi_iocen_vec_TL)\n", " print(\"phi_iocen_vec_BL:\", phi_iocen_vec_BL)\n", " print(\"phi_iocen_vec_BR:\", phi_iocen_vec_BR)\n", " \n", " phi_iocen_vec_TRTLBLBR_vec.append(phi_iocen_vec_TR)\n", " phi_iocen_vec_TRTLBLBR_vec.append(phi_iocen_vec_TL)\n", " phi_iocen_vec_TRTLBLBR_vec.append(phi_iocen_vec_BL)\n", " phi_iocen_vec_TRTLBLBR_vec.append(phi_iocen_vec_BR)\n", " \n", " # ROIs' deviation from tangentiality\n", " AoLP_vs_radial_norm_val = np.mean([phi_iocen_vec_TR,phi_iocen_vec_BL,phi_iocen_vec_TL,phi_iocen_vec_BR]) # useful for tests; e.g., \"[...] * np.mean([phi_iocen_vec_TR,phi_iocen_vec_BL,phi_iocen_vec_TL,phi_iocen_vec_BR])\"\n", " AoLP_vs_radial_norm_val_min = np.min([np.abs(np.nanmean(AoLP_vs_radial_TR)), np.abs(np.nanmean(AoLP_vs_radial_BL)), np.abs(np.nanmean(AoLP_vs_radial_TL)), np.abs(np.nanmean(AoLP_vs_radial_BR))])\n", " AoLP_vs_radial_norm_val_max = np.max([np.abs(np.nanmean(AoLP_vs_radial_TR)), np.abs(np.nanmean(AoLP_vs_radial_BL)), np.abs(np.nanmean(AoLP_vs_radial_TL)), np.abs(np.nanmean(AoLP_vs_radial_BR))])\n", " AoLP_vs_radial_norm_val_mean = np.mean([np.abs(np.nanmean(AoLP_vs_radial_TR)), np.abs(np.nanmean(AoLP_vs_radial_BL)), np.abs(np.nanmean(AoLP_vs_radial_TL)), np.abs(np.nanmean(AoLP_vs_radial_BR))])\n", " \n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec.append(AoLP_vs_radial_norm_val)\n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_min.append(AoLP_vs_radial_norm_val_min)\n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_max.append(AoLP_vs_radial_norm_val_max)\n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_mean.append(AoLP_vs_radial_norm_val_mean)\n", " \n", " # Average and standard deviation on the points in the ROIs\n", " mean_x_vecTR, mean_y_vecTR = np.mean(x_vecTR), np.mean(y_vecTR)\n", " mean_x_vecTL, mean_y_vecTL = np.mean(x_vecTL), np.mean(y_vecTL)\n", " mean_x_vecBL, mean_y_vecBL = np.mean(x_vecBL), np.mean(y_vecBL)\n", " mean_x_vecBR, mean_y_vecBR = np.mean(x_vecBR), np.mean(y_vecBR)\n", " std_x_vecTR, std_y_vecTR = np.std(x_vecTR), np.std(y_vecTR)\n", " std_x_vecTL, std_y_vecTL = np.std(x_vecTL), np.std(y_vecTL)\n", " std_x_vecBL, std_y_vecBL = np.std(x_vecBL), np.std(y_vecBL)\n", " std_x_vecBR, std_y_vecBR = np.std(x_vecBR), np.std(y_vecBR)\n", " std_TR = np.sqrt(std_x_vecTR**2 + std_y_vecTR**2)\n", " std_TL = np.sqrt(std_x_vecTL**2 + std_y_vecTL**2)\n", " std_BL = np.sqrt(std_x_vecBL**2 + std_y_vecBL**2)\n", " std_BR = np.sqrt(std_x_vecBR**2 + std_y_vecBR**2)\n", " std_ROI = (std_TR+std_TL+std_BL+std_BR)/4\n", " std_ROI_vec.append(std_ROI)\n", " \n", " if verbose:\n", " print(\"***** len(std_ROI_vec):\", len(std_ROI_vec))\n", "\n", " # Intersection point\n", " # Line 1\n", " A = [mean_x_vecTL, mean_y_vecTL]\n", " B = [mean_x_vecBR, mean_y_vecBR]\n", " # Line 2\n", " C = [mean_x_vecBL, mean_y_vecBL]\n", " D = [mean_x_vecTR, mean_y_vecTR]\n", " # Intersection of Line1 and Line 2\n", " x_inters, y_inters = line_intersection((A, B), (C, D))\n", " \n", " # Distance between Sun centers (Astrometrical - Polarimetric)\n", " dist = np.sqrt((image_SUNcen[0]-x_inters)**2 + (image_SUNcen[1]-y_inters)**2) \n", " dist_vec.append(dist)\n", " #print(\"dist_vec:\", dist_vec, \"\\n\")\n", "\n", " if verbose:\n", " print(\"RealCenter[pixel]: (x, y) = ({0}, {1})\".format(image_SUNcen[0], image_SUNcen[1]))\n", " print(\"MyCenter[pixel]: (x, y) = ({0}, {1})\".format(x_inters, y_inters))\n", " print(\"Difference: {0:.2f} pixel = {1:.2f} arcsec = {2:.2f} min = {3:.2f} deg\".format(dist, dist*platescale, dist*platescale/60, dist*platescale/60/60))\n", " print(\"Offests:\\n\", dist_vec)\n", " \n", " if plotFig:\n", " \n", " # Draw avg points P_i\n", " ax.plot(mean_x_vecTR, mean_y_vecTR, '.', color='black') # P1\n", " ax.plot(mean_x_vecTL, mean_y_vecTL, '.', color='black') # P2\n", " ax.plot(mean_x_vecBL, mean_y_vecBL, '.', color='black') # P3\n", " ax.plot(mean_x_vecBR, mean_y_vecBR, '.', color='black') # P4\n", " \n", " # Draw lines\n", " ax.plot([mean_x_vecTL, mean_x_vecBR], [mean_y_vecTL, mean_y_vecBR], color='green') # Line 1 \n", " ax.plot([mean_x_vecBL, mean_x_vecTR], [mean_y_vecBL, mean_y_vecTR], color='green') # Line 2\n", " \n", " # Draw Sun centers and Internal Occulter points\n", " ax.plot(x_inters, y_inters, '.', color='yellow') # Polarimetric Sun center\n", " ax.plot(image_SUNcen[0], image_SUNcen[1], '.', color='cyan') # Astrometric Sun center\n", " ax.plot(image_IOcen[0], image_IOcen[1], '.', color='red') # Internal Occulter center\n", " \n", " # Plot cosmetic\n", " lon, lat = ax.coords\n", " lon.set_major_formatter('d.dd')\n", " lat.set_major_formatter('d.dd')\n", " ax.coords.grid(True, color = 'white', ls = 'dotted', alpha = 0.5)\n", " my_map.plot(cmap = \"jet\", vmin = 0, vmax = 90)\n", " #hdu_AoLPdata_vs_theta_map.plot(cmap = \"jet\", vmin = 0, vmax = 10)\n", " plt.colorbar(label = \"|AoLP| [deg]\", shrink = 1.00, pad = 0.07)\n", " my_map.draw_limb()\n", " my_map.draw_grid()\n", " \n", " plt.xlabel('Helioprojective Longitude (Solar-X)')\n", " plt.ylabel('Helioprojective Latitude (Solar-Y)')\n", " \n", " title_name = \"ObsTime: {0:} | AU: {1:.2f}\\nOffset: ({2:.2f} $\\pm$ {3:.2f}) pix\\n\".format(DATE_AVG_AoLP, distance, np.nanmean(dist_vec), np.nanstd(dist_vec))\n", " plt.title(title_name, y = 0.96, fontsize = 15)\n", "\n", " # Save images\n", " if savePNG:\n", " #if True:\n", " # plt.savefig(path+\"/output/Fig{0}_MetisSunDist_{1:.3f}AU_ObsTime_{2:}_SCsDist_{3:.2f}pix.png\".format(AoLPimg, distance, DATE_AVG_AoLP, np.nanmean(dist_vec)))\n", " plt.savefig(path+\"/output/Fig{0}_Phi{1}_MetisSunDist_{2:.3f}AU_ObsTime_{3:}_TR{4:.2f}_TL{5:.2f}_BL{6:.2f}_BR{7:.2f}.png\".format(AoLPimg, phi_i, distance, DATE_AVG_AoLP, np.nanmean(AoLP_vs_radial_TR), np.nanmean(AoLP_vs_radial_TL), np.nanmean(AoLP_vs_radial_BL), np.nanmean(AoLP_vs_radial_BR)))\n", " \n", " #plotFig = False \n", " x_inters_vec.append(x_inters)\n", " y_inters_vec.append(y_inters)\n", " # --------------------------------------\n", " \n", " # **************************************\n", " \n", " \n", " \n", " # About lists on the ROI features ****** \n", " \n", " # ROIs lists\n", " if len(LEN_ROIsector_vec) == 0:\n", " LEN_ROIsector_vec_avg.append(np.nan)\n", " else:\n", " LEN_ROIsector_vec_avg.append(np.mean(LEN_ROIsector_vec))\n", " \n", " mean_std_ROI_vec.append(np.mean(std_ROI_vec))\n", " mean_phi_iocen_vec_TRTLBLBR_vec.append(np.mean(phi_iocen_vec_TRTLBLBR_vec))\n", " std_phi_iocen_vec_TRTLBLBR_vec.append(np.std(phi_iocen_vec_TRTLBLBR_vec))\n", " if verbose:\n", " print(\"----- len(mean_std_ROI_vec):\", len(mean_std_ROI_vec))\n", " print(\"----- len(mean_phi_iocen_vec_TRTLBLBR_vec):\", len(mean_phi_iocen_vec_TRTLBLBR_vec))\n", " \n", " if verbose:\n", " print(\"AoLP_vs_radial_ROIsector_differentrotation_AVG_vec:\", AoLP_vs_radial_ROIsector_differentrotation_AVG_vec)\n", " \n", " AoLP_vs_radial_vecsimg.append(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec) # i.e., a list of the following lists: [max value among the four ROIs, for each angle] per considered image\n", " AoLP_vs_radial_img.append(np.nanmean(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec)) # i.e., the following list: [average of [max value among the four ROIs, for each angle], per considered image]\n", " \n", " if verbose:\n", " print(\"AoLP_vs_radial_vecsimg:\", AoLP_vs_radial_vecsimg)\n", " print(\"Len(AoLP_vs_radial_vecsimg):\", len(AoLP_vs_radial_vecsimg))\n", " print(\"Len(AoLP_vs_radial_vecsimg[0]):\", len(AoLP_vs_radial_vecsimg[0]))\n", " print(\"AoLP_vs_radial_img:\", AoLP_vs_radial_img)\n", " \n", " # Smooting for plot\n", " window = 3\n", " dist_vec = np.convolve(np.ravel(dist_vec), np.ones(window)/window, mode='same')\n", " \n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec = [1-(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_mean[i]/np.max(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_mean)) for i in range(len(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_min))]\n", " if len(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec) > 0:\n", " AoLP_vs_radial_ROIsector_differentrotation_AVG_vec = np.convolve(np.ravel(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec), np.ones(window)/window, mode='same')\n", " \n", " if verbose:\n", " print(\"phi_i_vec:\", phi_i_vec)\n", " print(\"dist_vec:\", dist_vec)\n", " print(\"AoLP_vs_radial_ROIsector_differentrotation_AVG_vec:\", AoLP_vs_radial_ROIsector_differentrotation_AVG_vec)\n", "\n", " # Best area selection\n", " A = AoLP_vs_radial_ROIsector_differentrotation_AVG_vec # list of TQI\n", " B = phi_i_vec # list of considered angles\n", " C = dist_vec # list of all offsets in phi_i_vec range\n", " \n", " # Find the highest \"N values\" in A\n", " N = 1\n", " top_indices = sorted(range(len(A)), key=lambda i: A[i], reverse=True)[:N]\n", " \n", " # Sort the indexes according to the original order\n", " top_indices_sorted = sorted(top_indices)\n", " \n", " # Extract the corresponding B values\n", " B_top_original_order = [B[i] for i in top_indices_sorted] # new angles to consider\n", " \n", " # Extract the corresponding C values\n", " C_top_original_order = [C[i] for i in top_indices_sorted] # offsets if considering only top_indices\n", "\n", " if verbose:\n", " print(\"top_indices (N = {0}):\".format(N), top_indices)\n", " print(\"top_indices_sorted:\", top_indices_sorted)\n", " print(\"B_top_original_order:\", B_top_original_order)\n", " print(\"C_top_original_order:\", C_top_original_order)\n", " \n", " DeltaMax = np.max(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_max)-np.min(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_max)\n", " DeltaMin = np.max(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_min)-np.min(AoLP_vs_radial_ROIsector_differentrotation_AVG_vec_min)\n", " if verbose:\n", " print(\"AoLPimg\", AoLPimg)\n", " print(\"DeltaMax\", DeltaMax)\n", " print(\"DeltaMin\", DeltaMin)\n", " \n", " if plotFig:\n", " fig, ax1 = plt.subplots(figsize = [5.5, 3.5], dpi = 100)\n", " ax1.axvspan(phi_istart, phi_istop, color='orange', alpha=0.3, label=f'Area tra x={phi_istart} e x={phi_istop}')\n", " ax2 = ax1.twinx()\n", " \n", " line1, = ax1.plot(phi_i_vec, dist_vec, \".-\", color = \"blue\", label = \"Offset\")\n", " line2, = ax2.plot(phi_i_vec, AoLP_vs_radial_ROIsector_differentrotation_AVG_vec, \".-\", color = \"red\", label = r\"Tangency Quality Index\")\n", " \n", " ax1.set_xlim(0, 90)\n", " ax1.set_xlabel(r\"$\\vartheta_i$ [deg]\")\n", " ax1.tick_params(axis = 'x', top = True, labeltop = False, direction = 'in')\n", " \n", " ax1.set_ylabel(\"Offset [pix]\", color = 'blue')\n", " ax1.tick_params(axis = 'y', direction = 'in', colors = \"blue\")\n", " ax2.spines['left'].set_color('blue')\n", " ax2.spines['left'].set_linewidth(1.5)\n", " \n", " ax2.set_ylabel(r\"TQI = $1 - |\\Delta\\Psi|/|\\Delta\\Psi|_{Max}$\", color='red')\n", " ax2.tick_params(axis = 'both', direction = 'in', colors = \"red\")\n", " ax2.spines['right'].set_color('red')\n", " ax2.spines['right'].set_linewidth(1.5)\n", " \n", " lines = [line1, line2]\n", " labels = [line.get_label() for line in lines]\n", " ax1.legend(lines, labels, loc='upper center', bbox_to_anchor=(0.5, 1.15), ncol=2, frameon=False, fontsize=9)\n", " ax1.grid(True, linestyle = ':', alpha = 0.5)\n", " \n", " # Plot a line for each considered angle\n", " for x in B_top_original_order:\n", " ax1.axvline(x=x, color='green', alpha=0.5, linestyle='--', linewidth=1)\n", " \n", " plt.tight_layout()\n", " if savePNG:\n", " plt.savefig(path+\"/output/TQI_Fig{0}_MetisSunDist_{1:.3f}AU_ObsTime_{2:}.png\".format(AoLPimg, distance, DATE_AVG_AoLP))\n", "\n", " # List of offsets and associated standard deviation\n", " dist_vecALL.append(np.nanmean(dist_vec))\n", " dist_vecALL_best.append(np.nanmean(C_top_original_order))\n", " sigma_vecALL.append(np.nanstd(dist_vec))\n", " sigma_vecALL_best.append(np.nanstd(C_top_original_order))\n", " if verbose:\n", " print(\"dist_vecALL:\", dist_vecALL)\n", " print(\"dist_vecALL_best:\", dist_vecALL_best)\n", " print(\"sigma_vecALL:\", sigma_vecALL)\n", " print(\"sigma_vecALL_best:\", sigma_vecALL_best)\n", " # **************************************\n", " \n", " # ########################################## \n", "\n", "AUvec = [round(num, 6) for num in AUvec] # To approx the Sun-Spacecraft distance to the 6th digits (comment this line for the full number)\n", "phi_i_vec = [phi_i for phi_i in np.arange(phi_istart, phi_istop, phi_istep)] # list of considered phi\n", "\n", "plt.ion()" ] }, { "cell_type": "code", "execution_count": 8, "id": "cf1c479c-3f39-4c93-8f32-0d7592dedc07", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of considered images: 4\n", "Offsets = [2.0260941596947513, 2.0687986775721336, 1.9749479511235446, 1.9831566032807038]\n", "Average offset: (2.01 +/- 1.22) pixels\n", "[ Average best offset: 0.81 pixels ]\n" ] } ], "source": [ "# Offsets values (i.e., distances between Astrometrical Sun center and Polarimetric Sun center) for all images\n", "print(\"Number of considered images:\", np.count_nonzero(~np.isnan(dist_vecALL)))\n", "# Offsets\n", "print(\"Offsets =\", dist_vecALL)\n", "# Average\n", "print(\"Average offset: ({0:.2f} +/- {1:.2f}) pixels\".format(np.mean(dist_vecALL[:]), np.mean(sigma_vecALL[:])))\n", "print(\"[ Average best offset: {0:.2f} pixels ]\".format(np.mean(dist_vecALL_best[:])))\n", "\n", "# Distances in Solar Radii\n", "dist_ROI_Rsun = []\n", "\n", "for i in AUvec:\n", " \n", " d = i * AU_m/Rsun_m # Sun-S/C distance [Rsun]\n", " theta = (1.6 + ((((rho_limIN + rho_limOUT)/2)*20.276)/3600)) * np.pi/180 # FoV [rad] = inner FoV + avg. ROI distance\n", " # theta = ((((rho_limIN + rho_limOUT)/2)*20.276)/3600) * np.pi/180 # FoV [rad] = avg. ROI distance\n", " s = d * np.tan(theta) # Linear FoV [R_Sun]\n", " \n", " dist_ROI_Rsun.append(s)" ] }, { "cell_type": "markdown", "id": "c69d424e", "metadata": {}, "source": [ "---" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "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.9.6" } }, "nbformat": 4, "nbformat_minor": 5 }