excercise1B2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Excercise 1B2\n",
    "\n",
    "Import modules, ```numpy```, set constants."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "source": [
    "from typing import Tuple\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "LIGHT_SPEED = 299792.458"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Step 1\n",
    "\n",
    "Complete first step of solution. \n",
    "\n",
    "Needs ```locations``` of the satellites. \n",
    "$$\n",
    "\\begin{bmatrix} \n",
    "a_1 & b_1 & c_1 \\\\\n",
    "a_2 & b_2 & c_2 \\\\\n",
    "a_3 & b_3 & c_3 \\\\\n",
    "a_4 & b_4 & c_4 \\\\\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "And needs the ```transmission_times``` in a ```numpy``` array.\n",
    "$\\begin{bmatrix} t_1 \\\\ t_2 \\\\ t_3 \\\\ t_4 \\end{bmatrix}$"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "source": [
    "def step_1(\n",
    "    locations: np.ndarray,\n",
    "    transmission_times: np.ndarray\n",
    ") -> Tuple[\n",
    "    np.ndarray,\n",
    "    np.ndarray,\n",
    "    np.ndarray,\n",
    "    np.ndarray,\n",
    "    np.ndarray,\n",
    "]:\n",
    "    vector_1: np.ndarray = (2 * (locations[1:, 0] - locations[0, 0])).reshape((3, 1))\n",
    "    vector_2: np.ndarray = (2 * (locations[1:, 1] - locations[0, 1])).reshape((3, 1))\n",
    "    vector_3: np.ndarray = (2 * (locations[1:, 2] - locations[0, 2])).reshape((3, 1))\n",
    "    vector_4: np.ndarray = (2 * LIGHT_SPEED**2 * (transmission_times[0] - transmission_times[1:])).reshape((3, 1))\n",
    "    vector_5: np.ndarray = (\n",
    "        locations[0, 0] ** 2 - locations[1:, 0] ** 2 + \n",
    "        locations[0, 1] ** 2 - locations[1:, 1] ** 2 +\n",
    "        locations[0, 2] ** 2 - locations[1:, 2] ** 2 + \n",
    "        LIGHT_SPEED ** 2 * (transmission_times[1:] ** 2 - transmission_times[0] ** 2)\n",
    "    ).reshape((3, 1))\n",
    "    \n",
    "    return (vector_1, vector_2, vector_3, vector_4, vector_5)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Step 2\n",
    "\n",
    "Calculates the second step. Needs vectors calculated in the first step. Names are not entirely correct anymore, but changing it takes too much time."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "source": [
    "def step_2(\n",
    "    vector_2: np.ndarray, \n",
    "    vector_3: np.ndarray, \n",
    "    vector_4: np.ndarray, \n",
    "    vector_5: np.ndarray,\n",
    "    vector_given: np.ndarray\n",
    ") -> Tuple[float, float]:\n",
    "    alpha = (-1 * \n",
    "        np.linalg.det(np.concatenate((vector_2, vector_3, vector_5), axis = 1)) / \n",
    "        np.linalg.det(np.concatenate((vector_2, vector_3, vector_given), axis = 1))\n",
    "    )\n",
    "\n",
    "    beta = (-1 * \n",
    "        np.linalg.det(np.concatenate((vector_2, vector_3, vector_4), axis = 1)) / \n",
    "        np.linalg.det(np.concatenate((vector_2, vector_3, vector_given), axis = 1))\n",
    "    )\n",
    "    return (alpha, beta)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Step 3\n",
    "\n",
    "Calculates the third step of the calculation. Needs the $\\alpha_x, \\; \\beta_x, \\; \\alpha_y, \\; \\beta_y, \\; \\alpha_z, \\; \\beta_z.$\n",
    "\n",
    "Also needs the position $(a_i, b_i, z_i)$ of a satellite, and the transmission time $t_i$."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "source": [
    "def step_3(\n",
    "    alpha_x: float,\n",
    "    beta_x: float,\n",
    "    alpha_y: float,\n",
    "    beta_y: float, \n",
    "    alpha_z: float, \n",
    "    beta_z: float,\n",
    "    position_1_x: float, \n",
    "    position_1_y: float, \n",
    "    position_1_z: float,\n",
    "    transmission_time_1: float,\n",
    "):\n",
    "    q_0 = (\n",
    "        position_1_x ** 2 +\n",
    "        position_1_y ** 2 +\n",
    "        position_1_z ** 2 -\n",
    "        (LIGHT_SPEED ** 2) * (transmission_time_1 ** 2) +\n",
    "        (alpha_x ** 2) +\n",
    "        (alpha_y ** 2) +\n",
    "        (alpha_z ** 2)\n",
    "        -2 * (\n",
    "            position_1_x * alpha_x +\n",
    "            position_1_y * alpha_y +\n",
    "            position_1_z * alpha_z\n",
    "        ))\n",
    "\n",
    "    q_1 = (\n",
    "        -2 * (\n",
    "            position_1_x * beta_x +\n",
    "            position_1_y * beta_y +\n",
    "            position_1_z * beta_z -\n",
    "            (LIGHT_SPEED ** 2) * transmission_time_1\n",
    "        ) \n",
    "        + 2 * (\n",
    "            alpha_x * beta_x +\n",
    "            alpha_y * beta_y +\n",
    "            alpha_z * beta_z\n",
    "        ))\n",
    "\n",
    "    q_2 = (\n",
    "        (beta_x ** 2) +\n",
    "        (beta_y ** 2) +\n",
    "        (beta_z ** 2) -\n",
    "        (LIGHT_SPEED ** 2)\n",
    "    )\n",
    "\n",
    "    return (q_0, q_1, q_2)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ABC-formula\n",
    "\n",
    "The best formula that exists in mathematics, if you do not know how to solve quadratic equations using the \"kwadraat afsplitsen\" method."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "source": [
    "def abc_formula(\n",
    "    a: float,\n",
    "    b: float,\n",
    "    c: float,\n",
    "):\n",
    "    determinant: float  = np.sqrt((b ** 2) - 4 * a * c) #type:ignore\n",
    "    value_1 = ((-1 * b - determinant) / (2 * a))\n",
    "    value_2 = ((-1 * b + determinant) / (2 * a))\n",
    "    return (value_1, value_2)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Calculate location\n",
    "\n",
    "Calculates the location, using the variables given."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "source": [
    "def calculate_location(\n",
    "    locations: np.ndarray,\n",
    "    transmission_times: np.ndarray\n",
    "):\n",
    "    vector_1, vector_2, vector_3, vector_4, vector_5 = step_1(locations, transmission_times)\n",
    "    \n",
    "    alpha_x, beta_x = step_2(vector_2, vector_3, vector_4, vector_5, vector_1)\n",
    "    alpha_y, beta_y = step_2(vector_1, vector_3, vector_4, vector_5, vector_2)\n",
    "    alpha_z, beta_z = step_2(vector_1, vector_2, vector_4, vector_5, vector_3)\n",
    "\n",
    "    position_1_x = locations[0, 0]\n",
    "    position_1_y = locations[0, 1]\n",
    "    position_1_z = locations[0, 2]\n",
    "    transmission_time_1 = transmission_times[0]\n",
    "    \n",
    "    q_0, q_1, q_2 = step_3(alpha_x, beta_x, alpha_y, beta_y, alpha_z, beta_z, position_1_x, position_1_y, position_1_z, transmission_time_1)\n",
    "    time_difference_1, time_difference_2 = abc_formula(q_2, q_1, q_0)\n",
    "\n",
    "    location_x_1 = alpha_x + beta_x * time_difference_1\n",
    "    location_y_1 = alpha_y + beta_y * time_difference_1\n",
    "    location_z_1 = alpha_z + beta_z * time_difference_1\n",
    "\n",
    "    location_x_2 = alpha_x + beta_x * time_difference_2\n",
    "    location_y_2 = alpha_y + beta_y * time_difference_2\n",
    "    location_z_2 = alpha_z + beta_z * time_difference_2\n",
    "\n",
    "    print(f\"{location_x_1=}, {location_y_1=}, {location_z_1=}\")\n",
    "    print(f\"{location_x_2=}, {location_y_2=}, {location_z_2=}\")\n",
    "\n",
    "    return (\n",
    "        (location_x_1, location_y_1, location_z_1), \n",
    "        (location_x_2, location_y_2, location_z_2)\n",
    "    )"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Main\n",
    "\n",
    "The main program."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "source": [
    "def main():\n",
    "    locations = np.array([\n",
    "        [15600, 7540, 20140], \n",
    "        [18760, 2750, 18610], \n",
    "        [17610, 14630, 13480], \n",
    "        [19170, 610, 18390]\n",
    "    ])\n",
    "\n",
    "    transmission_times = np.array([\n",
    "        0.07074,\n",
    "        0.07220,\n",
    "        0.07690,\n",
    "        0.07242\n",
    "    ])\n",
    "\n",
    "    calculate_location(locations, transmission_times)\n",
    "\n",
    "main()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "location_x_1=-39.74783734818158, location_y_1=-134.27414436066428, location_z_1=-9413.624553735734\n",
      "location_x_2=-41.77270957081522, location_y_2=-16.78919410652558, location_z_2=6370.059559223332\n"
     ]
    }
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "orig_nbformat": 4,
  "language_info": {
   "name": "python",
   "version": "3.8.3",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.3 64-bit ('base': conda)"
  },
  "interpreter": {
   "hash": "250e59cf0b7b5cec3664e2265f2ec6cf89f1074736b01d93c1f9583811222aad"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}