Spinor_Cube_Ver2.1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "54834b7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5d03ddd7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!pip3 install mayavi\n",
    "!pip install clifford\n",
    "\n",
    "#!jupyter nbextension enable  --py mayavi --user\n",
    "\n",
    "#!jupyter nbextension install  --py mayavi --user\n",
    "#!jupyter notebook --generate-config\n",
    "\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "938ddb73",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import mayavi\n",
    "from mayavi import mlab\n",
    "\n",
    "from numpy import arange, pi, cos, sin, exp\n",
    "\n",
    "from traits.api import HasTraits, Range, Instance, \\\n",
    "        on_trait_change\n",
    "from traitsui.api import View, Item, Group\n",
    "\n",
    "from mayavi.core.api import PipelineBase\n",
    "from mayavi.core.ui.api import MayaviScene, SceneEditor, \\\n",
    "                MlabSceneModel\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5230c29e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clifford \n",
    "from clifford.g3c import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "21a1cb26",
   "metadata": {},
   "outputs": [],
   "source": [
    "R12 = lambda lam : exp(-e12*pi*lam)\n",
    "R23 = lambda lam : exp(-e23*pi*lam)\n",
    "R31 = lambda lam : exp(e13*pi*lam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5fd7a4af",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Strings:\n",
    "    def __init__(self,elems):\n",
    "        self.vector = elems[0]\n",
    "        self.beads  = len(elems)\n",
    "\n",
    "        self.elems = elems\n",
    "\n",
    "    def s(self, Rotor): #Sandwich product\n",
    "\n",
    "        return Strings(Rotor*self.elems*~Rotor)\n",
    "\n",
    "\n",
    "class Cubes:\n",
    "    def __init__(self,elems):\n",
    "        \n",
    "        self.elems = elems\n",
    "\n",
    "    def s(self, Rotor): #Sandwich product\n",
    "\n",
    "        return Cubes(Rotor*self.elems*~Rotor)\n",
    "\n",
    "Cube = Cubes( np.array([\n",
    "                 e1 + e2 + e3,\n",
    "                 e1 - e2 + e3,\n",
    "                -e1 - e2 + e3,\n",
    "                -e1 + e2 + e3,\n",
    "                 e1 + e2 - e3,\n",
    "                 e1 - e2 - e3,\n",
    "                -e1 - e2 - e3,\n",
    "                -e1 + e2 - e3,]))\n",
    "M = 80\n",
    "spacing = 0.1\n",
    "\n",
    "String = Strings(spacing*np.arange(1/spacing,M+1)*e1)\n",
    "N = 5\n",
    "\n",
    "StringX1 = String\n",
    "StringX2 = String.s(R12(0.5))\n",
    "\n",
    "StringY1 = String.s(R12(0.25))\n",
    "StringY2 = String.s(R12(0.75))\n",
    "\n",
    "StringZ1 = String.s(R23(0.75)*R12(0.75))\n",
    "StringZ2 = String.s(R23(0.25)*R12(0.75))\n",
    "\n",
    "StringList = np.array([[StringX1,StringY1,StringZ1],\n",
    "                       [StringX2,StringY2,StringZ2]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7783df41",
   "metadata": {},
   "outputs": [],
   "source": [
    "def W(lam,rotation_axis,string_axis,String):\n",
    "    '''\n",
    "    string_axis i : axis on which string is attached 1,2,3 \n",
    "    rotation_axis k : rotation axis 1,2,3\n",
    "\n",
    "    returns rotor\n",
    "    '''\n",
    "\n",
    "    to_vector = {1 : e1, -1 : -e1,\n",
    "                 2 : e2, -2 : -e2,\n",
    "                 3 : e3, -3 : -e3}\n",
    "\n",
    "    ei = to_vector[string_axis]\n",
    "    ek = to_vector[rotation_axis]\n",
    "\n",
    "    ej = -(ei ^ ek) / e123\n",
    "    \n",
    "\n",
    "    Rij = lambda lam : exp(-ei^ej*pi*lam) #around rot axis\n",
    "    Rjk = lambda lam : exp(-ej^ek*pi*lam)\n",
    "\n",
    "    \n",
    "    lam %= 2\n",
    "\n",
    "    M = len(String.elems)+1\n",
    "    RotString = np.zeros_like(String.elems)\n",
    "\n",
    "    a = np.arange(2,M+1) #index along the string\n",
    "    alpha = a / (M-1)\n",
    "    \n",
    "    \"\"\"\n",
    "    lambda_ij = (lam      if 0 <= lam and lam < 0.5 else \n",
    "                        1 - lam  if 0.5 <= lam <= 1 else\n",
    "                        lam-1     if 1 < lam <= 1.5 else\n",
    "                        2-lam) * np.maximum(1-alpha**3,0)\n",
    "\n",
    "    lambda_jk = 0.5*(lam  if 0<=lam and lam < 1 else\n",
    "                            1-lam) \n",
    "    \"\"\"\n",
    "\n",
    "    lambda_ij = (lam      if 0 <= lam and lam < 0.5 else \n",
    "                        1 - lam  if 0.5 <= lam <= 1 else\n",
    "                        1-lam   if 1 < lam <= 1.5 else\n",
    "                        lam-2 ) \n",
    "\n",
    "    lambda_jk = 0.5*(lam  if 0<=lam and lam < 1 else\n",
    "                            2-lam)    \n",
    "\n",
    "    \n",
    "    \n",
    "    RotString = String.s(Rjk(lambda_jk )\n",
    "                         * Rij(lambda_ij *(1-alpha**3))    #perpendicular to rotation plane\n",
    "                                    #along rotation axis\n",
    "                         ) \n",
    "    \n",
    "\n",
    "\n",
    "    return RotString\n",
    "\n",
    "\n",
    "\n",
    "R = [R23,R31,R12]\n",
    "\n",
    "def rotors(a,b,lam,StringList):\n",
    "    '''\n",
    "    a : quat current state 1,2,3\n",
    "    b : quat rotation 1,2,3\n",
    "    lam : rotation number\n",
    "    StringList : 3-tuple of strings\n",
    "    '''\n",
    "    sign = +1\n",
    "    if a < 0:\n",
    "        a = -a\n",
    "        sign = -1\n",
    "\n",
    "    a -= 1; b -= 1\n",
    "    a %= 3; b %= 3\n",
    "\n",
    "    if b == (a+1) % 3:\n",
    "        c = (a-1) % 3\n",
    "        phase = -1\n",
    "    else:\n",
    "        c = (a+1) % 3\n",
    "        phase = +1\n",
    "\n",
    "    StringList = [StringList[a], StringList[b], StringList[c]]\n",
    "\n",
    "    RotStringList = [W(lam + 1 + (1 if sign<0 else 0), b+1, a+1, StringList[0]), \n",
    "                     W(3/2,a+1,b+1,StringList[1]).s(R[b](lam/2+1/4 + (1/2 if sign<0 else 0))), \n",
    "                     W(lam + phase*1/2 + (1 if sign<0 else 0), b+1, c+1, StringList[2])]\n",
    "        \n",
    "    RotStringList_ = [0,0,0]\n",
    "    RotStringList_[a] = RotStringList[0] \n",
    "    RotStringList_[b] = RotStringList[1]\n",
    "    RotStringList_[c] = RotStringList[2]\n",
    "    \n",
    "    return RotStringList_\n",
    "\n",
    "to_symbol = {1 : \"i\", -1 : \"-i\",\n",
    "             2 : \"j\", -2 : \"-j\",\n",
    "             3 : \"k\", -3 : \"-k\"\n",
    "             }\n",
    "\n",
    "#plt.rcParams['figure.figsize'] = [4*N, 4]\n",
    "#fig, axs = plt.subplots(1,N,subplot_kw=dict(projection='3d'))\n",
    "\n",
    "\n",
    "StringList1 = [StringX1,StringY1,StringZ1]\n",
    "StringList2 = [StringX2,StringY2,StringZ2]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cc362d0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "up_ = np.array([\n",
    "    +e1+e2+e3,\n",
    "    -e1+e2+e3,\n",
    "    +e1-e2+e3,\n",
    "    -e1-e2+e3,\n",
    "])  \n",
    "down_ = np.array([\n",
    "    +e1+e2-e3,\n",
    "    -e1+e2-e3,\n",
    "    +e1-e2-e3,\n",
    "    -e1-e2-e3,\n",
    "]) \n",
    "front = np.array([\n",
    "    +e1+e2+e3,\n",
    "    -e1+e2+e3,\n",
    "    +e1+e2-e3,\n",
    "    -e1+e2-e3,\n",
    "]) \n",
    "back = np.array([\n",
    "    +e1-e2+e3,\n",
    "    -e1-e2+e3,\n",
    "    +e1-e2-e3,\n",
    "    -e1-e2-e3,\n",
    "]) \n",
    "left = np.array([\n",
    "    -e1+e2+e3,\n",
    "    -e1-e2+e3,\n",
    "    -e1+e2-e3,\n",
    "    -e1-e2-e3,\n",
    "]) \n",
    "right = np.array([\n",
    "    +e1+e2+e3,\n",
    "    +e1-e2+e3,\n",
    "    +e1+e2-e3,\n",
    "    +e1-e2-e3,\n",
    "]) \n",
    "\n",
    "faces = np.array([\n",
    "    right,front, up_,\n",
    "    left, back,  down_,\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "98c1acdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "faces = faces.reshape((6,2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "61b18579",
   "metadata": {},
   "outputs": [],
   "source": [
    "Cube = Cubes(faces)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0ac595c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def cube_faces(lam):\n",
    "    \n",
    "    b = 3 #axis of rot\n",
    "\n",
    "    RotCube = Cube.s(R[abs(b)-1](lam))\n",
    "    \n",
    "    return RotCube.elems\n",
    "\n",
    "def string_points(lam):\n",
    "    a = -1 #state\n",
    "    b = 3 #axis of rot\n",
    "    \n",
    "    ######## \n",
    "    #sampling later and interpolate before? ?? \n",
    "    #\n",
    "    ########\n",
    "    RotStrings1 = rotors(a,b,lam,StringList1) #pos coor dir\n",
    "    RotStrings2 = rotors(a,b,lam,StringList2) #neg coor dir\n",
    "    \n",
    "    \n",
    "    return RotStrings1, RotStrings2\n",
    "\n",
    "\n",
    "class MyModel(HasTraits):\n",
    "    lam    = Range(-0.5, 0.5, 0.0)  # mode='spinner')\n",
    "\n",
    "    scene = Instance(MlabSceneModel, ())\n",
    "    \n",
    "    #mult plot instances for mult refeshes?\n",
    "    face_plot1 = Instance(PipelineBase)\n",
    "    face_plot2 = Instance(PipelineBase)\n",
    "    face_plot3 = Instance(PipelineBase)\n",
    "    face_plot_1 = Instance(PipelineBase)\n",
    "    face_plot_2 = Instance(PipelineBase)\n",
    "    face_plot_3 = Instance(PipelineBase)\n",
    "    \n",
    "    axis_plot1 = Instance(PipelineBase)\n",
    "    axis_plot2 = Instance(PipelineBase)\n",
    "    axis_plot3 = Instance(PipelineBase)\n",
    "    axis_plot_1 = Instance(PipelineBase)\n",
    "    axis_plot_2 = Instance(PipelineBase)\n",
    "    axis_plot_3 = Instance(PipelineBase)\n",
    "    \n",
    "        \n",
    "    # When the scene is activated, or when the parameters are changed, we\n",
    "    # update the plot.\n",
    "\n",
    "    \n",
    "    @on_trait_change('lam,scene.activated')\n",
    "    def update_plot(self):\n",
    "        #mlab.clf()\n",
    "        \n",
    "        faces = cube_faces(self.lam)\n",
    "        axes1,axes2 = string_points(self.lam)\n",
    "        \n",
    "        colors = ((1,0,0),(0,1,0),(0,0,1))\n",
    "        \n",
    "        self.face_plot1; self.face_plot2; self.face_plot3\n",
    "        self.face_plot_1; self.face_plot_2; self.face_plot_3\n",
    "        \n",
    "        self.axis_plot1; self.axis_plot2; self.axis_plot3\n",
    "        self.axis_plot_1; self.axis_plot_2; self.axis_plot_3\n",
    "        \n",
    "        ##### --> iter through self plot attributes \n",
    "        face_plots = [\"face_plot1\",\"face_plot2\",\"face_plot3\",\n",
    "                      \"face_plot_1\",\"face_plot_2\",\"face_plot_3\"]\n",
    "        axis_plots1 = [\"axis_plot1\",\"axis_plot2\",\"axis_plot3\"]\n",
    "        axis_plots2 = [\"axis_plot_1\",\"axis_plot_2\",\"axis_plot_3\"]\n",
    "        \n",
    "        \"\"\"\n",
    "        ###\n",
    "        \n",
    "        \n",
    "        x,y,z = (np.array(faces[0]|e1,dtype=float),\n",
    "                 np.array(faces[0]|e2,dtype=float),\n",
    "                 np.array(faces[0]|e3,dtype=float))\n",
    "        \n",
    "        if self.face_plot1 is None:\n",
    "            self.face_plot1 = self.scene.mlab.mesh(x,y,z,opacity=1.0, color = colors[0])\n",
    "        else:\n",
    "            self.face_plot1.mlab_source.trait_set(x=x, y=y, z=z) \n",
    "         \n",
    "            \n",
    "        x,y,z = (np.array(axes1[0].elems|e1,dtype=float),\n",
    "                 np.array(axes1[0].elems|e2,dtype=float),\n",
    "                 np.array(axes1[0].elems|e3,dtype=float))\n",
    "\n",
    "        if self.axis_plot1 is None:\n",
    "            self.axis_plot1 = self.scene.mlab.plot3d(x, y, z, color = colors[0],tube_radius = 0.2)\n",
    "        else:\n",
    "            self.axis_plot1.mlab_source.trait_set(x=x, y=y, z=z) \n",
    "            \n",
    "        \"\"\"\n",
    "        for face_plot,face,color in zip(face_plots,faces,2*colors): #gives rotated face elems\n",
    "            x,y,z = (np.array(face|e1,dtype=float),\n",
    "                     np.array(face|e2,dtype=float),\n",
    "                     np.array(face|e3,dtype=float))\n",
    "                \n",
    "            if vars(self)[face_plot] is None:\n",
    "                vars(self)[face_plot] = self.scene.mlab.mesh(x,y,z,opacity=1.0, color = color)\n",
    "            else:\n",
    "                vars(self)[face_plot].mlab_source.trait_set(x=x, y=y, z=z) \n",
    "        \n",
    "        for axis_plot,points,color in zip(axis_plots1,axes1,colors):\n",
    "            points     = points.elems\n",
    "\n",
    "\n",
    "            x,y,z = (np.array(points|e1,dtype=float),\n",
    "                     np.array(points|e2,dtype=float),\n",
    "                     np.array(points|e3,dtype=float))\n",
    "\n",
    "            if vars(self)[axis_plot] is None:\n",
    "                vars(self)[axis_plot] = self.scene.mlab.plot3d(x, y, z, color = color,tube_radius = 0.2)\n",
    "            else:\n",
    "                vars(self)[axis_plot].mlab_source.trait_set(x=x, y=y, z=z) \n",
    "        \n",
    "        \n",
    "        for axis_plot,points,color in zip(axis_plots2,axes2,colors):\n",
    "            points     = points.elems\n",
    "\n",
    "            x,y,z = (np.array(points|e1,dtype=float),\n",
    "                     np.array(points|e2,dtype=float),\n",
    "                     np.array(points|e3,dtype=float))\n",
    "\n",
    "            if vars(self)[axis_plot] is None:\n",
    "                vars(self)[axis_plot] = self.scene.mlab.plot3d(x, y, z, color = color,tube_radius = 0.2)\n",
    "            else:\n",
    "                vars(self)[axis_plot].mlab_source.trait_set(x=x, y=y, z=z) \n",
    "\n",
    "        ###\n",
    "        \n",
    "        \n",
    "    # The layout of the dialog created\n",
    "    view = View(Item('scene', editor=SceneEditor(scene_class=MayaviScene),\n",
    "                     height=500, width=600, show_label=False),\n",
    "                Group(\n",
    "                        '_', 'lam',\n",
    "                     ),\n",
    "                resizable=True,\n",
    "                )\n",
    "\n",
    "my_model = MyModel()\n",
    "my_model.configure_traits()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed8b22ac",
   "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
}