Computing Volumes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Philosophy for Physics Majors<br/>[Oregon Curriculum Network](http://4dsolutions.net/ocn/)\n",
    "<h3 align=\"center\">Computing Volumes in XYZ and IVM units</h3>\n",
    "<h4 align=\"center\">by Kirby Urner, July 2016</h4>\n",
    "\n",
    "\n",
    "![Fig. 1](https://c1.staticflickr.com/5/4117/4902708217_451afaa8c5_z.jpg \"Fig 1: Mitey Cube\")\n",
    "\n",
    "A cube is composed of 24 identical not-regular tetrahedrons, each with a corner at the cube's center, an edge from cube's center to a face center, and two more to adjacent cube corners on that face, defining six edges in all (Fig. 1).  \n",
    "\n",
    "If we define the cube's edges to be √2 then the whole cube would have volume √2 * √2 * √2 in XYZ units.  \n",
    "\n",
    "However, in IVM units, the very same cube has a volume of 3, owing to the differently-shaped volume unit, a tetrahedron of edges 2, inscribed in this same cube.  [Fig. 986.210](http://www.rwgrayprojects.com/synergetics/findex/fx0900.html) from *Synergetics*:\n",
    "\n",
    "![Fig. 2](http://www.rwgrayprojects.com/synergetics/s09/figs/f86210.gif)\n",
    "\n",
    "Those lengths would be in R-units, where R is the radius of a unit sphere.  In D-units, twice as long (D = 2R), the tetrahedron has edges 1 and the cube has edges √2/2.\n",
    "\n",
    "By XYZ we mean the XYZ coordinate system of René Descartes (1596 – 1650).  \n",
    "\n",
    "By IVM we mean the \"octet-truss\", a space-frame consisting of tetrahedrons and octahedrons in a space-filling matrix, with twice as many tetrahedrons as octahedrons.  \n",
    "\n",
    "![octet truss](http://grunch.net/synergetics/images/truss.gif)\n",
    "\n",
    "The tetrahedron and octahedron have relative volumes of 1:4.  The question then becomes, how to superimpose the two.\n",
    "\n",
    "The canonical solution is to start with unit-radius balls (spheres) of radius R.  R = 1 in other words, whereas D, the diameter, is 2.  Alternatively, we may set D = 1 and R = 0.5, keeping the same 2:1 ratio for D:R.  \n",
    "\n",
    "The XYZ cube has edges R, whereas the IVM tetrahedron has edges D.  That relative sizing convention brings their respective volumes fairly close together, with the cube's volume exceeding the tetrahedron's by about six percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XYZ units: 2.8284271247461907\n",
      "IVM units: 3\n",
      "Conversion constant: 1.060660171779821\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "xyz_volume = math.sqrt(2)**3\n",
    "ivm_volume = 3\n",
    "print(\"XYZ units:\", xyz_volume)\n",
    "print(\"IVM units:\", ivm_volume)\n",
    "print(\"Conversion constant:\", ivm_volume/xyz_volume)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Python code below encodes a Tetrahedron type based solely on its six edge lengths.  The code makes no attempt to determine the consequent angles.  \n",
    "\n",
    "A complicated volume formula, mined from the history books and streamlined by mathematician Gerald de Jong, outputs the volume of said tetrahedron in both IVM and XYZ units.  \n",
    "\n",
    "The [unittests](http://pythontesting.net/framework/unittest/unittest-introduction/) that follow assure it's producing the expected results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt, hypot\n",
    "\n",
    "class Tetrahedron:\n",
    "    \"\"\"\n",
    "    Takes six edges of tetrahedron with faces\n",
    "    (a,b,d)(b,c,e)(c,a,f)(d,e,f) -- returns volume\n",
    "    in ivm and xyz units\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, a,b,c,d,e,f):\n",
    "        self.a, self.a2 = a, a**2\n",
    "        self.b, self.b2 = b, b**2\n",
    "        self.c, self.c2 = c, c**2\n",
    "        self.d, self.d2 = d, d**2\n",
    "        self.e, self.e2 = e, e**2\n",
    "        self.f, self.f2 = f, f**2\n",
    "\n",
    "    def ivm_volume(self):\n",
    "        ivmvol = ((self._addopen() - self._addclosed() - self._addopposite())/2) ** 0.5\n",
    "        return ivmvol\n",
    "\n",
    "    def xyz_volume(self):\n",
    "        xyzvol = sqrt(8/9) * self.ivm_volume()\n",
    "        return xyzvol\n",
    "\n",
    "    def _addopen(self):\n",
    "        a2,b2,c2,d2,e2,f2 = self.a2, self.b2, self.c2, self.d2, self.e2, self.f2\n",
    "        sumval = f2*a2*b2\n",
    "        sumval +=  d2 * a2 * c2\n",
    "        sumval +=  a2 * b2 * e2\n",
    "        sumval +=  c2 * b2 * d2\n",
    "        sumval +=  e2 * c2 * a2\n",
    "        sumval +=  f2 * c2 * b2\n",
    "        sumval +=  e2 * d2 * a2\n",
    "        sumval +=  b2 * d2 * f2\n",
    "        sumval +=  b2 * e2 * f2\n",
    "        sumval +=  d2 * e2 * c2\n",
    "        sumval +=  a2 * f2 * e2\n",
    "        sumval +=  d2 * f2 * c2\n",
    "        return sumval\n",
    "\n",
    "    def _addclosed(self):\n",
    "        a2,b2,c2,d2,e2,f2 = self.a2, self.b2, self.c2, self.d2, self.e2, self.f2\n",
    "        sumval =   a2 * b2 * d2\n",
    "        sumval +=  d2 * e2 * f2\n",
    "        sumval +=  b2 * c2 * e2\n",
    "        sumval +=  a2 * c2 * f2\n",
    "        return sumval\n",
    "\n",
    "    def _addopposite(self):\n",
    "        a2,b2,c2,d2,e2,f2 = self.a2, self.b2, self.c2, self.d2, self.e2, self.f2\n",
    "        sumval =  a2 * e2 * (a2 + e2)\n",
    "        sumval += b2 * f2 * (b2 + f2)\n",
    "        sumval += c2 * d2 * (c2 + d2)\n",
    "        return sumval\n",
    "\n",
    "\n",
    "PHI = sqrt(5)/2 + 0.5\n",
    "\n",
    "R =0.5\n",
    "D =1.0\n",
    "\n",
    "tet = Tetrahedron(D, D, D, D, D, D)\n",
    "print(tet.ivm_volume())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "...\n",
      "----------------------------------------------------------------------\n",
      "Ran 3 tests in 0.004s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.runner.TextTestResult run=3 errors=0 failures=0>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "class Test_Tetrahedron(unittest.TestCase):\n",
    "\n",
    "    def test_unit_volume(self):\n",
    "        tet = Tetrahedron(D, D, D, D, D, D)\n",
    "        print(tet.ivm_volume())\n",
    "        self.assertAlmostEqual(tet.ivm_volume(), 1.0, places=5)\n",
    "\n",
    "    def test_unit_volume(self):\n",
    "        tet = Tetrahedron(R, R, R, R, R, R)\n",
    "        self.assertAlmostEqual(tet.xyz_volume(), 0.11785, places=5)\n",
    "\n",
    "    def test_phi_edge_tetra(self):\n",
    "        tet = Tetrahedron(D, D, D, D, D, PHI)\n",
    "        self.assertAlmostEqual(tet.ivm_volume(), 0.70711, places=5)\n",
    "\n",
    "    def test_right_tetra(self):\n",
    "        e = hypot(sqrt(3)/2, sqrt(3)/2)  # right tetrahedron\n",
    "        tet = Tetrahedron(D, D, D, D, D, e)\n",
    "        self.assertAlmostEqual(tet.xyz_volume(), 1.0, places=5)\n",
    "\n",
    "a = Test_Tetrahedron()\n",
    "\n",
    "R =0.5\n",
    "D =1.0\n",
    "\n",
    "suite = unittest.TestLoader().loadTestsFromModule(a)\n",
    "unittest.TextTestRunner().run(suite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IVM volume of tetra: 39.99999999999998\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "b = 4\n",
    "c = 5\n",
    "d = 3.4641016151377544\n",
    "e = 4.58257569495584\n",
    "f = 4.358898943540673\n",
    "tetra = Tetrahedron(a,b,c,d,e,f)\n",
    "print(\"IVM volume of tetra:\", tetra.ivm_volume())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets define a MITE, one of these 24 identical space-filling tetrahedrons, with reference to D=1, R=0.5, as this is how our Tetrahedron class is calibrated.  The cubes 12 edges will all be √2/2.\n",
    "\n",
    "Edges 'a' 'b' 'c' fan out from the cube center, with 'b' going up to a face center, with 'a' and 'c' to adjacent ends of the face's edge. \n",
    "\n",
    "From the cube's center to mid-face is √2/4 (half an edge), our 'b'. 'a' and 'c' are both half the cube's body diagonal of √(3/2)/2 or √(3/8). \n",
    "\n",
    "Edges 'd', 'e' and 'f' define the facet opposite the cube's center. \n",
    "\n",
    "'d' and 'e' are both half face diagonals or 0.5, whereas 'f' is a cube edge, √2/2.  This gives us our tetrahedron:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IVM volume of Mite: 0.12499999999999994\n",
      "XYZ volume of Mite: 0.11785113019775786\n"
     ]
    }
   ],
   "source": [
    "b = sqrt(2)/4\n",
    "a = c = sqrt(3/8)\n",
    "d = e = 0.5\n",
    "f = sqrt(2)/2\n",
    "mite = Tetrahedron(a, b, c, d, e, f)\n",
    "print(\"IVM volume of Mite:\", mite.ivm_volume())\n",
    "print(\"XYZ volume of Mite:\", mite.xyz_volume())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Allowing for floating point error, this space-filling right tetrahedron has a volume of 0.125 or 1/8. Since 24 of them form a cube, said cube has a volume of 3.  The XYZ volume, on the other hand, is what we'd expect from a regular tetrahedron of edges 0.5 in the current calibration system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MITE volume in XYZ units: 0.11785113019775792\n",
      "XYZ volume of 24-Mite Cube: 2.82842712474619\n"
     ]
    }
   ],
   "source": [
    "regular = Tetrahedron(0.5, 0.5, 0.5, 0.5, 0.5, 0.5)\n",
    "print(\"MITE volume in XYZ units:\", regular.xyz_volume())\n",
    "print(\"XYZ volume of 24-Mite Cube:\", 24 * regular.xyz_volume())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MITE (minimum tetrahedron) further dissects into component modules, a left and right A module, then either a left or right B module.  Outwardly, the positive and negative MITEs look the same.  Here are some drawings from R. Buckminster Fuller's research, the chief popularizer of the A and B modules.\n",
    "\n",
    "![A and B mods](http://www.rwgrayprojects.com/synergetics/s09/figs/f5400b.gif)\n",
    "\n",
    "In a different Jupyter Notebook, we could run these tetrahedra through our volume computer to discover both As and Bs have a volume of 1/24 in IVM units.\n",
    "\n",
    "This information is being shared around Portland in various contexts.  Below, an image from a hands-on workshop in 2010 organized by the Portland Free School."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Free School, Portland](https://c1.staticflickr.com/5/4058/4431307684_8655ee3198_z.jpg)"
   ]
  }
 ],
 "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.5.1"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}