abstract type AbstractElectrolyteData

Abstract super type for electrolytes.

mutable struct ElectrolyteData <: AbstractElectrolyteData

Data for electrolyte. It is defined using Base.@kwdef allowing for keyword constructors like

    ElectrolyteData(nc=3,z=[-1,2,1])

To see default values, just create an instance as ElectrolyteData(). Fields (reserved fields are modified by some algorithms):

• nc::Int64: Number of ionic species.

• na::Int64: Number of surface species

• iϕ::Int64: Potential index in species list.

• ip::Int64: Pressure index in species list

• D::Vector{Float64}: Mobility coefficient

• z::Vector{Int64}: Charge numbers of ions

• M0::Float64: Molar weight of solvent

• M::Vector{Float64}: Molar weights of ions

• v0::Float64: Molar volume of solvent

• v::Vector{Float64}: Molar volumes of ions

• κ::Vector{Float64}: Solvation numbers of ions

• c_bulk::Vector{Float64}: Bulk ion concentrations

• ϕ_bulk::Float64: Bulk voltage

• p_bulk::Float64: Bulk pressure

• Γ_bulk::Int64: Bulk boundary number

• ϕ_we::Float64: Working electrode voltage. Reserved. Used by sweep algorithms to pass boundary data.

• Γ_we::Int64: Working electrode boundary number

• T::Float64: Temperature

• RT::Float64: Molar gas constant scaled with temperature

• F::Float64: Faraday constant

• ε::Float64: Dielectric permittivity of solvent

• ε_0::Float64: Dielectric permittivity of vacuum

• pscale::Float64: Pressure scaling factor

• eneutral::Bool: Local electroneutrality switch

• scheme::Symbol: Flux caculation scheme This allows to choose between

  • :μex (default): excess chemical potential (SEDAN) scheme, see sflux
  • :act : scheme based on reciprocal activity coefficients, see aflux
  • :cent : central scheme, see cflux.

• solvepressure::Bool: Solve for pressure.

  This is true by default. Setting this to false can serve two purposes:

  • Take the pressure from the solution of a flow equation
  • Ignore the pressure contribution to the excess chemical potential

• weights::Vector{Float64}: Species weights for norms in solver control.

• edgevelocity::Union{Float64, Vector{Float64}}: Edge velocity projection.

• model::Symbol: Electrolyte model

dlcap0(electrolyte)

Double layer capacitance at zero voltage for symmetric binary electrolyte.

Example

using LessUnitful
ely = ElectrolyteData(c_bulk=fill(0.01ufac"mol/dm^3",2))
round(dlcap0(ely),sigdigits=5) |> u"μF/cm^2"
# output

22.847 μF cm^-2

debyelength(electrolyte)

Debye length.

using LessUnitful
ely = ElectrolyteData(c_bulk=fill(0.01ufac"mol/dm^3",2))
round(debyelength(ely),sigdigits=5) |> u"nm"
# output

4.3018 nm

chargedensity(c,electrolyte)

Calculate charge density from vector of concentrations (in one grid point).

chargedensity(sol,electrolyte)

Calculate charge density vector from solution (on whole grid)

chargedensity(tsol,electrolyte)

Calculate charge densities from from time/voltage dependent solution solution (on whole grid)

 chemical_potential(c, barc, p, barv, electrolyte)

Calculate chemical potential of species with concentration c

\[ μ = \bar v(p-p_{ref}) + RT\log \frac{c}{\bar c}\]

chemical_potentials!(μ,u,electrolyte)

Calculate chemical potentials from concentrations.

Input:

• μ: memory for result (will be filled)
• u: local solution vector (concentrations, potential, pressure)

Returns μ0, μ: chemical potential of solvent and chemical potentials of ions.

using LessUnitful
ely = ElectrolyteData(c_bulk = fill(0.01ufac"mol/dm^3", 2))
μ0, μ = chemical_potentials!([0.0, 0.0], vcat(ely.c_bulk, [0, 0]), ely)
round(μ0, sigdigits = 5), round.(μ, sigdigits = 5)
# output

