MasterclassCode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7c961553",
   "metadata": {},
   "source": [
    "Start by importing all libraries needed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ec0465d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Holly Chandler\n",
    "# Masterclass Research Project\n",
    "# Code to support maths required in the X-Z laplacian for various functions\n",
    "\n",
    "#import all neccesary libraries and allow use of unicode symbols\n",
    "import sympy\n",
    "from sympy import symbols, expand, factor, latex\n",
    "from sympy import *\n",
    "init_printing(use_unicode=True)\n",
    "#import library allowing ext and latex to be on the same line:\n",
    "from IPython.display import display, Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "4a65abcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#set it so you can have pretty outputs for multiple different functions in one cell\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = 'all'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbf1e6f4",
   "metadata": {},
   "source": [
    "Inistialise symbols and create lists containing all required values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "40a30320",
   "metadata": {},
   "outputs": [],
   "source": [
    "#initialise all the symbols used for each coordinate system\n",
    "alpha, gamma, beta, x, y, z, r, theta, phi, R, A, B, D, h, I, Bpol  = symbols('alpha gamma beta x y z r theta phi R A B D h_theta I B_pol')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "42e22351",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#order for all lists of components follows:\n",
    "\n",
    "#0 cartesian (xyz), \n",
    "#1 cyllindrical (r,theta,z), \n",
    "#2 spherical (r,theta,phi), \n",
    "#3 toroidal (r,theta,phi), \n",
    "#4 Clebsch Field Alligned Coordinates (x,y,z)\n",
    "\n",
    "#initialsise coordinate system order:\n",
    "C = [\"cartesian (xyz)\",\"cyllindrical (r,theta,z)\",\"spherical (r,theta,phi)\",\"toroidal (r,theta,phi)\",\"Clebsch Field Alligned Coordinates (x,y,z)\" ]\n",
    "\n",
    "#Initialise all the known Jacobians\n",
    "J = [1, r, r**(2)*sin(theta),-r*(R+r*cos(theta)),h/Bpol]\n",
    "\n",
    "#initialise the main diagonal metric tensors in order g11,g22,g33 where 1,2,3 refer to the coordinate system variables in order as below\n",
    "g = [[1,1,1],[1,1/(r**2),1],[1,1/(r**2),1],[1,1/(r**2),1/(R+r*cos(theta))**2],[(R*Bpol)**2, 1/(h)**2,B**2/(R*Bpol)**2]]\n",
    "\n",
    "#all the coordinate system variables.\n",
    "coords = [[x,y,z],[r,theta,z],[r,theta,phi],[r,theta,phi],[x,y,z]]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1a4c13d",
   "metadata": {},
   "source": [
    "Functions that calculates b depending on constants, function, metric tensors and jacobian.\n",
    "Different options suggested to be correct so both made available.\\\n",
    "gxz is 0 for Clebsch coordinates when I = 0 so 1st function is used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "b59e1ded",
   "metadata": {},
   "outputs": [],
   "source": [
    "#create a function to independently calculate b\n",
    "def calculate_b_1(A,D,f,J,gxx,gzz,z_coord,x_coord):\n",
    "    b = A/J*(diff(J*gxx*diff(f, x_coord),x_coord)+(diff(J*gzz*diff(f, z_coord),z_coord)))+D*f\n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "20cacd98",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_b_2(A,D,f,J,gxx,gzz,z_coord,x_coord,gxz):\n",
    "     \n",
    "    b = A/J*(diff(J*gxx*diff(f, x_coord),x_coord)+(diff(J*gzz*diff(f, z_coord),z_coord))+diff(J*gxz*diff(f,z),x)+diff(J*gxz*diff(f,z),z))+D*f"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98bfb738",
   "metadata": {},
   "source": [
    "Function that converts ** powers to pow powers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "ad57749b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pow( 23,2)+pow((236-(x+y)),(4+x))+x*pow(cos(x),(2+5*(x+2)+6(x-2))) \n"
     ]
    }
   ],
   "source": [
    "def convertPowers(function):\n",
    "    #first replace all the ** with commas as this is what splits the item to the power\n",
    "    function = function.replace(\"**\",\",\")\n",
    "    \n",
    "    #add space to start and end in case of digit being a power-involved digit\n",
    "    function = \" \" + function + \" \"\n",
    "\n",
    "    #count the number of powers in the string to loop through them\n",
    "    numberOfPowers = function.count(\",\")\n",
    "\n",
    "    #inistialse the start of the search to be the beginning of the string\n",
    "    whereToSearch = 0\n",
    "    \n",
    "    #loop through each power situation\n",
    "    for item in range (0,numberOfPowers):\n",
    "        \n",
    "        #find the next instance of a comma (demonstrating a power)\n",
    "        powerIndex = function.find(',',whereToSearch)\n",
    "\n",
    "        #change where to start the search start point to just after the location of the comma just found\n",
    "        # ensure different instances are checked each time\n",
    "        # +5 as +1 to search after the current comma and +4 to account for the extra indexs' from inserting pow( before comma \n",
    "        whereToSearch = powerIndex + 5\n",
    "\n",
    "        #first start checking where the bracket should go after/before the comma i.e. where the power ends.\n",
    "        numberIndexEnd = powerIndex + 1\n",
    "        \n",
    "        #START WITH EXPONENT\n",
    "        #start by checking if the exponent is a function i.e. in brackets.\n",
    "        if function[numberIndexEnd]==\"(\":\n",
    "            #now increase the index so we are looking at brackets past the first open one\n",
    "            #if there are brackets within the exponent bracket then these need to be considered- numberClosed counts them\n",
    "            finished = False\n",
    "            numberIndexEnd +=1\n",
    "            numberClosed = 0\n",
    "            #while loop to find end of function\n",
    "            while not finished:\n",
    "                #look for the next closed and open bracket after the initial open one\n",
    "                closedBracketIndexBack = function.find(\")\",numberIndexEnd)\n",
    "                openBracketIndexBack = function.find(\"(\",numberIndexEnd)\n",
    "                \n",
    "                if (openBracketIndexBack > closedBracketIndexBack)or(openBracketIndexBack == -1):\n",
    "                    #then the open bracket is after the closed for the exponent\n",
    "                    #then there are no open brackets after the last point\n",
    "                    \n",
    "                    #now check if there are any seconary opened brackets \n",
    "                    #if numberClosed == 0 then there arent any to be considered- end loop\n",
    "                    if numberClosed == 0:\n",
    "                        function = str(function[ :closedBracketIndexBack]+\")\"+function[closedBracketIndexBack: ])\n",
    "                        finished = True\n",
    "                    #if there are opened brackets then we close one off numberClosed -1\n",
    "                    #we change where we look for the next closed bracket to be one past the current closed bracket\n",
    "                    else:\n",
    "                        numberClosed = numberClosed -1\n",
    "                        numberIndexEnd = closedBracketIndexBack +1\n",
    "                #otherwise there is an open bracket before the closed for the exponent\n",
    "                #we consider this by looking for closed brackets after and noting we need more than one closed bracket now\n",
    "                else:\n",
    "                    numberClosed +=1\n",
    "                    numberIndexEnd = openBracketIndexBack+1\n",
    "            \n",
    "        #or if there is no bracket    \n",
    "        else:\n",
    "            #if it is not bracketed then it is just a number so we check each charater until we don't reach a digit.\n",
    "            #when we reach a non-digit we know its the end of the exponent and add the bracket\n",
    "            end = False\n",
    "            while not end:\n",
    "                if function[numberIndexEnd].isdigit():\n",
    "                    numberIndexEnd +=1\n",
    "                else:\n",
    "                    function = str(function[ :numberIndexEnd]+\")\"+function[numberIndexEnd: ])\n",
    "                    end = True \n",
    "        \n",
    "        #NOW DO BASE of power:\n",
    "        \n",
    "        numberIndexStart =  powerIndex - 1\n",
    "        #if the base is bracketed then we search for the open bracket and insert pow( there\n",
    "        \n",
    "        if function[numberIndexStart]==\")\":\n",
    "            found = False\n",
    "            index = 1\n",
    "            numberClosed = 0\n",
    "            #while loop that looks at each character indiviually and continues till brackets are closed\n",
    "            while not found:\n",
    "                #identify the next character\n",
    "                nextIndex = numberIndexStart-index\n",
    "                nextCharacter = function[nextIndex]\n",
    "                \n",
    "                #if there are no more brackets to closed and we found the final closed bracket- insert pow(\n",
    "                if (nextCharacter == \"(\") and (numberClosed ==0):\n",
    "                    \n",
    "                    #if there is a sin or cos etc in front of the brackets we want to put the pow before this\n",
    "                    #awkwardSymbold[] is where you can input such symbols\n",
    "                    awkwardSymbols = [\"cos\",\"sin\",\"tan\",\"cosh\", \"sinh\", \"tanh\", \"log\", \"cot\"]\n",
    "                    #as they can be 3 or 4 length units we have both options\n",
    "                    find3Letter = function[nextIndex-3:nextIndex]\n",
    "                    find4Letter = function[nextIndex-4:nextIndex]\n",
    "                    #check if it meets each item in the list\n",
    "                    #if it does we change the nextIndex to that position so that pow is inserted there\n",
    "                    for item in awkwardSymbols:\n",
    "                        if (str(item) == str(find3Letter)):\n",
    "                            nextIndex = nextIndex -3\n",
    "                        if item ==find4Letter:\n",
    "                            nextIndex = nextIndex -4\n",
    "                    found = True\n",
    "                    function = str(function[ :nextIndex]+\"pow(\"+function[nextIndex: ])\n",
    "                #otherwise add one to index - look at next character before this one\n",
    "                else:\n",
    "                    index +=1\n",
    "                    #if the current character was a close brackets- we need to find another open in order to insert pow(\n",
    "                    #add one to numberClosed\n",
    "                    if nextCharacter == \")\":\n",
    "                        numberClosed +=1\n",
    "                    #otherwise if it was a closed bracket and numberClosed !=1 then we remove one from number closed\n",
    "                    #i.e we are closer to closing the surrounding bracket of the base\n",
    "                    if nextCharacter ==\"(\":\n",
    "                        numberClosed -=1\n",
    "                        \n",
    "                        \n",
    "        #if it is a number base we loop until we find a non number. Insert pow there.    \n",
    "        else:\n",
    "            end = False\n",
    "            while not end:\n",
    "                if function[numberIndexStart].isdigit():\n",
    "                    numberIndexStart =numberIndexStart -1\n",
    "                else:\n",
    "                    function = str(function[ :numberIndexStart]+\"pow(\"+function[numberIndexStart: ])\n",
    "                    end = True  \n",
    "    print(function)\n",
    "                \n",
    "convertPowers(\"23**2+(236-(x+y))**(4+x)+x*cos(x)**(2+5*(x+2)+6(x-2))\")\n",
    "#pow( 23,2)+pow((236-(x+y)),(4+x))+pow(x,(2+5(x+2)+6(x-2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e43ccfa4",
   "metadata": {},
   "source": [
    "Function that calculates the forward laplacian and outputs the results based on coordinate system and variables chosen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "5a496075",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coordinate system choice is spherical (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r^{2} \\sin{\\left(\\theta \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = y z \\sin{\\left(x y \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = B y z \\sin{\\left(x y \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*y*z*sin(x*y)\n",
      "\n",
      "c++ conversion\n",
      " B*y*z*sin(x*y) \n",
      "None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#function finds the symbols of the coordinate system and outputs the result of calculating the forward laplacian\n",
    "\n",
    "def calculateForwardLaplacian(f,coordSystemChoice,xCoordIndex,zCoordIndex):\n",
    "    #choose x coordinate unit based on coordinate system and which combination\n",
    "    x_coord = coords[coordSystemChoice][xCoordIndex]\n",
    "    z_coord = coords[coordSystemChoice][zCoordIndex]\n",
    "            \n",
    "    #assign x and z the units found above to ensure that the function inputted is changed to have those units\n",
    "    x= x_coord\n",
    "    z= z_coord         \n",
    "            \n",
    "    #calculate result of laplacian by calling calculae_b function\n",
    "    b = calculate_b_1(A,B,f,J[coordSystemChoice],g[coordSystemChoice][xCoordIndex],g[coordSystemChoice][zCoordIndex],z_coord,x_coord)\n",
    "            \n",
    "    #print out all the values used\n",
    "    print(\"Coordinate system choice is\", C[coordSystemChoice])\n",
    "    display(Math(f'Jacobian = {latex(J[coordSystemChoice])}'))\n",
    "    display(Math(f'X-Coordinate = {latex(x)}'))\n",
    "    display(Math(f'Z-Coordinate = {latex(z)}'))\n",
    "    display(Math(f'f = {latex(f)}'))\n",
    "    display(Math(f'b = {latex(b)}'))\n",
    "    print ()\n",
    "    print(\"sympy result\")\n",
    "    print(b)\n",
    "    print()\n",
    "    print(\"c++ conversion\")\n",
    "    print(convertPowers(str(b)))\n",
    "    print()\n",
    "\n",
    "calculateForwardLaplacian(sin(x*y)*y*z,2,1,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "581777b2",
   "metadata": {},
   "source": [
    "Loop that calculates the output of the forward laplacian in all coordinate systems except for Clebsch with all options of general xz for a given function f."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "8a5f98c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coordinate system choice is cartesian (xyz)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = 1$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = x$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = y$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = A \\left(- \\frac{x y \\sin{\\left(x \\right)}}{z} + \\frac{2 y \\cos{\\left(x \\right)}}{z}\\right) + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "A*(-x*y*sin(x)/z + 2*y*cos(x)/z) + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " A*(-x*y*sin(x)/z + 2*y*cos(x)/z) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cartesian (xyz)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = 1$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = x$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = A \\left(- \\frac{x y \\sin{\\left(x \\right)}}{z} + \\frac{2 x y \\sin{\\left(x \\right)}}{z^{3}} + \\frac{2 y \\cos{\\left(x \\right)}}{z}\\right) + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "A*(-x*y*sin(x)/z + 2*x*y*sin(x)/z**3 + 2*y*cos(x)/z) + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " A*(-x*y*sin(x)/z + 2*x*y*sin(x)/pow(z,3) + 2*y*cos(x)/z) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cartesian (xyz)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = 1$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = y$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{2 A x y \\sin{\\left(x \\right)}}{z^{3}} + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "2*A*x*y*sin(x)/z**3 + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " 2*A*x*y*sin(x)/pow(z,3) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cartesian (xyz)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = 1$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = y$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = x$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = A \\left(- \\frac{x y \\sin{\\left(x \\right)}}{z} + \\frac{2 y \\cos{\\left(x \\right)}}{z}\\right) + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "A*(-x*y*sin(x)/z + 2*y*cos(x)/z) + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " A*(-x*y*sin(x)/z + 2*y*cos(x)/z) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cartesian (xyz)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = 1$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = x$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = A \\left(- \\frac{x y \\sin{\\left(x \\right)}}{z} + \\frac{2 x y \\sin{\\left(x \\right)}}{z^{3}} + \\frac{2 y \\cos{\\left(x \\right)}}{z}\\right) + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "A*(-x*y*sin(x)/z + 2*x*y*sin(x)/z**3 + 2*y*cos(x)/z) + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " A*(-x*y*sin(x)/z + 2*x*y*sin(x)/pow(z,3) + 2*y*cos(x)/z) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cartesian (xyz)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = 1$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = y$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{2 A x y \\sin{\\left(x \\right)}}{z^{3}} + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "2*A*x*y*sin(x)/z**3 + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " 2*A*x*y*sin(x)/pow(z,3) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cyllindrical (r,theta,z)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cyllindrical (r,theta,z)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{2 A x y \\sin{\\left(x \\right)}}{z^{3}} + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "2*A*x*y*sin(x)/z**3 + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " 2*A*x*y*sin(x)/pow(z,3) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cyllindrical (r,theta,z)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{2 A x y \\sin{\\left(x \\right)}}{z^{3}} + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "2*A*x*y*sin(x)/z**3 + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " 2*A*x*y*sin(x)/pow(z,3) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cyllindrical (r,theta,z)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cyllindrical (r,theta,z)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{2 A x y \\sin{\\left(x \\right)}}{z^{3}} + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "2*A*x*y*sin(x)/z**3 + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " 2*A*x*y*sin(x)/pow(z,3) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is cyllindrical (r,theta,z)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{2 A x y \\sin{\\left(x \\right)}}{z^{3}} + \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "2*A*x*y*sin(x)/z**3 + B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " 2*A*x*y*sin(x)/pow(z,3) + B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is spherical (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r^{2} \\sin{\\left(\\theta \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is spherical (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r^{2} \\sin{\\left(\\theta \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\phi$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is spherical (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r^{2} \\sin{\\left(\\theta \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\phi$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is spherical (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r^{2} \\sin{\\left(\\theta \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is spherical (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r^{2} \\sin{\\left(\\theta \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\phi$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is spherical (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = r^{2} \\sin{\\left(\\theta \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\phi$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is toroidal (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = - r \\left(R + r \\cos{\\left(\\theta \\right)}\\right)$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is toroidal (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = - r \\left(R + r \\cos{\\left(\\theta \\right)}\\right)$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\phi$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is toroidal (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = - r \\left(R + r \\cos{\\left(\\theta \\right)}\\right)$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\phi$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is toroidal (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = - r \\left(R + r \\cos{\\left(\\theta \\right)}\\right)$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is toroidal (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = - r \\left(R + r \\cos{\\left(\\theta \\right)}\\right)$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\phi$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = r$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n",
      "Coordinate system choice is toroidal (r,theta,phi)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Jacobian = - r \\left(R + r \\cos{\\left(\\theta \\right)}\\right)$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = \\phi$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = \\theta$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = \\frac{x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = \\frac{B x y \\sin{\\left(x \\right)}}{z}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sympy result\n",
      "B*x*y*sin(x)/z\n",
      "\n",
      "c++ conversion\n",
      " B*x*y*sin(x)/z \n",
      "None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def loopAllCoordinatesAndSystems(f):\n",
    "    #for each coordinate system all combinations of units are used i.e 01, 12, 20.\n",
    "    #coordinate systems are shown as above\n",
    "    #to change the function that is being inputted into the laplacian, you change f which is seen within the for loops\n",
    "\n",
    "    #for loop to go through each coordinate system\n",
    "    for i in range(0,4):\n",
    "        #for loop for x to go through each basis vector\n",
    "        for j in range (0,3):\n",
    "            #for loop to ensure that each combination of basis vectors are seen i.e 01,12,21,02,10,20\n",
    "            for k in range(0,2):\n",
    "            \n",
    "                #set the coordinate system and coord choice through for loop\n",
    "                coordSystemChoice = i\n",
    "                coordChoiceX = j\n",
    "            \n",
    "                #% is modulus which is the remainder when (j+1) is divided by 3. Y goes 1,2,0.\n",
    "                coordChoiceZ = (j+k+1)%3\n",
    "            \n",
    "                #calculate result:\n",
    "                calculateForwardLaplacian(f,coordSystemChoice,coordChoiceX,coordChoiceZ)\n",
    "\n",
    "loopAllCoordinatesAndSystems(sin(x)*x*y*1/z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "547294b1",
   "metadata": {},
   "source": [
    "Function that calculates the Forward Laplacian for a Clebsch coordinate system where the coordinate dependent variables are considered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "0f97fbe7",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coordinate system choice is Clebsch\n",
      "Facts about the system\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle X-Coordinate = x$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Z-Coordinate = z$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Bpol = \\frac{1}{\\cos{\\left(x \\right)}}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Btor = \\frac{1.0}{\\cos{\\left(x \\right)} \\cos{\\left(y \\right)}}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Bxy = \\sqrt{\\frac{1}{\\cos^{2}{\\left(x \\right)}} + \\frac{1.0}{\\cos^{2}{\\left(x \\right)} \\cos^{2}{\\left(y \\right)}}}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle gxx = \\cos^{2}{\\left(y \\right)}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle gzz = I^{2} \\cos^{2}{\\left(y \\right)} + \\frac{\\frac{1}{\\cos^{2}{\\left(x \\right)}} + \\frac{1.0}{\\cos^{2}{\\left(x \\right)} \\cos^{2}{\\left(y \\right)}}}{\\cos^{2}{\\left(y \\right)}}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inputted function\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f = x^{2}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b = x^{2} + \\frac{- 4 x \\sin{\\left(x \\right)} \\cos{\\left(x \\right)} \\cos^{2}{\\left(y \\right)} + 2 \\cos^{2}{\\left(x \\right)} \\cos^{2}{\\left(y \\right)}}{\\cos^{2}{\\left(x \\right)}}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sympy result\n",
      "x**2 + (-4*x*sin(x)*cos(x)*cos(y)**2 + 2*cos(x)**2*cos(y)**2)/cos(x)**2\n",
      "\n",
      "c++ conversion\n",
      " pow(x,2) + (-4*x*sin(x)*cos(x)*pow(cos(y),2) + 2*pow(cos(x),2)*pow(cos(y),2))/pow(cos(x),2) \n",
      "None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def clebschCoordinatesForwardLaplacian(f):\n",
    "    #set the coordinate system and coord choice through for loop\n",
    "    coordSystemChoice = 4\n",
    "\n",
    "    #choose x and z coordinate to e x and z.\n",
    "    x_coord = coords[coordSystemChoice][0]\n",
    "    z_coord = coords[coordSystemChoice][2]\n",
    "            \n",
    "    #assign x and z the units found above to ensure that the function inputted is changed to have those units\n",
    "    x= x_coord\n",
    "    z= z_coord        \n",
    "        \n",
    "    #NEW STUFF\n",
    "    #write Jacobian, metric tensors and functions for B and R\n",
    "    #start with B functions as then, when the Jacobian and metric tensors are applied, the functions are subbed in.\n",
    "\n",
    "    eps = 1\n",
    "    r = cos(x)\n",
    "    theta = y\n",
    "    Rxy = r*cos(theta)\n",
    "    Bpol = 1/r\n",
    "    Btor = 1./Rxy\n",
    "    Bxy = sqrt(Bpol**2 + Btor**2)\n",
    "    h = r\n",
    "    JClebsch = h/Bpol\n",
    "    clebschMetricTensor = [(Rxy*Bpol)**2, 1/(h)**2,I**2*(Rxy*Bpol)**2+Bxy**2/(Rxy*Bpol)**2]\n",
    "\n",
    "    A = 1\n",
    "    D = 1\n",
    "        \n",
    "    #calculate result of laplacian by calling calculae_b function\n",
    "    b = calculate_b_1(A,D,f,JClebsch,clebschMetricTensor[0],clebschMetricTensor[2],z_coord,x_coord)\n",
    "            \n",
    "    #print out all the values used\n",
    "    print(\"Coordinate system choice is Clebsch\")\n",
    "    print(\"Facts about the system\")\n",
    "    display(Math(f'X-Coordinate = {latex(x)}'))\n",
    "    display(Math(f'Z-Coordinate = {latex(z)}'))\n",
    "    display(Math(f'Bpol = {latex(Bpol)}'))\n",
    "    display(Math(f'Btor = {latex(Btor)}'))\n",
    "    display(Math(f'Bxy = {latex(Bxy)}'))\n",
    "    display(Math(f'gxx = {latex(clebschMetricTensor[0])}'))\n",
    "    display(Math(f'gzz = {latex(clebschMetricTensor[2])}'))\n",
    "    print(\"Inputted function\")\n",
    "    display(Math(f'f = {latex(f)}'))\n",
    "    print(\"Result\")\n",
    "    display(Math(f'b = {latex(b)}'))\n",
    "    print(\"sympy result\")\n",
    "    print(b)\n",
    "    print()\n",
    "    print(\"c++ conversion\")\n",
    "    print(convertPowers(str(b)))\n",
    "    print()\n",
    "    \n",
    "    \n",
    "clebschCoordinatesForwardLaplacian(x**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fff52dd",
   "metadata": {},
   "source": [
    "#need to figure out how to stop cospow from occuring as shown above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6113e6b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}