polykin.thermo.acm¤

Wilson ¤

Wilson multicomponent activity coefficient model.

This model is based on the following molar excess Gibbs energy expression:

\[ \frac{g^{E}}{RT} = -\sum_{i} x_i\ln{\left(\sum_{j}{x_{j}\Lambda_{ij}}\right)} \]

where \(x_i\) are the mole fractions and \(\Lambda_{ij}\) are the interaction parameters.

In this particular implementation, the interaction parameters are allowed to depend on temperature according to the following empirical relationship (as done in Aspen Plus):

\[ \Lambda_{ij} = \exp( a_{ij} + b_{ij}/T + c_{ij} \ln{T} + d_{ij} T ) \]

Moreover, \(\Lambda_{ij} \neq \Lambda_{ji}\) and \(\Lambda_{ii}=1\).

References

G.M. Wilson, J. Am. Chem. Soc., 1964, 86, 127.

PARAMETER	DESCRIPTION
`N`	Number of components. TYPE: `int`
`a`	Matrix of interaction parameters, by default 0. TYPE: `FloatSquareMatrix(N, N) \| None` DEFAULT: `None`
`b`	Matrix of interaction parameters, by default 0. Unit = K. TYPE: `FloatSquareMatrix(N, N) \| None` DEFAULT: `None`
`c`	Matrix of interaction parameters, by default 0. TYPE: `FloatSquareMatrix(N, N) \| None` DEFAULT: `None`
`d`	Matrix of interaction parameters, by default 0. TYPE: `FloatSquareMatrix(N, N) \| None` DEFAULT: `None`
`name`	Name. TYPE: `str` DEFAULT: `''`

See also

Wilson_gamma: related activity coefficient method.

Source code in src/polykin/thermo/acm/wilson.py

class Wilson(SmallSpeciesActivityModel):
    r"""Wilson multicomponent activity coefficient model.

    This model is based on the following molar excess Gibbs energy
    expression:

    $$ \frac{g^{E}}{RT} =
        -\sum_{i} x_i\ln{\left(\sum_{j}{x_{j}\Lambda_{ij}}\right)} $$

    where $x_i$ are the mole fractions and $\Lambda_{ij}$ are the interaction
    parameters.

    In this particular implementation, the interaction parameters are allowed
    to depend on temperature according to the following empirical relationship
    (as done in Aspen Plus):

    $$ \Lambda_{ij} = \exp( a_{ij} + b_{ij}/T + c_{ij} \ln{T} + d_{ij} T ) $$

    Moreover, $\Lambda_{ij} \neq \Lambda_{ji}$ and $\Lambda_{ii}=1$.

    **References**

    *   G.M. Wilson, J. Am. Chem. Soc., 1964, 86, 127.

    Parameters
    ----------
    N : int
        Number of components.
    a : FloatSquareMatrix (N,N) | None
        Matrix of interaction parameters, by default 0.
    b : FloatSquareMatrix (N,N) | None
        Matrix of interaction parameters, by default 0. Unit = K.
    c : FloatSquareMatrix (N,N) | None
        Matrix of interaction parameters, by default 0.
    d : FloatSquareMatrix (N,N) | None
        Matrix of interaction parameters, by default 0.
    name: str
        Name.

    See also
    --------
    * [`Wilson_gamma`](Wilson_gamma.md): related activity coefficient
    method.

    """

    _a: FloatSquareMatrix
    _b: FloatSquareMatrix
    _c: FloatSquareMatrix
    _d: FloatSquareMatrix

    def __init__(self,
                 N: int,
                 a: Optional[FloatSquareMatrix] = None,
                 b: Optional[FloatSquareMatrix] = None,
                 c: Optional[FloatSquareMatrix] = None,
                 d: Optional[FloatSquareMatrix] = None,
                 name: str = ''
                 ) -> None:

        # Set default values
        if a is None:
            a = np.zeros((N, N))
        if b is None:
            b = np.zeros((N, N))
        if c is None:
            c = np.zeros((N, N))
        if d is None:
            d = np.zeros((N, N))

        # Check shapes
        for array in [a, b, c, d]:
            if array.shape != (N, N):
                raise ShapeError(
                    f"The shape of matrix {array} is invalid: {array.shape}.")

        # Check bounds (same as Aspen Plus)
        check_bounds(a, -50., 50., 'a')
        check_bounds(b, -1.5e4, 1.5e4, 'b')

        # Ensure Lambda_ii=1
        for array in [a, b, c, d]:
            np.fill_diagonal(array, 0.)

        super().__init__(N, name)
        self._a = a
        self._b = b
        self._c = c
        self._d = d

    @functools.cache
    def Lambda(self,
               T: float
               ) -> FloatSquareMatrix:
        r"""Compute the matrix of interaction parameters.

        $$ \Lambda_{ij}=\exp(a_{ij} + b_{ij}/T + c_{ij} \ln{T} + d_{ij} T) $$

        Parameters
        ----------
        T : float
            Temperature. Unit = K.

        Returns
        -------
        FloatSquareMatrix (N,N)
            Interaction parameters.
        """
        return exp(self._a + self._b/T + self._c*log(T) + self._d*T)

    def gE(self, T: float, x: FloatVector) -> float:
        return -R*T*dot(x, log(dot(self.Lambda(T), x)))

    def gamma(self, T: float, x: FloatVector) -> FloatVector:
        return Wilson_gamma(x, self.Lambda(T))

