{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "To toggle on/off output_stderr, click here." ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import HTML\n", "HTML('''\n", "To toggle on/off output_stderr, click here.''')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "imports" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [], "source": [ "#import several packaged that we will need\n", "import sys\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pylab as pl\n", "from copy import deepcopy\n", "from IPython import display\n", "from scipy.integrate import odeint\n", "from scipy.integrate import solve_bvp\n", "from scipy.optimize import curve_fit, fmin\n", "from scipy.interpolate import interp1d\n", "import scipy.constants as const\n", "import matplotlib.pyplot as plt\n", "from scipy.optimize import fsolve\n", "from scipy.signal import argrelextrema\n", "import matplotlib.ticker as mtick\n", "import warnings\n", "\n", "#this is just needed to change the font size in the figures\n", "SMALL_SIZE = 8#12\n", "MEDIUM_SIZE = 8#14\n", "BIGGER_SIZE = 10#16\n", "\n", "plt.rc('font', size=SMALL_SIZE) # controls default text sizes\n", "plt.rc('axes', titlesize=SMALL_SIZE) # fontsize of the axes title\n", "plt.rc('axes', labelsize=MEDIUM_SIZE) # fontsize of the x and y labels\n", "plt.rc('xtick', labelsize=SMALL_SIZE) # fontsize of the tick labels\n", "plt.rc('ytick', labelsize=SMALL_SIZE) # fontsize of the tick labels\n", "plt.rc('legend', fontsize=SMALL_SIZE) # legend fontsize\n", "plt.rc('figure', titlesize=BIGGER_SIZE) # fontsize of the figure title" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "constants" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [], "source": [ "#define several constants and conversion factors\n", "Navo=const.Avogadro #6.022E23 #Avogadro number\n", "au2m=5.29177E-11 #conversion from au of length to m\n", "au2eV=27.2114 #conversion from au of energy to eV\n", "e0=const.e # 1.602188E-19 #C (unit of charge)\n", "au2J=au2eV*e0\n", "kB=const.k #1.3806E-23 #J/K\n", "eps0=const.epsilon_0 #8.854E-12 #F/m" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "conversions" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [], "source": [ "#converts concentrations in M (mol/l) to SI units (partcles per cubic meter)\n", "def M2SI(c0,**kwargs):\n", " return c0*Navo*1000" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [], "source": [ "#converts concentrations in M (mol/l) to atomic units (particles per bohr^3)\n", "def M2au(c0,**kwargs):\n", " c0SI=M2SI(c0,**kwargs)\n", " return c0SI*au2m**3" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [], "source": [ "#converts concentrations in atomic units (particles per bohr^3) to M (mol/l)\n", "def au2M(c0,**kwargs):\n", " return c0/au2m**3/Navo/1000" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [], "source": [ "def SI2M(c0,**kwargs):\n", " return c0/Navo/1000" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "gamma" ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [], "source": [ "#define a function gamma, which defines the space in which ions may reside. Will be used to define epsilon too (see later)\n", "def gamma(x,xGamma,DeltaGamma,**kwargs):\n", " return 1./(np.exp((xGamma-x)/DeltaGamma)+1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "epsilon" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [], "source": [ "#define the dielectric function that changes with distance from the electrode making use of the function gamma defined before\n", "def epsilonGamma(x,epsilonLeft,epsilonRight,xEpsilon,DeltaEpsilon,**kwargs):\n", " return epsilonLeft+gamma(x,xEpsilon,DeltaEpsilon)*(epsilonRight-epsilonLeft)" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [], "source": [ "def epsilonLinear(x,epsilonLeft,epsilonRight,xEpsilon,xEpsilon2,**kwargs):\n", " x2=deepcopy(x)\n", " x2=np.minimum(x2,xEpsilon2)\n", " x2=np.maximum(x2,xEpsilon)\n", " return (epsilonLeft-epsilonRight)*(xEpsilon2-x2)/(xEpsilon2-xEpsilon)+epsilonRight" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "charge on metal" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\rho=\\frac{q}{A\\sqrt{2\\pi}\\Delta}e^{-\\frac{x^2}{2\\Delta^2}}$" ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [], "source": [ "def rho(x,q,A,DeltaQ,**kwargs):\n", " return q/(A*np.sqrt(2*np.pi)*DeltaQ)*np.exp(-x**2/DeltaQ**2/2.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ion-metal interactions Upot" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [], "source": [ "def repulsive(x,ion,xRepulsiveAn, DeltaRepulsiveAn,xRepulsiveCat, DeltaRepulsiveCat,T,**kwargs):\n", " if ion=='an':\n", " xRepulsive=xRepulsiveAn\n", " DeltaRepulsive=DeltaRepulsiveAn\n", " elif ion=='cat':\n", " xRepulsive=xRepulsiveCat\n", " DeltaRepulsive=DeltaRepulsiveCat\n", " else:\n", " sys.exit('Unknown calctype')\n", " \n", " return kB*T/au2J*np.exp(-(x-xRepulsive)/DeltaRepulsive)" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [], "source": [ "def repulsive2(x,ion,xRepulsiveAn, xRepulsive2An,ERepulsiveAn,xRepulsiveCat, xRepulsive2Cat,ERepulsiveCat,**kwargs):\n", " if ion=='an':\n", " xRepulsive=xRepulsiveAn\n", " xRepulsive2=xRepulsive2An\n", " ERepulsive=ERepulsiveAn\n", " elif ion=='cat':\n", " xRepulsive=xRepulsiveCat\n", " xRepulsive2=xRepulsive2Cat\n", " ERepulsive=ERepulsiveCat\n", " else:\n", " sys.exit('Unknown calctype')\n", " x2=deepcopy(x)\n", " x2=np.minimum(x2,xRepulsive2)\n", " x2=np.maximum(x2,xRepulsive)\n", " kwargs['xRepulsive']=xRepulsive\n", " return ERepulsive/au2eV*(xRepulsive2-x2)/(xRepulsive2-xRepulsive)+repulsive(x,**kwargs)" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [], "source": [ "def attractive(x,ion,EAttractiveAn, xAttractiveAn, DeltaAttractiveAn,EAttractiveCat, xAttractiveCat, DeltaAttractiveCat,**kwargs):\n", " if ion=='an':\n", " xAttractive=xAttractiveAn\n", " DeltaAttractive=DeltaAttractiveAn\n", " EAttractive=EAttractiveAn\n", " elif ion=='cat':\n", " xAttractive=xAttractiveCat\n", " DeltaAttractive=DeltaAttractiveCat\n", " EAttractive=EAttractiveCat\n", " else:\n", " sys.exit('Unknown calctype')\n", " return EAttractive/au2eV*((1-np.exp(-(x-xAttractive)/DeltaAttractive))**2-1)" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [], "source": [ "def attractiveOnly(x,ion,EAttractiveAn, xAttractiveAn, DeltaAttractiveAn,EAttractiveCat, xAttractiveCat, DeltaAttractiveCat,**kwargs):\n", " if ion=='an':\n", " xAttractive=xAttractiveAn\n", " DeltaAttractive=DeltaAttractiveAn\n", " EAttractive=EAttractiveAn\n", " elif ion=='cat':\n", " xAttractive=xAttractiveCat\n", " DeltaAttractive=DeltaAttractiveCat\n", " EAttractive=EAttractiveCat\n", " else:\n", " sys.exit('Unknown calctype')\n", " return -EAttractive/au2eV*gamma(-x,-xAttractive,DeltaAttractive)" ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [], "source": [ "def attractive2(x,ion,**kwargs):\n", " return attractiveOnly(x,ion,**kwargs)+repulsive(x,ion,**kwargs)" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [], "source": [ "def zero(x,ion,**kwargs):\n", " return 0*np.array(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ion concentration as function of phi" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [], "source": [ "def conc(x,ion,Phi,z,otherz,thisc0, otherc0,cmax,T,Upot,**kwargs):\n", " kwargs['T']=T\n", " kbT=kB*T/au2J\n", " return gamma(x,**kwargs)*M2au(thisc0,**kwargs)*np.exp(-z*Phi/kbT-Upot(x,ion,**kwargs)/kbT)/(1-1./M2au(cmax,**kwargs)*(M2au(thisc0,**kwargs)*(1-np.exp(-z*Phi/kbT-Upot(x,ion,**kwargs)/kbT))+M2au(otherc0,**kwargs)*(1-np.exp(-otherz*Phi/kbT-Upot(x,ion,**kwargs)/kbT))))\n", " #return -z*0.5*q/(A*np.sqrt(2*np.pi)*DeltaQ)*np.exp(-(x-xGamma)**2/DeltaQ**2/2.) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "GC and Helmholz related computes" ] }, { "cell_type": "code", "execution_count": 76, "metadata": {}, "outputs": [], "source": [ "def get_lambdaDebeye(eps,T,c0An,c0Cat,zan,zcat,**kwargs):\n", " return np.sqrt(eps*eps0*kB*T/(M2SI(c0An,**kwargs)*zan**2*e0**2+M2SI(c0Cat,**kwargs)*zcat**2*e0**2))/au2m" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [], "source": [ "def get_chargeGC(PhiSI,eps,T,c0An,c0Cat,zan,zcat,A,**kwargs):\n", " #return np.sqrt(8*kB*T*M2SI(c0,**kwargs)*eps*eps0)*np.sinh(e0*PhiSI/2./kB*T)/e0*A*au2m**2\n", " return np.sign(PhiSI)*np.sqrt(2*kB*T*eps*eps0)*np.sqrt(M2SI(c0An,**kwargs)*(np.exp(-zan*e0*PhiSI/(kB*T))-1)+M2SI(c0Cat,**kwargs)*(np.exp(-zcat*e0*PhiSI/(kB*T))-1))/e0*A*au2m**2" ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [], "source": [ "def get_chargeH(PhiSI,eps,A,xEpsilon,xEpsilon2,**kwargs):\n", " if xEpsilon2<0:\n", " d=xEpsilon\n", " else:\n", " d=xEpsilon2/10\n", " return PhiSI*eps*eps0*A*au2m**2/(d*au2m)/e0" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [], "source": [ "def get_linGCcapacitance(eps,**kwargs):\n", " lambdaDebeye=get_lambdaDebeye(eps,**kwargs)\n", " kappa=1./(lambdaDebeye*au2m)\n", " return eps*eps0*kappa*1E2 #returns capacitance in muF/cm2" ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [], "source": [ "def get_nonlinGCcapacitance(eps,phi,T,**kwargs):\n", " kwargs['T']=T\n", " if not -kwargs['zan']==kwargs['zcat']:\n", " sys.error(\"GC capacitance so far only implemented for zan=-zcat\")\n", " lambdaDebeye=get_lambdaDebeye(eps,**kwargs)\n", " kappa=1./(lambdaDebeye*au2m)\n", " return eps*eps0*kappa*np.cosh(kwargs['zan']*e0*phi/(2*kB*T))*1E2" ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [], "source": [ "def CGC(c0, phi1):\n", " return const.epsilon_0*eps_r/lambdaD(c0)*np.cosh(const.e*phi1/(2*const.k*T))" ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [], "source": [ "def get_lambdaFromGC(CGC,eps,**kwargs):\n", " return eps*eps0*1E2/(CGC*au2m)" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [], "source": [ "def get_c0From1OverLinGC(OneOverCGC):\n", " eps=80\n", " T=300\n", " return SI2M((1./OneOverCGC/eps/eps0/1E2)**2*eps*eps0*kB*T/2/e0**2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "simplified relations at 300K assuminv |z|=1, not using the entire dict structure and assuming constant Helmholtz capacitance" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [], "source": [ "#get the deltax=(xAttractive_xRepulsive) corresponding to a fit value a (using a square well assumption)\n", "def a2delx(a):\n", " T=300\n", " return a/M2SI(1)/2/e0**2*kB*T/1E6/1E-4/au2m" ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [], "source": [ "#returns C_attractive in muF/cm^2\n", "def getC_att(delx, b, c0, EAttractiveCat, EAttractiveAn, U1):\n", " T=300\n", " return M2SI(c0)*e0**2/kB/T*delx*au2m*1E-4*(np.exp(-e0*U1/kB/T)*(np.exp(e0*b*EAttractiveCat/kB/T)-1)+np.exp(e0*U1/kB/T)*(np.exp(e0*b*EAttractiveAn/kB/T)-1))*1E6\n", "#myc0*a/2*np.exp((b*kwargs['EAttractiveCat']/au2eV*au2J)/(kwargs['T']*kB))*(np.exp(-e0*kwargs['zcat']*U1i/(kwargs['T']*kB)))\n", "#myc0*a/2*(np.exp((b*kwargs['EAttractiveCat']/au2eV*au2J)/(kwargs['T']*kB))*(np.exp(-e0*kwargs['zcat']*U1i/(kwargs['T']*kB)))+np.exp((b*kwargs['EAttractiveAn']/au2eV*au2J)/(kwargs['T']*kB))*(np.exp(-e0*kwargs['zan']*U1i/(kwargs['T']*kB))))" ] }, { "cell_type": "code", "execution_count": 86, "metadata": {}, "outputs": [], "source": [ "#returns the coefficients of the polynomial defining the minimum in the capacitance\n", "def polyMinCap(delx, b, c0, EAttractiveCat, EAttractiveAn):\n", " T=300\n", " lambdaDebeye=np.sqrt(80*eps0*kB*T/(M2SI(c0)*e0**2+M2SI(c0)*e0**2))/au2m\n", " kappa=1./(lambdaDebeye*au2m)\n", " p0=-M2SI(c0)*e0**2/kB/T*delx*au2m*(np.exp(b*e0*EAttractiveCat/kB/T)-1)\n", " p1=-80*eps0*kappa/4\n", " p2=0\n", " p3=80*eps0*kappa/4\n", " p4=M2SI(c0)*e0**2/kB/T*delx*au2m*(np.exp(b*e0*EAttractiveAn/kB/T)-1)\n", " plist=np.array([p4,p3,p2,p1,p0])\n", " return plist\n", " \n", "#get the location of minimum in capacitance and the corresponding capacitance value and the expected GC capacitance(assumes constant Helmboltz capacitance C0)\n", "def getMinCap(delx, b, c0, EAttractiveCat, EAttractiveAn, C0):\n", " T=300\n", " plist=polyMinCap(delx, b, c0, EAttractiveCat, EAttractiveAn)\n", " if plist[0]==0:\n", " soln=cardan(plist[1],plist[2],plist[3],plist[4])\n", " soln=np.array(soln)\n", " else:\n", " soln=ferrari(plist[0],plist[1],plist[2],plist[3],plist[4])\n", " #print(soln)\n", " #print(np.roots([plist[4], plist[3], plist[2], plist[1], plist[0]]))\n", " res=getPositiveRealSol(soln)\n", " #print(res)\n", " U1_min=np.log(res)/e0*2*kB*T\n", " #print(U1_min)\n", " C_att=getC_att(delx, b, c0, EAttractiveCat, EAttractiveAn, U1_min)\n", " C_GC_atMin=get_nonlinGCcapacitance(80,U1_min, c0An=c0, c0Cat=c0, T=T, zan=1, zcat=-1)\n", " C_GC_exp=get_nonlinGCcapacitance(80,0, c0An=c0, c0Cat=c0, T=T, zan=1, zcat=-1)\n", " C=1/(1/(C_att+C_GC_atMin)+1/C0)\n", " #print(U1_min,C_att,C_GC_atMin,C)\n", " return U1_min, C, C_GC_exp" ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [], "source": [ "# WARNING; THIS FUNCITON WAS NEVER USED OR TESTED!!!!\n", "def get1OverMinCapForFitting(OneOverCGC, delx, c0, EAttractiveCat, EAttractiveAn, C0):\n", " T=300\n", " b=1\n", " c0=get_c0From1OverLinGC(OneOverCGC)\n", " plist=polyMinCap(delx, b, c0, EAttractiveCat, EAttractiveAn)\n", " if plist[0]==0:\n", " soln=cardan(plist[1],plist[2],plist[3],plist[4])\n", " soln=np.array(soln)\n", " else:\n", " soln=ferrari(plist[0],plist[1],plist[2],plist[3],plist[4])\n", " #print(soln)\n", " #print(np.roots([plist[4], plist[3], plist[2], plist[1], plist[0]]))\n", " res=getPositiveRealSol(soln)\n", " #print(res)\n", " U1_min=np.log(res)/e0*2*kB*T\n", " #print(U1_min)\n", " C_att=getC_att(delx, b, c0, EAttractiveCat, EAttractiveAn, U1_min)\n", " C_GC_atMin=get_nonlinGCcapacitance(80,U1_min, c0An=c0, c0Cat=c0, T=T, zan=1, zcat=-1)\n", " C_GC_exp=get_nonlinGCcapacitance(80,0, c0An=c0, c0Cat=c0, T=T, zan=1, zcat=-1)\n", " C=1/(1/(C_att+C_GC_atMin)+1/C0)\n", " #print(U1_min,C_att,C_GC_atMin,C)\n", " return 1./C" ] }, { "cell_type": "code", "execution_count": 88, "metadata": {}, "outputs": [], "source": [ "#get Utot from U1 assuming constant C0\n", "def getUtot(delx, b, c0, EAttractiveCat, EAttractiveAn, C0,U1, returnC=False):\n", " T=300\n", " #compute capacitances\n", " C_att=getC_att(delx, b, c0, EAttractiveCat, EAttractiveAn, U1)\n", " C_GC=get_nonlinGCcapacitance(80,U1, c0An=c0, c0Cat=c0, T=T, zan=1, zcat=-1)\n", " #compute charges\n", " qPerCm2=-e0*M2SI(c0)*delx*au2m*((np.exp(b*EAttractiveCat*e0/kB/T)-1)*np.exp(-e0*U1/kB/T)-(np.exp(b*EAttractiveAn*e0/kB/T)-1)*np.exp(e0*U1/kB/T))*1E-4\n", " A=1 #in au^2\n", " qGCPerCm2=get_chargeGC(U1,80,T,c0,c0,-1,1,A=1)/A/au2m**2*e0*1E-4\n", " #compute potential drop over Helmholz region\n", " deltaU=(qGCPerCm2+qPerCm2)/(C0*1E-6)\n", " #add up potential drops\n", " Utot=U1+deltaU\n", " if returnC:\n", " C=1/(1/(C_att+C_GC)+1/C0)\n", " return Utot, C, qPerCm2\n", " else:\n", " return Utot" ] }, { "cell_type": "code", "execution_count": 89, "metadata": {}, "outputs": [], "source": [ "def getCapacity_analytical(delx, b, c0, EAttractiveCat, EAttractiveAn, C0, delU1=2E-2, U1start=0, UtotMin=-0.4, UtotMax=0.4):\n", " T=300\n", " qV=[]\n", " UCdiff=[]\n", " Utot, C, qPerCm2 =getUtot(delx, b, c0, EAttractiveCat, EAttractiveAn, C0,U1start, returnC=True)\n", " qV.append([qPerCm2,Utot])\n", " UCdiff.append([Utot,C]) #uF/cm2\n", " U1=U1start\n", " #print(Utot)\n", " while Utot>UtotMin: \n", " U1=U1-delU1\n", " #print('decrease', Utot)\n", " Utot, C, qPerCm2 =getUtot(delx, b, c0, EAttractiveCat, EAttractiveAn, C0,U1, returnC=True)\n", " qV.append([qPerCm2,Utot])\n", " UCdiff.append([Utot,C]) #uF/cm2\n", " Utot, C, qPerCm2 =getUtot(delx, b, c0, EAttractiveCat, EAttractiveAn, C0,U1start, returnC=True)\n", " U1=U1start\n", " while Utot epsion*Phi'=0 " ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [], "source": [ "def solve_laplaceEq(epsilon,tol=None,max_nodes=None,**kwargs):\n", " kwargs['epsilon']=epsilon\n", " #estimate grid size\n", " maxeps=epsilon(1000,**kwargs)\n", " lambdaDebeye=get_lambdaDebeye(maxeps,**kwargs)\n", " #solve diffEq., increase grid size until boundary contiditions are met\n", " dPhi=100\n", " maxx=10*lambdaDebeye\n", " if tol==None:\n", " tol=0.00001\n", " if max_nodes==None:\n", " max_nodes=100000\n", " while abs(dPhi)>1E-8:\n", " xs=np.append(np.arange(-10,20,0.001),np.arange(20,maxx,maxx/500))#np.arange(-10,maxx,0.01)\n", " ys=np.array([[0]*len(xs),[0]*len(xs)] )\n", " var=solve_bvp(fun=lambda x,y: diffeq(x,y,**kwargs), bc=boundary, x=xs, y=ys, tol=tol, max_nodes=max_nodes)\n", " dPhi=var.yp[0,-1]\n", " maxx+=2*lambdaDebeye\n", " return var" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "routines (e.g., getCapacity as function of V, getCdiffvsCGC as function of c0, plotForChangeDicts: plot 1/Cdiff vs 1/CGS for several change dicts)" ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [], "source": [ "def getCapacity(calctype,show,T,zan,zcat,UpotAn,UpotCat,c0An,c0Cat,A,xGamma,epsilon,rangeMult=None,nMult=1,startq=None, stopq=None, tol=None, max_nodes=None, **kwargs):\n", " #calctype can be 'curve' (returns a capacitance curve for -0.2V/pzc:0.2V/pzc) or 'pzc' (returns a capacitance near pzc)\n", " kwargs['T']=T\n", " kwargs['zan']=zan\n", " kwargs['zcat']=zcat\n", " kwargs['UpotAn']=UpotAn\n", " kwargs['UpotCat']=UpotCat\n", " kwargs['c0An']=c0An\n", " kwargs['c0Cat']=c0Cat\n", " kwargs['A']=A\n", " kwargs['xGamma']=xGamma\n", " kwargs['epsilon']=epsilon\n", " #estimate charge\n", " if calctype=='curve':\n", " Phi0max=0.6 #V\n", " elif calctype=='pzc':\n", " Phi0max=0.005 #V\n", " else:\n", " sys.exit('Unknown calctype')\n", " maxeps=epsilon(1000,**kwargs)\n", " mineps=epsilon(0,**kwargs)\n", " qmaxGC=get_chargeGC(Phi0max,maxeps,**kwargs)\n", " qmaxH=get_chargeH(Phi0max,mineps,**kwargs)\n", " qmax=min(qmaxGC,qmaxH)\n", " if not rangeMult==None:\n", " qmax=qmax*rangeMult\n", " if calctype=='curve':\n", " if startq==None:\n", " qlist=np.linspace(-qmax,qmax,int(60*nMult))\n", " else:\n", " qlist=np.linspace(startq,stopq,int(60*nMult))\n", " else:\n", " qlist=[-qmax,qmax]\n", " #cycle through all q in qlist\n", " qV=[]\n", " #plt.ion()\n", " if show>=0:\n", " fig,ax=pl.subplots(1,3, figsize=(12,3))\n", " for q in qlist:\n", " kwargs['q']=q\n", " var=solve_laplaceEq(tol=tol, max_nodes=max_nodes, **kwargs)\n", " if var.status==0:\n", " V=(var.y[0,0]-var.y[0,-1])*au2eV\n", " #if calctype=='pzc', only accept value if 0.0020.01):\n", " qnew=q*Phi0max/V*np.sign(V)\n", " #qnew=(q+qnew)*0.5\n", " #print(\"V={}; Old q={}, new q={}\".format(V,q,qnew))\n", " qlist.append(qnew)\n", " continue\n", " qV.append([q,V])\n", " #qV.append([-q,-V])\n", " #print(q,V)\n", " if show>=0:\n", " #pl.plot(var.x,var.y[0,:]*27.211, label='numerical');\n", " #pl.xlabel('x [au]')\n", " #pl.ylabel('U [V/pzc]')\n", " #display.clear_output(wait=True)\n", " #display.display(pl.gcf())\n", " ax[0].plot(var.x,var.y[0,:]*27.211, label='numerical');\n", " ax[0].set_xlabel(\"x [au]\")\n", " ax[0].set_ylabel(\"U [V/pzc]\")\n", " #ax[1].plot(var.x,au2M(conc(var.x,var.y[0,:],zan,zcat,**kwargs)))\n", " ax[1].plot(var.x,au2M(conc(var.x,'an',var.y[0,:],zan,zcat,c0An, c0Cat,Upot=UpotAn,**kwargs)))\n", " ax[1].set_xlim(var.x[0], max(40,var.x[-1]/6))\n", " ax[1].set_xlabel(\"x [au]\")\n", " ax[1].set_ylabel(\"c_Anion [M]\")\n", " ax[2].plot(var.x,au2M(conc(var.x,'cat',var.y[0,:],zcat,zan,c0Cat, c0An,Upot=UpotCat,**kwargs)))\n", " ax[2].set_xlim(var.x[0], max(40,var.x[-1]/6))\n", " ax[2].set_xlabel(\"x [au]\")\n", " ax[2].set_ylabel(\"c_Cation [M]\")\n", " pl.tight_layout()\n", " display.clear_output(wait=True)\n", " display.display(pl.gcf())\n", " else:\n", " print(\"not converged\")\n", " if show>=0:\n", " plt.close()\n", " #sort qV array\n", " qV=np.array(qV)\n", " qV.sort(0)\n", " #compute differential capacitance\n", " UCdiff=[]\n", " for i in range(len(qV[:,0])-1):\n", " U=0.5*(qV[i,1]+qV[i+1,1])\n", " Cdiff=((qV[i+1,0]-qV[i,0])*e0/(A*au2m**2))/(qV[i+1,1]-qV[i,1])\n", " UCdiff.append([U,Cdiff*1E6*1E-4]) #uF/cm2\n", " UCdiff=np.array(UCdiff)\n", " #plot results\n", " if (show>=1):\n", " fig,ax=pl.subplots(1,2, figsize=(8,3))\n", " ax[0].plot(qV[:,1], qV[:,0],'x')\n", " ax[0].set_xlabel('U [V/pzc]')\n", " ax[0].set_ylabel('q/A [e0]')\n", " \n", " ax[1].plot(UCdiff[:,0], UCdiff[:,1], 'x')\n", " ax[1].set_xlabel('U [V/pzc]')\n", " ax[1].set_ylabel('diff. capacitance \\n[uF/cm2]')\n", " plt.tight_layout()\n", " return qV,UCdiff" ] }, { "cell_type": "code", "execution_count": 94, "metadata": {}, "outputs": [], "source": [ "def get_Cdiff_vs_CGC(**kwargs):\n", " if 'c0An' in kwargs:\n", " print(\"WARNING: c0An and c0Cat in kwargs will be overwritten!\")\n", " c0list=[0.001,0.002,0.003, 0.005,0.01,0.02,0.03,0.05,0.1,0.5,1]\n", " #c0list=[0.001,0.003,0.007,0.026] #for Au\n", " #c0list=[0.0001,0.0002, 0.0004,0.0006, 0.0011, 0.0031, 0.01,0.1,0.5,1]\n", " #c0list=[0.0001,0.0002, 0.0004,0.0006, 0.0011, 0.0031, 0.01,0.1]\n", " #c0list=[0.00005, 0.0001,0.0003, 0.0005,0.001,0.002,0.003, 0.005,0.01,0.02,0.03,0.05,0.1,0.5,1]\n", " Cdiff=[]\n", " CGC=[]\n", " for c0 in c0list:\n", " kwargs['c0An']=c0\n", " kwargs['c0Cat']=c0\n", " qV,UCdiff=getCapacity(calctype='pzc',show=-1,**kwargs)\n", " Cdiff.append(UCdiff[0,1])\n", " CGC.append(get_linGCcapacitance(80,**kwargs))\n", " return np.array([c0list,CGC,Cdiff]).transpose()\n", " " ] }, { "cell_type": "code", "execution_count": 95, "metadata": {}, "outputs": [], "source": [ "def twinaxis_lambdaDebeye(ax1,**kwargs):\n", " #ax1 = fig.gca()\n", " ax2 = ax1.twiny()\n", " ax1Xs = ax1.get_xticks()\n", " ax2Xs=get_lambdaFromGC(1/ax1Xs,80)\n", " ax2.set_xticks(ax1Xs)\n", " ax2.set_xbound(ax1.get_xbound())\n", " ax2.set_xticklabels([\"{:.0f}\".format(x) for x in ax2Xs]);\n", " ax2.set_xlabel(r\"$\\lambda_D [au]$\")\n", " " ] }, { "cell_type": "code", "execution_count": 96, "metadata": {}, "outputs": [], "source": [ "def plotForChangeDicts(changeDicts,**kwargs0):\n", " results=[]\n", " for changeDict in changeDicts:\n", " kwargs=deepcopy(kwargs0)\n", " del kwargs['c0An']\n", " del kwargs['c0Cat']\n", " for key in changeDict:\n", " kwargs[key]=changeDict[key]\n", " res=get_Cdiff_vs_CGC(**kwargs)\n", " kwargs['res']=res\n", " kwargs['changeDict']=changeDict\n", " results.append(kwargs)\n", " fig=plt.figure()\n", " for result in results:\n", " res=result['res']\n", " plt.plot(1/res[:,1], 1/res[:,2], 'x-', label=str(result['changeDict']))\n", " plt.xlabel(\"1/C_GC [cm2/uF]\")\n", " plt.ylabel(\"1/C [cm2/uF]\")\n", " plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", " twinaxis_lambdaDebeye(fig,**kwargs)\n", " fig=plt.figure()\n", " for result in results:\n", " res=result['res']\n", " plt.plot(1/res[-4:-1,1], 1/res[-4:-1,2], 'x-', label=str(result['changeDict']))\n", " plt.xlabel(\"1/C_GC [cm2/uF]\")\n", " plt.ylabel(\"1/C [cm2/uF]\")\n", " plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", " plt.xlim(0)\n", " twinaxis_lambdaDebeye(fig,**kwargs)\n", " return results" ] }, { "cell_type": "code", "execution_count": 97, "metadata": {}, "outputs": [], "source": [ "def plotCC_forChangeDicts(changeDicts,show=1,axret=False,**kwargs0):\n", " results=[]\n", " for changeDict in changeDicts:\n", " #print(changeDict)\n", " kwargs=deepcopy(kwargs0)\n", " c0AnOrig=kwargs['c0An']\n", " c0CatOrig=kwargs['c0Cat']\n", " if not c0AnOrig==c0AnOrig:\n", " sys.exit(\"Function onlz written for 1:1 electrolytes so far\")\n", " del kwargs['c0An']\n", " del kwargs['c0Cat']\n", " for key in changeDict:\n", " kwargs[key]=changeDict[key]\n", " res=get_Cdiff_vs_CGC(**kwargs)\n", " kwargs['res']=res\n", " kwargs['changeDict']=changeDict\n", " results.append(kwargs)\n", " if show==1:\n", " fig,ax=plt.subplots(1,2,figsize=(15,4))\n", " for result in results:\n", " res=result['res']\n", " ax[0].plot(1/res[:,1], 1/res[:,2], 'x-', label=str(result['changeDict']))\n", " ax[0].set_xlabel(\"1/C_GC [cm2/uF]\")\n", " ax[0].set_ylabel(\"1/C [cm2/uF]\")\n", " #ax[0].legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", " twinaxis_lambdaDebeye(ax[0],**kwargs)\n", " for result in results:\n", " res=result['res']\n", " ax[1].plot(1/res[-7:-1,1], 1/res[-7:-1,2], 'x-', label=str(result['changeDict']))\n", " ax[1].set_xlabel(\"1/C_GC [cm2/uF]\")\n", " ax[1].set_ylabel(\"1/C [cm2/uF]\")\n", " #ax[1].legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", " ax[1].set_xlim(0)\n", " twinaxis_lambdaDebeye(ax[1],**kwargs)\n", " if not show:\n", " ax=0\n", " if not axret:\n", " return results\n", " else:\n", " return results,ax" ] }, { "cell_type": "code", "execution_count": 98, "metadata": {}, "outputs": [], "source": [ "def fitfun(c0, alpha,CH, **kwargs):\n", " if 'c0An' in kwargs:\n", " print(\"WARNING: c0 in kwargs will be overwritten!\")\n", " kwargs['c0An']=c0\n", " kwargs['c0Cat']=c0\n", " CGC=get_linGCcapacitance(80,**kwargs)\n", " del kwargs['c0An']\n", " del kwargs['c0Cat']\n", " return 1./(CGC+alpha*c0)+1./CH\n", " #return 1./(alpha*c0+beta*CGC)+1./CH\n", " #return 1./CGC + 1/(alpha*c0) #does not work!!!!" ] }, { "cell_type": "code", "execution_count": 99, "metadata": {}, "outputs": [], "source": [ "def fitfun2(EAttractive,a,b):\n", " return a*(np.exp(EAttractive)-1)" ] }, { "cell_type": "code", "execution_count": 100, "metadata": {}, "outputs": [], "source": [ "def fit_results_C0_EAtt(changeDicts, show=True,**mykwargs):\n", " results,ax=plotCC_forChangeDicts(changeDicts,show=show, axret=True, **mykwargs)\n", " #line_colors = ['r', 'g', 'b', 'c', 'm', 'y', 'k']*2\n", " line_colors=plt.rcParams['axes.prop_cycle'].by_key()['color']\n", " EAttractive=[]\n", " for j,result in enumerate(results):\n", " res=result['res']\n", " EAttractive.append(result['EAttractiveAn'])\n", " fitfunEAttractive=lambda c0,alpha,CH,**kwargs: fitfun(c0,alpha,CH,**result)\n", " popt, pcov = curve_fit(fitfunEAttractive, res[:,0], 1./res[:,2],p0=[1E4,100]) #p0=[1E4,1,10])\n", " result['popt']=popt\n", " #plt.plot(1/get_linGCcapacitance(80,c0=res[:,0],**result), 1./res[:,2], 'x',color=line_colors[j], label=str(result['changeDict']))\n", " if show:\n", " ax[0].plot(1/get_linGCcapacitance(80,c0An=res[:,0],c0Cat=res[:,0],**result), fitfunEAttractive(res[:,0], *result['popt'],**result),marker='o',markersize=8, mfc='none', color=line_colors[j])\n", " xmin,xmax=ax[0].get_xlim();\n", " ax[0].text(xmax,fitfunEAttractive(res[0,0], *result['popt'],**result),r'$\\alpha={:1.1e}, C_H={:.0f}$'.format(popt[0],popt[1]) , color=line_colors[j])\n", " ax[1].plot(1/get_linGCcapacitance(80,c0An=res[-7:-1,0],c0Cat=res[-7:-1,0],**result), fitfunEAttractive(res[-7:-1,0], *result['popt'],**result),marker='o',markersize=8, mfc='none',color=line_colors[j])\n", " if show:\n", " box = ax[1].get_position()\n", " box.x0 = box.x0 + 0.15\n", " box.x1 = box.x1 + 0.15\n", " ax[1].set_position(box)\n", " ax[1].set_xlim(0)\n", " \n", " if show:\n", " plt.figure(figsize=(3.5,2.5))\n", " #plt.figure();\n", " Elist=[result['EAttractiveAn']/(au2eV*kB*result['T']/au2J) for result in results[1:]]\n", " alphalist=[result['popt'][0] for result in results[1:]]\n", " [a,b], pcov = curve_fit(fitfun2,Elist,alphalist)\n", " if show:\n", " plt.plot(Elist,alphalist,'x')\n", " plt.plot(Elist, fitfun2(np.array(Elist),a,b))\n", " plt.xlabel(r'$\\frac{ U}{k_B\\cdot T}$', fontsize=18)\n", " plt.ylabel(r'$\\alpha$', fontsize=18)\n", " plt.yscale('log')\n", " plt.text(Elist[-1]+1, alphalist[-1],r'$C_{{ads}}={:2.2f}\\cdot c_0\\cdot \\left(e^{{\\frac{{U}}{{k_B\\cdot T}}}}-1\\right)$'.format(a), fontsize=24);\n", " return results,a,b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Helper functions" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [], "source": [ "#solving for the roots of a 4th order polynomial using the ferrari method\n", "#from\n", "#https://stackoverflow.com/questions/35795663/fastest-way-to-find-the-smallest-positive-real-root-of-quartic-polynomial-4-degr\n", "def ferrari(a,b,c,d,e):\n", " \"resolution of P=ax^4+bx^3+cx^2+dx+e=0\"\n", " \"CN all coeffs real.\"\n", " \"First shift : x= z-b/4/a => P=z^4+pz^2+qz+r\"\n", " z0=b/4/a\n", " a2,b2,c2,d2 = a*a,b*b,c*c,d*d \n", " p = -3*b2/(8*a2)+c/a\n", " q = b*b2/8/a/a2 - 1/2*b*c/a2 + d/a\n", " r = -3/256*b2*b2/a2/a2 +c*b2/a2/a/16-b*d/a2/4+e/a\n", " \"Second find X so P2=AX^3+BX^2+C^X+D=0\"\n", " A=8\n", " B=-4*p\n", " C=-8*r\n", " D=4*r*p-q*q\n", " y0,y1,y2=cardan(A,B,C,D)\n", " if abs(y1.imag)=0) ].real\n", " if not len(res)==1:\n", " if len(res)==0:\n", " sys.exit(\"getPositiveRealsSoln could not find a valid solution: {}\".format(soln))\n", " return zero\n", " if len(res)>1:\n", " #sys.warning(\"getPositiveRealsSoln found more than one valid solution: {}\".format(soln))\n", " imin=np.argmin(abs(res-1))\n", " return res[imin]\n", " else:\n", " return res[0]" ] }, { "cell_type": "code", "execution_count": 102, "metadata": {}, "outputs": [], "source": [ "def linfun(x,a,b):\n", " return a*x+b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Functions for water adsorption from Jiabo Le's paper" ] }, { "cell_type": "code", "execution_count": 103, "metadata": {}, "outputs": [], "source": [ "waterAds0={}\n", "waterAds0['p']=0.26*const.e*const.angstrom\n", "waterAds0['l_A']=1.7*const.angstrom\n", "waterAds0['l_H']=1.8*const.angstrom\n", "waterAds0['eps_s']=4\n", "waterAds0['eps_r']=80\n", "waterAds0['theta_max']=0.51\n", "waterAds0['areaPerPt']=2.772**2*np.sqrt(3)/2*const.angstrom**2\n", "waterAds0['Nsite']=1/waterAds0['areaPerPt']\n", "waterAds0['T']=300\n", "waterAds0['theta_sigma0']=0.2\n", "#waterAds0['sigma0']=-const.k*waterAds['T']*waterAds['eps_s']*const.epsilon_0/waterAds['p']*np.log(waterAds['theta_sigma0']/(waterAds['theta_max']-waterAds['theta_sigma0']))-waterAds['p']*waterAds['theta_sigma0']*waterAds['Nsite']*waterAds['eps_s']/waterAds['l_A']\n", "#waterAds0['phi0']=waterAds['p']*waterAds['theta_sigma0']*waterAds['Nsite']/const.epsilon_0" ] }, { "cell_type": "code", "execution_count": 104, "metadata": {}, "outputs": [], "source": [ "def get_sigma0(T, eps_s, p, theta_sigma0, theta_max, Nsite, l_A, **kwargs):\n", " return -const.k*T*eps_s*const.epsilon_0/p*np.log(theta_sigma0/(theta_max-theta_sigma0))-p*theta_sigma0*Nsite*eps_s/l_A" ] }, { "cell_type": "code", "execution_count": 105, "metadata": {}, "outputs": [], "source": [ "def get_phi0(p, Nsite, theta_sigma0, **kwargs):\n", " return p*theta_sigma0*Nsite/const.epsilon_0" ] }, { "cell_type": "code", "execution_count": 106, "metadata": {}, "outputs": [], "source": [ "kwargs0={\n", " #temperature\n", " 'T':waterAds0['T'],\n", " #parameters for rho\n", " 'q':0.5, #charge on metal surf\n", " 'A':10**2, #area of metal surf\n", " 'DeltaQ':0.02, #width of charge dist on metal surf\n", " #parameters for conc\n", " 'c0An':0.01, #M\n", " 'cmax':3, #M\n", " 'c0Cat':0.01, #M\n", " 'zcat':1, #charge of cations\n", " 'zan':-1, #charge of anions\n", " #+parameters for gamma\n", " 'xGamma':0.1, #au\n", " 'DeltaGamma':0.03, #au\n", " #parameters for repulsive function\n", " 'xRepulsiveAn':6.0, #au\n", " 'DeltaRepulsiveAn':0.2, #au\n", " 'xRepulsiveCat':6.0, #au\n", " 'DeltaRepulsiveCat':0.2, #au\n", " #paramters for attractive function\n", " 'EAttractiveAn':0.1, #eV\n", " 'xAttractiveAn':8.0, #au\n", " 'DeltaAttractiveAn':0.1, #au was 0.5\n", " 'EAttractiveCat':0.1, #eV\n", " 'xAttractiveCat':8.0, #au\n", " 'DeltaAttractiveCat':0.1, #au was 0.5\n", " #parameters for dielectric function\n", " 'epsilon':epsilonLinear,\n", " 'epsilonLeft':waterAds0['eps_s'], #epsilon on left of xEpsilon function\n", " 'epsilonRight':waterAds0['eps_r'], #epsilon on right of xEpsilon function\n", " 'xEpsilon':waterAds0['l_H']/au2m, #au\n", " 'xEpsilon2':(waterAds0['l_H']+0.5*const.angstrom)/au2m, #au should be negative epsilonGamma\n", " 'DeltaEpsilon':0.03, #au\n", " #set ion function\n", " 'UpotAn':repulsive,\n", " 'UpotCat':repulsive\n", "}" ] }, { "cell_type": "code", "execution_count": 107, "metadata": {}, "outputs": [], "source": [ "def sigma(thetaA, T, eps_s, p, theta_max, Nsite, l_A, sigmaVal=0, **kwargs):\n", " kwargs['T']=T\n", " kwargs['eps_s']=eps_s\n", " kwargs['p']=p\n", " kwargs['theta_max']=theta_max\n", " kwargs['Nsite']=Nsite\n", " kwargs['l_A']=l_A\n", " sigma0=get_sigma0(**kwargs)\n", " return const.k*T*eps_s*const.epsilon_0/p*np.log(thetaA/(theta_max-thetaA))+p*thetaA*Nsite*eps_s/l_A+sigma0-sigmaVal" ] }, { "cell_type": "code", "execution_count": 108, "metadata": {}, "outputs": [], "source": [ "def DeltaPhiWater(thetaA, sigmaVal, p, Nsite, **kwargs):\n", " kwargs['p']=p\n", " kwargs['Nsite']=Nsite\n", " phi0=get_phi0(**kwargs)\n", " return -p*thetaA*Nsite/const.epsilon_0 + phi0" ] }, { "cell_type": "code", "execution_count": 109, "metadata": {}, "outputs": [], "source": [ "def DeltaPhiHelmholtz(thetaA, sigmaVal, eps_s, l_H, **kwargs):\n", " return sigmaVal/(const.epsilon_0*eps_s)*l_H" ] }, { "cell_type": "code", "execution_count": 110, "metadata": {}, "outputs": [], "source": [ "def get_OneOverCWater(thetaA, p, Nsite, T, theta_max, eps_s, l_A, **kwargs):\n", " return -p*Nsite/const.epsilon_0*1/(const.k*T*eps_s*const.epsilon_0/p*theta_max/thetaA/(theta_max-thetaA)+p*Nsite*eps_s/l_A)" ] }, { "cell_type": "code", "execution_count": 111, "metadata": {}, "outputs": [], "source": [ "def DeltaPhi(thetaA, sigmaVal, p, Nsite, eps_s, l_H, **kwargs):\n", " kwargs['p']=p\n", " kwargs['Nsite']=Nsite\n", " phi0=get_phi0(**kwargs)\n", " return -p*thetaA*Nsite/const.epsilon_0+sigmaVal/(const.epsilon_0*eps_s)*l_H + phi0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Results for paper" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ion attraction (same ion size) and water adsorption (with modified parameters for water adsorption)" ] }, { "cell_type": "code", "execution_count": 113, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#c0list=[0.0001,0.0002, 0.0004,0.0006, 0.0011, 0.0021]\n", "c0list=[0.0001, 0.0002, 0.0004,0.0006, 0.001, 0.005, 0.01, 0.05, 0.1]#,0.0004, 0.0021]\n", "kwargs=deepcopy(kwargs0)\n", "waterAds=deepcopy(waterAds0)\n", "waterAds['l_A']=2.0*const.angstrom\n", "kwargs['cmax']=40000\n", "kwargs['xRepulsiveAn']=6\n", "kwargs['xRepulsiveCat']=6\n", "kwargs['xAttractiveAn']=10\n", "kwargs['xAttractiveCat']=10\n", "kwargs['UpotCat']=attractive2\n", "kwargs['UpotAn']=attractive2\n", "kwargs['EAttractiveAn']=0.22\n", "kwargs['EAttractiveCat']=0.22\n", "\n", "fig1=plt.figure(figsize=(3.33,2))\n", "#fig1=plt.figure()\n", "ax1=fig1.gca()\n", "line_colors=plt.rcParams['axes.prop_cycle'].by_key()['color']\n", "nMult=1\n", "for j,myc0 in enumerate(c0list):\n", " kwargs['c0An']=myc0\n", " kwargs['c0Cat']=myc0\n", " qVAt,UCdiffAt=getCapacity('curve',show=-1,rangeMult=0.3,nMult=nMult,tol=1E-7, **kwargs)#1.8\n", " \n", " sigma_list=qVAt[:,0]*const.e/(kwargs['A']*au2m**2)\n", " thetaA_list=[]\n", " DeltaPhiWater_list=[]\n", " OneOverCWater_list=[]\n", " CWaterNum_list=[]\n", " DeltaPhiWater_list_forCH=[]\n", " for sigmaVal in sigma_list:\n", " mysigma=lambda x: sigma(x, **waterAds, sigmaVal=sigmaVal)\n", " thetaA=fsolve(mysigma, 0.01)[0]\n", " thetaA_list.append(thetaA)\n", " DeltaPhiVal=DeltaPhiWater(thetaA, sigmaVal, **waterAds)\n", " DeltaPhiWater_list.append(DeltaPhiVal)\n", " OneOverCWater=get_OneOverCWater(thetaA, **waterAds)\n", " OneOverCWater_list.append(OneOverCWater)\n", " for i in range(0,len(sigma_list)-1):\n", " CWaterNum_list.append((sigma_list[i+1]-sigma_list[i])/(DeltaPhiWater_list[i+1]-DeltaPhiWater_list[i]))\n", " DeltaPhiWater_list_forCH.append((DeltaPhiWater_list[i+1]+DeltaPhiWater_list[i])/2)\n", " OneOverCWater_list=np.array(OneOverCWater_list)\n", " CWaterNum_list=np.array(CWaterNum_list)\n", " \n", " #plt.figure()\n", " #plt.plot(DeltaPhiWater_list, 1/OneOverCWater_list)\n", " #plt.plot(DeltaPhiWater_list_forCH, CWaterNum_list)\n", " \n", " #ax1.plot(UCdiffAt[:,0], UCdiffAt[:,1], label='c0={}'.format(myc0), color=line_colors[j])\n", " ax1.plot(UCdiffAt[:,0]+DeltaPhiWater_list_forCH, 1/(1/UCdiffAt[:,1]+1/CWaterNum_list*1E-2), color=line_colors[j], label='c0={}'.format(myc0))\n", "\n", "ax1.legend(loc='lower center', bbox_to_anchor=(0.5, -1.0),ncol=3)\n", "#ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", "ax1.set_xlabel(\"$\\Delta \\phi$ [V/pzc]\")\n", "ax1.set_ylabel(\"$C$ [$\\mu$F/cm$^2$]\")\n", "#ax1.set_ylabel(\"diff. capacitance [uF/cm2]\")\n", "fig1.savefig('ionAtt_waterAds.svg', format='svg', dpi=300)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "same as above but without model by Le" ] }, { "cell_type": "code", "execution_count": 114, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#c0list=[0.0001,0.0002, 0.0004,0.0006, 0.0011, 0.0021]\n", "c0list=[0.0001, 0.0002, 0.0004,0.0006, 0.001, 0.005, 0.01, 0.05, 0.1]#,0.0004, 0.0021]\n", "kwargs=deepcopy(kwargs0)\n", "waterAds=deepcopy(waterAds0)\n", "waterAds['l_A']=2.0*const.angstrom\n", "kwargs['cmax']=40000\n", "kwargs['xRepulsiveAn']=6\n", "kwargs['xRepulsiveCat']=6\n", "kwargs['xAttractiveAn']=10\n", "kwargs['xAttractiveCat']=10\n", "kwargs['UpotCat']=attractive2\n", "kwargs['UpotAn']=attractive2\n", "kwargs['EAttractiveAn']=0.22\n", "kwargs['EAttractiveCat']=0.22\n", "\n", "fig1=plt.figure(figsize=(3.33,2))\n", "ax1=fig1.gca()\n", "line_colors=plt.rcParams['axes.prop_cycle'].by_key()['color']\n", "nMult=1\n", "for j,myc0 in enumerate(c0list):\n", " kwargs['c0An']=myc0\n", " kwargs['c0Cat']=myc0\n", " qVAt,UCdiffAt=getCapacity('curve',show=-1,rangeMult=0.3,nMult=nMult,tol=1E-7, **kwargs)#1.8\n", " \n", " sigma_list=qVAt[:,0]*const.e/(kwargs['A']*au2m**2)\n", " thetaA_list=[]\n", " DeltaPhiWater_list=[]\n", " OneOverCWater_list=[]\n", " CWaterNum_list=[]\n", " DeltaPhiWater_list_forCH=[]\n", " for sigmaVal in sigma_list:\n", " mysigma=lambda x: sigma(x, **waterAds, sigmaVal=sigmaVal)\n", " thetaA=fsolve(mysigma, 0.01)[0]\n", " thetaA_list.append(thetaA)\n", " DeltaPhiVal=DeltaPhiWater(thetaA, sigmaVal, **waterAds)\n", " DeltaPhiWater_list.append(DeltaPhiVal)\n", " OneOverCWater=get_OneOverCWater(thetaA, **waterAds)\n", " OneOverCWater_list.append(OneOverCWater)\n", " for i in range(0,len(sigma_list)-1):\n", " CWaterNum_list.append((sigma_list[i+1]-sigma_list[i])/(DeltaPhiWater_list[i+1]-DeltaPhiWater_list[i]))\n", " DeltaPhiWater_list_forCH.append((DeltaPhiWater_list[i+1]+DeltaPhiWater_list[i])/2)\n", " OneOverCWater_list=np.array(OneOverCWater_list)\n", " CWaterNum_list=np.array(CWaterNum_list)\n", " \n", " #plt.figure()\n", " #plt.plot(DeltaPhiWater_list, 1/OneOverCWater_list)\n", " #plt.plot(DeltaPhiWater_list_forCH, CWaterNum_list)\n", " \n", " #ax1.plot(UCdiffAt[:,0], UCdiffAt[:,1], label='c0={}'.format(myc0), color=line_colors[j])\n", " ax1.plot(UCdiffAt[:,0], UCdiffAt[:,1], color=line_colors[j], label='c0={}'.format(myc0))\n", " \n", "ax1.legend(loc='lower center', bbox_to_anchor=(0.5, -1.0),ncol=3)\n", "#ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", "ax1.set_xlabel(\"$\\Delta \\phi$ [V/pzc]\")\n", "ax1.set_ylabel(\"$C$ [$\\mu$F/cm$^2$]\")\n", "fig1.savefig('ionAtt.svg', format='svg', dpi=300)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "same as above, but for EAttractive=0" ] }, { "cell_type": "code", "execution_count": 115, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#c0list=[0.0001,0.0002, 0.0004,0.0006, 0.0011, 0.0021]\n", "c0list=[0.01, 0.05, 0.1,1,10]#,0.0004, 0.0021]\n", "kwargs=deepcopy(kwargs0)\n", "waterAds=deepcopy(waterAds0)\n", "waterAds['l_A']=2.0*const.angstrom\n", "kwargs['cmax']=40000\n", "kwargs['xRepulsiveAn']=6\n", "kwargs['xRepulsiveCat']=6\n", "kwargs['xAttractiveAn']=10\n", "kwargs['xAttractiveCat']=10\n", "kwargs['UpotCat']=attractive2\n", "kwargs['UpotAn']=attractive2\n", "kwargs['EAttractiveAn']=0.0\n", "kwargs['EAttractiveCat']=0.0\n", "\n", "fig1=plt.figure(figsize=(3.33,2))\n", "ax1=fig1.gca()\n", "line_colors=plt.rcParams['axes.prop_cycle'].by_key()['color']\n", "nMult=1\n", "for j,myc0 in enumerate(c0list):\n", " kwargs['c0An']=myc0\n", " kwargs['c0Cat']=myc0\n", " qVAt,UCdiffAt=getCapacity('curve',show=-1,rangeMult=0.3,nMult=nMult,tol=1E-7, **kwargs)#1.8\n", " \n", " sigma_list=qVAt[:,0]*const.e/(kwargs['A']*au2m**2)\n", " thetaA_list=[]\n", " DeltaPhiWater_list=[]\n", " OneOverCWater_list=[]\n", " CWaterNum_list=[]\n", " DeltaPhiWater_list_forCH=[]\n", " for sigmaVal in sigma_list:\n", " mysigma=lambda x: sigma(x, **waterAds, sigmaVal=sigmaVal)\n", " thetaA=fsolve(mysigma, 0.01)[0]\n", " thetaA_list.append(thetaA)\n", " DeltaPhiVal=DeltaPhiWater(thetaA, sigmaVal, **waterAds)\n", " DeltaPhiWater_list.append(DeltaPhiVal)\n", " OneOverCWater=get_OneOverCWater(thetaA, **waterAds)\n", " OneOverCWater_list.append(OneOverCWater)\n", " for i in range(0,len(sigma_list)-1):\n", " CWaterNum_list.append((sigma_list[i+1]-sigma_list[i])/(DeltaPhiWater_list[i+1]-DeltaPhiWater_list[i]))\n", " DeltaPhiWater_list_forCH.append((DeltaPhiWater_list[i+1]+DeltaPhiWater_list[i])/2)\n", " OneOverCWater_list=np.array(OneOverCWater_list)\n", " CWaterNum_list=np.array(CWaterNum_list)\n", " \n", " #plt.figure()\n", " #plt.plot(DeltaPhiWater_list, 1/OneOverCWater_list)\n", " #plt.plot(DeltaPhiWater_list_forCH, CWaterNum_list)\n", " \n", " #ax1.plot(UCdiffAt[:,0], UCdiffAt[:,1], label='c0={}'.format(myc0), color=line_colors[j])\n", " ax1.plot(UCdiffAt[:,0]+DeltaPhiWater_list_forCH, 1/(1/UCdiffAt[:,1]+1/CWaterNum_list*1E-2), color=line_colors[j], label='c0={}'.format(myc0))\n", " \n", "ax1.legend(loc='lower center', bbox_to_anchor=(0.5, -1.0),ncol=3)\n", "#ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", "ax1.set_xlabel(\"$\\Delta \\phi$ [V/pzc]\")\n", "ax1.set_ylabel(\"$C$ [$\\mu$F/cm$^2$]\")\n", "fig1.savefig('waterAds.svg', format='svg', dpi=300)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "same as above, but only model by Le" ] }, { "cell_type": "code", "execution_count": 116, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0.0, 150.0)" ] }, "execution_count": 116, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#c0list=[0.0001,0.0002, 0.0004,0.0006, 0.0011, 0.0021]\n", "c0list=[0.01, 0.05, 0.1]#,0.0004, 0.0021]\n", "C_H=18\n", "kwargs=deepcopy(kwargs0)\n", "waterAds=deepcopy(waterAds0)\n", "waterAds['l_A']=2.0*const.angstrom\n", "kwargs['cmax']=40000\n", "kwargs['xRepulsiveAn']=6\n", "kwargs['xRepulsiveCat']=6\n", "kwargs['xAttractiveAn']=10\n", "kwargs['xAttractiveCat']=10\n", "kwargs['UpotCat']=attractive2\n", "kwargs['UpotAn']=attractive2\n", "kwargs['EAttractiveAn']=0.0\n", "kwargs['EAttractiveCat']=0.0\n", "\n", "fig1=plt.figure()\n", "ax1=fig1.gca()\n", "line_colors=plt.rcParams['axes.prop_cycle'].by_key()['color']\n", "nMult=1\n", "for j,myc0 in enumerate(c0list):\n", " kwargs['c0An']=myc0\n", " kwargs['c0Cat']=myc0\n", " #qVAt,UCdiffAt=getCapacity('curve',show=-1,rangeMult=0.3,nMult=nMult,tol=1E-7, **kwargs)#1.8\n", " \n", " #sigma_list=qVAt[:,0]*const.e/(kwargs['A']*au2m**2)\n", " sigma_list=(np.arange(-0.6,0.8,0.02)+0.001)*const.e/(kwargs['A']*au2m**2)\n", " thetaA_list=[]\n", " DeltaPhiWater_list=[]\n", " OneOverCWater_list=[]\n", " DeltaPhiCH_list=[]\n", " CWaterNum_list=[]\n", " DeltaPhiWater_list_forCH=[]\n", " DeltaPhiCH_list_forCH=[]\n", " for sigmaVal in sigma_list:\n", " mysigma=lambda x: sigma(x, **waterAds, sigmaVal=sigmaVal)\n", " thetaA=fsolve(mysigma, 0.01)[0]\n", " thetaA_list.append(thetaA)\n", " DeltaPhiVal=DeltaPhiWater(thetaA, sigmaVal, **waterAds)\n", " DeltaPhiWater_list.append(DeltaPhiVal)\n", " OneOverCWater=get_OneOverCWater(thetaA, **waterAds)\n", " OneOverCWater_list.append(OneOverCWater)\n", " DeltaPhiCH_list.append(sigmaVal/C_H*1E2)\n", " for i in range(0,len(sigma_list)-1):\n", " CWaterNum_list.append((sigma_list[i+1]-sigma_list[i])/(DeltaPhiWater_list[i+1]-DeltaPhiWater_list[i]))\n", " DeltaPhiWater_list_forCH.append((DeltaPhiWater_list[i+1]+DeltaPhiWater_list[i])/2)\n", " DeltaPhiCH_list_forCH.append((DeltaPhiCH_list[i+1]+DeltaPhiCH_list[i])/2)\n", " OneOverCWater_list=np.array(OneOverCWater_list)\n", " CWaterNum_list=np.array(CWaterNum_list)\n", " DeltaPhiCH_list_forCH=np.array(DeltaPhiCH_list_forCH)\n", " DeltaPhiWater_list_forCH=np.array(DeltaPhiWater_list_forCH)\n", " \n", " #plt.figure()\n", " #plt.plot(DeltaPhiWater_list, 1/OneOverCWater_list)\n", " #plt.plot(DeltaPhiWater_list_forCH, CWaterNum_list)\n", " \n", " #ax1.plot(UCdiffAt[:,0], UCdiffAt[:,1], label='c0={}'.format(myc0), color=line_colors[j])\n", " ax1.plot(DeltaPhiWater_list_forCH+DeltaPhiCH_list_forCH, 1/(1/C_H+1/CWaterNum_list*1E-2), color=line_colors[j], label='c0={}'.format(myc0))\n", " \n", "ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", "ax1.set_xlabel(\"U [V/pzc]\")\n", "ax1.set_ylabel(\"diff. capacitance [uF/cm2]\")\n", "ax1.set_xlim(-0.4,0.5)\n", "ax1.set_ylim(0,150)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ion attraction (cations larger than anions) and water adsorption (with modified parameters for water adsorption)" ] }, { "cell_type": "code", "execution_count": 117, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#c0list=[0.0001,0.0002, 0.0004,0.0006, 0.0011, 0.0021]\n", "c0list=[0.0001, 0.0002, 0.0004,0.0006, 0.001, 0.005, 0.01, 0.05, 0.1]#,0.0004, 0.0021]\n", "kwargs=deepcopy(kwargs0)\n", "waterAds=deepcopy(waterAds0)\n", "waterAds['l_A']=2.0*const.angstrom\n", "kwargs['cmax']=40000\n", "kwargs['xRepulsiveAn']=6\n", "kwargs['xRepulsiveCat']=8\n", "kwargs['xAttractiveAn']=10\n", "kwargs['xAttractiveCat']=10\n", "kwargs['UpotCat']=attractive2\n", "kwargs['UpotAn']=attractive2\n", "kwargs['EAttractiveAn']=0.22\n", "kwargs['EAttractiveCat']=0.22\n", "\n", "fig1=plt.figure(figsize=(3.33,2))\n", "ax1=fig1.gca()\n", "line_colors=plt.rcParams['axes.prop_cycle'].by_key()['color']\n", "nMult=1\n", "for j,myc0 in enumerate(c0list):\n", " kwargs['c0An']=myc0\n", " kwargs['c0Cat']=myc0\n", " qVAt,UCdiffAt=getCapacity('curve',show=-1,rangeMult=0.3,nMult=nMult,tol=1E-7, **kwargs)#1.8\n", " \n", " sigma_list=qVAt[:,0]*const.e/(kwargs['A']*au2m**2)\n", " thetaA_list=[]\n", " DeltaPhiWater_list=[]\n", " OneOverCWater_list=[]\n", " CWaterNum_list=[]\n", " DeltaPhiWater_list_forCH=[]\n", " for sigmaVal in sigma_list:\n", " mysigma=lambda x: sigma(x, **waterAds, sigmaVal=sigmaVal)\n", " thetaA=fsolve(mysigma, 0.01)[0]\n", " thetaA_list.append(thetaA)\n", " DeltaPhiVal=DeltaPhiWater(thetaA, sigmaVal, **waterAds)\n", " DeltaPhiWater_list.append(DeltaPhiVal)\n", " OneOverCWater=get_OneOverCWater(thetaA, **waterAds)\n", " OneOverCWater_list.append(OneOverCWater)\n", " for i in range(0,len(sigma_list)-1):\n", " CWaterNum_list.append((sigma_list[i+1]-sigma_list[i])/(DeltaPhiWater_list[i+1]-DeltaPhiWater_list[i]))\n", " DeltaPhiWater_list_forCH.append((DeltaPhiWater_list[i+1]+DeltaPhiWater_list[i])/2)\n", " OneOverCWater_list=np.array(OneOverCWater_list)\n", " CWaterNum_list=np.array(CWaterNum_list)\n", " \n", " #plt.figure()\n", " #plt.plot(DeltaPhiWater_list, 1/OneOverCWater_list)\n", " #plt.plot(DeltaPhiWater_list_forCH, CWaterNum_list)\n", " \n", " #ax1.plot(UCdiffAt[:,0], UCdiffAt[:,1], label='c0={}'.format(myc0), color=line_colors[j])\n", " ax1.plot(UCdiffAt[:,0]+DeltaPhiWater_list_forCH, 1/(1/UCdiffAt[:,1]+1/CWaterNum_list*1E-2), color=line_colors[j], label='c0={}'.format(myc0))\n", " \n", "ax1.legend(loc='lower center', bbox_to_anchor=(0.5, -1.0),ncol=3)\n", "#ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", "ax1.set_xlabel(\"$\\Delta \\phi$ [V/pzc]\")\n", "ax1.set_ylabel(\"$C$ [$\\mu$F/cm$^2$]\")\n", "fig1.savefig('cationsLargerThanAnions.svg', format='svg', dpi=300)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ion attraction (cations smaller than anions) and water adsorption (with modified parameters for water adsorption)" ] }, { "cell_type": "code", "execution_count": 118, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n", "C:\\Users\\doblhoffdierk\\AppData\\Roaming\\Python\\Python36\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: overflow encountered in exp\n", " This is separate from the ipykernel package so we can avoid doing imports until\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#c0list=[0.0001,0.0002, 0.0004,0.0006, 0.0011, 0.0021]\n", "c0list=[0.0001, 0.0002, 0.0004,0.0006, 0.001, 0.005, 0.01, 0.05, 0.1]#,0.0004, 0.0021]\n", "kwargs=deepcopy(kwargs0)\n", "waterAds=deepcopy(waterAds0)\n", "waterAds['l_A']=2.0*const.angstrom\n", "kwargs['cmax']=40000\n", "kwargs['xRepulsiveAn']=6\n", "kwargs['xRepulsiveCat']=4\n", "kwargs['xAttractiveAn']=10\n", "kwargs['xAttractiveCat']=10\n", "kwargs['UpotCat']=attractive2\n", "kwargs['UpotAn']=attractive2\n", "kwargs['EAttractiveAn']=0.22\n", "kwargs['EAttractiveCat']=0.22\n", "\n", "fig1=plt.figure(figsize=(3.33,2))\n", "ax1=fig1.gca()\n", "line_colors=plt.rcParams['axes.prop_cycle'].by_key()['color']\n", "nMult=1\n", "for j,myc0 in enumerate(c0list):\n", " kwargs['c0An']=myc0\n", " kwargs['c0Cat']=myc0\n", " qVAt,UCdiffAt=getCapacity('curve',show=-1,rangeMult=0.3,nMult=nMult,tol=1E-7, **kwargs)#1.8\n", " \n", " sigma_list=qVAt[:,0]*const.e/(kwargs['A']*au2m**2)\n", " thetaA_list=[]\n", " DeltaPhiWater_list=[]\n", " OneOverCWater_list=[]\n", " CWaterNum_list=[]\n", " DeltaPhiWater_list_forCH=[]\n", " for sigmaVal in sigma_list:\n", " mysigma=lambda x: sigma(x, **waterAds, sigmaVal=sigmaVal)\n", " thetaA=fsolve(mysigma, 0.01)[0]\n", " thetaA_list.append(thetaA)\n", " DeltaPhiVal=DeltaPhiWater(thetaA, sigmaVal, **waterAds)\n", " DeltaPhiWater_list.append(DeltaPhiVal)\n", " OneOverCWater=get_OneOverCWater(thetaA, **waterAds)\n", " OneOverCWater_list.append(OneOverCWater)\n", " for i in range(0,len(sigma_list)-1):\n", " CWaterNum_list.append((sigma_list[i+1]-sigma_list[i])/(DeltaPhiWater_list[i+1]-DeltaPhiWater_list[i]))\n", " DeltaPhiWater_list_forCH.append((DeltaPhiWater_list[i+1]+DeltaPhiWater_list[i])/2)\n", " OneOverCWater_list=np.array(OneOverCWater_list)\n", " CWaterNum_list=np.array(CWaterNum_list)\n", " \n", " #plt.figure()\n", " #plt.plot(DeltaPhiWater_list, 1/OneOverCWater_list)\n", " #plt.plot(DeltaPhiWater_list_forCH, CWaterNum_list)\n", " \n", " #ax1.plot(UCdiffAt[:,0], UCdiffAt[:,1], label='c0={}'.format(myc0), color=line_colors[j])\n", " ax1.plot(UCdiffAt[:,0]+DeltaPhiWater_list_forCH, 1/(1/UCdiffAt[:,1]+1/CWaterNum_list*1E-2), color=line_colors[j], label='c0={}'.format(myc0))\n", " \n", "ax1.legend(loc='lower center', bbox_to_anchor=(0.5, -1.0),ncol=3)\n", "#ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", "ax1.set_xlabel(\"$\\Delta \\phi$ [V/pzc]\")\n", "ax1.set_ylabel(\"$C$ [$\\mu$F/cm$^2$]\")\n", "fig1.savefig('cationsSmallerThanAnions.svg', format='svg', dpi=300)" ] } ], "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.5" } }, "nbformat": 4, "nbformat_minor": 4 }