(-0.89834, [-21359.0, -21359.0])

rrate(R0,β,A)

Reaction rate expression

rrate(R0,β,A)=R0*(exp(-β*A) - exp((1-β)*A))

iselectroneutral(cx::Vector,celldata)

Check for electroneutrality of concentration vector

iselectroneutral(tsol::TransientSolution,celldata)

Check for electroneutrality of transient solution

isincompressible(cx::Vector,celldata)

Check if the concentration vector fulfills incompressibility constraint, including the fact that the solvent concentration is nonnegative

isincompressible(tsol::TransientSolution,celldata)

Check for incompressibility of transient solution

c0_barc(u,electrolyte)

Calculate solvent concentration $c_0$ and summary concentration $\bar c$ from vector of concentrations c using the incompressibility constraint (assuming $κ_0=0$):

\[ \sum_{i=0}^N c_i (v_i + κ_iv_0) =1\]

This gives

\[ c_0v_0=1-\sum_{i=1}^N c_i (v_i+ κ_iv_0)\]

\[c_0= 1/v_0 - \sum_{i=1}^N c_i(\frac{v_i}{v_0}+κ_i)\]

Then we can calculate

\[ \bar c= \sum_{i=0}^N c_i\]

PNPSystem(grid;
         celldata=ElectrolyteData(),
         bcondition=(f, u, n, e)-> nothing,
         reaction=(f, u, n, e)-> nothing,
         kwargs...)

Create VoronoiFVM system for generalized Poisson-Nernst-Planck. Input:

• grid: discretization grid
• celldata: composite struct containing electrolyte data
• bcondition: boundary condition
• reaction : reactions of the bulk species
• kwargs: Keyword arguments of VoronoiFVM.System

pnpunknowns(sys)

Return vector of unknowns initialized with bulk data.

electrolytedata(sys)

Extract electrolyte data from system.

   solventconcentration(U::Array, electrolyte)

Calculate vector of solvent concentrations from solution array.

chemical_potentials(solution, electrolyte)

Calculate chemical potentials from solution. Returns μ0, μ, where μ0 is the vector of solvent chemical potentials, and μ is the nc×nnodes matrix of solute chemical potentials.

electrochemical_potentials(solution, electrolyte)

Calculate electrochemical potentials from solution. and return nc×nnodes matrix of solute electrochemical potentials measured in Volts.

PBSystem(grid;
         celldata=ElectrolyteData(),
         bcondition=(f, u, n, e)-> nothing,
         kwargs...)

Create VoronoiFVM system generalized Poisson-Boltzmann. Input:

• grid: discretization grid
• celldata: composite struct containing electrolyte data
• bcondition: boundary condition
• kwargs: Keyword arguments of VoronoiFVM.System

struct PNPStokesSolver{Tflow, Tpnp}

Stokes solver struct.

• flowsolver::Any

• pnpsolver::Any

RLog(eps)

Callable struct for regularized logarithm. Smooth linear continuation for x<eps. This means we can calculate a "logarithm" of a small negative number. Objects mylog::RLog of this type are meant to replace the logarithm function and allow to invoke mylog(x).

rlog(x::Any)

Logarithm function used in LiquidElectrolytes.jl. Calls Base.log by default.

This can be overwritten by defining e.g, LiquidElectrolytes.rlog(x::Number)=mylog(x) where mylog=RLog().

RExp(trunc)

Callable struct for regularized exponential. Linear continuation for x>trunc, returns 1/rexp(-x) for x<-trunc. Objects myexp::RExp of this type are meant to replace the exponential function and allow to invoke myexp(x).

rexp(x::Any)

Exponential function used in LiquidElectrolytes.jl. Calls Base.exp by default.

This can be overwritten by defining e.g, LiquidElectrolytes.rexp(x::Number)=myexp(x) where myexp=RExp().