API_use/api_use_2017.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# The Materials API\n",
    "\n",
    "### Presented by: John Dagdelen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "In this lesson, we will learn how to interact with the Materials Project database and go through some practical examples of combining our own code with MP data to uncover new materials insights. We will do this through the Materials API (MAPI), which is an open API for accessing Materials Project data based on [Representational state transfer (REST)](https://en.wikipedia.org/wiki/Representational_state_transfer) principles.\n",
    "\n",
    "In this module, we cover:\n",
    "\n",
    "* The Materials Project API (MAPI).\n",
    "* Getting your Materials Project API key.\n",
    "* The `MPRester.query` method for accessing the MP database.\n",
    "* A hands-on example of using the API and pymatgen to screen the database for interesting materials.\n",
    "* The [mapidoc](https://github.com/materialsproject/mapidoc) (Materials Project documentation) repository."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "***\n",
    "## Section 0: Getting an API key\n",
    "\n",
    "The first step to getting started with the API is to get an API key. API keys are unique identifiers that are used to track and control how the API is being used. \n",
    "\n",
    "To get yours, go to the dashboard page on the Materials Project website (https://materialsproject.org/dashboard). Click the 'Generate API key' button and copy the string under the button; this is your API key.\n",
    "\n",
    "Paste your key in the line below, which will assign it the environment variable name MAPI_KEY."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Existing /home/jovyan/.pmgrc.yaml backed up to /home/jovyan/.pmgrc.yaml.bak\r\n",
      "New /home/jovyan/.pmgrc.yaml written!\r\n"
     ]
    }
   ],
   "source": [
    "!pmg config --add PMG_MAPI_KEY [your API key]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "***\n",
    "## Section 1: The MPRester\n",
    "\n",
    "In this section we will:\n",
    "\n",
    "* Open the pymatgen.MPRester web documentation.\n",
    "* Create our first instance of an MPRester object.\n",
    "* Get our feet wet with calling a few of the MPRester's \"specialty\" methods.\n",
    "* Introduce the powerful `query` method. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Background and Documentation\n",
    "\n",
    "REST is a widely used type of standardization that allows different computer systems to work together. In RESTful systems, information is organized into resources, each of which is uniquely identified via a uniform resource identifier (URI). Since MAPI is a RESTful system, users can interact with the MP database regardless of their computer system or programming language (as long as it supports basic http requests.)\n",
    "\n",
    "To facilitate researchers in using our API, we implemented a convenient wrapper for it in the Python Materials Genomics (pymatgen) library called the `MPRester`. You can find the relevant pymatgen documentation for it [here](http://pymatgen.org/pymatgen.ext.matproj.html?highlight=mprester#pymatgen.ext.matproj.MPRester).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Starting up an instance of the MPRester\n",
    "\n",
    "We'll create an instance of the MPRester object using our API key as an input argument. (Note for power-users: If you add \"PMG_MAPI_KEY: [your API key]\" to your .pmgrc.yaml file, you can skip filling in this argument in the future.) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('energy', 'energy_per_atom', 'volume', 'formation_energy_per_atom', 'nsites', 'unit_cell_formula', 'pretty_formula', 'is_hubbard', 'elements', 'nelements', 'e_above_hull', 'hubbards', 'is_compatible', 'spacegroup', 'task_ids', 'band_gap', 'density', 'icsd_id', 'icsd_ids', 'cif', 'total_magnetization', 'material_id', 'oxide_type', 'tags', 'elasticity')\n"
     ]
    }
   ],
   "source": [
    "from pymatgen import MPRester\n",
    "\n",
    "mpr = MPRester() # object for connecting to MP REST interface\n",
    "print(mpr.supported_properties)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we recommend that you use the “with” context manager to ensure that sessions are properly closed after usage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('energy', 'energy_per_atom', 'volume', 'formation_energy_per_atom', 'nsites', 'unit_cell_formula', 'pretty_formula', 'is_hubbard', 'elements', 'nelements', 'e_above_hull', 'hubbards', 'is_compatible', 'spacegroup', 'task_ids', 'band_gap', 'density', 'icsd_id', 'icsd_ids', 'cif', 'total_magnetization', 'material_id', 'oxide_type', 'tags', 'elasticity')\n"
     ]
    }
   ],
   "source": [
    "with MPRester() as mpr: # object for connecting to MP REST interface\n",
    "    print(mpr.supported_properties)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Section 2: Using the MPRester and Pymatgen to Find Materials With Exotic Mechanical Properties\n",
    "\n",
    "The SiO$_2$ polymorph $\\alpha$-cristobalite [(mp-6945)](https://materialsproject.org/materials/mp-6945/) is one of the very few crystalline materials known to have a negative average Poisson's ratio, which means that its cross-section expands under tensile strain rather than contracting. This property can be extremely useful in a variety of applications such as scratch-resistant coatings and high-toughness ceramics. \n",
    "\n",
    "Why does $\\alpha$-cristobalite exhibit this property while other materials do not? The prevailing hypothesis is that $\\alpha$-cristobalite's negative Poisson's ratio is a result of its crystal structure. If that's the case, then perhaps we can find other materials with this exotic property by looking for materials with similar structures and then calculating their Poisson's ratios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, it might be nice to inspect $\\alpha$-cristobalite's structure. The MPRester has a handy special method called `get_structure_by_material_id` that allows us to request the pymatgen structure object for a material by passing in its mpid. Let's use this method to get $\\alpha$-cristobalite's structure and print it out. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full Formula (Si4 O8)\n",
      "Reduced Formula: SiO2\n",
      "abc   :   5.082618   5.082618   7.095207\n",
      "angles:  90.000000  90.000000  90.000000\n",
      "Sites (12)\n",
      "  #  SP           a         b         c    coordination_no  forces\n",
      "---  ----  --------  --------  --------  -----------------  ---------------------------------------\n",
      "  0  O     0.905861  0.75898   0.325631                  4  [0.00469072, -0.00073419, 0.00270727]\n",
      "  1  O     0.094139  0.24102   0.825631                  4  [-0.00469072, 0.00073419, 0.00270727]\n",
      "  2  O     0.75898   0.905861  0.674369                  4  [-0.00073419, 0.00469072, -0.00270727]\n",
      "  3  O     0.258979  0.594139  0.075631                  4  [-0.00073419, -0.00469072, 0.00270727]\n",
      "  4  O     0.24102   0.094139  0.174369                  4  [0.00073419, -0.00469072, -0.00270727]\n",
      "  5  O     0.405861  0.74102   0.424369                  4  [0.00469072, 0.00073419, -0.00270727]\n",
      "  6  O     0.594139  0.258979  0.924369                  4  [-0.00469072, -0.00073419, -0.00270727]\n",
      "  7  O     0.74102   0.405861  0.575631                  4  [0.00073419, 0.00469072, 0.00270727]\n",
      "  8  Si    0.705544  0.705544  0.5                       4  [0.00198735, 0.00198735, 0.0]\n",
      "  9  Si    0.794456  0.205544  0.75                      4  [-0.00198735, 0.00198735, 0.0]\n",
      " 10  Si    0.205544  0.794456  0.25                      4  [0.00198735, -0.00198735, 0.0]\n",
      " 11  Si    0.294456  0.294456  0                         4  [-0.00198735, -0.00198735, 0.0]\n"
     ]
    }
   ],
   "source": [
    "# ac_structure = [your code here]\n",
    "# print(ac_structure)\n",
    "ac_structure = mpr.get_structure_by_material_id(\"mp-6945\")\n",
    "print(ac_structure)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MPRester also has a very powerful method called `query`, which allows us to perform sophisticated searches on the database. The `query` method uses MongoDB's [query syntax](https://docs.mongodb.com/manual/tutorial/query-documents/). In this syntax, query submissions have two parts: a set of criteria that you want to base the search on (in the form of a python dict), and a set of properties that you want the database to return (in the form of either a list or dict). \n",
    "\n",
    "The general structure of a MPRester query is:\n",
    "                            \n",
    "                            mpr.query(criteria={}, properties=[])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example: Say that we want to get a list of the mpid and crystal system (cubic, tetragonal, etc) for every SiO$_2$ polymorph in the MP database. How would we construct the query?\n",
    "\n",
    "The first step is to consult the Materials API Documentation [(mapidoc)](https://github.com/materialsproject/mapidoc) to find the right keywords. After that, we can fill in the query method's arguments `criteria` and `properties`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(We find that the keys are \"pretty_formula\", \"material_id\", and \"spacegroup.crystal_system\" since crystal_system is a sub-property of spacegroup.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data1 = mpr.query(criteria={\"pretty_formula\":'SiO2'}, \n",
    "                 properties=[\"material_id\", \"spacegroup.crystal_system\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You don't actually have to specify the argument names as long as the criteria are first and the properties second. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data2 = mpr.query({\"pretty_formula\":'SiO2'}, [\"material_id\", \"spacegroup.crystal_system\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, if you're querying on a simple property, such as the chemical formula, you can skip passing it as a dictionary. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data3 = mpr.query('SiO2', [\"material_id\", \"spacegroup.crystal_system\"])\n",
    "\n",
    "data1 == data2 and data2 == data3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we investigate the object that the query method returns, we find that it is a list of dicts. Furthermore, we find that the keys of the dictionaries are the very same keywords that we passed to the query method as the `properties` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'material_id': 'mp-685184', 'spacegroup.crystal_system': 'triclinic'},\n",
       " {'material_id': 'mp-34150', 'spacegroup.crystal_system': 'monoclinic'},\n",
       " {'material_id': 'mp-554243', 'spacegroup.crystal_system': 'hexagonal'},\n",
       " {'material_id': 'mp-555411', 'spacegroup.crystal_system': 'orthorhombic'},\n",
       " {'material_id': 'mp-557873', 'spacegroup.crystal_system': 'triclinic'}]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data1[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### Quick Aside About MongoDB Query Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "source": [
    "Above, we specified the chemical formula SiO$_2$ for our query. This is an example of, the \"specify\" operator. However, MongoDB's syntax also includes other [query operators](https://docs.mongodb.com/manual/reference/operator/query/#query-selectors), allowing us to bulid complex conditionals into our queries. \n",
    "\n",
    "A recent paper by McEnany et. al. proposes a novel ammonia synthesis process based on the electrochemical cycling of lithium ([link](http://pubs.rsc.org/en/content/articlelanding/2017/ee/c7ee01126a#!divAbstract)). As an exercise, let's use some of MongoDB's operators and ask the database for nitrides of alkali metals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'material_id': 'mp-2659', 'pretty_formula': 'LiN3'},\n",
       " {'material_id': 'mp-827', 'pretty_formula': 'KN3'},\n",
       " {'material_id': 'mp-2341', 'pretty_formula': 'Li3N'},\n",
       " {'material_id': 'mp-743', 'pretty_formula': 'RbN3'},\n",
       " {'material_id': 'mp-636056', 'pretty_formula': 'KN3'},\n",
       " {'material_id': 'mp-581833', 'pretty_formula': 'RbN3'},\n",
       " {'material_id': 'mp-2251', 'pretty_formula': 'Li3N'},\n",
       " {'material_id': 'mp-11801', 'pretty_formula': 'K3N'},\n",
       " {'material_id': 'mp-1009221', 'pretty_formula': 'NaN'},\n",
       " {'material_id': 'mp-634410', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-22003', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-999495', 'pretty_formula': 'Na3N'},\n",
       " {'material_id': 'mp-570538', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-999496', 'pretty_formula': 'Na3N'},\n",
       " {'material_id': 'mp-22777', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-2639', 'pretty_formula': 'Na3N'},\n",
       " {'material_id': 'mp-510557', 'pretty_formula': 'CsN3'}]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alkali_metals = ['Li', 'Na', 'K', 'Rb', 'Cs']\n",
    "\n",
    "criteria={\"elements\":{\"$in\":alkali_metals, \"$all\": [\"N\"]}, \"nelements\":2}\n",
    "properties=['material_id', 'pretty_formula']\n",
    "\n",
    "mpr.query(criteria, properties)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience, the MPRester also accepts a simplified syntax for queries by chemical system. For example, the query we made above can be simplified to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'material_id': 'mp-510557', 'pretty_formula': 'CsN3'},\n",
       " {'material_id': 'mp-827', 'pretty_formula': 'KN3'},\n",
       " {'material_id': 'mp-636056', 'pretty_formula': 'KN3'},\n",
       " {'material_id': 'mp-11801', 'pretty_formula': 'K3N'},\n",
       " {'material_id': 'mp-2659', 'pretty_formula': 'LiN3'},\n",
       " {'material_id': 'mp-2341', 'pretty_formula': 'Li3N'},\n",
       " {'material_id': 'mp-2251', 'pretty_formula': 'Li3N'},\n",
       " {'material_id': 'mp-1009221', 'pretty_formula': 'NaN'},\n",
       " {'material_id': 'mp-634410', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-22003', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-999495', 'pretty_formula': 'Na3N'},\n",
       " {'material_id': 'mp-570538', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-999496', 'pretty_formula': 'Na3N'},\n",
       " {'material_id': 'mp-22777', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-2639', 'pretty_formula': 'Na3N'},\n",
       " {'material_id': 'mp-743', 'pretty_formula': 'RbN3'},\n",
       " {'material_id': 'mp-581833', 'pretty_formula': 'RbN3'}]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mpr.query('{Li,Na,K,Rb,Cs}-N', ['material_id', 'pretty_formula'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can also perform the same query, but ask the database to only return compounds with energies above the hull less than 10 meV/atom by using the \"less than\" operator, \"`$lt`\". (The energy above the convex hull gives us a sense of how stable a compound is relative to other compounds with the same composition.) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'material_id': 'mp-2659', 'pretty_formula': 'LiN3'},\n",
       " {'material_id': 'mp-827', 'pretty_formula': 'KN3'},\n",
       " {'material_id': 'mp-2341', 'pretty_formula': 'Li3N'},\n",
       " {'material_id': 'mp-743', 'pretty_formula': 'RbN3'},\n",
       " {'material_id': 'mp-2251', 'pretty_formula': 'Li3N'},\n",
       " {'material_id': 'mp-22003', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-570538', 'pretty_formula': 'NaN3'},\n",
       " {'material_id': 'mp-510557', 'pretty_formula': 'CsN3'}]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "criteria={\"elements\":{\"$in\":alkali_metals, \"$all\":[\"N\"]}, \"nelements\":2, 'e_above_hull':{\"$lt\":0.010}}\n",
    "properties=['material_id', 'pretty_formula']\n",
    "mpr.query(criteria, properties)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's get back to our example of finding materials with similar crystal structures to $\\alpha$-cristobalite. \n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For our search, we want to start with a set of structures that are:\n",
    "* Computationally tractable (not too many sites)\n",
    "* Not too unlikely to be synthesizable (small energy above hull, i.e. <100 meV)\n",
    "\n",
    "Let's construct this query:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['mp-1357', 'mp-23219', 'mp-11416', 'mp-21030', 'mp-22460', 'mp-749', 'mp-1751', 'mp-19962', 'mp-11412', 'mp-530', 'mp-7631', 'mp-680570', 'mp-12608', 'mp-2772', 'mp-1463', 'mp-2033', 'mp-611', 'mp-861975', 'mp-2715', 'mp-619']\n"
     ]
    }
   ],
   "source": [
    "criteria={'nsites':{'$lte':50}, 'e_above_hull':{'$lte':0.100}}\n",
    "properties=['material_id', 'spacegroup']\n",
    "\n",
    "data = mpr.query(criteria,properties)\n",
    "\n",
    "print([d['material_id'] for d in data[20000:20020]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to compare all of these materials to $\\alpha$-cristobalite. We'll need something that can tell us whether two structures are similar. Luckily for us, the pymatgen StructureMatcher does just that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "from pymatgen.analysis.structure_matcher import StructureMatcher\n",
    "\n",
    "sm = StructureMatcher()\n",
    "ac_structure = mpr.get_structure_by_material_id(\"mp-6945\")\n",
    "\n",
    "print(sm.fit(ac_structure, ac_structure))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know that the high-temperature phase of cristobalite, $\\beta$-cristobalite [(mp-546794)](https://materialsproject.org/materials/mp-546794/), has a very similar structure to $\\alpha$-cristobalite. Let's see if the structure matcher agrees."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "bc_structure = mpr.get_structure_by_material_id(\"mp-546794\")\n",
    "\n",
    "print(sm.fit(ac_structure, bc_structure))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, the default settings of the structure matcher are too strict for our purposes. We want a comparison engine that will return True if two structures are similar to each other, not just those that are exactly the same. \n",
    "\n",
    "To solve this problem, we can instantiate our comparison engine with looser tolerances and use a species-agnostic FrameworkComparator from pymatgen, which allows us to compare structures across different chemistries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from pymatgen.analysis.structure_matcher import FrameworkComparator\n",
    "\n",
    "comparison_engine = StructureMatcher(ltol=.2, stol=.5, angle_tol=10, primitive_cell=True, scale=True, \n",
    "                                     attempt_supercell=True, comparator=FrameworkComparator())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "bc_structure = mpr.get_structure_by_material_id(\"mp-546794\")\n",
    "\n",
    "print(comparison_engine.fit(ac_structure, bc_structure))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just to make sure we haven't increased the tolerances too much, let's try it against a random compound to make sure it's not matching un-similar structures. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "random_structure = mpr.get_structure_by_material_id(\"mp-4991\")\n",
    "print(comparison_engine.fit(ac_structure, random_structure))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's get back to our example of finding materials with similar crystal structures to $\\alpha$-cristobalite. \n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine that we have an experimental colleague, Dr. Soren Tsarpinski, who is an expert at synthesizing vanadate compounds. We have a hunch that some of the vanadates coming out of Dr. Tsarpinski's lab might have similar structures to $\\alpha$-cristobalite and therefore might have negative Poisson's ratios. Let's see if we're right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.5/site-packages/pymatgen/core/periodic_table.py:398: UserWarning: No electronegativity for He. Setting to infinity. This has no physical meaning, and is mainly done to avoid errors caused by the code expecting a float.\n",
      "  % self.symbol)\n",
      "/opt/conda/lib/python3.5/site-packages/pymatgen/core/periodic_table.py:398: UserWarning: No electronegativity for Ne. Setting to infinity. This has no physical meaning, and is mainly done to avoid errors caused by the code expecting a float.\n",
      "  % self.symbol)\n",
      "/opt/conda/lib/python3.5/site-packages/pymatgen/core/periodic_table.py:398: UserWarning: No electronegativity for Ar. Setting to infinity. This has no physical meaning, and is mainly done to avoid errors caused by the code expecting a float.\n",
      "  % self.symbol)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['BaV3O8',\n",
       " 'CsV3O8',\n",
       " 'KV3O8',\n",
       " 'LiV3O8',\n",
       " 'LiV3O8',\n",
       " 'LiV3O8',\n",
       " 'LiV3O8',\n",
       " 'LiV3O8',\n",
       " 'MgV3O8',\n",
       " 'MgV3O8',\n",
       " 'MnV3O8',\n",
       " 'MnV3O8',\n",
       " 'NaV3O8',\n",
       " 'NaV3O8',\n",
       " 'NbV3O8',\n",
       " 'NbV3O8',\n",
       " 'RbV3O8',\n",
       " 'TiV3O8',\n",
       " 'TlV3O8',\n",
       " 'V3CoO8',\n",
       " 'V3CoO8',\n",
       " 'V3CoO8',\n",
       " 'V3CoO8',\n",
       " 'V3CrO8',\n",
       " 'V3CuO8',\n",
       " 'V3CuO8',\n",
       " 'V3FeO8',\n",
       " 'V3FeO8',\n",
       " 'V3FeO8',\n",
       " 'V3NiO8',\n",
       " 'V3NiO8',\n",
       " 'V3SnO8',\n",
       " 'V3ZnO8']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vanadates = mpr.query('*V3O8', ['material_id', 'structure', 'pretty_formula'])\n",
    "[v['pretty_formula'] for v in vanadates]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'elasticity.homogeneous_poisson': -0.04,\n",
       "  'material_id': 'mp-766784',\n",
       "  'pretty_formula': 'V3CoO8'},\n",
       " {'elasticity.homogeneous_poisson': None,\n",
       "  'material_id': 'mp-771790',\n",
       "  'pretty_formula': 'V3NiO8'},\n",
       " {'elasticity.homogeneous_poisson': -0.06,\n",
       "  'material_id': 'mp-775001',\n",
       "  'pretty_formula': 'V3FeO8'},\n",
       " {'elasticity.homogeneous_poisson': 0.08,\n",
       "  'material_id': 'mp-776985',\n",
       "  'pretty_formula': 'MnV3O8'}]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matches = []\n",
    "for v in vanadates:\n",
    "    if comparison_engine.fit(ac_structure, v['structure']):\n",
    "        matches.append(v['material_id'])\n",
    "\n",
    "\n",
    "criteria = {\"material_id\":{\"$in\":matches}}\n",
    "properties = ['material_id', 'pretty_formula', 'elasticity.homogeneous_poisson']\n",
    "\n",
    "possible_candidates = mpr.query(criteria, properties)\n",
    "    \n",
    "possible_candidates"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}