## Share

# examples.reactiveWetting.liquidVapor1DΒΆ

Solve a single-component, liquid-vapor, van der Waals system.

This example solves a single-component, liquid-vapor, van der Waals system as
described by Wheeler et *al.* [6]. The free energy for this
system takes the form,

(1)

where is the density. This free energy supports a two phase equilibrium with densities given by and in the liquid and vapor phases, respectively. The densities are determined by solving the following system of equations,

(2)

and

(3)

where is the chemical potential,

(4)

and is the pressure,

(5)

One choice of thermodynamic parameters that yields a relatively physical two phase system is

```
>>> molarWeight = 0.118
>>> ee = -0.455971
>>> gasConstant = 8.314
>>> temperature = 650.
>>> vbar = 1.3e-05
```

with equilibrium density values of

```
>>> liquidDensity = 7354.3402662299995
>>> vaporDensity = 82.855803327810008
```

The equilibrium densities are verified by substitution into Eqs. (2) and (3). Firstly, Eqs. (1), (4) and (5) are defined as python functions,

```
>>> from fipy import *
```

```
>>> def f(rho):
... return ee * rho**2 / molarWeight**2 + gasConstant * temperature * rho / molarWeight * \
... numerix.log(rho / (molarWeight - vbar * rho))
```

```
>>> def mu(rho):
... return 2 * ee * rho / molarWeight**2 + gasConstant * temperature / molarWeight * \
... (numerix.log(rho / (molarWeight - vbar * rho)) + molarWeight / (molarWeight - vbar * rho))
```

```
>>> def P(rho):
... return rho * mu(rho) - f(rho)
```

The equilibrium densities values are verified with

```
>>> print numerix.allclose(mu(liquidDensity), mu(vaporDensity))
True
```

and

```
>>> print numerix.allclose(P(liquidDensity), P(vaporDensity))
True
```

In order to derive governing equations, the free energy functional is defined.

Using standard dissipation laws, we write the governing equations for mass and momentum conservation,

(6)

and

(7)

where the non-classical potential, , is given by,

(8)

As usual, to proceed, we define a mesh

```
>>> Lx = 1e-6
>>> nx = 100
>>> dx = Lx / nx
>>> mesh = Grid1D(nx=nx, dx=dx)
```

and the independent variables.

```
>>> density = CellVariable(mesh=mesh, hasOld=True, name=r'$\rho$')
>>> velocity = CellVariable(mesh=mesh, hasOld=True, name=r'$u$')
>>> densityPrevious = density.copy()
>>> velocityPrevious = velocity.copy()
```

The system of equations is solved in a fully coupled manner using a block matrix. Defining as an independent variable makes it easier to script the equations without using higher order terms.

```
>>> potentialNC = CellVariable(mesh=mesh, name=r'$\mu^{NC}$')
```

```
>>> epsilon = 1e-16
>>> freeEnergy = (f(density) + epsilon * temperature / 2 * density.grad.mag**2).cellVolumeAverage
```

In order to solve the equations numerically, an interpolation method is used to prevent the velocity and density fields decoupling. The following velocity correction equation (expressed in discretized form) prevents decoupling from occuring,

(9)

where is the face area, is the distance between the adjacent cell centers and is the momentum conservation equation’s matrix diagonal. The overbar refers to an averaged value between the two adjacent cells to the face. The notation refers to a derivative evaluated directly at the face (not averaged). The variable is used to modify the velocity used in Eq. (6) such that,

(10)

Equation (10) becomes

```
>>> matrixDiagonal = CellVariable(mesh=mesh, name=r'$a_f$', value=1e+20, hasOld=True)
>>> correctionCoeff = mesh._faceAreas * mesh._cellDistances / matrixDiagonal.faceValue
>>> massEqn = TransientTerm(var=density) \
... + VanLeerConvectionTerm(coeff=velocity.faceValue + correctionCoeff \
... * (density * potentialNC.grad).faceValue, \
... var=density) \
... - DiffusionTerm(coeff=correctionCoeff * density.faceValue**2, var=potentialNC)
```

where the first term on the LHS of
Eq. (9) is calculated in an
explicit manner in the `VanLeerConvectionTerm`

and the second term is
calculated implicitly as a `DiffusionTerm`

with as the
independent variable.

In order to write Eq. (7) as a FiPy expression, the last term is rewritten such that,

which results in

```
>>> viscosity = 1e-3
>>> ConvectionTerm = CentralDifferenceConvectionTerm
>>> momentumEqn = TransientTerm(coeff=density, var=velocity) \
... + ConvectionTerm(coeff=[[1]] * density.faceValue * velocity.faceValue, var=velocity) \
... == DiffusionTerm(coeff=2 * viscosity, var=velocity) \
... - ConvectionTerm(coeff=density.faceValue * [[1]], var=potentialNC) \
... + ImplicitSourceTerm(coeff=density.grad[0], var=potentialNC)
```

