{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Voigt notation of strain and elastic modulus\n",
    "\n",
    "The `qha-cij` package provide the `qha.cij.voigt` module to facilitate converison between standard ($c_{ijkl}$, $e_{ij}$, where $i,j,k,l=1,2,3$) and [Voigt notation](https://en.wikipedia.org/wiki/Voigt_notation) ($c_{ij}$, $e_{i}$, where $i,j,k,l=1,...,6$) of symmetric metric tensor. With the help of this module, users could easily use both types of notations to work with strains and modulus.\n",
    "\n",
    "The class `cij.util.voigt.ModulusRepresentation` (or `C_`) and `cij.util.voigt.StrainRepresentation` (or `S_`) are used to represent strain and modulus keys. But to create these values, user should use the lowercase `c_` and `s_` from `cij.util`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'cij.util.voigt.ModulusRepresentation'>\n",
      "<class 'cij.util.voigt.StrainRepresentation'>\n"
     ]
    }
   ],
   "source": [
    "from cij.util import c_, e_\n",
    "\n",
    "print(type(c_(11)))\n",
    "print(type(e_(1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `c_` and `s_` allow different types of input, including standard and Voigt notations, as `str` and `int`. And best yet, they can be used to do compairson, to check whether they represent same value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23(2233)\n",
      "23(2233)\n",
      "23(2233)\n",
      "23(2233)\n",
      "56(1312)\n",
      "45(2313)\n",
      "44(2323)\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(c_(23))\n",
    "print(c_('23'))\n",
    "print(c_(2233))\n",
    "print(c_('2233'))\n",
    "\n",
    "print(c_(56))\n",
    "print(c_(1323))\n",
    "print(c_('2323'))\n",
    "\n",
    "print(c_(11) == c_('1111'))\n",
    "print(e_('1') == e_('11'))\n",
    "print(e_('23') == e_(6))\n",
    "print(c_('66') == c_(3223))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By accessing the `.voigt` (or `.v`) and `.standard` (or `.s`) property, one could retrive the Voigt and standard notations in the tuple format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 5)\n",
      "(1, 3, 1, 3)\n",
      "(5, 5)\n",
      "(1, 3, 1, 3)\n"
     ]
    }
   ],
   "source": [
    "print(c_(55).v)\n",
    "print(c_(55).s)\n",
    "print(c_(55).voigt)\n",
    "print(c_(55).standard)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One could also create elastic modulus key from its two repective strains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "from cij.util import C_\n",
    "\n",
    "print(c_(46) == C_.from_standard(*e_(4), *e_(6)))\n",
    "print(c_(46) == C_.from_voigt(e_(4).v, e_(6).v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For elastic modulus, we also provide `.is_longitudinal`, `.is_off_diagonal`, and `.is_shear` to check what type of modulus it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(c_(11).is_shear)\n",
    "print(c_(55).is_shear)\n",
    "print(c_(55).is_longitudinal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.mulitplicity` property checks the multiplicity of $c_ij$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "print(c_(11).multiplicity)\n",
    "print(c_(55).multiplicity)\n",
    "print(c_(46).multiplicity)"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}