AAA_Final_OpticalPathOfAncientPhotons.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import math\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.optimize import fsolve, curve_fit\n",
    "from scipy.stats import chisquare\n",
    "from astropy.cosmology import Planck15\n",
    "from astropy import constants as cc, units as uu\n",
    "import parameters\n",
    "\n",
    "DefaultSize=[10,6]\n",
    "font = {'family': 'serif',\n",
    "        'color':  'black',\n",
    "        'weight': 'normal',\n",
    "        'size': 14,\n",
    "        }\n",
    "axis_font = {'name':'Arial', 'size':'18'}\n",
    "\n",
    "title_font = {'name':'Arial', 'size':'18'}\n",
    "\n",
    "def d_planck15(z):\n",
    "    R0 = (cc.c)/(Planck15.H0)\n",
    "    d_L = (Planck15.luminosity_distance(z))/R0.to(uu.Mpc)\n",
    "    plt.plot(z, d_L)\n",
    "    R0=R0.to(uu.lyr)/1e9\n",
    "    return R0,d_L\n",
    "z = np.arange(0.0,1.5,0.01)\n",
    "R0_GLY,d_L=d_planck15(z)\n",
    "R0_GLY_CMB=R0_GLY\n",
    "print(R0_GLY)\n",
    "HubbleGRData=pd.DataFrame()\n",
    "HubbleGRData['z']=z\n",
    "HubbleGRData['d']=d_L\n",
    "\n",
    "# http://astronomy.swin.edu.au/cosmos/D/Distance+Modulus\n",
    "\n",
    "\n",
    "SCPData = pd.ExcelFile(parameters.supernovaAddress + 'SCPUnionData.xlsx').parse('Sheet2')\n",
    "angle=math.pi/4\n",
    "# First let's create a set of lambda-shifts\n",
    "z = SCPData['redshift']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Below is the application of the theory to the usd Wil Supernova (z=1.917)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cosmological Angle\n",
    "def alpha(z):\n",
    "    return [math.pi/4 - math.asin(1/math.sqrt(2)/(1+x)) for x in z]\n",
    "# 4D Radius of the Universe\n",
    "def RofT(z):\n",
    "    a = alpha(z)\n",
    "    return [math.cos(x) - math.sin(x) for x in a]\n",
    "# Distance to the Epoch\n",
    "def DistanceOfT(z):\n",
    "    d= 13.58\n",
    "    return [(1-x)*d for x in RofT(z)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DefaultSize=[6,6]\n",
    "\n",
    "font = {\n",
    "        'weight' : 'regular',\n",
    "        'size'   : 14}\n",
    "\n",
    "matplotlib.rc('font', **font)\n",
    "title_font = {'name':'Arial', 'size':'14'}\n",
    "\n",
    "axis_font = {'name':'Arial', 'size':'13'}\n",
    "label_font = {'name':'Arial', 'size':'13'}\n",
    "fig, ax = plt.subplots()  \n",
    "fig.set_size_inches( DefaultSize )# resetthe size\n",
    "Size = fig.get_size_inches()\n",
    "print (\"Size in Inches\", Size)\n",
    "# print(radius)\n",
    "plt.axis([0, 1.1, 0, 1.1])\n",
    "plt.plot([0,0],[0,1.1])\n",
    "\n",
    "\n",
    "def plotAncientPhotons(fig, ax, n=10, rays=False):\n",
    "    # define radiuses\n",
    "    radius = [x/10 for x in range(n+1)]\n",
    "    thetas = [x/n for x in range(1,n+1)]\n",
    "# Create the circles\n",
    "    for i in range(0,n+1):\n",
    "        rad=i/10\n",
    "        ax.add_artist(plt.Circle(xy=(0,0),radius=rad, color='r', fill=False)) \n",
    "        \n",
    "# create the meridians\n",
    "    if rays:\n",
    "        for i in range(0,n):\n",
    "            r=n/10\n",
    "            x1=[r*np.sin(thetas[i]),r*np.cos(thetas[i])]\n",
    "            plt.plot([0,x1[0]],[0,x1[1]] )\n",
    "            \n",
    "# Create the sinusoidals\n",
    "    for j in range(0, n):\n",
    "        x=[]\n",
    "        y=[]\n",
    "        miniangle=np.linspace(0,6*np.pi,100)\n",
    "        miniangletheta=np.linspace(0,0.1,100)\n",
    "        angle=1-thetas[j]+miniangletheta\n",
    "        rad=radius[j+1]+0.01*np.cos(miniangle)\n",
    "        x.append(rad*np.sin(angle))\n",
    "        y.append(rad*np.cos(angle))\n",
    "        plt.plot(x,y,\".\")\n",
    "    return ax\n",
    "            \n",
    " \n",
    "ax=plotAncientPhotons(fig, ax, n=5)   \n",
    "ax=plotAncientPhotons(fig, ax, n=10, rays=True)   \n",
    "\n",
    "ax.plot([0,0],[0,0],'ro')\n",
    "ax.set_xlabel(\"Cosmological Time\", **label_font)\n",
    "ax.set_ylabel(\"Cosmological Time\", **label_font)\n",
    "ax.set_title(\"Wavelength Stretching\", fontdict=title_font)\n",
    "plt.text(np.sin(1),np.cos(1), r'$\\theta$=1 radian', **axis_font)\n",
    "ax.ticklabel_format(style='sci', axis='x') \n",
    "ax.ticklabel_format(style='sci', axis='y') \n",
    "plt.savefig(parameters.imgAddress + \"WavelengthStretching.png\", dpi=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# jupyterlab_vim\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "# Define the rotation matrix for 45 degrees anticlockwise\n",
    "def rotation_matrix(theta):\n",
    "    c, s = np.cos(theta), np.sin(theta)\n",
    "    return np.array([[c, -s], [s, c]])\n",
    "\n",
    "# Create the rotation matrix for 45 degrees (pi/4 radians)\n",
    "alpha = 0\n",
    "theta = np.pi/4 - np.radians(alpha)\n",
    "rot_matrix = rotation_matrix(theta)\n",
    "\n",
    "# Define the figure and axis\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "n=6\n",
    "# Define the range for the plot\n",
    "x = np.linspace(0, n*np.pi, 400)\n",
    "y_sin = np.sin(x)\n",
    "\n",
    "# Apply the rotation matrix to the sinusoidal curve\n",
    "xy_original = np.vstack((x, y_sin))\n",
    "xy_rotated = np.dot(rot_matrix, xy_original)\n",
    "# Plot the original sinusoidal curve for reference (dashed blue line)\n",
    "ax.plot(xy_rotated[0], xy_rotated[1], label='$\\lambda_{4D}$', color='blue', linestyle='-')\n",
    "\n",
    "# Apply the rotation matrix to the sinusoidal curve\n",
    "xy_original = np.vstack((x, y_sin*0.0))\n",
    "xy_rotated = np.dot(rot_matrix, xy_original)\n",
    "# Plot the original sinusoidal curve for reference (dashed blue line)\n",
    "ax.plot(xy_rotated[0], xy_rotated[1], color='blue', linestyle='-')\n",
    "\n",
    "# Plot the original sinusoidal curve for reference (dashed blue line)\n",
    "ax.plot(x/np.cos(theta), y_sin, label='$\\lambda_{3D} (Observed)$', color='blue', linestyle='--')\n",
    "\n",
    "ax.hlines(y=0, xmin=0, xmax=n*np.pi/np.cos(theta))\n",
    "ax.vlines(x=0, ymin=-1, ymax=2*n*np.pi/np.cos(theta))\n",
    "\n",
    "\n",
    "# Drawing lines at n*2*pi crossings\n",
    "for n in range(1, int(n/2)+1):  # Adjust range of n as needed\n",
    "    cross_x = n * 2 * np.pi\n",
    "    cross_y = 0\n",
    "    cross_point_rotated = np.dot(rot_matrix, np.array([cross_x, cross_y]))\n",
    "    \n",
    "    # Draw line for the rotated sinusoidal\n",
    "    ax.plot([cross_x/np.cos(theta), cross_point_rotated[0]], [cross_y, cross_point_rotated[1]], color='red')\n",
    "    \n",
    "#     # Draw horizontal line for the original sinusoidal\n",
    "#     ax.plot([cross_x, cross_x], [0, np.sin(cross_x)], color='green')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Set the same scaling for both axes\n",
    "# ax.axis('equal')\n",
    "\n",
    "# Set the limit for better visualization\n",
    "plt.xlim(-1, 2*(n)*np.pi/np.cos(theta))\n",
    "plt.ylim(-1, (n)*np.pi/np.cos(theta))\n",
    "# plt.ylim(-1, 2*(n)*np.pi)\n",
    "\n",
    "# Add labels and title\n",
    "plt.xlabel('Distance')\n",
    "plt.ylabel('Radial Direction')\n",
    "plt.title('Projection of $\\lambda_{4D}$ onto $\\lambda_{Observed}$')\n",
    "\n",
    "# Annotate the angle (pi/4 - alpha)\n",
    "ax.annotate(r'$ \\Gamma = \\frac{\\pi}{4} - \\alpha_0$', \n",
    "             xy=(0, 0), \n",
    "             xytext=(5, 90), \n",
    "             textcoords='offset points',\n",
    "#              arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"arc3,rad=.5\"),\n",
    "             fontsize=12)\n",
    "\n",
    "\n",
    "# Annotate the angle (pi/4 - alpha) with an arc\n",
    "arc = patches.Arc((0, 0),  # Center point\n",
    "                  6,       # Width\n",
    "                  7,       # Height\n",
    "                  theta1=45-alpha,        # Starting angle\n",
    "                  theta2=90,  # Ending angle\n",
    "                  color='black',\n",
    "                  linewidth=1)\n",
    "ax.add_patch(arc)\n",
    "\n",
    "\n",
    "# Add a legend\n",
    "ax.set_aspect('equal')\n",
    "plt.legend()\n",
    "plt.savefig(\"./Drawing For Publications/LightPropagationin4D.png\")\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "# Define the rotation matrix for 45 degrees anticlockwise\n",
    "def rotation_matrix(theta):\n",
    "    c, s = np.cos(theta), np.sin(theta)\n",
    "    return np.array([[c, -s], [s, c]])\n",
    "\n",
    "# Create the rotation matrix for 45 degrees (pi/4 radians)\n",
    "alpha = 10\n",
    "theta = np.pi/4 - np.radians(alpha)\n",
    "rot_matrix = rotation_matrix(-theta)\n",
    "\n",
    "# Define the figure and axis\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "n=6\n",
    "# Define the range for the plot\n",
    "x = np.linspace(-n*np.pi,0, 400)\n",
    "y_sin = np.sin(x)\n",
    "y_h_line = y_sin*0\n",
    "\n",
    "\n",
    "# Apply the rotation matrix to the sinusoidal curve\n",
    "xy_original = np.vstack((x, y_sin))\n",
    "xy_rotated = np.dot(rot_matrix, xy_original)\n",
    "# Plot the original sinusoidal curve for reference (dashed blue line)\n",
    "ax.plot(xy_rotated[0], xy_rotated[1], label='$\\lambda_{4D}$', color='blue', linestyle='-')\n",
    "\n",
    "# Apply the rotation matrix to the h_line curve\n",
    "xy_original = np.vstack((x, y_h_line))\n",
    "xy_rotated = np.dot(rot_matrix, xy_original)\n",
    "# Plot the original sinusoidal curve for reference (dashed blue line)\n",
    "ax.plot(xy_rotated[0], xy_rotated[1], color='blue', linestyle='-')\n",
    "\n",
    "# Plot the original sinusoidal curve for reference (dashed blue line)\n",
    "ax.plot(x/np.cos(theta), y_sin, label='$\\lambda_{3D} (Observed)$', color='blue', linestyle='--')\n",
    "\n",
    "ax.hlines(y=0, xmin=0, xmax=-n*np.pi/np.cos(theta))\n",
    "ax.vlines(x=0, ymin=-1, ymax=2*n*np.pi/np.cos(theta))\n",
    "\n",
    "\n",
    "# Drawing lines at n*2*pi crossings\n",
    "for n in range(1, int(n/2)+1):  # Adjust range of n as needed\n",
    "    cross_x = -n * 2 * np.pi\n",
    "    cross_y = 0\n",
    "    cross_point_rotated = np.dot(rot_matrix, np.array([cross_x, cross_y]))\n",
    "    \n",
    "    # Draw line for the rotated sinusoidal\n",
    "    ax.plot([cross_x/np.cos(theta), cross_point_rotated[0]], [cross_y, cross_point_rotated[1]], color='red')\n",
    "    \n",
    "    # Draw horizontal line for the original sinusoidal\n",
    "    ax.plot([-cross_x, cross_x], [0, np.sin(cross_x)], color='green')\n",
    "\n",
    "# Set the limit for better visualization\n",
    "plt.xlim(-2*(n)*np.pi/np.cos(theta), 1)  # Adjusted for the negative x values\n",
    "plt.ylim(-1, (n)*np.pi/np.cos(theta))\n",
    "\n",
    "# Add labels and title\n",
    "plt.xlabel('Distance')\n",
    "plt.ylabel('Radial Direction')\n",
    "plt.title('Projection of $\\lambda_{4D}$ onto $\\lambda_{Observed}$')\n",
    "\n",
    "# Annotate the angle (pi/4 - alpha)\n",
    "ax.annotate(r'$ \\Gamma =  \\frac{\\pi}{4} - \\alpha_0$', \n",
    "             xy=(0, 0), \n",
    "             xytext=(-65, 75), \n",
    "             textcoords='offset points',\n",
    "#              arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"arc3,rad=.5\"),\n",
    "             fontsize=12)\n",
    "\n",
    "\n",
    "# Annotate the angle (pi/4 - alpha) with an arc\n",
    "arc = patches.Arc((0, 0),  # Center point\n",
    "                  15,       # Width\n",
    "                  15,       # Height\n",
    "                  theta1=90,        # Starting angle\n",
    "                  theta2=135+alpha,  # Ending angle\n",
    "                  color='black',\n",
    "                  linewidth=1)\n",
    "ax.add_patch(arc)\n",
    "ax.set_aspect('equal')\n",
    "\n",
    "# Add a legend\n",
    "plt.legend()\n",
    "plt.savefig(\"./Drawing For Publications/LightPropagationin4D_left.png\")\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def rotation_matrix(theta):\n",
    "    c, s = np.cos(theta), np.sin(theta)\n",
    "    return np.array([[c, -s], [s, c]])\n",
    "\n",
    "def plotme(ax, theta, wavelength, label=\"\", periods=3):\n",
    "    # Convert theta from degrees to radians for np functions\n",
    "    theta_rad = np.radians(theta+90)\n",
    "    \n",
    "    # Create a rotation matrix for the given angle\n",
    "    rot_matrix = rotation_matrix(theta_rad)\n",
    "\n",
    "    # Define the range and calculate the sinusoidal values\n",
    "    x = np.linspace(0, periods * wavelength, 1000)\n",
    "    y = np.sin(2 * np.pi * x / wavelength)\n",
    "\n",
    "    # Find the crossing points on the x-axis (where y = 0)\n",
    "    crossing_points = [(n * wavelength, 0) for n in range(periods + 1)]\n",
    "\n",
    "    # Rotate the crossing points\n",
    "    rotated_crossing_points = [np.dot(rot_matrix, point) for point in crossing_points]\n",
    "\n",
    "    # Rotate the sinusoidal curve\n",
    "    xy_original = np.vstack((x, y))\n",
    "    xy_rotated = np.dot(rot_matrix, xy_original)\n",
    "\n",
    "    # Plot the rotated sinusoidal curve\n",
    "    ax.plot(xy_rotated[0], xy_rotated[1], label=label)\n",
    "    \n",
    "    # Plot the crossing points\n",
    "    for point in rotated_crossing_points:\n",
    "        ax.plot(point[0], point[1], 'ro')  # 'ro' is the marker style for red circles\n",
    "\n",
    "    # Draw the segment along the same angle as the sinusoid\n",
    "    segment_end = rotated_crossing_points[-1]\n",
    "    ax.plot([0, segment_end[0]], [0, segment_end[1]], 'k-')  # 'k-' is the style for a black line\n",
    "\n",
    "    # Return the rotated crossing points\n",
    "    return rotated_crossing_points\n",
    "\n",
    "def draw_lines(rotated_crossing_points_1, rotated_crossing_points_2, ax,  linestyle=\"--\"):\n",
    "    # Draw lines between vertical and inclined sinusoid crossing points\n",
    "    for p1, p2 in zip(rotated_crossing_points_1, rotated_crossing_points_2):\n",
    "        ax.plot([p1[0], p2[0]], [p1[1], p2[1]], 'orange', linestyle='--')  # Draw line with orange color\n",
    "\n",
    "def createPlot(alpha, fig, ax):\n",
    "    # Example usage:\n",
    "    theta = 45 -alpha\n",
    "    lambda_r = 2 * np.pi\n",
    "    lambda_light = lambda_r / np.cos(np.radians(theta))\n",
    "    lambda_light_x = lambda_light/np.sin(np.radians(theta))\n",
    "    \n",
    "    label=f'Transition Dipole Oscillation'\n",
    "    rotated_crossing_points_vertical = plotme(ax, 0, lambda_r, label=label)  # Plot a sinusoid with a wavelength of 2pi\n",
    "    \n",
    "    label=f'Light Propagation in 4D'\n",
    "    rotated_crossing_points_inclined = plotme(ax, theta, lambda_light, label=label)  # Plot a sinusoid at a 45-degree angle with adjusted wavelength\n",
    "    draw_lines(rotated_crossing_points_vertical, rotated_crossing_points_inclined, ax, linestyle=\"--\")\n",
    "    \n",
    "    label=f'Light Propagation as seen in 3D'\n",
    "    rotated_crossing_points_horizontal = plotme(ax, 90, lambda_light_x, label=label)  # Plot a sinusoid at a 45-degree angle with adjusted wavelength\n",
    "    draw_lines(rotated_crossing_points_horizontal, rotated_crossing_points_inclined, ax, linestyle=\".\")\n",
    "    \n",
    "    # Set plot labels and title\n",
    "    ax.set_xlabel('3D-Distance')\n",
    "    ax.set_ylabel('Radial Direction Distance')\n",
    "    ax.set_title(f'Light Propagation in 4D at {theta} degrees')\n",
    "    ax.legend(loc='upper left', bbox_to_anchor=(1, 1))\n",
    "    ax.grid(True)\n",
    "     # Set aspect of the plot to be equal\n",
    "    ax.set_aspect('equal')\n",
    "    ax.set_xlim([-50,1])\n",
    "    ax.set_ylim([-1,20])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "for alpha in np.arange(20, -1,-1):  # Corrected to decrement from 30 to 5\n",
    "    theta = 45 - alpha \n",
    "    fig, ax = plt.subplots()\n",
    "    createPlot(alpha, fig, ax)\n",
    "    plt.savefig(f\"./ChangingRedshift/LightPropagationin4D_{theta}degrees.png\", bbox_inches='tight')\n",
    "    plt.close(fig)  # Close the figure after saving to free memory\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:Cosmos3020]",
   "language": "python",
   "name": "conda-env-Cosmos3020-py"
  },
  "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}