08gafccalloys.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Genetic algorithm Search for stable FCC alloys\n",
    "https://wiki.fysik.dtu.dk/ase/tutorials/ga/ga_fcc_alloys.html\n",
    "\n",
    "In this tutorial we will emulate an older paper and determine the most stable FCC alloy using the genetic algorithm. Since the purpose is only the tutorial we will limit the phase space to the elements supported by the EMT potential."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic outline of the search\n",
    "\n",
    "* Choose the phase space of your problem. Is the number of possible individuals large enough to prevent a full screening and is the fitness function too discontinuous for a traditional optimization by derivation? If so continue.\n",
    "* Choose model structures and calculate references in those structures. Put the results somewhere accesible for a script initiated by the genetic algorithm.\n",
    "* Choose suitable parameters like population size (general rule of thumb for the population size: $\\log_2(N)$ < pop size < $2\\log_2(N)$, where $N$ is the size of the phase space), convergence criteria etc.\n",
    "* Create the initial population.\n",
    "* Choose procreation operators, i.e. how should offspring be produced. New operators can easily be created by modifying the existing operators.\n",
    "* Run the algorithm.\n",
    "Here we would like to predict the most stable fcc alloys. In this tutorial we only have the `ase.calculators.emt` available thus we are limited to the supported metal elements: Al, Ni, Cu, Pd, Ag, Pt and Au. We limit ourselves to at most 4 different metals in one structure, thereby having only $7^4=2401$ candidates in the phase space, symmetry would make this number even lower but the number is fitting for this tutorial.\n",
    "\n",
    "For a real application of the algorithm it is necessary to use a more sophisticated calculator, in that case each individual calculation is performed on a cluster by submitting to a queuing system. How this is achieved in the algorithm is covered in Optimization with a Genetic Algorithm.\n",
    "\n",
    "defined for an alloy $ABC_2$: A + B + 2C -> $ABC_2$ as: $\\Delta Hf=E_{ABC_2}-E_A-E_B-2E_C$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up reference database\n",
    "\n",
    "Now we need to set up a database in which reference calculations can be stored. This can either be in a central database server where keywords distinguish between different references or dedicated separate databases for each different type of reference calculations.\n",
    "\n",
    "In the following script, ga_fcc_references.py, we put the references in the database file refs.db. Our model structure is fcc which is loaded with `ase.lattice.cubic.FaceCenteredCubic()`. We perform a volume relaxation to find the optimal lattice constant and lowest energy, which we save in the database as key-value pairs for quick retrieval."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ase.lattice.cubic import FaceCenteredCubic\n",
    "from ase.calculators.emt import EMT\n",
    "from ase.eos import EquationOfState\n",
    "from ase.db import connect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "db = connect('refs.db')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "metals = ['Al', 'Au', 'Cu', 'Ag', 'Pd', 'Pt', 'Ni']\n",
    "for m in metals:\n",
    "    atoms = FaceCenteredCubic(m)\n",
    "    atoms.set_calculator(EMT())\n",
    "    e0 = atoms.get_potential_energy()\n",
    "    a = atoms.cell[0][0]\n",
    "\n",
    "    eps = 0.05\n",
    "    volumes = (a * np.linspace(1 - eps, 1 + eps, 9))**3\n",
    "    energies = []\n",
    "    for v in volumes:\n",
    "        atoms.set_cell([v**(1. / 3)] * 3, scale_atoms=True)\n",
    "        energies.append(atoms.get_potential_energy())\n",
    "\n",
    "    eos = EquationOfState(volumes, energies)\n",
    "    v1, e1, B = eos.fit()\n",
    "\n",
    "    atoms.set_cell([v1**(1. / 3)] * 3, scale_atoms=True)\n",
    "    ef = atoms.get_potential_energy()\n",
    "\n",
    "    db.write(atoms, metal=m,\n",
    "             latticeconstant=v1**(1. / 3),\n",
    "             energy_per_atom=ef / len(atoms))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initial population\n",
    "\n",
    "We choose a population size of 10 individuals and create the initial population by randomly selecting four elements for each starting individual."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ase import Atoms\n",
    "from ase.ga.data import PrepareDB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "metals = ['Al', 'Au', 'Cu', 'Ag', 'Pd', 'Pt', 'Ni']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "population_size = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "db = PrepareDB('fcc_alloys.db',\n",
    "               population_size=population_size,\n",
    "               metals=metals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create starting population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(population_size):\n",
    "    atoms_string = [random.choice(metals) for _ in range(4)]\n",
    "    db.add_unrelaxed_candidate(Atoms(atoms_string),\n",
    "                               atoms_string=''.join(atoms_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we add the population size and metals as extra key-value pairs when we create the database fcc_alloys.db. We can then retrieve these parameters later when running the main script to avoid having to input the same parameters twice.\n",
    "\n",
    "We can study our initial population by doing (on the command-line):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id|age|user  |formula |pbc|charge|   mass|atoms_string\r\n",
      " 1| 2s|jovyan|        |FFF| 0.000|  0.000|            \r\n",
      " 2| 2s|jovyan|AgAlNiPt|FFF| 0.000|388.627|NiAlPtAg    \r\n",
      " 3| 2s|jovyan|AgAlPdPt|FFF| 0.000|436.354|AlPtAgPd    \r\n",
      " 4| 2s|jovyan|CuNiPd2 |FFF| 0.000|335.079|NiCuPdPd    \r\n",
      " 5| 2s|jovyan|AgAu3   |FFF| 0.000|698.768|AgAuAuAu    \r\n",
      " 6| 2s|jovyan|Al2AuPt |FFF| 0.000|446.014|AlAuAlPt    \r\n",
      " 7| 2s|jovyan|AgAlCuPt|FFF| 0.000|393.480|CuPtAlAg    \r\n",
      " 8| 2s|jovyan|Al2CuPt |FFF| 0.000|312.593|CuAlAlPt    \r\n",
      " 9| 2s|jovyan|AgCu2Pt |FFF| 0.000|430.044|PtAgCuCu    \r\n",
      "10| 1s|jovyan|AgAuCuPd|FFF| 0.000|474.801|AgCuPdAu    \r\n",
      "11| 1s|jovyan|Ag2AlPt |FFF| 0.000|437.802|AgAgPtAl    \r\n",
      "Rows: 11\r\n",
      "Keys: atoms_string, extinct, gaid, generation, origin, relaxed, simulation_cell\r\n"
     ]
    }
   ],
   "source": [
    "! ase db fcc_alloys.db -c +atoms_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the term `atoms_string` determines the order in which the elements are put into the model structure. So it is possible to fully describe an individual by just providing the `atoms_string`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run the algorithm\n",
    "The following script runs the algorithm, also find it here: `ga_fcc_alloys_main.py`. Note that the relaxation script is imported from an external file `ga_fcc_alloys_relax.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ase.lattice.cubic import FaceCenteredCubic\n",
    "from ase.calculators.emt import EMT\n",
    "from ase.eos import EquationOfState\n",
    "from ase.db import connect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relax(input_atoms, ref_db):\n",
    "    atoms_string = input_atoms.get_chemical_symbols()\n",
    "\n",
    "    # Open connection to the database with reference data\n",
    "    db = connect(ref_db)\n",
    "\n",
    "    # Load our model structure which is just FCC\n",
    "    atoms = FaceCenteredCubic('X', latticeconstant=1.)\n",
    "    atoms.set_chemical_symbols(atoms_string)\n",
    "\n",
    "    # Compute the average lattice constant of the metals in this individual\n",
    "    # and the sum of energies of the constituent metals in the fcc lattice\n",
    "    # we will need this for calculating the heat of formation\n",
    "    a = 0\n",
    "    ei = 0\n",
    "    for m in set(atoms_string):\n",
    "        dct = db.get(metal=m)\n",
    "        count = atoms_string.count(m)\n",
    "        a += count * dct.latticeconstant\n",
    "        ei += count * dct.energy_per_atom\n",
    "    a /= len(atoms_string)\n",
    "    atoms.set_cell([a, a, a], scale_atoms=True)\n",
    "\n",
    "    # Since calculations are extremely fast with EMT we can also do a volume\n",
    "    # relaxation\n",
    "    atoms.set_calculator(EMT())\n",
    "    eps = 0.05\n",
    "    volumes = (a * np.linspace(1 - eps, 1 + eps, 9))**3\n",
    "    energies = []\n",
    "    for v in volumes:\n",
    "        atoms.set_cell([v**(1. / 3)] * 3, scale_atoms=True)\n",
    "        energies.append(atoms.get_potential_energy())\n",
    "\n",
    "    eos = EquationOfState(volumes, energies)\n",
    "    v1, ef, B = eos.fit()\n",
    "    latticeconstant = v1**(1. / 3)\n",
    "\n",
    "    # Calculate the heat of formation by subtracting ef with ei\n",
    "    hof = (ef - ei) / len(atoms)\n",
    "\n",
    "    # Place the calculated parameters in the info dictionary of the\n",
    "    # input_atoms object\n",
    "    input_atoms.info['key_value_pairs']['hof'] = hof\n",
    "    \n",
    "    # Raw score must always be set\n",
    "    # Use one of the following two; they are equivalent\n",
    "    input_atoms.info['key_value_pairs']['raw_score'] = -hof\n",
    "    # set_raw_score(input_atoms, -hof)\n",
    "    \n",
    "    input_atoms.info['key_value_pairs']['latticeconstant'] = latticeconstant\n",
    "\n",
    "    # Setting the atoms_string directly for easier analysis\n",
    "    atoms_string = ''.join(input_atoms.get_chemical_symbols())\n",
    "    input_atoms.info['key_value_pairs']['atoms_string'] = atoms_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ase.ga.data import DataConnection\n",
    "from ase.ga.element_mutations import RandomElementMutation\n",
    "from ase.ga.element_crossovers import OnePointElementCrossover\n",
    "from ase.ga.offspring_creator import OperationSelector\n",
    "from ase.ga.population import Population\n",
    "from ase.ga.convergence import GenerationRepetitionConvergence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specify the number of generations this script will run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_gens = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "db = DataConnection('fcc_alloys.db')\n",
    "ref_db = 'refs.db'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Retrieve saved parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "population_size = db.get_param('population_size')\n",
    "metals = db.get_param('metals')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specify the procreation operators for the algorithm Try and play with the mutation operators that move to nearby places in the periodic table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "oclist = ([1, 1], [RandomElementMutation(metals),\n",
    "                   OnePointElementCrossover(metals)])\n",
    "operation_selector = OperationSelector(*oclist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pass parameters to the population instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "pop = Population(data_connection=db,\n",
    "                 population_size=population_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We form generations in this algorithm run and can therefore set a convergence criteria based on generations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc = GenerationRepetitionConvergence(pop, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Relax the starting population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "while db.get_number_of_unrelaxed_candidates() > 0:\n",
    "    a = db.get_an_unrelaxed_candidate()\n",
    "    relax(a, ref_db)\n",
    "    db.add_relaxed_step(a)\n",
    "pop.update()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ni-Cu-Pt-Pd', 'Pt-Ag-Cu-Cu', 'Ag-Au-Au-Au', 'Al-Au-Au-Au', 'Pt-Ag-Pt-Cu', 'Ni-Cu-Pd-Pd', 'Pt-Ag-Pd-Cu', 'Ag-Cu-Pd-Au', 'Al-Au-Al-Pd', 'Ag-Au-Al-Pt']\n",
      "['Ni-Cu-Pt-Pd', 'Pt-Ag-Cu-Cu', 'Ag-Au-Au-Au', 'Al-Au-Au-Au', 'Pt-Ag-Pt-Cu', 'Ni-Cu-Pd-Pd', 'Pt-Ag-Pd-Cu', 'Ag-Cu-Pt-Pd', 'Ag-Au-Cu-Cu', 'Ag-Cu-Pd-Au']\n",
      "['Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Pt-Ag-Cu-Cu', 'Ag-Au-Au-Au', 'Al-Au-Au-Au', 'Pt-Ag-Pt-Cu', 'Ni-Pd-Pt-Pd', 'Ni-Cu-Pd-Cu', 'Ag-Au-Au-Pd', 'Ni-Cu-Pd-Pd']\n",
      "['Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Pt-Ag-Cu-Cu', 'Ag-Au-Au-Au', 'Al-Au-Au-Au', 'Pt-Ag-Pt-Cu', 'Ni-Pd-Pt-Pd', 'Ni-Cu-Pt-Au', 'Ni-Cu-Pd-Cu', 'Ag-Cu-Au-Au']\n",
      "['Pt-Cu-Pt-Ni', 'Ni-Cu-Pt-Pt', 'Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Ag-Al-Au-Au', 'Pt-Ag-Cu-Cu', 'Ag-Au-Au-Au', 'Al-Au-Au-Au', 'Pt-Ag-Pt-Cu', 'Ni-Pd-Pt-Pd']\n",
      "['Pt-Cu-Pt-Ni', 'Ni-Cu-Pt-Pt', 'Ni-Cu-Pt-Ni', 'Pt-Cu-Pt-Pt', 'Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Ag-Al-Au-Au', 'Pt-Ag-Cu-Cu', 'Ag-Au-Au-Au', 'Al-Au-Au-Au']\n",
      "['Pt-Cu-Pt-Cu', 'Pt-Cu-Pt-Ni', 'Ni-Cu-Pt-Pt', 'Ni-Cu-Pt-Ni', 'Pt-Cu-Pt-Pt', 'Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Ag-Al-Au-Au', 'Pt-Ag-Cu-Cu', 'Ag-Au-Au-Au']\n",
      "['Pt-Cu-Pt-Cu', 'Pt-Cu-Pt-Ni', 'Ni-Cu-Pt-Pt', 'Ni-Cu-Pt-Ni', 'Ni-Cu-Pt-Cu', 'Pt-Cu-Pt-Pt', 'Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Pt-Cu-Au-Cu', 'Ag-Al-Au-Au']\n",
      "['Pt-Cu-Pt-Cu', 'Pt-Cu-Pt-Ni', 'Ni-Cu-Pt-Pt', 'Pt-Ni-Pt-Cu', 'Ni-Cu-Pt-Ni', 'Ni-Cu-Pt-Cu', 'Pt-Cu-Pt-Pt', 'Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Pt-Cu-Au-Cu']\n",
      "['Pt-Cu-Pt-Cu', 'Pt-Cu-Pt-Ni', 'Ni-Cu-Pt-Pt', 'Pt-Ni-Pt-Cu', 'Ni-Cu-Pt-Ni', 'Ni-Cu-Pt-Cu', 'Pt-Cu-Pt-Pt', 'Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Pt-Cu-Au-Cu']\n",
      "['Pt-Cu-Pt-Cu', 'Pt-Cu-Pt-Ni', 'Ni-Cu-Pt-Pt', 'Pt-Ni-Pt-Cu', 'Ni-Cu-Pt-Ni', 'Ni-Cu-Pt-Cu', 'Pt-Cu-Pt-Pt', 'Pt-Cu-Pt-Pd', 'Ni-Cu-Pt-Pd', 'Pt-Cu-Au-Cu']\n",
      "converged\n"
     ]
    }
   ],
   "source": [
    "for _ in range(num_gens):\n",
    "    if cc.converged():\n",
    "        print('converged')\n",
    "        break\n",
    "    for i in range(population_size):\n",
    "        a1, a2 = pop.get_two_candidates(with_history=False)\n",
    "        op = operation_selector.get_operator()\n",
    "        a3, desc = op.get_new_individual([a1, a2])\n",
    "\n",
    "        db.add_unrelaxed_candidate(a3, description=desc)\n",
    "\n",
    "        relax(a3, ref_db)\n",
    "        db.add_relaxed_step(a3)\n",
    "\n",
    "    pop.update()\n",
    "\n",
    "    # Print the current population to monitor the evolution\n",
    "    print(['-'.join(p.get_chemical_symbols()) for p in pop.pop])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this script we run a generational GA as opposed to the pool GA outlined in Optimization with a Genetic Algorithm. This is achieved by having two for-loops; the innermost loop runs the number of times specified by the population size it corresponds to one generation. The outermost loop runs as many generations as specified in `num_gens`. The function `pop.update()` is called after the innermost loop has finished thereby only adding individuals to the population after a whole generation is calculated.\n",
    "\n",
    "After each generation is finished the population is printed to the screen so we can follow the evolution. The calculated individuals are continuously added to `fcc_alloys.db`, we can evaluate them directly by doing from the command line (in another shell instance if the GA is still running):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " id| age|user  |formula |pbc|charge|   mass|atoms_string|raw_score|generation|  hof\r\n",
      " 73|106s|jovyan|AlCuNiPd|FFF| 0.000|255.641|NiCuAlPd    |   -0.139|         3|0.139\r\n",
      " 12|146s|jovyan|AgAlNiPt|FFF| 0.000|388.627|NiAlPtAg    |   -0.112|         0|0.112\r\n",
      "235|  6s|jovyan|AgCuNi2 |FFF| 0.000|288.801|NiCuAgNi    |   -0.105|        11|0.105\r\n",
      "211| 21s|jovyan|AlCuNiPt|FFF| 0.000|344.305|NiCuPtAl    |   -0.098|        10|0.098\r\n",
      "151| 58s|jovyan|AlCuNiPt|FFF| 0.000|344.305|AlCuPtNi    |   -0.098|         7|0.098\r\n",
      "231|  8s|jovyan|AlCuNiPt|FFF| 0.000|344.305|PtCuAlNi    |   -0.098|        11|0.098\r\n",
      "189| 34s|jovyan|AlAu2Ni |FFF| 0.000|479.608|NiAlAuAu    |   -0.093|         9|0.093\r\n",
      " 79|103s|jovyan|AgAlCu2 |FFF| 0.000|261.942|AlAgCuCu    |   -0.079|         3|0.079\r\n",
      " 18|140s|jovyan|Al2CuPt |FFF| 0.000|312.593|CuAlAlPt    |   -0.075|         0|0.075\r\n",
      " 29|132s|jovyan|Au3Ni   |FFF| 0.000|649.593|NiAuAuAu    |   -0.068|         1|0.068\r\n",
      " 93| 95s|jovyan|AgAu2Ni |FFF| 0.000|560.495|AgAuAuNi    |   -0.066|         4|0.066\r\n",
      " 53|118s|jovyan|AgCuNiPd|FFF| 0.000|336.528|NiAgPdCu    |   -0.065|         2|0.065\r\n",
      " 43|123s|jovyan|AgNiPdPt|FFF| 0.000|468.066|NiAgPtPd    |   -0.055|         2|0.055\r\n",
      " 31|130s|jovyan|Au2CuNi |FFF| 0.000|516.173|NiCuAuAu    |   -0.048|         1|0.048\r\n",
      " 65|111s|jovyan|Au2CuNi |FFF| 0.000|516.173|NiCuAuAu    |   -0.048|         3|0.048\r\n",
      "125| 75s|jovyan|Au2CuNi |FFF| 0.000|516.173|NiCuAuAu    |   -0.048|         6|0.048\r\n",
      " 85|100s|jovyan|AuNiPd2 |FFF| 0.000|468.500|NiPdAuPd    |   -0.047|         4|0.047\r\n",
      " 17|141s|jovyan|AgAlCuPt|FFF| 0.000|393.480|CuPtAlAg    |   -0.045|         0|0.045\r\n",
      "195| 30s|jovyan|AlCuPdPt|FFF| 0.000|392.032|AlCuPtPd    |   -0.045|         9|0.045\r\n",
      " 13|145s|jovyan|AgAlPdPt|FFF| 0.000|436.354|AlPtAgPd    |   -0.035|         0|0.035\r\n",
      "Rows: 241 (showing first 20)\r\n",
      "Keys: atoms_string, extinct, gaid, generation, hof, latticeconstant, origin, raw_score, relaxed\r\n"
     ]
    }
   ],
   "source": [
    "! ase db fcc_alloys.db -c +atoms_string,raw_score,generation,hof -s raw_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: When reading the database using `ase db`, it might be necessary to increase the number of shown entries, e.g. `ase db fcc-alloys.db --limit N`, where `N` is the number of entries to show (as default only the first 20 entries are shown, `--limit 0` will show all. For further info use ase `db --help`, or consult the ase db manual)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The relaxation script is naturally similar to the script we used to calculate the references."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the global optimum is $PtNi_3$ with a -0.12 eV heat of formation, whereas the second worst alloy is $AlNi_3$ heat of formation 0.26 eV. This result is in complete contrast to the conclusion obtained in Johannesson, where $AlNi_3$ is the most stable alloy within the phase space chosen here. Obviously there is a limit to the predictive power of EMT!"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}