{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Irreducible K-Points N\n",
    "\n",
    "This module contains the classes that deals with irreducible K-Points at arbitrary order, \n",
    "as well as a method that finds the points that fit in a given supercell.\n",
    "\n",
    "Except for the get_tpoins method, most of the algorithms used in this code will go under a complete overhaul. The basic concept remains. The new algorithm will be similar to that of the kmesh module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from coordinate_tools import coord_to_string as c2s\n",
    "from irreducible_kpts_n import get_tpoints, ibz_mesh_n, k_mesh_n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## get_tpoints\n",
    "\n",
    "This is the method that finds all the points that fit in a given cell, it is used by the k-points finders here as well as the supercell constructors in the periodica. The detailed algorithm is described appendix D of the paper PhysRevB.100.014303.\n",
    "\n",
    "#### function get_tpoints(supa, vol=None, decimals=6)\n",
    "- supa: 2d array of integers, coordinate_parse compatible format\n",
    "        The supercell to find the points that fit in.\n",
    "        The dimension of this matrix determines the dimension of the points.\n",
    "- vol: int, optional\n",
    "        The volume of the supercell, if provided, will check if the volume match that of the supercell matrix \n",
    "- decimals: int, optional\n",
    "        The decimal point of the error tolerence for handling floating point precision issues.\n",
    "        \n",
    "**Examples**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [1, 0],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpoints = get_tpoints(\"2 -1;  -1 2\")\n",
    "tpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [1, 0, 0],\n",
       "       [0, 1, 0]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpoints = get_tpoints(\"2 -1 0;  -1 2 0;  0 0 1\")\n",
    "tpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0],\n",
       "       [1, 0, 0, 0],\n",
       "       [0, 1, 0, 0],\n",
       "       [0, 0, 0, 1],\n",
       "       [1, 0, 0, 1],\n",
       "       [0, 1, 0, 1],\n",
       "       [0, 0, 1, 0],\n",
       "       [1, 0, 1, 0],\n",
       "       [0, 1, 1, 0]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpoints = get_tpoints(\"2 -1 0 0;  -1 2 0 0; 0 0 -1 2; 0 0 2 -1\")\n",
    "tpoints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Irreducible K-Points at arbitrary order with symmetry\n",
    "\n",
    "While *k_mesh_n* handles the permutation symmetry of the K-Points, *ibz_mesh_n* utilizes *k_mesh_n* to account for both point and permutation symmetry.\n",
    "\n",
    "\n",
    "#### class k_mesh_n(supa,order,tetra=False,tol=1.0E-6)\n",
    "- order: int\n",
    "        The order of the system, as well as the number of k-point that forms a single Q.\n",
    "- tol: float\n",
    "        Error tolerence for floating point precision issues.\n",
    "        \n",
    "        \n",
    "#### class ibz_mesh_n(supa,pgn,lattice_vecs,order=2,tetra=True,tol=1.0E-6)\n",
    "- pgn: Point_Group or str\n",
    "        The point group of the system.\n",
    "- lattice_vecs: array of floats\n",
    "        The lattice vectors of the system.\n",
    "- tetra: bool, optional, default to True, *deprecated*\n",
    "\n",
    "Key attributes:\n",
    "- ksets_ibz_trans: OrderedDict\n",
    "        The permutation and point operation that transforms to a given k-point from the matching irreducible k-point (The point symmetry is actually from the given point to the irreducible).\n",
    "- ksets_ibz_fraction: List of nested tuple of Fraction\n",
    "        The irreducible Q. The one without \"_fraction\" suffix is the integer version (p point).\n",
    "- ksets_ibz_map_fraction: \n",
    "        The map between Q and irreducible Q.\n",
    "        \n",
    "**Examples**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "kmesh = ibz_mesh_n(\"2 0 0; 0 2 0; 0 0 1\", 'C6v', np.array([[np.sqrt(3)/2,0.5,0],[np.sqrt(3)/2,-0.5,0],[0,0,1]]), tetra=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[((Fraction(0, 1), Fraction(0, 1), Fraction(0, 1)),\n",
       "  (Fraction(0, 1), Fraction(0, 1), Fraction(0, 1))),\n",
       " ((Fraction(1, 2), Fraction(0, 1), Fraction(0, 1)),\n",
       "  (Fraction(1, 2), Fraction(0, 1), Fraction(0, 1)))]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmesh.ksets_ibz_fraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([(((0, 0, 0), (0, 0, 0)), ((0, 1), 'E', (0, 1))),\n",
       "             (((1, 0, 0), (1, 0, 0)), ((0, 1), 'E', (0, 1))),\n",
       "             (((0, 1, 0), (0, 1, 0)), ((0, 1), 'Ic2x', (0, 1))),\n",
       "             (((1, 1, 0), (1, 1, 0)), ((0, 1), 'Ic2B', (0, 1)))])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmesh.ksets_ibz_trans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}