elliptical_convolution.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "14d9af76-bfd9-47de-a370-6e65e87cbe58",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3/dist-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.17.3 and <1.25.0 is required for this version of SciPy (detected version 1.26.1\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np \n",
    "import healpy as hp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "edf13094-3f5b-4bc4-b5a3-aa99ee5f6cd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "setting the output map dtype to [dtype('float64')]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 850x540 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nside1 = 1024\n",
    "nside2 = 32\n",
    "map1 = np.zeros(12 * nside1 * nside1)\n",
    "\n",
    "# Fill the map1 array\n",
    "for i in range(12 * 32 * 32):\n",
    "    vec1 = hp.pix2vec(32, i,nest=True)\n",
    "    pix = hp.vec2pix(1024, vec1[0], vec1[1], vec1[2],nest=True)\n",
    "    map1[pix] = 1\n",
    "\n",
    "# Write the map1 array to a FITS file\n",
    "hp.write_map(\"map1.fits\", map1, overwrite=True,nest=True)\n",
    "hp.mollview(map1,nest=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9b68ba38-bb57-41de-863f-b67babf76379",
   "metadata": {},
   "outputs": [],
   "source": [
    "def RVector(t):\n",
    "    theta1 = 7.5*np.pi / 180\n",
    "    theta2 = 85*np.pi / 180\n",
    "    w1 = 2*np.pi / 60 #rad/sec\n",
    "    w2 = 2*w1 #rad/sec\n",
    "    w3 = 3.14159 / 60 #rad/sec\n",
    "    \n",
    "    A=[[np.cos(w1*t),np.sin(w1*t),0],\n",
    "       [-np.sin(w1*t),np.cos(w1*t),0],\n",
    "       [0,0,1]]\n",
    "    \n",
    "    B=[[1,0,0],\n",
    "       [0,np.cos(w2*t),np.sin(w2*t)],\n",
    "       [0,-np.sin(w2*t),np.cos(w2*t)]]\n",
    "    \n",
    "    C=[[np.cos(theta1),0,np.sin(theta1)],\n",
    "       [0,1,0],\n",
    "       [-np.sin(theta1),0,np.cos(theta1)]]\n",
    "    \n",
    "    D=[[np.cos(theta2)],\n",
    "       [np.sin(theta2)*np.cos(w3*t)],\n",
    "       [np.sin(theta2)*np.sin(w3*t)]]\n",
    "    \n",
    "    result1 = np.matmul(A,B)\n",
    "    result2 = np.matmul(result1,C)\n",
    "    result = np.matmul(result2,D)\n",
    "    return result\n",
    "\n",
    "\n",
    "def SVector(t):\n",
    "    theta1 = 7.5*np.pi / 180\n",
    "    theta2 = 0\n",
    "    w1 = 2*np.pi / 60 #rad/sec\n",
    "    # w1 = 0.000011954 / 60 #rad/sec\n",
    "    w2 = 2*w1  #rad/sec\n",
    "    w3 = 3.14159 / 60 #rad/sec\n",
    "    \n",
    "    A=[[np.cos(w1*t),np.sin(w1*t),0],\n",
    "       [-np.sin(w1*t),np.cos(w1*t),0],\n",
    "       [0,0,1]]\n",
    "    \n",
    "    B=[[1,0,0],\n",
    "       [0,np.cos(w2*t),np.sin(w2*t)],\n",
    "       [0,-np.sin(w2*t),np.cos(w2*t)]]\n",
    "    \n",
    "    C=[[np.cos(theta1),0,np.sin(theta1)],\n",
    "       [0,1,0],\n",
    "       [-np.sin(theta1),0,np.cos(theta1)]]\n",
    "    \n",
    "    D=[[np.cos(theta2)],\n",
    "       [-np.sin(theta2)*np.cos(w3*t)],\n",
    "       [-np.sin(theta2)*np.sin(w3*t)]]\n",
    "    \n",
    "    result1 = np.dot(A,B)\n",
    "    result2 = np.dot(C,D)\n",
    "    result = np.dot(result1,result2)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5ffda939-86e8-4ba6-bdc4-0b4a2abc5b38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# angular saperation between two pixel\n",
    "def ang_distance(theta1,theta2,phi1,phi2):\n",
    "    # cos(∆θ) = sin(θ1)sin(θ2)cos(φ1 - φ2) + cos(θ1)cos(θ2)\n",
    "    theta = np.arccos(np.cos(theta1) * np.cos(theta2) + np.sin(theta1) * np.sin(theta2) * np.cos(phi1 - phi2))\n",
    "    return theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a7bcb361-865c-4841-9661-85dae6df097f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Angle between two vector\n",
    "def angle_vec(A, B):\n",
    "    dot_product = np.dot(A, B.T)  # Transpose B to make it a column vector\n",
    "    mag_A = np.linalg.norm(A)\n",
    "    mag_B = np.linalg.norm(B)\n",
    "    \n",
    "    cos_theta = dot_product / (mag_A * mag_B)\n",
    "    angle = np.arccos(cos_theta)\n",
    "    \n",
    "    return angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9eccba3d-a43f-4bc8-86b4-d46944c5a103",
   "metadata": {},
   "outputs": [],
   "source": [
    "theta1 = 7.5*np.pi / 180\n",
    "theta2 = 85*np.pi / 180\n",
    "w1 = 2*np.pi / 60 #rad/sec\n",
    "w2 = 2*w1 #rad/sec\n",
    "w3 = 3.14159 / 60 #rad/sec\n",
    "\n",
    "nside=1024\n",
    "npix = 12*nside**2\n",
    "\n",
    "# time_step=scan_time\n",
    "scan_time = np.sqrt(4*np.pi/npix)/w1\n",
    "fwhm_x = np.radians(20) \n",
    "fwhm_y = np.radians(12)\n",
    "sigma_x = fwhm_x / np.sqrt(8 * np.log(2)) \n",
    "sigma_y = fwhm_y / np.sqrt(8 * np.log(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "02094314-7efc-4143-895b-802167d4d52b",
   "metadata": {},
   "outputs": [],
   "source": [
    "temperature_map = hp.read_map(\"map1.fits\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d296db16-9153-4879-afdc-80a054144080",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_time_step(time_step):\n",
    "    \n",
    "    t = time_step  \n",
    "\n",
    "    # 1. Calculate R(t) and S(t) vectors\n",
    "    R = RVector(t)\n",
    "    S = SVector(t)\n",
    "\n",
    "    # 2. Calculate pixel number along R(t) vector (ring format)\n",
    "    theta_R, phi_R = hp.vec2ang(R)\n",
    "    pic_ring = hp.ang2pix(nside, theta=theta_R, phi=phi_R)\n",
    "    nest_pix = hp.ring2nest(nside, pic_ring)\n",
    "\n",
    "    #3. Calculate Z, I and N (N = I for phi = 0)\n",
    "    Z_t = np.cross(np.transpose(R), np.transpose(S))\n",
    "    I_t = np.cross(np.transpose(R), Z_t)\n",
    "    N_t = I_t\n",
    "    \n",
    "    # 4. Find neighboring pixels in NEST format\n",
    "    # neighbours = hp.get_all_neighbours(nside, nest_pix,nest=True)\n",
    "    neighbours = hp.query_disc(nside, R , radius=np.radians(0.75),nest = True)\n",
    "\n",
    "    x = np.zeros_like(neighbours)\n",
    "    y = np.zeros_like(neighbours)\n",
    "    \n",
    "    for i, neighbour_pix in enumerate(neighbours):\n",
    "        # 5. angular separation between central pixel and neighbouring pixels\n",
    "        theta_neighbour, phi_neighbour = hp.pix2ang(nside, neighbour_pix,nest=True)\n",
    "        theta_i = ang_distance(theta_R, theta_neighbour, phi_R, phi_neighbour) \n",
    "\n",
    "        # 6. A_i = line joining central pixel and neighbour pixel\n",
    "        R_i = hp.pix2vec(nside,neighbour_pix,nest=True)\n",
    "        A_i = np.transpose(R) - R_i\n",
    "\n",
    "        # 7. angle between N & A_i\n",
    "        alpha_i = angle_vec(A_i, N_t)\n",
    "\n",
    "        # 8. x_i and y_i\n",
    "        x[i] = theta_i * np.cos(alpha_i)\n",
    "        y[i] = theta_i * np.sin(alpha_i)\n",
    "\n",
    "    # 9. Retrieve temperatures of neighboring pixels\n",
    "    neighbor_temperatures = temperature_map[neighbours]\n",
    "\n",
    "\n",
    "    # 10. Apply elliptical convolution\n",
    "    convolved_temperature = np.sum(neighbor_temperatures * np.exp(-x**2 / (2 * sigma_x**2) -y**2 / (2 * sigma_y**2))) / np.sum(np.exp(-x**2 / (2 * sigma_x**2) -y**2 / (2 * sigma_y**2)))\n",
    "\n",
    "    return int(nest_pix),convolved_temperature\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da738489-9e4a-4936-805d-4ecf218d355d",
   "metadata": {},
   "source": [
    "- - - - - Vizualization - - - - - "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2b305d00-68c7-45d8-af61-dc9c68df9dce",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "setting the output map dtype to [dtype('float64')]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 850x540 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nside = 128\n",
    "npix = 12*nside*nside\n",
    "map_array = np.ones(npix)\n",
    "hp.write_map(\"ones.fits\", map_array, overwrite=True,)\n",
    "hp.mollview(map_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "452aa496-b201-450d-9843-a553aeded73c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_19576/4077522880.py:16: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  neighbours = hp.query_disc(nside, R , radius=np.radians(25),nest = True)\n",
      "/tmp/ipykernel_19576/4077522880.py:31: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  temperature[neighbour_pix] = np.exp(- (x_i**2/(2*sigma_x**2)) - (y_i**2/(2*sigma_y**2)))\n"
     ]
    }
   ],
   "source": [
    "temperature= hp.read_map(\"ones.fits\", nest=True)\n",
    "sigma_x = 10 / np.sqrt(8 * np.log(2)) \n",
    "sigma_y = 5 / np.sqrt(8 * np.log(2)) \n",
    "t = 0\n",
    "R = RVector(t)\n",
    "S = SVector(t)\n",
    "# to get the vector N\n",
    "Z_t = np.cross(np.transpose(R), np.transpose(S))\n",
    "I_t = np.cross(np.transpose(R), Z_t)\n",
    "N_t = I_t\n",
    "\n",
    "#To calculate angular separation \n",
    "theta_R, phi_R = hp.vec2ang(R)\n",
    "pix = hp.vec2pix(nside,R[0],R[1],R[2],nest= True)\n",
    "#  Get all the neighbours\n",
    "neighbours = hp.query_disc(nside, R , radius=np.radians(25),nest = True)\n",
    "for i, neighbour_pix in enumerate(neighbours):\n",
    "    # print(neighbours[i])\n",
    "    R_i = hp.pix2vec(nside,neighbour_pix,nest=True)\n",
    "    A_i = np.transpose(R)-R_i\n",
    "    # print(A_i)\n",
    "    # print(N_t,\"\\n\")\n",
    "    theta_R_i, phi_R_i = hp.pix2ang(nside, neighbour_pix,nest=True)\n",
    "    alpha_i = angle_vec(A_i, N_t)\n",
    "\n",
    "    theta_i = ang_distance(theta_R, theta_R_i, phi_R, phi_R_i)\n",
    "\n",
    "    # set temperature\n",
    "    x_i = theta_i*np.cos(alpha_i)\n",
    "    y_i = theta_i*np.sin(alpha_i)\n",
    "    temperature[neighbour_pix] = np.exp(- (x_i**2/(2*sigma_x**2)) - (y_i**2/(2*sigma_y**2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ae9aa9c3-80bc-4f48-bf4a-df7c462f4524",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 850x540 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# print(temperature)\n",
    "hp.mollview(temperature,cmap='jet_r',nest=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3f78e180-6df2-4704-9468-52be726e3f06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 850x540 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# if sigma_x = sigma_y\n",
    "hp.mollview(temperature,cmap='jet_r',nest=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6389a5f-7bde-4a4f-8414-68a62bffca93",
   "metadata": {},
   "outputs": [],
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}