Dgmix ¤

Dgmix(T: float, x: FloatVector) -> float

Molar Gibbs energy of mixing, \(\Delta g_{mix}\).

\[ \Delta g_{mix} = \Delta h_{mix} -T \Delta s_{mix} \]

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`
`x`	Mole fractions of all components. Unit = mol/mol. TYPE: `FloatVector(N)`

RETURNS	DESCRIPTION
`float`	Molar Gibbs energy of mixing. Unit = J/mol.

Source code in src/polykin/thermo/acm/base.py

def Dgmix(self,
          T: float,
          x: FloatVector
          ) -> float:
    r"""Molar Gibbs energy of mixing, $\Delta g_{mix}$.

    $$ \Delta g_{mix} = \Delta h_{mix} -T \Delta s_{mix} $$

    Parameters
    ----------
    T : float
        Temperature. Unit = K.
    x : FloatVector (N)
        Mole fractions of all components. Unit = mol/mol.

    Returns
    -------
    float
        Molar Gibbs energy of mixing. Unit = J/mol.
    """
    return self.gE(T, x) - T*self._Dsmix_ideal(T, x)

Dhmix ¤

Dhmix(T: float, x: FloatVector) -> float

Molar enthalpy of mixing, \(\Delta h_{mix}\).

\[ \Delta h_{mix} = h^{E} \]

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`
`x`	Mole fractions of all components. Unit = mol/mol. TYPE: `FloatVector(N)`

RETURNS	DESCRIPTION
`float`	Molar enthalpy of mixing. Unit = J/mol.

Source code in src/polykin/thermo/acm/base.py

def Dhmix(self,
          T: float,
          x: FloatVector
          ) -> float:
    r"""Molar enthalpy of mixing, $\Delta h_{mix}$.

    $$ \Delta h_{mix} = h^{E} $$

    Parameters
    ----------
    T : float
        Temperature. Unit = K.
    x : FloatVector (N)
        Mole fractions of all components. Unit = mol/mol.

    Returns
    -------
    float
        Molar enthalpy of mixing. Unit = J/mol.
    """
    return self.hE(T, x)

Dsmix ¤

Dsmix(T: float, x: FloatVector) -> float

Molar entropy of mixing, \(\Delta s_{mix}\).

\[ \Delta s_{mix} = s^{E} - R \sum_i {x_i \ln{x_i}} \]

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`
`x`	Mole fractions of all components. Unit = mol/mol. TYPE: `FloatVector(N)`

RETURNS	DESCRIPTION
`float`	Molar entropy of mixing. Unit = J/(mol·K).

Source code in src/polykin/thermo/acm/base.py

def Dsmix(self,
          T: float,
          x: FloatVector
          ) -> float:
    r"""Molar entropy of mixing, $\Delta s_{mix}$.

    $$ \Delta s_{mix} = s^{E} - R \sum_i {x_i \ln{x_i}} $$

    Parameters
    ----------
    T : float
        Temperature. Unit = K.
    x : FloatVector (N)
        Mole fractions of all components. Unit = mol/mol.

    Returns
    -------
    float
        Molar entropy of mixing. Unit = J/(mol·K).
    """
    return self.sE(T, x) + self._Dsmix_ideal(T, x)

Lambda `cached` ¤

Lambda(T: float) -> FloatSquareMatrix

Compute the matrix of interaction parameters.

\[ \Lambda_{ij}=\exp(a_{ij} + b_{ij}/T + c_{ij} \ln{T} + d_{ij} T) \]

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`

RETURNS	DESCRIPTION
`FloatSquareMatrix(N, N)`	Interaction parameters.

Source code in src/polykin/thermo/acm/wilson.py

