generate_field.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "In this notebook, we simulate the field created by the TRIF electromagnet and save it as a data set. This data set is going to be used to test our calibration approach.\n",
    "\n",
    "The electromagnet has three poles, that we model as three magnetic dipoles oriented in the same direction (physically, each pole is a coil wrapped around a ferromagnetic core). The dipoles are located in the same plain at the same distance from the axis of symmetry, and their position vectors are at $120^0$ with respect to each other.\n",
    "\n",
    "Here we create a set of various dipole magnitudes and calculate the corresponding magnetic field.\n",
    "\n",
    "In the experiment each dipole magnitude corresponds to a voltage applied to the corresponding coil inside the magnet. In case of linear relationship between the voltage and magnetic field vector, it is enough to collect and combine the field-vs-voltage characteristic from each individual coil. We'll save this data set separately as linear_calibration_set.csv.\n",
    "\n",
    "In the non-linear case, in order to properly train an artificial neural network, we'll additionally need data with all coils receiving voltage simultaneously.\n",
    "\n",
    "Since a constant ambient field can be easily dealt with by subtracting its value from the data set, we do not consider it here.\n",
    "\n",
    "***"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f8078939",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fee8fb9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functions for the field calculations\n",
    "\n",
    "def mag(x):\n",
    "    \"\"\"Calculates magnitude of vector x\"\"\"\n",
    "    return np.sqrt(np.dot(x,x))\n",
    "\n",
    "def dipole_field(r, r0, m, a):\n",
    "    \"\"\"\n",
    "    Calculates magnetic field of a single dipole\n",
    "    r - location of the field\n",
    "    r0 - position of the dipole\n",
    "    m - magnitude of the dipole. Negative values correspond to the opposite orientation of  the dipole axis\n",
    "    a - dipole axis\"\"\"\n",
    "    M = m*a   # Magnetic moment vector\n",
    "    R = r-r0\n",
    "    if np.dot(R,R) == 0: #This one is to avoid singularities\n",
    "        return np.array([0, 0, 0])\n",
    "    return mu0*(3*R*(np.dot(M,R))/(mag(R)**5) - M/(mag(R)**3))\n",
    "\n",
    "def total_field(r, m_array: np.array, dipole_axis: np.array) -> np.array:\n",
    "    \"\"\"Calculates the total field at point r\n",
    "    To simplify the data set generation later, the magnitudes of the three dipoles are placed in array m.\n",
    "    B0 is the external field.\n",
    "    dipole_axis is the dipole orientation (same for all three)\"\"\"\n",
    "    B1 = dipole_field(r, R1, m_array[0], dipole_axis)\n",
    "    B2 = dipole_field(r, R2, m_array[1], dipole_axis)\n",
    "    B3 = dipole_field(r, R3, m_array[2], dipole_axis)\n",
    "    return B1+B2+B3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "854a922a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constants and the setup parameters\n",
    "\n",
    "mu0 = 10**-7# magnetic constant\n",
    "m = 1e8 # Scaling factor magnetic dipole magnitude\n",
    "\n",
    "# Magnetic dipole position vectors\n",
    "R1 = np.array([1, 0, 1])\n",
    "R2 = np.array([-np.cos(np.pi/3), np.sin(np.pi/3), 1])\n",
    "R3 = np.array([-np.cos(np.pi/3), -np.sin(np.pi/3), 1])\n",
    "\n",
    "# Magnetic dipole orientation (same for all three)\n",
    "A = np.array([0, 0, 1]) # It is a global variable\n",
    "\n",
    "# The magnetometer location. Magnetic field is calculated here\n",
    "r0 = np.array([0., 0., 0.])\n",
    "\n",
    "# Voltage range\n",
    "v_range = 10\n",
    "\n",
    "# Non-linearity factor\n",
    "nf = 15"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "***"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Linear case"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fcf460ae",
   "metadata": {
    "pycharm": {
     "name": "#%% training sets for individual dipoles\n"
    }
   },
   "outputs": [],
   "source": [
    "# Apply voltage to a single coil in a linear fashion\n",
    "\n",
    "N1 = 128 # Number of training samples for each dipole\n",
    "\n",
    "V1 = np.concatenate((np.linspace(-v_range, v_range, N1), np.zeros(N1), np.zeros(N1)))\n",
    "V2 = np.concatenate((np.zeros(N1), np.linspace(-v_range, v_range, N1), np.zeros(N1)))\n",
    "V3 = np.concatenate((np.zeros(N1), np.zeros(N1), np.linspace(-v_range, v_range, N1)))\n",
    "\n",
    "V_ind = np.stack((V1, V2, V3), axis=1) # Stack vertically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "# Calculate magnetic field\n",
    "\n",
    "B_ind = []\n",
    "for V in V_ind:\n",
    "    B_ind.append(total_field(r0, V * m, A))\n",
    "\n",
    "individual_calibration_set = pd.DataFrame(np.concatenate((B_ind, V_ind), axis = 1), columns = [\"B_x\", \"B_y\", \"B_z\", \"V_1\", \"V_2\", \"V_3\"]) # Combine fields and voltages into a single dataset"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "data": {
      "text/plain": "         B_x  B_y        B_z        V_1  V_2  V_3\n0 -53.033009  0.0 -17.677670 -10.000000  0.0  0.0\n1 -52.197843  0.0 -17.399281  -9.842520  0.0  0.0\n2 -51.362678  0.0 -17.120893  -9.685039  0.0  0.0\n3 -50.527512  0.0 -16.842504  -9.527559  0.0  0.0\n4 -49.692347  0.0 -16.564116  -9.370079  0.0  0.0",
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>B_x</th>\n      <th>B_y</th>\n      <th>B_z</th>\n      <th>V_1</th>\n      <th>V_2</th>\n      <th>V_3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-53.033009</td>\n      <td>0.0</td>\n      <td>-17.677670</td>\n      <td>-10.000000</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-52.197843</td>\n      <td>0.0</td>\n      <td>-17.399281</td>\n      <td>-9.842520</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-51.362678</td>\n      <td>0.0</td>\n      <td>-17.120893</td>\n      <td>-9.685039</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-50.527512</td>\n      <td>0.0</td>\n      <td>-16.842504</td>\n      <td>-9.527559</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-49.692347</td>\n      <td>0.0</td>\n      <td>-16.564116</td>\n      <td>-9.370079</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "individual_calibration_set.head()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "# Save\n",
    "individual_calibration_set.to_csv('data/individual_calibration_set.csv')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "***"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Non-linear case\n",
    "As the non-linearity, we apply a hyperbolic tangent to the voltage before calculating the field. Since in this case we'll need to use deep learning, we generate two sets: one for training and one for validation."
   ],
   "metadata": {
    "collapsed": false
   },
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "\n",
    "## Training set"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "For visualization purposes, to compare to the linear case, we create a separate set with only one magnetic pole activated at a time, by applying the non-linearity to the voltage from linear set."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "B_nl_ind = []\n",
    "for V in V_ind:\n",
    "    B_nl_ind.append(total_field(r0, v_range*np.tanh(V/nf) * m, A))\n",
    "\n",
    "nl_individual_calibration_set = pd.DataFrame(np.concatenate((B_nl_ind, V_ind), axis = 1), columns = [\"B_x\", \"B_y\", \"B_z\", \"V_1\", \"V_2\", \"V_3\"]) # Combine fields and voltages into a single dataset"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "# Save\n",
    "nl_individual_calibration_set.to_csv('data/nl_individual_calibration_set.csv')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         B_x  B_y        B_z        V_1  V_2  V_3\n",
      "0 -30.906733  0.0 -10.302244 -10.000000  0.0  0.0\n",
      "1 -30.536808  0.0 -10.178936  -9.842520  0.0  0.0\n",
      "2 -30.162383  0.0 -10.054128  -9.685039  0.0  0.0\n",
      "3 -29.783460  0.0  -9.927820  -9.527559  0.0  0.0\n",
      "4 -29.400042  0.0  -9.800014  -9.370079  0.0  0.0\n",
      "            B_x        B_y        B_z       V_1       V_2       V_3\n",
      "1403 -41.204335 -20.135963   0.305817 -8.485704  0.683564  7.922229\n",
      "1404  36.969830  11.738892   0.357241  7.679499 -1.472263 -5.540380\n",
      "1405  20.741209  -8.978066  -5.603215  2.345093 -5.205851 -2.087591\n",
      "1406  22.545590 -35.990299  13.720525  9.107563 -4.230792  8.417075\n",
      "1407  20.499477  14.172104  -1.289368  3.566450  0.016897 -4.765838\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Apply random voltages to all three coils\n",
    "N2 = 1024 # Total number of values\n",
    "V_rand = np.random.uniform(-v_range, v_range, (N2, 3)) # Random voltages between -10 and 10\n",
    "\n",
    "# Calculate magnetic field\n",
    "\n",
    "B_rand = []\n",
    "for V in V_rand:\n",
    "    B_rand.append(total_field(r0, v_range*np.tanh(V/nf) * m, A))\n",
    "\n",
    "# stack with the individual voltage set\n",
    "V_full = np.concatenate((V_ind, V_rand))\n",
    "B_full = np.concatenate((B_nl_ind, B_rand))\n",
    "\n",
    "full_calibration_set = pd.DataFrame(np.concatenate((B_full, V_full), axis = 1), columns = [\"B_x\", \"B_y\", \"B_z\", \"V_1\", \"V_2\", \"V_3\"]) # Combine fields and voltages into a single dataset\n",
    "print(full_calibration_set.head())\n",
    "print(full_calibration_set.tail())"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [
    "# Save\n",
    "full_calibration_set.to_csv('data/full_calibration_set.csv')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Validation set for deep learning\n",
    "\n",
    "We'll use this set to monitor the neural network performance during training in the non-linear case."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [],
   "source": [
    "N_val = 256"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%testing set \n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [
    "\n",
    "V_val = np.random.uniform(-v_range, v_range, (N_val, 3)) # Random voltages between -10 and 10\n",
    "B_val = []\n",
    "\n",
    "for V in V_val:\n",
    "    B_val.append(total_field(r0, v_range*np.tanh(V/nf) * m, A))\n",
    "\n",
    "val_set = pd.DataFrame(np.concatenate((B_val, V_val), axis = 1), columns = [\"B_x\", \"B_y\", \"B_z\", \"V_1\", \"V_2\", \"V_3\"])"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "data": {
      "text/plain": "         B_x        B_y        B_z       V_1       V_2       V_3\n0   4.500840 -18.290073 -12.168477 -2.619383 -7.399992 -0.880361\n1   9.479666 -15.559839   4.852217  3.207946 -2.075391  3.061383\n2  10.978775  25.562388  14.883915  6.691094  8.039640 -1.001086\n3  22.570786 -16.243607  13.430083  8.998378 -0.983369  4.449224\n4  12.518581  24.769166  13.476236  6.560851  7.178195 -1.417601",
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>B_x</th>\n      <th>B_y</th>\n      <th>B_z</th>\n      <th>V_1</th>\n      <th>V_2</th>\n      <th>V_3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>4.500840</td>\n      <td>-18.290073</td>\n      <td>-12.168477</td>\n      <td>-2.619383</td>\n      <td>-7.399992</td>\n      <td>-0.880361</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>9.479666</td>\n      <td>-15.559839</td>\n      <td>4.852217</td>\n      <td>3.207946</td>\n      <td>-2.075391</td>\n      <td>3.061383</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>10.978775</td>\n      <td>25.562388</td>\n      <td>14.883915</td>\n      <td>6.691094</td>\n      <td>8.039640</td>\n      <td>-1.001086</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>22.570786</td>\n      <td>-16.243607</td>\n      <td>13.430083</td>\n      <td>8.998378</td>\n      <td>-0.983369</td>\n      <td>4.449224</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>12.518581</td>\n      <td>24.769166</td>\n      <td>13.476236</td>\n      <td>6.560851</td>\n      <td>7.178195</td>\n      <td>-1.417601</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val_set.head()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [],
   "source": [
    "# Save\n",
    "val_set.to_csv('data/validation_set.csv')"
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}