From 1f2d998d694ea4f36026be2be31e636401214c44 Mon Sep 17 00:00:00 2001 From: Suzy Date: Tue, 23 Oct 2018 11:33:07 +0100 Subject: [PATCH] Merging dE_calc_stencil_test with ElectrostaticsChecks branch --- analysis-notebooks/2D_antisite_maps.ipynb | 621 ++++++++++++++++++++++ 1 file changed, 621 insertions(+) create mode 100644 analysis-notebooks/2D_antisite_maps.ipynb diff --git a/analysis-notebooks/2D_antisite_maps.ipynb b/analysis-notebooks/2D_antisite_maps.ipynb new file mode 100644 index 0000000..2a53328 --- /dev/null +++ b/analysis-notebooks/2D_antisite_maps.ipynb @@ -0,0 +1,621 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Script to plot location of Cu-on-Zn or Zn-on-Cu antisites\n", + "Plot adapted from script to generate 3D scatter plot to 2D Cu-Zn layers.\n", + "\n", + "First 3 scripts generate files containing coordinates of antisites (make sure to have a directory called 'antisite_data' for these to be stored in and that gulp input files are in a directory called 'GULP_inputs').\n", + "\n", + "The script below then sorts these files according to z values and allows the user to generate 2D scatter plots of antisite locations for particular z-values." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Horrendous old script to modify (or just use to generate .txt files for antisite locations for 3D data for each T and post-process after?)\n", + "\n", + "Need to add T range and system dimensions to top of script and run all 3 cells." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "mkdir: antisite_data: File exists\n" + ] + } + ], + "source": [ + "%%bash\n", + "mkdir antisite_data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "############################## USER INPUTS #########################################\n", + "\n", + "# Name of gulp input files (not including temperature - check outputs for format in latest version of code)\n", + "filename_start = \"T_\"\n", + "filename_end = \"_gulp_final_lattice.in\"\n", + "# Temperature range and step size from Eris simulation\n", + "TMIN = 0\n", + "TMAX = 1000\n", + "TSTEP = 50\n", + "# Enter dimensions of lattice\n", + "X_dim = 32\n", + "Y_dim = 32\n", + "Z_dim = 32" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['T_0000_gulp_final_lattice.in', 'T_0050_gulp_final_lattice.in', 'T_0100_gulp_final_lattice.in', 'T_0150_gulp_final_lattice.in', 'T_0200_gulp_final_lattice.in', 'T_0250_gulp_final_lattice.in', 'T_0300_gulp_final_lattice.in', 'T_0350_gulp_final_lattice.in', 'T_0400_gulp_final_lattice.in', 'T_0450_gulp_final_lattice.in', 'T_0500_gulp_final_lattice.in', 'T_0550_gulp_final_lattice.in', 'T_0600_gulp_final_lattice.in', 'T_0650_gulp_final_lattice.in', 'T_0700_gulp_final_lattice.in', 'T_0750_gulp_final_lattice.in', 'T_0800_gulp_final_lattice.in', 'T_0850_gulp_final_lattice.in', 'T_0900_gulp_final_lattice.in', 'T_0950_gulp_final_lattice.in', 'T_1000_gulp_final_lattice.in']\n" + ] + } + ], + "source": [ + "# Generating list containing input and output filenames for lattice configurations at each simulation T\n", + "input_files=[]\n", + "#Q_param_files=[]\n", + "#site_occ_files=[]\n", + "Cu_on_Zn_files=[]\n", + "Zn_on_Cu_files=[]\n", + "Sn_on_Cu_files=[]\n", + "Sn_on_Zn_files=[]\n", + "Cu_on_Sn_files=[]\n", + "Zn_on_Sn_files=[]\n", + "#disorder_sites_files=[]\n", + "error_files=[]\n", + "order_files=[]\n", + "for T in range (TMIN, TMAX+TSTEP, TSTEP):\n", + " T_formatted= str(T).zfill(4)\n", + " input_files.append(str(filename_start)+str(T_formatted)+str(filename_end))\n", + "# Q_param_files.append(\"Q_data/Q_parameter_T_\"+str(T_formatted)+\".txt\")\n", + "# site_occ_files.append(\"Q_data/site_occupancies_T_\"+str(T_formatted)+\".txt\")\n", + " Cu_on_Zn_files.append(\"antisite_data/Cu_on_Zn_coords_T_\"+str(T_formatted)+\".txt\")\n", + " Zn_on_Cu_files.append(\"antisite_data/Zn_on_Cu_coords_T_\"+str(T_formatted)+\".txt\")\n", + " Sn_on_Cu_files.append(\"antisite_data/Sn_on_Cu_coords_T_\"+str(T_formatted)+\".txt\")\n", + " Sn_on_Zn_files.append(\"antisite_data/Sn_on_Zn_coords_T_\"+str(T_formatted)+\".txt\")\n", + " Cu_on_Sn_files.append(\"antisite_data/Cu_on_Sn_coords_T_\"+str(T_formatted)+\".txt\")\n", + " Zn_on_Sn_files.append(\"antisite_data/Zn_on_Sn_coords_T_\"+str(T_formatted)+\".txt\")\n", + "# disorder_sites_files.append(\"Q_data/disordered_sites_T_\"+str(T_formatted)+\".txt\")\n", + " error_files.append(\"antisite_data/error_log_T_\"+str(T_formatted)+\".txt\")\n", + " order_files.append(\"antisite_data/order_log_T_\"+str(T_formatted)+\".txt\")\n", + "\n", + "print(input_files)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "### Generating antisite location files\n", + "\n", + "import sys\n", + "import numpy as np\n", + "import math\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from matplotlib.ticker import FormatStrFormatter\n", + "from IPython.core.pylabtools import figsize\n", + "#figsize(10, 10)\n", + "\n", + "# Defining temperature list from user input and initialising empty list to write Q as a function of T to\n", + "T = np.arange(TMIN, TMAX+TSTEP, TSTEP)\n", + "#Q_vs_T =[]\n", + "\n", + "# Defining row number where cation coords start and end based on supercell dimensions\n", + "cation_coord_start = 9+8*(X_dim//2)*(Y_dim//2)*(Z_dim//4) # Skipping over S ions (9 lines of text, 8 S ions per 2x2x4 unit)\n", + "cation_coord_end = cation_coord_start+(X_dim*Y_dim*Z_dim)//2 # half of initial lattice contained gap sites which are not written to gulp input file\n", + "\n", + "# Halving Z lattice dimension because half of initial lattice sites are empty, which are not written to the gulp input (see lattice initialisation method2 in eris-lattice.c)\n", + "Z=Z_dim//2 # /2 because gap sites from lattice[x][y][z] not written to gulp input\n", + "X=X_dim\n", + "Y=Y_dim\n", + "\n", + "# Reading in data files and calculating Q for each T\n", + "for i in range (0, len(T)):\n", + " \n", + "# print(\"Calculating Q for T = \"+str(T[i])+\" K lattice configuration\")\n", + " \n", + " # Reading in gulp input file and storing as a matrix where data[row from zero][col from zero]\n", + " data = pd.read_csv(input_files[i], names =[\"species\", \"core\", \"x\", \"y\", \"z\", \"charge\"], delimiter=\" \").as_matrix()\n", + " # Initialising empty lists for occupancy of 2a, 2b, 2c and 2d sites + a list containing coordinates (full gulp input row) for disordered sites\n", + "# a=[]\n", + "# b=[]\n", + "# c=[]\n", + "# d=[]\n", + " disordered=[]\n", + " order_log=[]\n", + " error_log=[]\n", + "# Cu_2c=0\n", + "# Zn_2d=0\n", + "# Cu_2d=0\n", + "# Zn_2c=0\n", + "\n", + "# x,y,z coords for all cation antisites\n", + " Cu_on_Zn_x=[]\n", + " Cu_on_Zn_y=[]\n", + " Cu_on_Zn_z=[]\n", + " Zn_on_Cu_x=[]\n", + " Zn_on_Cu_y=[]\n", + " Zn_on_Cu_z=[]\n", + " Sn_on_Zn_x=[]\n", + " Sn_on_Zn_y=[]\n", + " Sn_on_Zn_z=[]\n", + " Sn_on_Cu_x=[]\n", + " Sn_on_Cu_y=[]\n", + " Sn_on_Cu_z=[]\n", + " Cu_on_Sn_x=[]\n", + " Cu_on_Sn_y=[]\n", + " Cu_on_Sn_z=[]\n", + " Zn_on_Sn_x=[]\n", + " Zn_on_Sn_y=[]\n", + " Zn_on_Sn_z=[]\n", + " \n", + " # Opening files to write to\n", + "# Q_param_file=open(Q_param_files[i],'w')\n", + "# occupancies_file=open(site_occ_files[i],'w')\n", + " Cu_on_Zn_coords=open(Cu_on_Zn_files[i],'w')\n", + " Zn_on_Cu_coords=open(Zn_on_Cu_files[i],'w')\n", + " Sn_on_Cu_coords=open(Sn_on_Cu_files[i],'w')\n", + " Sn_on_Zn_coords=open(Sn_on_Zn_files[i],'w')\n", + " Cu_on_Sn_coords=open(Cu_on_Zn_files[i],'w')\n", + " Zn_on_Sn_coords=open(Zn_on_Sn_files[i],'w')\n", + "# disorder_file=open(disorder_sites_files[i], 'w')\n", + " error_log_file=open(error_files[i], 'w')\n", + " order_log_file=open(order_files[i], 'w')\n", + " \n", + " # ----- Begin calculation of Q parameter -------------------------------------\n", + " # Initialising number of rows contained within each x-loop iteration\n", + " x_block=0\n", + "\n", + " for x in range(0, X):\n", + " for y in range(0, Y):\n", + " # --------------------- even x,y -----------------------------------------------\n", + " if ( math.fmod(x, 2) == 0 and math.fmod(y, 2) == 0 ):\n", + " # Looping over list of z (repeats every 2 species)\n", + " for z in range(cation_coord_start, Z+cation_coord_start, 2):\n", + " \n", + " # Writing species to 2b site file\n", + " # b.append(data[z + (y*Z) + x_block][0])\n", + " # Checking if first of two repeating species for even x, even y list is correct\n", + " if data[z + (y*Z) + x_block][0] == \"Sn\": ### 2b site\n", + " order_log.append(\"yes! - Sn is Sn\")\n", + " else: \n", + " error_log.append(\"uh oh! Sn error! -- \"+str(data[z + (y*Z) + x_block][0]))\n", + " print(\"Looks like there's some Sn disorder! Has Sn been unfrozen?\")\n", + " disordered.append(str(data[z + (y*Z) + x_block][:]))\n", + " if data[z + (y*Z) + x_block][0] == \"Cu\":\n", + " Cu_on_Sn_x.append(data[z + (y*Z) + x_block][2])\n", + " Cu_on_Sn_y.append(data[z + (y*Z) + x_block][3])\n", + " Cu_on_Sn_z.append(data[z + (y*Z) + x_block][4])\n", + " if data[z + (y*Z) + x_block][0] == \"Zn\":\n", + " Zn_on_Sn_x.append(data[z + (y*Z) + x_block][2])\n", + " Zn_on_Sn_y.append(data[z + (y*Z) + x_block][3])\n", + " Zn_on_Sn_z.append(data[z + (y*Z) + x_block][4])\n", + " \n", + " # Writing species to 2a site file\n", + "# a.append(data[z+1 + (y*Z) + x_block][0])\n", + " # Checking if second of two repeating species for even x, even y list is correct\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Cu\": ### 2a site\n", + " order_log.append(\"yes! - Cu is Cu\")\n", + " else:\n", + " error_log.append(\"uh oh! Cu error! -- \"+str(data[z+1 + (y*Z) + x_block][0]))\n", + " print(\"Cu is not on the 2a site - are you simulating 3D Cu-Zn disorder?\")\n", + " disordered.append(str(data[z+1 + (y*Z) + x_block][:]))\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Zn\":\n", + " Zn_on_Cu_x.append(data[z+1 + (y*Z) + x_block][2])\n", + " Zn_on_Cu_y.append(data[z+1 + (y*Z) + x_block][3])\n", + " Zn_on_Cu_z.append(data[z+1 + (y*Z) + x_block][4])\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Sn\":\n", + " Sn_on_Cu_x.append(data[z+1 + (y*Z) + x_block][2])\n", + " Sn_on_Cu_y.append(data[z+1 + (y*Z) + x_block][3])\n", + " Sn_on_Cu_z.append(data[z+1 + (y*Z) + x_block][4])\n", + " \n", + " # ------------------ even x, odd y --------------------------------------------\n", + " elif ( math.fmod(x, 2) == 0 and math.fmod(y, 2) != 0 ):\n", + " # Loop over list of length Z\n", + " for z in range(cation_coord_start, Z+cation_coord_start, 2):\n", + " \n", + " # Writing species to 2d site file\n", + "# d.append(data[z + (y*Z) + x_block][0])\n", + " if data[z + (y*Z) + x_block][0] == \"Zn\": ### 2d site\n", + " order_log.append(\"yes! - Zn is Zn!\")\n", + "# Zn_2d += 1\n", + " else:\n", + "# error_log.append(\"uh oh! Zn error! -- \"+str(data[z + (y*Z) + x_block][0]))\n", + " disordered.append(str(data[z + (y*Z) + x_block][:]))\n", + " if data[z + (y*Z) + x_block][0] == \"Cu\":\n", + " Cu_on_Zn_x.append(data[z + (y*Z) + x_block][2])\n", + " Cu_on_Zn_y.append(data[z + (y*Z) + x_block][3])\n", + " Cu_on_Zn_z.append(data[z + (y*Z) + x_block][4])\n", + " if data[z + (y*Z) + x_block][0] == \"Sn\":\n", + " Sn_on_Zn_x.append(data[z + (y*Z) + x_block][2])\n", + " Sn_on_Zn_y.append(data[z + (y*Z) + x_block][3])\n", + " Sn_on_Zn_z.append(data[z + (y*Z) + x_block][4])\n", + "\n", + " # Writing species to 2c site file\n", + " # c.append(data[z+1 + (y*Z) + x_block][0])\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Cu\": ### 2c site\n", + " order_log.append(\"yes! - Cu is Cu again\")\n", + " # Cu_2c += 1\n", + " else:\n", + " # error_log.append(\"uh oh! error for 2c Cu -- \"+str(data[z+1 + (y*Z) + x_block][0]))\n", + " disordered.append(str(data[z+1 + (y*Z) + x_block][:]))\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Zn\":\n", + " # Zn_2c += 1\n", + " Zn_on_Cu_x.append(data[z+1 + (y*Z) + x_block][2])\n", + " Zn_on_Cu_y.append(data[z+1 + (y*Z) + x_block][3])\n", + " Zn_on_Cu_z.append(data[z+1 + (y*Z) + x_block][4])\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Sn\":\n", + " Sn_on_Cu_x.append(data[z+1 + (y*Z) + x_block][2])\n", + " Sn_on_Cu_y.append(data[z+1 + (y*Z) + x_block][3])\n", + " Sn_on_Cu_z.append(data[z+1 + (y*Z) + x_block][4])\n", + "\n", + " # --------------------- odd x,even y -----------------------------------------------\n", + " if ( math.fmod(x, 2) != 0 and math.fmod(y, 2) == 0 ):\n", + " \n", + " # Looping over list of z (repeats every 2 species)\n", + " for z in range(cation_coord_start, Z+cation_coord_start, 2):\n", + " \n", + " # Writing species to 2c site file\n", + " # c.append(data[z + (y*Z) + x_block][0])\n", + " # Checking if first of two repeating species for even x, even y list is correct\n", + " if data[z + (y*Z) + x_block][0] == \"Cu\": ### 2c site\n", + " order_log.append(\"yes! - Cu is Cu again\")\n", + " # Cu_2c += 1\n", + " else:\n", + " error_log.append(\"Cu 2c disorder (okay if this is Zn) -- \"+str(data[z + (y*Z) + x_block][0]))\n", + " disordered.append(str(data[z + (y*Z) + x_block][:]))\n", + " if data[z + (y*Z) + x_block][0] == \"Zn\":\n", + " # Zn_2c += 1\n", + " Zn_on_Cu_x.append(data[z + (y*Z) + x_block][2])\n", + " Zn_on_Cu_y.append(data[z + (y*Z) + x_block][3])\n", + " Zn_on_Cu_z.append(data[z + (y*Z) + x_block][4])\n", + " if data[z + (y*Z) + x_block][0] == \"Sn\":\n", + " Sn_on_Cu_x.append(data[z + (y*Z) + x_block][2])\n", + " Sn_on_Cu_y.append(data[z + (y*Z) + x_block][3])\n", + " Sn_on_Cu_z.append(data[z + (y*Z) + x_block][4])\n", + " \n", + " # Writing species to 2d site file\n", + " # d.append(data[z+1 + (y*Z) + x_block][0]) \n", + " # Checking if second of two repeating species for even x, even y list is correct\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Zn\": ### 2d site\n", + " order_log.append(\"yes! - Zn is Zn\")\n", + " # Zn_2d += 1\n", + " else:\n", + " error_log.append(\"Zn disorder (okay if this is Cu) -- \"+str(data[z+1 + (y*Z) + x_block][0]))\n", + " disordered.append(str(data[z+1 + (y*Z) + x_block][:]))\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Cu\":\n", + "# Cu_2d += 1 \n", + " Cu_on_Zn_x.append(data[z+1 + (y*Z) + x_block][2])\n", + " Cu_on_Zn_y.append(data[z+1 + (y*Z) + x_block][3])\n", + " Cu_on_Zn_z.append(data[z+1 + (y*Z) + x_block][4])\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Sn\":\n", + " Sn_on_Zn_x.append(data[z+1 + (y*Z) + x_block][2])\n", + " Sn_on_Zn_y.append(data[z+1 + (y*Z) + x_block][3])\n", + " Sn_on_Zn_z.append(data[z+1 + (y*Z) + x_block][4])\n", + "\n", + " # ------------------ odd x,y -----------------------------------------------------\n", + " elif ( math.fmod(x, 2) != 0 and math.fmod(y, 2) != 0 ):\n", + "\n", + " # Loop over list of length Z\n", + " for z in range(cation_coord_start, Z+cation_coord_start, 2):\n", + " \n", + " # Writing species to 2a site file\n", + " # a.append(data[z + (y*Z) + x_block][0])\n", + " if data[z + (y*Z) + x_block][0] == \"Cu\": ### 2a site\n", + " order_log.append(\"yes! - Cu is Cu!\")\n", + " else:\n", + " error_log.append(\"uh oh! Cu error! -- \"+str(data[z + (y*Z) + x_block][0]))\n", + " print(\"Cu is not on the 2a site - are you simulating 3D Cu-Zn disorder?\")\n", + " disordered.append(str(data[z + (y*Z) + x_block][:]))\n", + " if data[z + (y*Z) + x_block][0] == \"Zn\":\n", + " Zn_on_Cu_x.append(data[z + (y*Z) + x_block][2])\n", + " Zn_on_Cu_y.append(data[z + (y*Z) + x_block][3])\n", + " Zn_on_Cu_z.append(data[z + (y*Z) + x_block][4])\n", + " if data[z + (y*Z) + x_block][0] == \"Sn\":\n", + " Sn_on_Cu_x.append(data[z + (y*Z) + x_block][2])\n", + " Sn_on_Cu_y.append(data[z + (y*Z) + x_block][3])\n", + " Sn_on_Cu_z.append(data[z + (y*Z) + x_block][4])\n", + "\n", + " # Writing species to 2b site file\n", + " # b.append(data[z+1 + (y*Z) + x_block][0])\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Sn\": ### 2b site\n", + " order_log.append(\"yes! - Sn is Sn\")\n", + " else:\n", + " error_log.append(\"uh oh! error for Sn -- \"+str(data[z+1 + (y*Z) + x_block][0]))\n", + " print(\"Looks like there's some Sn disorder! Has Sn been unfrozen?\")\n", + " disordered.append(str(data[z+1 + (y*Z) + x_block][:]))\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Cu\":\n", + " Cu_on_Sn_x.append(data[z+1 + (y*Z) + x_block][2])\n", + " Cu_on_Sn_y.append(data[z+1 + (y*Z) + x_block][3])\n", + " Cu_on_Sn_z.append(data[z+1 + (y*Z) + x_block][4])\n", + " if data[z+1 + (y*Z) + x_block][0] == \"Zn\":\n", + " Zn_on_Sn_x.append(data[z+1 + (y*Z) + x_block][2])\n", + " Zn_on_Sn_y.append(data[z+1 + (y*Z) + x_block][3])\n", + " Zn_on_Sn_z.append(data[z+1 + (y*Z) + x_block][4])\n", + "\n", + " # --------------------------------------------------------------------------------\n", + "\n", + " # Updating number of rows already checked from previous x-loop iteration\n", + " x_block += Y*Z\n", + "\n", + "\n", + " # ------------------------------------------------------------------------------------\n", + " # Writing lists to output files\n", + "\n", + " for j in order_log:\n", + " order_log_file.write(j+'\\n')\n", + " for j in error_log:\n", + " error_log_file.write(j+'\\n') \n", + "\n", + "# df = pd.DataFrame({'# 2a' : a, '2b' : b, '2c' : c, '2d' : d})\n", + "# df.to_csv(occupancies_file, sep='\\t')\n", + " \n", + " # Writing antisite coordinates to separate files (Cu-Zn disorder)\n", + " df = pd.DataFrame({'# x' : Cu_on_Zn_x, 'y' : Cu_on_Zn_y, 'z' : Cu_on_Zn_z})\n", + " df.to_csv(Cu_on_Zn_coords, sep='\\t')\n", + " df = pd.DataFrame({'# x' : Zn_on_Cu_x, 'y' : Zn_on_Cu_y, 'z' : Zn_on_Cu_z})\n", + " df.to_csv(Zn_on_Cu_coords, sep='\\t')\n", + " \n", + " df = pd.DataFrame({'# x' : Cu_on_Sn_x, 'y' : Cu_on_Sn_y, 'z' : Cu_on_Sn_z})\n", + " df.to_csv(Cu_on_Sn_coords, sep='\\t')\n", + " df = pd.DataFrame({'# x' : Zn_on_Sn_x, 'y' : Zn_on_Sn_y, 'z' : Zn_on_Sn_z})\n", + " df.to_csv(Zn_on_Sn_coords, sep='\\t')\n", + " df = pd.DataFrame({'# x' : Sn_on_Zn_x, 'y' : Sn_on_Zn_y, 'z' : Sn_on_Zn_z})\n", + " df.to_csv(Sn_on_Zn_coords, sep='\\t')\n", + " df = pd.DataFrame({'# x' : Sn_on_Cu_x, 'y' : Sn_on_Cu_y, 'z' : Sn_on_Cu_z})\n", + " df.to_csv(Sn_on_Cu_coords, sep='\\t')\n", + " \n", + " \n", + " \n", + "# for i in disordered:\n", + "# disorder_file.write(i+'\\n')\n", + "\n", + " # Calculating Q parameter\n", + "# Q = float( (Cu_2c + Zn_2d) - (Zn_2c + Cu_2d) ) / ( (Cu_2c + Zn_2d) + (Zn_2c + Cu_2d) )\n", + "\n", + "# Q_param_file.write('# Q ='+str(Q)+'\\n')\n", + "# Q_param_file.write('# Where Q = [ (Cu-on-2c + Zn-on-2d) - (Zn-on-2c + Cu-on-2d) ] / [ (Cu-on-2c + Zn-on-2d) + (Zn-on-2c + Cu-on-2d) ]'+'\\n')\n", + "# Q_param_file.write('# Q=1 corresponds to perfect order, Q=0 is complete disorder where Cu and Zn (within the Cu-Zn plane only) show no preference for their correct crystallographic site'+'\\n')\n", + "# Q_param_file.write('# Where Cu is on the 2c site and Zn on the 2d site in ordered CZTS'+'\\n')\n", + "# Q_param_file.write('# Cu_2c Zn_2d Cu_2d Zn_2c'+'\\n') \n", + "# Q_param_file.write(str(Cu_2c)+' '+str(Zn_2d)+' '+str(Cu_2d)+' '+str(Zn_2c))\n", + "\n", + " order_log_file.close()\n", + " error_log_file.close()\n", + "# disorder_file.close()\n", + "# occupancies_file.close()\n", + "# Q_param_file.close()\n", + " Cu_on_Zn_coords.close()\n", + " Zn_on_Cu_coords.close()\n", + " Cu_on_Sn_coords.close()\n", + " Zn_on_Sn_coords.close()\n", + " Sn_on_Zn_coords.close()\n", + " Sn_on_Cu_coords.close()\n", + " \n", + "\n", + " ### Old way of plotting scatter plot\n", + " \n", + " # Writing Q to file to plot in ipython notebook\n", + " # Q_vs_T.append(Q)\n", + "\n", + "# if T[i] == 600:\n", + " \n", + " ### Generating 3D scatter plots of antisite locations for given T\n", + "# fig = plt.figure()\n", + " # ax = fig.add_subplot(111, projection='3d'))\n", + "# ax = fig.add_subplot(111)\n", + " \n", + " # print(Cu_on_Zn_y)\n", + "\n", + "# ax.scatter(Cu_on_Zn_x, Cu_on_Zn_y, c='r', marker='o', label=\"Cu-on-Zn defects\")\n", + "# ax.scatter(Zn_on_Cu_x, Zn_on_Cu_y, c='b', marker='^', label=\"Zn-on-Cu defects\")\n", + "\n", + " \n", + "# ax.set_xlabel('x (lattice units)')\n", + "# ax.set_ylabel('y (lattice units)')\n", + "#\n", + "# plt.xlim(0,35)\n", + " # plt.ylim(0,96)\n", + " # plt.zlim(0,96)\n", + " # ax.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))\n", + "# plt.legend()\n", + " # plt.savefig('3D_scatter_test.png')\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate 2D antisite location scatter plots for specific z-slices" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z-slices with Cu-Zn antisites are: [3, 7, 11, 15, 19, 23, 27, 31]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# New way of plotting scatter plot using antisite_data .txt files and plotting just for set z-value\n", + "\n", + "figsize(10, 10)\n", + "\n", + "### USER INPUTS #################################################\n", + "# Choose T and slice number to plot for\n", + "temp = 700\n", + "z_slice_plot = 15 # Ensure this is an odd number for Cu-Zn planes and less than max z-lattice dim\n", + "################################################################\n", + "\n", + "temp_formatted= str(temp).zfill(4)\n", + "\n", + "Cu_on_Zn_coord_file = pd.read_csv(\"antisite_data/Cu_on_Zn_coords_T_\"+str(temp_formatted)+\".txt\", skiprows=1, delimiter='\\t').as_matrix()\n", + "Zn_on_Cu_coord_file = pd.read_csv(\"antisite_data/Zn_on_Cu_coords_T_\"+str(temp_formatted)+\".txt\", skiprows=1, delimiter='\\t').as_matrix()\n", + "df = pd.DataFrame(Cu_on_Zn_coord_file)\n", + "df2 = pd.DataFrame(Zn_on_Cu_coord_file)\n", + "antisite_slices = []\n", + "\n", + "# In dataframe, col1 =x, col2 =y, col3 = z (0 is line number unfortunately!)\n", + "# Order is [columns][rows]\n", + "# Sort by z-coordinate\n", + "df_sorted = df.sort_values(by=[3]).reset_index(drop=True) # Cu-on-Zn z-coord sorted antisite locations\n", + "#print(df_sorted)\n", + "df2_sorted = df2.sort_values(by=[3]).reset_index(drop=True) # Zn-on-Cu z-coord sorted antisite locations\n", + "\n", + "# Getting coords for Cu-on-Zn antisites for simulation T and z_slice requested by user\n", + "# Initialise empty lists for slice coords\n", + "Cu_on_Zn_slice_x = []\n", + "Cu_on_Zn_slice_y = []\n", + "# Initialise z values to compare against in loop\n", + "z_val = df_sorted[3][0]\n", + "z_slice = int(round(z_val/2.72)) # Slice number is z-coord divide by lattice dim\n", + "if (z_slice_plot < z_slice): # Ensure user entered slice with antisites\n", + " print(\"Sorry, no Cu-on-Zn antisites in that slice, first slice number with Cu-Zn antisites is \"+str(z_slice))\n", + " \n", + "else: \n", + " for i in range(0,len(df_sorted)):\n", + " # Looping through sorted file and checking for when z-coordinate increases\n", + " z_val_new = df_sorted[3][i]\n", + " if int(z_val_new) != int(z_val):\n", + " z_val = z_val_new\n", + " z_slice = int(round(z_val/2.72))\n", + " # Writing coordinates of antisites if in slice of interest\n", + " if z_slice == z_slice_plot:\n", + " Cu_on_Zn_slice_x.append(df_sorted[1][i])\n", + " Cu_on_Zn_slice_y.append(df_sorted[2][i])\n", + " \n", + "# Getting coords for Zn-on-Cu antisites for simulation T and z_slice requested by user\n", + "# Initialise empty lists for slice coords\n", + "Zn_on_Cu_slice_x = []\n", + "Zn_on_Cu_slice_y = []\n", + "# Initialise z values to compare against in loop\n", + "z_val = df2_sorted[3][0]\n", + "z_slice = int(round(z_val/2.72))\n", + "antisite_slices.append(z_slice)\n", + "if (z_slice_plot < z_slice): # Ensure user entered slice with antisites\n", + " print(\"Sorry, no Zn-on-Cu antisites in that slice, first slice number with Cu-Zn antisites is \"+str(z_slice))\n", + " \n", + "else: \n", + " for i in range(0,len(df_sorted)):\n", + " # Looping through sorted file and checking for when z-coordinate increases\n", + " z_val_new = df2_sorted[3][i]\n", + " if int(z_val_new) != int(z_val):\n", + " z_val = z_val_new\n", + " z_slice = int(round(z_val/2.72))\n", + " antisite_slices.append(z_slice)\n", + " # Writing coordinates of antisites if in slice of interest\n", + " if z_slice == z_slice_plot:\n", + " Zn_on_Cu_slice_x.append(df2_sorted[1][i])\n", + " Zn_on_Cu_slice_y.append(df2_sorted[2][i])\n", + " \n", + " print(\"z-slices with Cu-Zn antisites are: \"+str(antisite_slices))\n", + " \n", + " plt.scatter(Cu_on_Zn_slice_x, Cu_on_Zn_slice_y, c='r', marker='o', label=\"Cu-on-Zn defects in slice z=\"+str(z_slice_plot))\n", + " plt.scatter(Zn_on_Cu_slice_x, Zn_on_Cu_slice_y, c='b', marker='^', label=\"Zn-on-Cu defects in slice z=\"+str(z_slice_plot))\n", + "\n", + " plt.xlabel(\"X lattice dimension ($\\AA$)\")\n", + " plt.ylabel(\"Y lattice dimension ($\\AA$)\")\n", + " plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.1), fancybox=True, shadow=True, ncol=5)\n", + " plt.title(\"Temperature = \"+str(temp)+\"K, slice = \"+str(z_slice_plot))\n", + " plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}