@functools.cache
def Lambda(self,
           T: float
           ) -> FloatSquareMatrix:
    r"""Compute the matrix of interaction parameters.

    $$ \Lambda_{ij}=\exp(a_{ij} + b_{ij}/T + c_{ij} \ln{T} + d_{ij} T) $$

    Parameters
    ----------
    T : float
        Temperature. Unit = K.

    Returns
    -------
    FloatSquareMatrix (N,N)
        Interaction parameters.
    """
    return exp(self._a + self._b/T + self._c*log(T) + self._d*T)

N `property` ¤

N: int

Number of components.

activity ¤

activity(T: float, x: FloatVector) -> FloatVector

Activities, \(a_i\).

\[ a_i = x_i \gamma_i \]

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`
`x`	Mole fractions of all components. Unit = mol/mol. TYPE: `FloatVector(N)`

RETURNS	DESCRIPTION
`FloatVector(N)`	Activities of all components.

Source code in src/polykin/thermo/acm/base.py

def activity(self,
             T: float,
             x: FloatVector
             ) -> FloatVector:
    r"""Activities, $a_i$.

    $$ a_i = x_i \gamma_i $$

    Parameters
    ----------
    T : float
        Temperature. Unit = K.
    x : FloatVector (N)
        Mole fractions of all components. Unit = mol/mol.

    Returns
    -------
    FloatVector (N)
        Activities of all components.
    """
    return x*self.gamma(T, x)

gE ¤

gE(T: float, x: FloatVector) -> float

Molar excess Gibbs energy, \(g^{E}\).

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`
`x`	Mole fractions of all components. Unit = mol/mol. TYPE: `FloatVector(N)`

RETURNS	DESCRIPTION
`float`	Molar excess Gibbs energy. Unit = J/mol.

Source code in src/polykin/thermo/acm/wilson.py

def gE(self, T: float, x: FloatVector) -> float:
    return -R*T*dot(x, log(dot(self.Lambda(T), x)))

gamma ¤

gamma(T: float, x: FloatVector) -> FloatVector

Activity coefficients based on mole fraction, \(\gamma_i\).

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`
`x`	Mole fractions of all components. Unit = mol/mol. TYPE: `FloatVector(N)`

RETURNS	DESCRIPTION
`FloatVector(N)`	Activity coefficients of all components.

Source code in src/polykin/thermo/acm/wilson.py

def gamma(self, T: float, x: FloatVector) -> FloatVector:
    return Wilson_gamma(x, self.Lambda(T))

hE ¤

hE(T: float, x: FloatVector) -> float

Molar excess enthalpy, \(h^{E}\).

\[ h^{E} = g^{E} + T s^{E} \]

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`
`x`	Mole fractions of all components. Unit = mol/mol. TYPE: `FloatVector(N)`

RETURNS	DESCRIPTION
`float`	Molar excess enthalpy. Unit = J/mol.

Source code in src/polykin/thermo/acm/base.py

def hE(self,
       T: float,
       x: FloatVector
       ) -> float:
    r"""Molar excess enthalpy, $h^{E}$.

    $$ h^{E} = g^{E} + T s^{E} $$

    Parameters
    ----------
    T : float
        Temperature. Unit = K.
    x : FloatVector (N)
        Mole fractions of all components. Unit = mol/mol.

    Returns
    -------
    float
        Molar excess enthalpy. Unit = J/mol.
    """
    return self.gE(T, x) + T*self.sE(T, x)

sE ¤

sE(T: float, x: FloatVector) -> float

Molar excess entropy, \(s^{E}\).

\[ s^{E} = -\left(\frac{\partial g^{E}}{\partial T}\right)_{P,x_i} \]

PARAMETER	DESCRIPTION
`T`	Temperature. Unit = K. TYPE: `float`
`x`	Mole fractions of all components. Unit = mol/mol. TYPE: `FloatVector(N)`

RETURNS	DESCRIPTION
`float`	Molar excess entropy. Unit = J/(mol·K).

Source code in src/polykin/thermo/acm/base.py

def sE(self,
       T: float,
       x: FloatVector
       ) -> float:
    r"""Molar excess entropy, $s^{E}$.

    $$ s^{E} = -\left(\frac{\partial g^{E}}{\partial T}\right)_{P,x_i} $$

    Parameters
    ----------
    T : float
        Temperature. Unit = K.
    x : FloatVector (N)
        Mole fractions of all components. Unit = mol/mol.

    Returns
    -------
    float
        Molar excess entropy. Unit = J/(mol·K).
    """
    return -1*derivative_complex(lambda t: self.gE(t, x), T)[0]

polykin.thermo.acm¤

Wilson ¤

Dgmix ¤

Dhmix ¤

Dsmix ¤

Lambda cached ¤

N property ¤

activity ¤

gE ¤

gamma ¤

hE ¤

sE ¤

Lambda `cached` ¤

N `property` ¤