The only required boundary condition eliminates flow in or out of the domain.

```
>>> velocity.constrain(0, mesh.exteriorFaces)
```

As previously stated, the variable will be solved implicitly. To do this the Eq. (8) is linearized in such that

(11)

The superscript denotes the current held value. In FiPy, is written as,

```
>>> potentialDerivative = 2 * ee / molarWeight**2 + gasConstant * temperature * molarWeight / density / (molarWeight - vbar * density)**2
```

and is simply,

```
>>> potential = mu(density)
```

Eq. (11) can be scripted as

```
>>> potentialNCEqn = ImplicitSourceTerm(coeff=1, var=potentialNC) \
... == potential \
... + ImplicitSourceTerm(coeff=potentialDerivative, var=density) \
... - potentialDerivative * density \
... - DiffusionTerm(coeff=epsilon * temperature, var=density)
```

Due to a quirk in FiPy, the gradient of needs to be
constrained on the boundary. This is because `ConvectionTerm`

‘s will
automatically assume a zero flux, which is not what we need in this case.

```
>>> potentialNC.faceGrad.constrain(value=[0], where=mesh.exteriorFaces)
```

All three equations are defined and an are combined together with

```
>>> coupledEqn = massEqn & momentumEqn & potentialNCEqn
```

The system will be solved as a phase separation problem with an initial density close to the average density, but with some small amplitude noise. Under these circumstances, the final condition should be two separate phases of roughly equal volume. The initial condition for the density is defined by

```
>>> numerix.random.seed(2011)
>>> density[:] = (liquidDensity + vaporDensity) / 2 * \
... (1 + 0.01 * (2 * numerix.random.random(mesh.numberOfCells) - 1))
```

Viewers are also defined.

```
>>> if __name__ == '__main__':
... viewers = Viewer(density), Viewer(velocity), Viewer(potentialNC)
... for viewer in viewers:
... viewer.plot()
... raw_input('arrange viewers')
... for viewer in viewers:
... viewer.plot()
```

The following section defines the required control parameters. The `cfl`

parameter limits the size of the time step so that ```
dt = cfl * dx /
max(velocity)
```

.

```
>>> cfl = 0.1
>>> tolerance = 1e-1
>>> dt = 1e-14
>>> timestep = 0
>>> relaxation = 0.5
>>> if __name__ == '__main__':
... totalSteps = 1e10
... else:
... totalSteps = 10
```

In the following time stepping scheme a time step is recalculated if the residual
increases between sweeps or the required tolerance is not attained within 20
sweeps. The major quirk in this scheme is the requirement of updating the
`matrixDiagonal`

using the entire coupled matrix. This could be achieved more
elegantly by calling `cacheMatrix()`

only on the necessary part of the
equation. This currently doesn’t work properly in FiPy.

```
>>> while timestep < totalSteps:
...
... sweep = 0
... dt *= 1.1
... residual = 1.
... initialResidual = None
...
... density.updateOld()
... velocity.updateOld()
... matrixDiagonal.updateOld()
...
... while residual > tolerance:
...
... densityPrevious[:] = density
... velocityPrevious[:] = velocity
... previousResidual = residual
...
... dt = min(dt, dx / max(abs(velocity)) * cfl)
...
... coupledEqn.cacheMatrix()
... residual = coupledEqn.sweep(dt=dt)
...
... if initialResidual is None:
... initialResidual = residual
...
... residual = residual / initialResidual
...
... if residual > previousResidual * 1.1 or sweep > 20:
... density[:] = density.old
... velocity[:] = velocity.old
... matrixDiagonal[:] = matrixDiagonal.old
... dt = dt / 10.
... if __name__ == '__main__':
... print 'Recalculate the time step'
... timestep -= 1
... break
... else:
... matrixDiagonal[:] = coupledEqn.matrix.takeDiagonal()[mesh.numberOfCells:2 * mesh.numberOfCells]
... density[:] = relaxation * density + (1 - relaxation) * densityPrevious
... velocity[:] = relaxation * velocity + (1 - relaxation) * velocityPrevious
...
... sweep += 1
...
... if __name__ == '__main__' and timestep % 10 == 0:
... print 'timestep: %i, dt: %1.5e, free energy: %1.5e' % (timestep, dt, freeEnergy)
... for viewer in viewers:
... viewer.plot()
...
... timestep += 1
```

```
>>> if __name__ == '__main__':
... raw_input('finished')
```

```
>>> print freeEnergy < 1.5e9
True
```

**FiPy: A Finite Volume PDE Solver Using Python**

Version 3.1.3-dev2-g11937196

### This Page

### Quick search

Enter search terms or a module, class or function name.

## Organizations

## Contact

Join our mailing list, open an issue at the tracker, or ask a question on StackOverflow.