pyEQL 0.5.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

pyEQL/solution.py

@@ -1,955 +1,1315 @@
 """
-pyEQL Solution Class
+pyEQL Solution Class.
 
-:copyright: 2013-2020 by Ryan S. Kingsbury
+:copyright: 2013-2024 by Ryan S. Kingsbury
 :license: LGPL, see LICENSE for more details.
 
 """
 
-# Dependencies
-# import libraries for scientific functions
-import math
-from pint import UndefinedUnitError
+from __future__ import annotations
 
-# internal pyEQL imports
-import pyEQL.activity_correction as ac
-import pyEQL.water_properties as h2o
-import pyEQL.solute as sol
-import pyEQL.salt_ion_match as salt
-
-# the pint unit registry
-from pyEQL import unit
-
-# import the parameters database
-from pyEQL import paramsDB as db
-
-# add a filter to emit only unique log messages to the handler
-from pyEQL.logging_system import Unique
-
-# logging system
 import logging
+import os
+import warnings
+from functools import lru_cache
+from importlib.resources import files
+from pathlib import Path
+from typing import Any, Literal
+
+import numpy as np
+from maggma.stores import JSONStore, Store
+from monty.dev import deprecated
+from monty.json import MontyDecoder, MSONable
+from monty.serialization import dumpfn, loadfn
+from pint import DimensionalityError, Quantity
+from pymatgen.core import Element
+from pymatgen.core.ion import Ion
+
+from pyEQL import IonDB, ureg
+from pyEQL.activity_correction import _debye_parameter_activity, _debye_parameter_B
+from pyEQL.engines import EOS, IdealEOS, NativeEOS, PhreeqcEOS
+from pyEQL.salt_ion_match import Salt
+from pyEQL.solute import Solute
+from pyEQL.utils import FormulaDict, create_water_substance, interpret_units, standardize_formula
+
+EQUIV_WT_CACO3 = ureg.Quantity(100.09 / 2, "g/mol")
+# string to denote unknown oxidation states
+UNKNOWN_OXI_STATE = "unk"
+
+
+class Solution(MSONable):
+    """
+    Class representing the properties of a solution. Instances of this class
+    contain information about the solutes, solvent, and bulk properties.
+    """
 
-logger = logging.getLogger(__name__)
-
-unique = Unique()
-logger.addFilter(unique)
-
-# add a handler for console output, since pyEQL is meant to be used interactively
-ch = logging.StreamHandler()
+    def __init__(
+        self,
+        solutes: list[list[str]] | dict[str, str] | None = None,
+        volume: str | None = None,
+        temperature: str = "298.15 K",
+        pressure: str = "1 atm",
+        pH: float = 7,
+        pE: float = 8.5,
+        balance_charge: str | None = None,
+        solvent: str | list = "H2O",
+        engine: EOS | Literal["native", "ideal", "phreeqc"] = "native",
+        database: str | Path | Store | None = None,
+        default_diffusion_coeff: float = 1.6106e-9,
+        log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = "ERROR",
+    ) -> None:
+        """
+        Instantiate a Solution from a composition.
 
-# create formatter for the log
-formatter = logging.Formatter("(%(name)s) - %(levelname)s - %(message)s")
+        Args:
+            solutes: dict, optional. Keys must be the chemical formula, while values must be
+                str Quantity representing the amount. For example:
 
-# add formatter to the handler
-ch.setFormatter(formatter)
-logger.addHandler(ch)
+                {"Na+": "0.1 mol/L", "Cl-": "0.1 mol/L"}
 
+                Note that an older "list of lists" syntax is also supported; however this
+                will be deprecated in the future and is no longer recommended. The equivalent
+                list syntax for the above example is
 
-class Solution:
-    """
-    Class representing the properties of a solution. Instances of this class
-    contain information about the solutes, solvent, and bulk properties.
+                [["Na+", "0.1 mol/L"], ["Cl-", "0.1 mol/L"]]
 
-    Parameters
-    ----------
-    solutes : list of lists, optional
-                See add_solute() documentation for formatting of this list.
                 Defaults to empty (pure solvent) if omitted
-    volume : str, optional
+            volume: str, optional
                 Volume of the solvent, including the unit. Defaults to '1 L' if omitted.
                 Note that the total solution volume will be computed using partial molar
                 volumes of the respective solutes as they are added to the solution.
-    temperature : str, optional
-                The solution temperature, including the unit. Defaults to '25 degC' if omitted.
-    pressure : Quantity, optional
+            temperature: str, optional
+                The solution temperature, including the ureg. Defaults to '25 degC' if omitted.
+            pressure: Quantity, optional
                 The ambient pressure of the solution, including the unit.
                 Defaults to '1 atm' if omitted.
-    pH : number, optional
+            pH: number, optional
                 Negative log of H+ activity. If omitted, the solution will be
                 initialized to pH 7 (neutral) with appropriate quantities of
                 H+ and OH- ions
+            pE: the pE value (redox potential) of the solution.     Lower values = more reducing,
+                higher values = more oxidizing. At pH 7, water is stable between approximately
+                -7 to +14. The default value corresponds to a pE value typical of natural
+                waters in equilibrium with the atmosphere.
+            balance_charge: The strategy for balancing charge during init and equilibrium calculations. Valid options
+                are 'pH', which will adjust the solution pH to balance charge, 'pE' which will adjust the
+                redox equilibrium to balance charge, or the name of a dissolved species e.g. 'Ca+2' or 'Cl-'
+                that will be added/subtracted to balance charge. If set to None, no charge balancing will be
+                performed either on init or when equilibrate() is called. Note that in this case, equilibrate()
+                can distort the charge balance!
+            solvent: Formula of the solvent. Solvents other than water are not supported at this time.
+            engine: Electrolyte modeling engine to use. See documentation for details on the available engines.
+            database: path to a .json file (str or Path) or maggma Store instance that
+                contains serialized SoluteDocs. `None` (default) will use the built-in pyEQL database.
+            log_level: Log messages of this or higher severity will be printed to stdout. Defaults to 'ERROR', meaning
+                that ERROR and CRITICAL messages will be shown, while WARNING, INFO, and DEBUG messages are not. If set to None, nothing will be printed.
+            default_diffusion_coeff: Diffusion coefficient value in m^2/s to use in
+                calculations when there is no diffusion coefficient for a species in the database. This affects several
+                important property calculations including conductivity and transport number, which are related to the
+                weighted sums of diffusion coefficients of all species. Setting this argument to zero will exclude any
+                species that does not have a tabulated diffusion coefficient from these calculations, possibly resulting
+                in underestimation of the conductivity and/or inaccurate transport numbers.
+
+                Missing diffusion coefficients are especially likely in complex electrolytes containing, for example,
+                complexes or paired species such as NaSO4[-1]. In such cases, setting default_diffusion_coeff  to zero
+                is likely to result in the above errors.
+
+                By default, this argument is set to the diffusion coefficient of NaCl salt, 1.61x10^-9 m2/s.
+
+        Examples:
+            >>> s1 = pyEQL.Solution({'Na+': '1 mol/L','Cl-': '1 mol/L'},temperature='20 degC',volume='500 mL')
+            >>> print(s1)
+            Components:
+            Volume: 0.500 l
+            Pressure: 1.000 atm
+            Temperature: 293.150 K
+            Components: ['H2O(aq)', 'H[+1]', 'OH[-1]', 'Na[+1]', 'Cl[-1]']
+        """
+        # create a logger and attach it to this class
+        self.log_level = log_level.upper()
+        self.logger = logging.getLogger("pyEQL")
+        if self.log_level is not None:
+            # set the level of the module logger
+            self.logger.setLevel(self.log_level)
+            # clear handlers and add a StreamHandler
+            self.logger.handlers.clear()
+            # use rich for pretty log formatting, if installed
+            try:
+                from rich.logging import RichHandler
+
+                sh = RichHandler(rich_tracebacks=True)
+            except ImportError:
+                sh = logging.StreamHandler()
+            # the formatter determines what our logs will look like
+            formatter = logging.Formatter("[%(asctime)s] [%(levelname)8s] --- %(message)s (%(filename)s:%(lineno)d)")
+            sh.setFormatter(formatter)
+            self.logger.addHandler(sh)
+
+        # per-instance cache of get_property and other calls that do not depend
+        # on composition
+        # see https://rednafi.com/python/lru_cache_on_methods/
+        self.get_property = lru_cache()(self._get_property)
+        self.get_molar_conductivity = lru_cache()(self._get_molar_conductivity)
+        self.get_mobility = lru_cache()(self._get_mobility)
+        self.default_diffusion_coeff = default_diffusion_coeff
+        self.get_diffusion_coefficient = lru_cache()(self._get_diffusion_coefficient)
 
-    Returns
-    -------
-    Solution
-        A Solution object.
-
-    Examples
-    --------
-    >>> s1 = pyEQL.Solution([['Na+','1 mol/L'],['Cl-','1 mol/L']],temperature='20 degC',volume='500 mL')
-    >>> print(s1)
-    Components:
-    ['H2O', 'Cl-', 'H+', 'OH-', 'Na+']
-    Volume: 0.5 l
-    Density: 1.0383030844030992 kg/l
-
-    See Also
-    --------
-    add_solute
-
-    """
-
-    def __init__(self, solutes=[], **kwargs):
+        # initialize the volume recalculation flag
+        self.volume_update_required = False
 
-        # initialize the volume
-        if "volume" in kwargs:
-            volume_set = True
-            self.volume = unit(kwargs["volume"])
+        # initialize the volume with a flag to distinguish user-specified volume
+        if volume is not None:
+            # volume_set = True
+            self._volume = ureg.Quantity(volume).to("L")
         else:
-            volume_set = False
-            self.volume = unit("1 L")
-
-        # set the temperature
-        if "temperature" in kwargs:
-            self.temperature = unit(kwargs["temperature"])
+            # volume_set = False
+            self._volume = ureg.Quantity(1, "L")
+        # store the initial conditions as private variables in case they are
+        # changed later
+        self._temperature = ureg.Quantity(temperature)
+        self._pressure = ureg.Quantity(pressure)
+        self._pE = pE
+        self._pH = pH
+        self.pE = self._pE
+        if isinstance(balance_charge, str) and balance_charge not in ["pH", "pE"]:
+            self.balance_charge = standardize_formula(balance_charge)
         else:
-            self.temperature = unit("25 degC")
-
-        # set the pressure
-        if "pressure" in kwargs:
-            self.pressure = unit(kwargs["pressure"])
+            self.balance_charge = balance_charge  #: Standardized formula of the species used for charge balancing.
+
+        # instantiate a water substance for property retrieval
+        self.water_substance = create_water_substance(self.temperature, self.pressure)
+        """IAPWS instance describing water properties."""
+
+        # create an empty dictionary of components. This dict comprises {formula: moles}
+        #  where moles is the number of moles in the solution.
+        self.components = FormulaDict({})
+        """Special dictionary where keys are standardized formula and values are the moles present in Solution."""
+
+        # connect to the desired property database
+        if database is None:
+            # load the default database, which is a JSONStore
+            db_store = IonDB
+        elif isinstance(database, (str, Path)):
+            db_store = JSONStore(str(database), key="formula")
+            self.logger.debug(f"Created maggma JSONStore from .json file {database}")
         else:
-            self.pressure = unit("1 atm")
-
-        # create an empty dictionary of components
-        self.components = {}
-
-        # initialize the volume recalculation flag
-        self.volume_update_required = False
-
-        # define the solvent
-        if "solvent" in kwargs:
-            self.solvent_name = kwargs["solvent"][0]
-            # warn if the solvent is anything besides water
-            if not kwargs["solvent"][0] == "H2O" or kwargs["solvent"][0] == "water":
-                logger.error(
-                    "Non-aqueous solvent detected. These are not yet supported!"
-                )
-
-            # raise an error if the solvent volume has also been given
-            if volume_set is True:
-                logger.error(
-                    "Solvent volume and mass cannot both be specified. Calculating volume based on solvent mass."
-                )
-
-            # add the solvent and the mass
-            self.add_solvent(self.solvent_name, kwargs["solvent"][1])
+            db_store = database
+        self.database = db_store
+        """`Store` instance containing the solute property database."""
+        self.database.connect()
+        self.logger.debug(f"Connected to property database {self.database!s}")
+
+        # set the equation of state engine
+        self._engine = engine
+        # self.engine: Optional[EOS] = None
+        if isinstance(self._engine, EOS):
+            self.engine: EOS = self._engine
+        elif self._engine == "ideal":
+            self.engine = IdealEOS()
+        elif self._engine == "native":
+            self.engine = NativeEOS()
+        elif self._engine == "phreeqc":
+            self.engine = PhreeqcEOS()
         else:
-            self.solvent_name = "H2O"
-
-            # calculate the solvent (water) mass based on the density and the solution volume
-            self.add_solvent(
-                self.solvent_name,
-                str(self.volume * h2o.water_density(self.temperature)),
-            )
+            raise ValueError(f'{engine} is not a valid value for the "engine" kwarg!')
+
+        # define the solvent. Allow for list input to support future use of mixed solvents
+        if not isinstance(solvent, list):
+            solvent = [solvent]
+        if len(solvent) > 1:
+            raise ValueError("Multiple solvents are not yet supported!")
+        if solvent[0] not in ["H2O", "H2O(aq)", "water", "Water", "HOH"]:
+            raise ValueError("Non-aqueous solvent detected. These are not yet supported!")
+        self.solvent = standardize_formula(solvent[0])
+        """Formula of the component that is set as the solvent (currently only H2O(aq) is supported)."""
+
+        # TODO - do I need the ability to specify the solvent mass?
+        # # raise an error if the solvent volume has also been given
+        # if volume_set is True:
+        #     self.logger.error(
+        #         "Solvent volume and mass cannot both be specified. Calculating volume based on solvent mass."
+        #     )
+        # # add the solvent and the mass
+        # self.add_solvent(self.solvent, kwargs["solvent"][1])
+
+        # calculate the moles of solvent (water) on the density and the solution volume
+        moles = self.volume.magnitude / 55.55  # molarity of pure water
+        self.components["H2O"] = moles
 
         # set the pH with H+ and OH-
-        if "pH" in kwargs:
-            pH = kwargs["pH"]
-        else:
-            pH = 7
-
         self.add_solute("H+", str(10 ** (-1 * pH)) + "mol/L")
         self.add_solute("OH-", str(10 ** (-1 * (14 - pH))) + "mol/L")
 
         # populate the other solutes
-        for item in solutes:
-            self.add_solute(*item)
-
-    def add_solute(self, formula, amount, parameters={}):
-        """
-        Primary method for adding substances to a pyEQL solution
-
-        Parameters
-        ----------
-        formula : str
-                    Chemical formula for the solute.
-                    Charged species must contain a + or - and (for polyvalent solutes) a number representing the net
-                    charge (e.g. 'SO4-2').
-        amount : str
-                    The amount of substance in the specified unit system. The string should contain both a quantity and
-                    a pint-compatible representation of a unit. e.g. '5 mol/kg' or '0.1 g/L'
-        parameters : dictionary, optional
-                    Dictionary of custom parameters, such as diffusion coefficients, transport numbers, etc. Specify
-                    parameters as key:value pairs separated by commas within curly braces, e.g. {diffusion_coeff:5e-10,
-                    transport_number:0.8}. The 'key' is the name that will be used to access the parameter, the value
-                    is its value.
-
-        """
-
-        # if units are given on a per-volume basis,
-        # iteratively solve for the amount of solute that will preserve the
-        # original volume and result in the desired concentration
-        if unit(amount).dimensionality in (
-            "[substance]/[length]**3",
-            "[mass]/[length]**3",
-        ):
-
-            # store the original volume for later
-            orig_volume = self.get_volume()
-
-            # add the new solute
-            new_solute = sol.Solute(
-                formula, amount, self.get_volume(), self.get_solvent_mass(), parameters
+        self._solutes = solutes
+        if self._solutes is None:
+            self._solutes = {}
+        if isinstance(self._solutes, dict):
+            for k, v in self._solutes.items():
+                self.add_solute(k, v)
+        elif isinstance(self._solutes, list):
+            msg = (
+                'List input of solutes (e.g., [["Na+", "0.5 mol/L]]) is deprecated! Use dictionary formatted input '
+                '(e.g., {"Na+":"0.5 mol/L"} instead.)'
             )
-            self.components.update({new_solute.get_name(): new_solute})
-
-            # calculate the volume occupied by all the solutes
-            solute_vol = self._get_solute_volume()
-
-            # determine the volume of solvent that will preserve the original volume
-            target_vol = orig_volume - solute_vol
-
-            # adjust the amount of solvent
-            target_mass = target_vol * h2o.water_density(self.get_temperature())
-            mw = self.get_solvent().get_molecular_weight()
-            target_mol = target_mass / mw
-            self.get_solvent().moles = target_mol
-
-        else:
-
-            # add the new solute
-            new_solute = sol.Solute(
-                formula, amount, self.get_volume(), self.get_solvent_mass(), parameters
+            self.logger.warning(msg)
+            warnings.warn(msg, DeprecationWarning)
+            for item in self._solutes:
+                self.add_solute(*item)
+
+        # adjust the charge balance, if necessary
+        cb = self.charge_balance
+        if not np.isclose(cb, 0, atol=1e-8) and self.balance_charge is not None:
+            balanced = False
+            self.logger.info(
+                f"Solution is not electroneutral (C.B. = {cb} eq/L). Adding {balance_charge} to compensate."
             )
-            self.components.update({new_solute.get_name(): new_solute})
-
-            # update the volume to account for the space occupied by all the solutes
-            # make sure that there is still solvent present in the first place
-            if self.get_solvent_mass() <= unit("0 kg"):
-                logger.error("All solvent has been depleted from the solution")
-                return None
+            if self.balance_charge == "pH":
+                self.components["H+"] += (
+                    -1 * cb * self.volume.to("L").magnitude
+                )  # if C.B. is negative, we need to add cations. H+ is 1 eq/mol
+                balanced = True
+            elif self.balance_charge == "pE":
+                raise NotImplementedError("Balancing charge via redox (pE) is not yet implemented!")
             else:
-                # set the volume recalculation flag
-                self.volume_update_required = True
+                ions = set().union(*[self.cations, self.anions])  # all ions
+                if self.balance_charge not in ions:
+                    raise ValueError(
+                        f"Charge balancing species {self.balance_charge} was not found in the solution!. "
+                        f"Species {ions} were found."
+                    )
+                z = self.get_property(balance_charge, "charge")
+                self.components[balance_charge] += -1 * cb / z * self.volume.to("L").magnitude
+                balanced = True
 
-    def add_solvent(self, formula, amount):
-        """
-        Same as add_solute but omits the need to pass solvent mass to pint
-        """
-        new_solvent = sol.Solute(formula, amount, self.get_volume(), amount)
-        self.components.update({new_solvent.get_name(): new_solvent})
+            if not balanced:
+                warnings.warn(f"Unable to balance charge using species {self.balance_charge}")
 
-    def get_solute(self, i):
+    @property
+    def mass(self) -> Quantity:
         """
-        Return the specified solute object.
+        Return the total mass of the solution.
 
-        """
-        return self.components[i]
+        The mass is calculated each time this method is called.
 
-    def get_solvent(self):
-        """
-        Return the solvent object.
+        Returns: The mass of the solution, in kg
 
         """
-        return self.components[self.solvent_name]
+        mass = np.sum([self.get_amount(item, "kg").magnitude for item in self.components])
+        return ureg.Quantity(mass, "kg")
 
-    def get_temperature(self):
+    @property
+    def solvent_mass(self) -> Quantity:
         """
-        Return the temperature of the solution.
+        Return the mass of the solvent.
 
-        Parameters
-        ----------
-        None
+        This property is used whenever mol/kg (or similar) concentrations
+        are requested by get_amount()
 
-        Returns
-        -------
-        Quantity: The temperature of the solution, in Kelvin.
-        """
-        return self.temperature.to("K")
+        Returns:
+            The mass of the solvent, in kg
 
-    def set_temperature(self, temperature):
+        See Also:
+            :py:meth:`get_amount()`
         """
-        Set the solution temperature.
+        return self.get_amount(self.solvent, "kg")
 
-        Parameters
-        ----------
-        temperature : str
-            String representing the temperature, e.g. '25 degC'
+    @property
+    def volume(self) -> Quantity:
         """
-        self.temperature = unit(temperature)
-
-        # recalculate the volume
-        self._update_volume()
+        Return the volume of the solution.
 
-    def get_pressure(self):
+        Returns:
+            Quantity: the volume of the solution, in L
         """
-        Return the hydrostatic pressure of the solution.
+        # if the composition has changed, recalculate the volume first
+        if self.volume_update_required is True:
+            self._update_volume()
+            self.volume_update_required = False
 
-        Returns
-        -------
-        Quantity: The hydrostatic pressure of the solution, in atm.
-        """
-        return self.pressure.to("atm")
+        return self._volume.to("L")
 
-    def set_pressure(self, pressure):
-        """
-        Set the hydrostatic pressure of the solution.
+    @volume.setter
+    def volume(self, volume: str):
+        """Change the total solution volume to volume, while preserving
+        all component concentrations.
 
-        Parameters
-        ----------
-        pressure : str
-            String representing the temperature, e.g. '25 degC'
-        """
-        self.pressure = unit(pressure)
+        Args:
+            volume : Total volume of the solution, including the unit, e.g. '1 L'
 
-        # recalculate the volume
-        self._update_volume()
+        Examples:
+            >>> mysol = Solution([['Na+','2 mol/L'],['Cl-','0.01 mol/L']],volume='500 mL')
+            >>> print(mysol.volume)
+            0.5000883925072983 l
+            >>> mysol.list_concentrations()
+            {'H2O': '55.508435061791985 mol/kg', 'Cl-': '0.00992937605907076 mol/kg', 'Na+': '2.0059345573880325 mol/kg'}
+            >>> mysol.volume = '200 mL')
+            >>> print(mysol.volume)
+            0.2 l
+            >>> mysol.list_concentrations()
+            {'H2O': '55.50843506179199 mol/kg', 'Cl-': '0.00992937605907076 mol/kg', 'Na+': '2.0059345573880325 mol/kg'}
 
-    def get_solvent_mass(self):
         """
-        Return the mass of the solvent.
+        # figure out the factor to multiply the old concentrations by
+        scale_factor = ureg.Quantity(volume) / self.volume
 
-        This method is used whenever mol/kg (or similar) concentrations
-        are requested by get_amount()
+        # scale down the amount of all the solutes according to the factor
+        for solute in self.components:
+            self.components[solute] *= scale_factor.magnitude
 
-        Parameters
-        ----------
-        None
+        # update the solution volume
+        self._volume *= scale_factor.magnitude
 
-        Returns
-        -------
-        Quantity: the mass of the solvent, in kg
+    @property
+    def temperature(self) -> Quantity:
+        """Return the temperature of the solution in Kelvin."""
+        return self._temperature.to("K")
 
-        See Also
-        --------
-        get_amount
+    @temperature.setter
+    def temperature(self, temperature: str):
         """
-        # return the total mass (kg) of the solvent
-        solvent = self.get_solvent()
-        mw = solvent.get_molecular_weight()
-
-        return solvent.get_moles().to("kg", "chem", mw=mw)
+        Set the solution temperature.
 
-    def get_volume(self):
+        Args:
+            temperature: pint-compatible string, e.g. '25 degC'
         """
-        Return the volume of the solution.
-
-        Parameters
-        ----------
-        None
+        self._temperature = ureg.Quantity(temperature)
 
-        Returns
-        -------
-        Quantity: the volume of the solution, in L
-        """
+        # update the water substance
+        self.water_substance = create_water_substance(self.temperature, self.pressure)
 
-        # if the composition has changed, recalculate the volume first
-        if self.volume_update_required is True:
-            self._update_volume()
-            self.volume_update_required = False
+        # recalculate the volume
+        self.volume_update_required = True
 
-        return self.volume.to("L")
+        # clear any cached solute properties that may depend on temperature
+        self.get_property.cache_clear()
+        self.get_molar_conductivity.cache_clear()
+        self.get_mobility.cache_clear()
+        self.get_diffusion_coefficient.cache_clear()
 
-    def set_volume(self, volume):
-        """Change the total solution volume to volume, while preserving
-        all component concentrations
+    @property
+    def pressure(self) -> Quantity:
+        """Return the hydrostatic pressure of the solution in atm."""
+        return self._pressure.to("atm")
 
-        Parameters
-        ----------
-        volume : str quantity
-                Total volume of the solution, including the unit, e.g. '1 L'
-
-        Examples
-        ---------
-        >>> mysol = Solution([['Na+','2 mol/L'],['Cl-','0.01 mol/L']],volume='500 mL')
-        >>> print(mysol.get_volume())
-        0.5000883925072983 l
-        >>> mysol.list_concentrations()
-        {'H2O': '55.508435061791985 mol/kg', 'Cl-': '0.00992937605907076 mol/kg', 'Na+': '2.0059345573880325 mol/kg'}
-        >>> mysol.set_volume('200 mL')
-        >>> print(mysol.get_volume())
-        0.2 l
-        >>> mysol.list_concentrations()
-        {'H2O': '55.50843506179199 mol/kg', 'Cl-': '0.00992937605907076 mol/kg', 'Na+': '2.0059345573880325 mol/kg'}
+    @pressure.setter
+    def pressure(self, pressure: str):
+        """
+        Set the solution pressure.
 
+        Args:
+            pressure: pint-compatible string, e.g. '1.2 atmC'
         """
-        # figure out the factor to multiply the old concentrations by
-        scale_factor = unit(volume) / self.get_volume()
+        self._pressure = ureg.Quantity(pressure)
 
-        # scale down the amount of all the solutes according to the factor
-        for item in self.components:
-            self.get_solute(item).moles = self.get_solute(item).moles * scale_factor
+        # update the water substance
+        self.water_substance = create_water_substance(self.temperature, self.pressure)
 
-        # update the solution volume
-        self.volume = unit(volume)
+        # recalculate the volume
+        self.volume_update_required = True
+
+    @property
+    def pH(self) -> float | None:
+        """Return the pH of the solution."""
+        return self.p("H+", activity=False)
 
-    def get_mass(self):
+    def p(self, solute: str, activity=True) -> float | None:
         """
-        Return the total mass of the solution.
+        Return the negative log of the activity of solute.
 
-        The mass is calculated each time this method is called.
-        Parameters
-        ----------
-        None
+        Generally used for expressing concentration of hydrogen ions (pH)
 
-        Returns
-        -------
-        Quantity: the mass of the solution, in kg
+        Args:
+            solute : str
+                String representing the formula of the solute
+            activity: bool, optional
+                If False, the function will use the molar concentration rather
+                than the activity to calculate p. Defaults to True.
 
+        Returns:
+            Quantity
+                The negative log10 of the activity (or molar concentration if
+                activity = False) of the solute.
         """
-        total_mass = 0
-        for item in self.components:
-            total_mass += self.get_amount(item, "kg")
-        return total_mass.to("kg")
+        try:
+            # TODO - for some reason this specific method requires the use of math.log10 rather than np.log10.
+            # Using np.exp raises ZeroDivisionError
+            import math
+
+            if activity is True:
+                return -1 * math.log10(self.get_activity(solute))
+            return -1 * math.log10(self.get_amount(solute, "mol/L").magnitude)
+        # if the solute has zero concentration, the log will generate a ValueError
+        except ValueError:
+            return 0
 
-    def get_density(self):
+    @property
+    def density(self) -> Quantity:
         """
         Return the density of the solution.
 
         Density is calculated from the mass and volume each time this method is called.
 
-        Returns
-        -------
-        Quantity: The density of the solution.
+        Returns:
+            Quantity: The density of the solution.
         """
-        return self.get_mass() / self.get_volume()
+        return self.mass / self.volume
 
-    def get_dielectric_constant(self):
-        """
+    @property
+    def dielectric_constant(self) -> Quantity:
+        r"""
         Returns the dielectric constant of the solution.
 
-        Parameters
-        ----------
-        None
+        Args:
+            None
 
-        Returns
-        -------
-        Quantity: the dielectric constant of the solution, dimensionless.
+        Returns:
+            Quantity: the dielectric constant of the solution, dimensionless.
 
-        Notes
-        -----
-        Implements the following equation as given by [#]_
+        Notes:
+            Implements the following equation as given by Zuber et al.
 
-        .. math:: \\epsilon = \\epsilon_solvent \\over 1 + \\sum_i \\alpha_i x_i
+            .. math:: \epsilon = \epsilon_{solvent} \over 1 + \sum_i \alpha_i x_i
 
-        where :math:`\\alpha_i` is a coefficient specific to the solvent and ion, and :math:`x_i`
-        is the mole fraction of the ion in solution.
+            where :math:`\alpha_i` is a coefficient specific to the solvent and ion, and :math:`x_i`
+            is the mole fraction of the ion in solution.
 
 
-        References
-        ----------
-        .. [#] [1] A. Zuber, L. Cardozo-Filho, V.F. Cabral, R.F. Checoni, M. Castier, \
-        An empirical equation for the dielectric constant in aqueous and nonaqueous \
-        electrolyte mixtures, Fluid Phase Equilib. 376 (2014) 116–123. \
-        doi:10.1016/j.fluid.2014.05.037.
+        References:
+            A. Zuber, L. Cardozo-Filho, V.F. Cabral, R.F. Checoni, M. Castier,
+            An empirical equation for the dielectric constant in aqueous and nonaqueous
+            electrolyte mixtures, Fluid Phase Equilib. 376 (2014) 116-123.
+            doi:10.1016/j.fluid.2014.05.037.
         """
-        di_water = h2o.water_dielectric_constant(self.get_temperature())
+        di_water = self.water_substance.epsilon
 
         denominator = 1
         for item in self.components:
             # ignore water
-            if item != "H2O":
+            if item != "H2O(aq)":
                 # skip over solutes that don't have parameters
-                try:
-                    fraction = self.get_amount(item, "fraction")
-                    coefficient = self.get_solute(item).get_parameter(
-                        "dielectric_parameter_water"
-                    )
+                # try:
+                fraction = self.get_amount(item, "fraction")
+                coefficient = self.get_property(item, "model_parameters.dielectric_zuber")
+                if coefficient is not None:
                     denominator += coefficient * fraction
-                except TypeError:
-                    logger.warning(
-                        "No dielectric parameters found for species %s." % item
-                    )
-                    continue
+                # except TypeError:
+                #     self.logger.warning("No dielectric parameters found for species %s." % item)
+                # continue
+
+        return ureg.Quantity(di_water / denominator, "dimensionless")
 
-        dielectric_constant = di_water / denominator
+    @property
+    def chemical_system(self) -> str:
+        """
+        Return the chemical system of the Solution as a "-" separated list of elements, sorted alphabetically. For
+        example, a solution containing CaCO3 would have a chemical system of "C-Ca-H-O".
+        """
+        return "-".join(self.elements)
 
-        return dielectric_constant
+    @property
+    def elements(self) -> list:
+        """
+        Return a list of elements that are present in the solution.
 
-    def get_viscosity_relative(self):
+        For example, a solution containing CaCO3 would return ["C", "Ca", "H", "O"]
         """
-        Return the viscosity of the solution relative to that of water
+        els = []
+        for s in self.components:
+            els.extend(self.get_property(s, "elements"))
+        return sorted(set(els))
 
-        This is calculated using a simplified form of the Jones-Dole equation:
+    @property
+    def cations(self) -> dict[str, float]:
+        """
+        Returns the subset of `components` that are cations.
 
-        .. math:: \\eta_{rel} = 1 + \\sum_i B_i m_i
+        The returned dict is sorted by amount in descending order.
+        """
+        return {k: v for k, v in self.components.items() if self.get_property(k, "charge") > 0}
 
-        Where :math:`m` is the molal concentration and :math:`B` is an empirical parameter.
+    @property
+    def anions(self) -> dict[str, float]:
+        """
+        Returns the subset of `components` that are anions.
 
-        See
-        <http://downloads.olisystems.com/ResourceCD/TransportProperties/Viscosity-Aqueous.pdf>
-        <http://www.nrcresearchpress.com/doi/pdf/10.1139/v77-148>
-        <http://apple.csgi.unifi.it/~fratini/chen/pdf/14.pdf>
+        The returned dict is sorted by amount in descending order.
         """
-        # if self.get_ionic_strength().magnitude > 0.2:
-        #   logger.warning('Viscosity calculation has limited accuracy above 0.2m')
+        return {k: v for k, v in self.components.items() if self.get_property(k, "charge") < 0}
 
-        #        viscosity_rel = 1
-        #        for item in self.components:
-        #            # ignore water
-        #            if item != 'H2O':
-        #                # skip over solutes that don't have parameters
-        #                try:
-        #                    conc = self.get_amount(item,'mol/kg').magnitude
-        #                    coefficients= self.get_solute(item).get_parameter('jones_dole_viscosity')
-        #                    viscosity_rel += coefficients[0] * conc ** 0.5 + coefficients[1] * conc + \
-        #                    coefficients[2] * conc ** 2
-        #                except TypeError:
-        #                    continue
-        viscosity_rel = self.get_viscosity_dynamic() / h2o.water_viscosity_dynamic(
-            self.get_temperature(), self.get_pressure()
-        )
+    @property
+    def neutrals(self) -> dict[str, float]:
+        """
+        Returns the subset of `components` that are neutral (not charged).
 
-        return viscosity_rel
+        The returned dict is sorted by amount in descending order.
+        """
+        return {k: v for k, v in self.components.items() if self.get_property(k, "charge") == 0}
 
-    def get_viscosity_dynamic(self):
+    # TODO - need tests for viscosity
+    @property
+    def viscosity_dynamic(self) -> Quantity:
         """
         Return the dynamic (absolute) viscosity of the solution.
 
         Calculated from the kinematic viscosity
 
-        See Also
-        --------
-        get_viscosity_kinematic
-        get_viscosity_relative
-        """
-        return self.get_viscosity_kinematic() * self.get_density()
-
-    def get_viscosity_kinematic(self):
-        """
+        See Also:
+            :attr:`viscosity_kinematic`
+        """
+        return self.viscosity_kinematic * self.density
+
+    # TODO - before deprecating get_viscosity_relative, consider whether the Jones-Dole
+    # model should be integrated here as a fallback, in case salt parameters for the
+    # other model are not available.
+    # if self.ionic_strength.magnitude > 0.2:
+    #   self.logger.warning('Viscosity calculation has limited accuracy above 0.2m')
+
+    #        viscosity_rel = 1
+    #        for item in self.components:
+    #            # ignore water
+    #            if item != 'H2O':
+    #                # skip over solutes that don't have parameters
+    #                try:
+    #                    conc = self.get_amount(item,'mol/kg').magnitude
+    #                    coefficients= self.get_property(item, 'jones_dole_viscosity')
+    #                    viscosity_rel += coefficients[0] * conc ** 0.5 + coefficients[1] * conc + \
+    #                    coefficients[2] * conc ** 2
+    #                except TypeError:
+    #                    continue
+    # return (
+    #     self.viscosity_dynamic / self.water_substance.mu * ureg.Quantity("1 Pa*s")
+    # )
+    @property
+    def viscosity_kinematic(self) -> Quantity:
+        r"""
         Return the kinematic viscosity of the solution.
 
-        Notes
-        -----
-        The calculation is based on a model derived from the Eyring equation
-        and presented in [#]_
+        Notes:
+            The calculation is based on a model derived from the Eyring equation
+            and presented in
 
-        .. math::
+            .. math::
 
-            \\ln \\nu = \\ln {\\nu_w MW_w \over \sum_i x_i MW_i } +
-            15 x_+^2 + x_+^3  \delta G^*_{123} + 3 x_+ \delta G^*_{23} (1-0.05x_+)
+                \ln \nu = \ln {\nu_w MW_w \over \sum_i x_i MW_i } +
+                15 x_+^2 + x_+^3  \delta G^*_{123} + 3 x_+ \delta G^*_{23} (1-0.05x_+)
 
-        Where:
+            Where:
 
-        .. math:: \delta G^*_{123} = a_o + a_1 (T)^{0.75}
-        .. math:: \delta G^*_{23} = b_o + b_1 (T)^{0.5}
+            .. math:: \delta G^*_{123} = a_o + a_1 (T)^{0.75}
+            .. math:: \delta G^*_{23} = b_o + b_1 (T)^{0.5}
 
-        In which :math: `\\nu` is the kinematic viscosity, MW is the molecular weight,
-        `x_+` is the mole fraction of cations, and T is the temperature in degrees C.
+            In which :math:`\nu` is the kinematic viscosity, MW is the molecular weight,
+            :math:`x_{+}` is the mole fraction of cations, and :math:`T` is the temperature in degrees C.
 
-        The a and b fitting parameters for a variety of common salts are included in the
-        database.
+            The a and b fitting parameters for a variety of common salts are included in the
+            database.
 
-        References
-        ----------
-        .. [#] Vásquez-Castillo, G.; Iglesias-Silva, G. a.; Hall, K. R. An extension \
-               of the McAllister model to correlate kinematic viscosity of electrolyte solutions. \
-               Fluid Phase Equilib. 2013, 358, 44–49.
+        References:
+            Vásquez-Castillo, G.; Iglesias-Silva, G. a.; Hall, K. R. An extension of the McAllister model to correlate
+            kinematic viscosity of electrolyte solutions. Fluid Phase Equilib. 2013, 358, 44-49.
 
-        See Also
-        --------
-        get_viscosity_dynamic
-        get_viscosity_relative
+        See Also:
+            :py:meth:`viscosity_dynamic`
         """
         # identify the main salt in the solution
         salt = self.get_salt()
-        cation = salt.cation
-
-        # search the database for parameters for 'salt'
-        db.search_parameters(salt.formula)
 
         a0 = a1 = b0 = b1 = 0
 
         # retrieve the parameters for the delta G equations
-        if db.has_parameter(salt.formula, "erying_viscosity_coefficients"):
-            params = db.get_parameter(salt.formula, "erying_viscosity_coefficients")
-
-            a0 = params.get_value()[0]
-            a1 = params.get_value()[1]
-            b0 = params.get_value()[2]
-            b1 = params.get_value()[3]
+        params = self.get_property(salt.formula, "model_parameters.viscosity_eyring")
+        if params is not None:
+            a0 = ureg.Quantity(params["a0"]["value"]).magnitude
+            a1 = ureg.Quantity(params["a1"]["value"]).magnitude
+            b0 = ureg.Quantity(params["b0"]["value"]).magnitude
+            b1 = ureg.Quantity(params["b1"]["value"]).magnitude
+
+            # compute the delta G parameters
+            temperature = self.temperature.to("degC").magnitude
+            G_123 = a0 + a1 * (temperature) ** 0.75
+            G_23 = b0 + b1 * (temperature) ** 0.5
         else:
+            # TODO - fall back to the Jones-Dole model! There are currently no eyring parameters in the database!
             # proceed with the coefficients equal to zero and log a warning
-            logger.warning(
-                "Viscosity coefficients for %s not found. Viscosity will be approximate."
-                % salt.formula
-            )
-
-        # compute the delta G parameters
-        temperature = self.get_temperature().to("degC")
-        G_123 = a0 + a1 * (temperature.magnitude) ** 0.75
-        G_23 = b0 + b1 * (temperature.magnitude) ** 0.5
+            self.logger.warning(f"Viscosity coefficients for {salt.formula} not found. Viscosity will be approximate.")
+            G_123 = G_23 = 0
 
-        # get the kinematic viscosity of water
-        nu_w = (
-            h2o.water_viscosity_kinematic(temperature, self.get_pressure())
-            .to("m**2 / s")
-            .magnitude
-        )
+        # get the kinematic viscosity of water, returned by IAPWS in m2/s
+        nu_w = self.water_substance.nu
 
         # compute the effective molar mass of the solution
-        MW = self.get_mass() / (
-            self.get_moles_solvent() + self.get_total_moles_solute()
-        )
+        total_moles = np.sum([v for k, v in self.components.items()])
+        MW = self.mass.to("g").magnitude / total_moles
 
         # get the MW of water
-        MW_w = self.get_solvent().get_molecular_weight()
+        MW_w = self.get_property(self.solvent, "molecular_weight").magnitude
 
         # calculate the cation mole fraction
-        x_cat = self.get_amount(cation, "fraction")
+        # x_cat = self.get_amount(cation, "fraction")
+        x_cat = self.get_amount(salt.cation, "fraction").magnitude
 
         # calculate the kinematic viscosity
-        nu = (
-            math.log(nu_w * MW_w / MW)
-            + 15 * x_cat ** 2
-            + x_cat ** 3 * G_123
-            + 3 * x_cat * G_23 * (1 - 0.05 * x_cat)
-        )
+        nu = np.log(nu_w * MW_w / MW) + 15 * x_cat**2 + x_cat**3 * G_123 + 3 * x_cat * G_23 * (1 - 0.05 * x_cat)
 
-        return math.exp(nu) * unit("m**2 / s")
+        return ureg.Quantity(np.exp(nu), "m**2 / s")
 
-    def get_conductivity(self):
-        """
+    @property
+    def conductivity(self) -> Quantity:
+        r"""
         Compute the electrical conductivity of the solution.
 
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        Quantity
+        Returns:
             The electrical conductivity of the solution in Siemens / meter.
 
-        Notes
-        -----
-        Conductivity is calculated by summing the molar conductivities of the respective
-        solutes, but they are activity-corrected and adjusted using an empricial exponent.
-        This approach is used in PHREEQC and Aqion models [#]_ [#]_
+        Notes:
+            Conductivity is calculated by summing the molar conductivities of the respective
+            solutes.
 
-        .. math::
+            .. math::
 
-            EC = {F^2 \\over R T} \\sum_i D_i z_i ^ 2 \\gamma_i ^ {\\alpha} m_i
+                EC = {F^2 \over R T} \sum_i D_i z_i ^ 2 m_i = \sum_i \lambda_i m_i
 
-        Where:
+            Where :math:`D_i` is the diffusion coefficient, :math:`m_i` is the molal concentration,
+            :math:`z_i` is the charge, and the summation extends over all species in the solution.
+            Alternatively, :math:`\lambda_i` is the molar conductivity of solute i.
 
-        .. math::
+            Diffusion coefficients :math:`D_i` (and molar conductivities :math:`\lambda_i`) are
+            adjusted for the effects of temperature and ionic strength using the method implemented
+            in PHREEQC >= 3.4. [aq]_ [hc]_  See `get_diffusion_coefficient for` further details.
 
-            \\alpha = \\begin{cases} {0.6 \\over \\sqrt{|z_i|}} & {I < 0.36|z_i|} \\\ {\\sqrt{I} \\over |z_i|} &
-            otherwise \\end{cases}
+        References:
+            .. [aq] https://www.aqion.de/site/electrical-conductivity
+            .. [hc] http://www.hydrochemistry.eu/exmpls/sc.html
 
-        Note: PHREEQC uses the molal rather than molar concentration according to
-        http://wwwbrr.cr.usgs.gov/projects/GWC_coupled/phreeqc/phreeqc3-html/phreeqc3-43.htm
+        See Also:
+            :py:attr:`ionic_strength`
+            :py:meth:`get_diffusion_coefficient`
+            :py:meth:`get_molar_conductivity`
+        """
+        EC = ureg.Quantity(
+            np.asarray(
+                [
+                    self.get_molar_conductivity(i).to("S*L/mol/m").magnitude * self.get_amount(i, "mol/L").magnitude
+                    for i in self.components
+                ]
+            ),
+            "S/m",
+        )
+        return np.sum(EC)
 
-        References
-        ----------
-        .. [#] http://www.aqion.de/site/77
-        .. [#] http://www.hydrochemistry.eu/exmpls/sc.html
+    @property
+    def ionic_strength(self) -> Quantity:
+        r"""
+        Return the ionic strength of the solution.
 
-        See Also
-        --------
-        get_ionic_strength
-        get_molar_conductivity
-        get_activity_coefficient
+        Return the ionic strength of the solution, calculated as 1/2 * sum ( molality * charge ^2) over all the ions.
 
-        """
-        EC = 0 * unit("S/m")
-        temperature = self.get_temperature()
+        Molal (mol/kg) scale concentrations are used for compatibility with the activity correction formulas.
 
-        for item in self.components:
-            z = abs(self.get_solute(item).get_formal_charge())
-            # ignore uncharged species
-            if not z == 0:
-                # determine the value of the exponent alpha
-                if self.get_ionic_strength().magnitude < 0.36 * z:
-                    alpha = 0.6 / z ** 0.5
-                else:
-                    alpha = self.get_ionic_strength().magnitude ** 0.5 / z
+        Returns:
+            Quantity:
+                The ionic strength of the parent solution, mol/kg.
 
-                diffusion_coefficient = self.get_property(item, "diffusion_coefficient")
+        See Also:
+            :py:meth:`get_activity`
+            :py:meth:`get_water_activity`
 
-                molar_cond = (
-                    diffusion_coefficient
-                    * (unit.e * unit.N_A) ** 2
-                    * self.get_solute(item).get_formal_charge() ** 2
-                    / (unit.R * temperature)
-                )
+        Notes:
+            The ionic strength is calculated according to:
 
-                EC += (
-                    molar_cond
-                    * self.get_activity_coefficient(item) ** alpha
-                    * self.get_amount(item, "mol/L")
-                )
+            .. math:: I = \sum_i m_i z_i^2
+
+            Where :math:`m_i` is the molal concentration and :math:`z_i` is the charge on species i.
 
-        return EC.to("S/m")
+        Examples:
+            >>> s1 = pyEQL.Solution([['Na+','0.2 mol/kg'],['Cl-','0.2 mol/kg']])
+            >>> s1.ionic_strength
+            <Quantity(0.20000010029672785, 'mole / kilogram')>
 
-    def get_osmotic_pressure(self):
+            >>> s1 = pyEQL.Solution([['Mg+2','0.3 mol/kg'],['Na+','0.1 mol/kg'],['Cl-','0.7 mol/kg']],temperature='30 degC')
+            >>> s1.ionic_strength
+            <Quantity(1.0000001004383303, 'mole / kilogram')>
         """
-        Return the osmotic pressure of the solution relative to pure water.
+        # compute using magnitudes only, for performance reasons
+        ionic_strength = np.sum(
+            [mol * self.get_property(solute, "charge") ** 2 for solute, mol in self.components.items()]
+        )
+        ionic_strength /= self.solvent_mass.to("kg").magnitude  # convert to mol/kg
+        ionic_strength *= 0.5
+        return ureg.Quantity(ionic_strength, "mol/kg")
 
-        Parameters
-        ----------
-        None
+    @property
+    def charge_balance(self) -> float:
+        r"""
+        Return the charge balance of the solution.
 
-        Returns
-        -------
-        Quantity
-                The osmotic pressure of the solution relative to pure water in Pa
+        Return the charge balance of the solution. The charge balance represents the net electric charge
+        on the solution and SHOULD equal zero at all times, but due to numerical errors will usually
+        have a small nonzero value. It is calculated according to:
 
-        See Also
-        --------
-        get_water_activity
-        get_osmotic_coefficient
-        get_salt
+        .. math:: CB = \sum_i C_i z_i
 
-        Notes
-        -----
-        Osmotic pressure is calculated based on the water activity [#]_ [#]_ :
+        where :math:`C_i` is the molar concentration, and :math:`z_i` is the charge on species i.
 
-        .. math:: \\Pi = {RT \\over V_w} \ln a_w
+        Returns:
+            float :
+                The charge balance of the solution, in equivalents (mol of charge) per L.
 
-        Where :math:`\\Pi` is the osmotic pressure, :math:`V_w` is the partial
-        molar volume of water (18.2 cm**3/mol), and :math:`a_w` is the water
-        activity.
+        """
+        charge_balance = 0
+        for solute in self.components:
+            charge_balance += self.get_amount(solute, "eq/L").magnitude
 
+        return charge_balance
 
-        References
-        ----------
-        .. [#] Sata, Toshikatsu. Ion Exchange Membranes: Preparation, Characterization, and Modification. \
-               Royal Society of Chemistry, 2004, p. 10.
+    # TODO - consider adding guard statements to prevent alkalinity from being negative
+    @property
+    def alkalinity(self) -> Quantity:
+        r"""
+        Return the alkalinity or acid neutralizing capacity of a solution.
+
+        Returns:
+            Quantity: The alkalinity of the solution in mg/L as CaCO3
+
+        Notes:
+            The alkalinity is calculated according to [stm]_
 
-        .. [#] http://en.wikipedia.org/wiki/Osmotic_pressure#Derivation_of_osmotic_pressure
+            .. math::   Alk = \sum_{i} z_{i} C_{B} + \sum_{i} z_{i} C_{A}
 
-        Examples
-        --------
-        >>> s1=pyEQL.Solution()
-        >>> s1.get_osmotic_pressure()
-        0.0
+            Where :math:`C_{B}` and :math:`C_{A}` are conservative cations and anions, respectively
+            (i.e. ions that do not participate in acid-base reactions), and :math:`z_{i}` is their signed charge.
+            In this method, the set of conservative cations is all Group I and Group II cations, and the
+            conservative anions are all the anions of strong acids.
+
+        References:
+            .. [stm] Stumm, Werner and Morgan, James J. Aquatic Chemistry, 3rd ed, pp 165. Wiley Interscience, 1996.
 
-        >>> s1 = pyEQL.Solution([['Na+','0.2 mol/kg'],['Cl-','0.2 mol/kg']])
-        >>> soln.get_osmotic_pressure()
-        <Quantity(906516.7318131207, 'pascal')>
         """
-        # TODO - tie this into parameter() and solvent() objects
-        partial_molar_volume_water = 1.82e-5 * unit("m ** 3/mol")
+        alkalinity = ureg.Quantity(0, "mol/L")
 
-        osmotic_pressure = (
-            -1
-            * unit.R
-            * self.get_temperature()
-            / partial_molar_volume_water
-            * math.log(self.get_water_activity())
-        )
-        logger.info(
-            "Computed osmotic pressure of solution as %s Pa at T= %s degrees C"
-            % (osmotic_pressure, self.get_temperature())
-        )
-        return osmotic_pressure.to("Pa")
+        base_cations = {
+            "Li[+1]",
+            "Na[+1]",
+            "K[+1]",
+            "Rb[+1]",
+            "Cs[+1]",
+            "Fr[+1]",
+            "Be[+2]",
+            "Mg[+2]",
+            "Ca[+2]",
+            "Sr[+2]",
+            "Ba[+2]",
+            "Ra[+2]",
+        }
+        acid_anions = {"Cl[-1]", "Br[-1]", "I[-1]", "SO4[-2]", "NO3[-1]", "ClO4[-1]", "ClO3[-1]"}
 
-    # Concentration  Methods
+        for item in self.components:
+            if item in base_cations.union(acid_anions):
+                z = self.get_property(item, "charge")
+                alkalinity += self.get_amount(item, "mol/L") * z
+
+        # convert the alkalinity to mg/L as CaCO3
+        return (alkalinity * EQUIV_WT_CACO3).to("mg/L")
 
-    def p(self, solute, activity=True):
+    @property
+    def hardness(self) -> Quantity:
         """
-        Return the negative log of the activity of solute.
+        Return the hardness of a solution.
 
-        Generally used for expressing concentration of hydrogen ions (pH)
+        Hardness is defined as the sum of the equivalent concentrations
+        of multivalent cations as calcium carbonate.
 
-        Parameters
-        ----------
-        solute : str
-            String representing the formula of the solute
-        activity: bool, optional
-            If False, the function will use the molar concentration rather
-            than the activity to calculate p. Defaults to True.
+        NOTE: at present pyEQL cannot distinguish between mg/L as CaCO3
+        and mg/L units. Use with caution.
 
-        Returns
-        -------
-        Quantity
-            The negative log10 of the activity (or molar concentration if
-            activity = False) of the solute.
+        Returns:
+            Quantity:
+                The hardness of the solution in mg/L as CaCO3
+
+        """
+        hardness = ureg.Quantity(0, "mol/L")
+
+        for item in self.components:
+            z = self.get_property(item, "charge")
+            if z > 1:
+                hardness += z * self.get_amount(item, "mol/L")
 
-        Examples
-        --------
-        TODO
+        # convert the hardness to mg/L as CaCO3
+        return (hardness * EQUIV_WT_CACO3).to("mg/L")
 
+    @property
+    def total_dissolved_solids(self) -> Quantity:
         """
-        try:
-            if activity is True:
-                return -1 * math.log10(self.get_activity(solute))
-            elif activity is False:
-                return -1 * math.log10(self.get_amount(solute, "mol/L").magnitude)
-        # if the solute has zero concentration, the log will generate a ValueError
-        except ValueError:
-            return 0
+        Total dissolved solids in mg/L (equivalent to ppm) including both charged and uncharged species.
 
-    def get_amount(self, solute, units):
+        The TDS is defined as the sum of the concentrations of all aqueous solutes (not including the solvent),
+        except for H[+1] and OH[-1]].
         """
-        Return the amount of 'solute' in the parent solution.
+        tds = ureg.Quantity(0, "mg/L")
+        for s in self.components:
+            # ignore pure water and dissolved gases, but not CO2
+            if s in ["H2O(aq)", "H[+1]", "OH[-1]"]:
+                continue
+            tds += self.get_amount(s, "mg/L")
 
-        The amount of a solute can be given in a variety of unit types.
-        1. substance per volume (e.g., 'mol/L')
-        1. substance per mass of solvent (e.g., 'mol/kg')
-        1. mass of substance (e.g., 'kg')
-        1. moles of substance ('mol')
-        1. mole fraction ('fraction')
-        1. percent by weight (%)
+        return tds
 
-        Parameters
-        ----------
-        solute : str
-                    String representing the name of the solute of interest
-        units : str
-                    Units desired for the output. Examples of valid units are
-                    'mol/L','mol/kg','mol', 'kg', and 'g/L'
-                    Use 'fraction' to return the mole fraction.
-                    Use '%' to return the mass percent
-
-        Returns
-        -------
-        The amount of the solute in question, in the specified units
+    @property
+    def TDS(self) -> Quantity:
+        """Alias of :py:meth:`total_dissolved_solids`."""
+        return self.total_dissolved_solids
 
+    @property
+    def debye_length(self) -> Quantity:
+        r"""
+        Return the Debye length of a solution.
 
-        See Also
-        --------
-        add_amount
-        set_amount
-        get_total_amount
-        get_osmolarity
-        get_osmolality
-        get_solvent_mass
-        get_mass
-        get_total_moles_solute
-        """
-        # retrieve the number of moles of solute and its molecular weight
-        try:
-            moles = self.get_solute(solute).get_moles()
-            mw = self.get_solute(solute).get_molecular_weight()
-        # if the solute is not present in the solution, we'll get a KeyError
+        Debye length is calculated as [wk3]_
+
+        .. math::
+
+            \kappa^{-1} = \sqrt({\epsilon_r \epsilon_o k_B T \over (2 N_A e^2 I)})
+
+        where :math:`I` is the ionic strength, :math:`\epsilon_r` and :math:`\epsilon_r`
+        are the relative permittivity and vacuum permittivity, :math:`k_B` is the
+        Boltzmann constant, and :math:`T` is the temperature, :math:`e` is the
+        elementary charge, and :math:`N_A` is Avogadro's number.
+
+        Returns The Debye length, in nanometers.
+
+        References:
+            .. [wk3] https://en.wikipedia.org/wiki/Debye_length#Debye_length_in_an_electrolyte
+
+        See Also:
+            :attr:`ionic_strength`
+            :attr:`dielectric_constant`
+
+        """
+        # to preserve dimensionality, convert the ionic strength into mol/L units
+        ionic_strength = ureg.Quantity(self.ionic_strength.magnitude, "mol/L")
+        dielectric_constant = self.dielectric_constant
+
+        debye_length = (
+            dielectric_constant
+            * ureg.epsilon_0
+            * ureg.k
+            * self.temperature
+            / (2 * ureg.N_A * ureg.e**2 * ionic_strength)
+        ) ** 0.5
+
+        return debye_length.to("nm")
+
+    @property
+    def bjerrum_length(self) -> Quantity:
+        r"""
+        Return the Bjerrum length of a solution.
+
+        Bjerrum length represents the distance at which electrostatic
+        interactions between particles become comparable in magnitude
+        to the thermal energy.:math:`\lambda_B` is calculated as
+
+        .. math::
+
+            \lambda_B = {e^2 \over (4 \pi \epsilon_r \epsilon_o k_B T)}
+
+        where :math:`e` is the fundamental charge, :math:`\epsilon_r` and :math:`\epsilon_r`
+        are the relative permittivity and vacuum permittivity, :math:`k_B` is the
+        Boltzmann constant, and :math:`T` is the temperature.
+
+        Returns:
+            Quantity:
+                The Bjerrum length, in nanometers.
+
+        References:
+            https://en.wikipedia.org/wiki/Bjerrum_length
+
+        Examples:
+            >>> s1 = pyEQL.Solution()
+            >>> s1.bjerrum_length
+            <Quantity(0.7152793009386953, 'nanometer')>
+
+        See Also:
+            :attr:`dielectric_constant`
+
+        """
+        bjerrum_length = ureg.e**2 / (4 * np.pi * self.dielectric_constant * ureg.epsilon_0 * ureg.k * self.temperature)
+        return bjerrum_length.to("nm")
+
+    @property
+    def osmotic_pressure(self) -> Quantity:
+        r"""
+        Return the osmotic pressure of the solution relative to pure water.
+
+        Returns:
+            The osmotic pressure of the solution relative to pure water in Pa
+
+        See Also:
+            :attr:`get_water_activity`
+            :attr:`get_osmotic_coefficient`
+            :attr:`get_salt`
+
+        Notes:
+            Osmotic pressure is calculated based on the water activity [sata]_ [wk]_
+
+            .. math:: \Pi = -\frac{RT}{V_{w}} \ln a_{w}
+
+            Where :math:`\Pi` is the osmotic pressure, :math:`V_{w}` is the partial
+            molar volume of water (18.2 cm**3/mol), and :math:`a_{w}` is the water
+            activity.
+
+        References:
+            .. [sata] Sata, Toshikatsu. Ion Exchange Membranes: Preparation, Characterization, and Modification.
+                Royal Society of Chemistry, 2004, p. 10.
+
+            .. [wk] http://en.wikipedia.org/wiki/Osmotic_pressure#Derivation_of_osmotic_pressure
+
+        Examples:
+            >>> s1=pyEQL.Solution()
+            >>> s1.osmotic_pressure
+            <Quantity(0.495791416, 'pascal')>
+
+            >>> s1 = pyEQL.Solution([['Na+','0.2 mol/kg'],['Cl-','0.2 mol/kg']])
+            >>> soln.osmotic_pressure
+            <Quantity(906516.7318131207, 'pascal')>
+        """
+        partial_molar_volume_water = self.get_property(self.solvent, "size.molar_volume")
+
+        osmotic_pressure = (
+            -1 * ureg.R * self.temperature / partial_molar_volume_water * np.log(self.get_water_activity())
+        )
+        self.logger.debug(
+            f"Calculated osmotic pressure of solution as {osmotic_pressure} Pa at T= {self.temperature} degrees C"
+        )
+        return osmotic_pressure.to("Pa")
+
+    # Concentration  Methods
+
+    def get_amount(self, solute: str, units: str = "mol/L") -> Quantity:
+        """
+        Return the amount of 'solute' in the parent solution.
+
+        The amount of a solute can be given in a variety of unit types.
+        1. substance per volume (e.g., 'mol/L', 'M')
+        2. equivalents (i.e., moles of charge) per volume (e.g., 'eq/L', 'meq/L')
+        3. substance per mass of solvent (e.g., 'mol/kg', 'm')
+        4. mass of substance (e.g., 'kg')
+        5. moles of substance ('mol')
+        6. mole fraction ('fraction')
+        7. percent by weight (%)
+        8. number of molecules ('count')
+        9. "parts-per-x" units, where ppm = mg/L, ppb = ug/L ppt = ng/L
+
+        Args:
+            solute : str
+                        String representing the name of the solute of interest
+            units : str
+                        Units desired for the output. Examples of valid units are
+                        'mol/L','mol/kg','mol', 'kg', and 'g/L'
+                        Use 'fraction' to return the mole fraction.
+                        Use '%' to return the mass percent
+
+        Returns:
+            The amount of the solute in question, in the specified units
+
+        See Also:
+            :attr:`mass`
+            :meth:`add_amount`
+            :meth:`set_amount`
+            :meth:`get_total_amount`
+            :meth:`get_osmolarity`
+            :meth:`get_osmolality`
+            :meth:`get_total_moles_solute`
+            :func:`pyEQL.utils.interpret_units`
+        """
+        z = 1
+        # sanitized unit to be passed to pint
+        if "eq" in units:
+            _units = units.replace("eq", "mol")
+            z = self.get_property(solute, "charge")
+            if z == 0:  # uncharged solutes have zero equiv concentration
+                return ureg.Quantity(0, _units)
+        else:
+            _units = interpret_units(units)
+
+        # retrieve the number of moles of solute and its molecular weight
+        try:
+            moles = ureg.Quantity(self.components[solute], "mol")
+        # if the solute is not present in the solution, we'll get a KeyError
         # In that case, the amount is zero
         except KeyError:
             try:
-                return 0 * unit(units)
-            except UndefinedUnitError:
-                logger.error("Unsupported unit specified for get_amount")
-                return 0
+                return ureg.Quantity(0, _units)
+            except DimensionalityError:
+                self.logger.error(
+                    f"Unsupported unit {units} specified for zero-concentration solute {solute}. Returned 0."
+                )
+                return ureg.Quantity(0, "dimensionless")
 
         # with pint unit conversions enabled, we just pass the unit to pint
         # the logic tests here ensure that only the required arguments are
-        # passed to pint for the unit conversion. This avoids unecessary
+        # passed to pint for the unit conversion. This avoids unnecessary
         # function calls.
+        if units == "count":
+            return round((moles * ureg.N_A).to("dimensionless"), 0)
         if units == "fraction":
             return moles / (self.get_moles_solvent() + self.get_total_moles_solute())
-        elif units == "%":
-            return moles.to("kg", "chem", mw=mw) / self.get_mass().to("kg") * 100
-        elif unit(units).dimensionality in (
-            "[substance]/[length]**3",
-            "[mass]/[length]**3",
+        mw = self.get_property(solute, "molecular_weight").to("g/mol")
+        if units == "%":
+            return moles.to("kg", "chem", mw=mw) / self.mass.to("kg") * 100
+        qty = ureg.Quantity(_units)
+        if _units in ["eq", "mol", "moles"] or qty.check("[substance]"):
+            return z * moles.to(_units)
+        if (
+            _units in ["mol/L", "eq/L", "g/L", "mg/L", "ug/L"]
+            or qty.check("[substance]/[length]**3")
+            or qty.check("[mass]/[length]**3")
         ):
-            return moles.to(units, "chem", mw=mw, volume=self.get_volume())
-        elif unit(units).dimensionality in ("[substance]/[mass]", "[mass]/[mass]"):
-            return moles.to(units, "chem", mw=mw, solvent_mass=self.get_solvent_mass())
-        elif unit(units).dimensionality == "[mass]":
-            return moles.to(units, "chem", mw=mw)
-        elif unit(units).dimensionality == "[substance]":
-            return moles.to(units)
-        else:
-            logger.error("Unsupported unit specified for get_amount")
-            return None
+            return z * moles.to(_units, "chem", mw=mw, volume=self.volume)
+        if _units in ["mol/kg"] or qty.check("[substance]/[mass]") or qty.check("[mass]/[mass]"):
+            return z * moles.to(_units, "chem", mw=mw, solvent_mass=self.solvent_mass)
+        if _units in ["kg", "g"] or qty.check("[mass]"):
+            return moles.to(_units, "chem", mw=mw)
+
+        raise ValueError(f"Unsupported unit {units} specified for get_amount")
 
-    def get_total_amount(self, element, units):
+    def get_components_by_element(self) -> dict[str, list]:
         """
-        Return the total amount of 'element' (across all solutes) in the solution.
+        Return a list of all species associated with a given element.
 
-        Parameters
-        ----------
-        element : str
-                    String representing the name of the element of interest
-        units : str
-                    Units desired for the output. Examples of valid units are
-                    'mol/L','mol/kg','mol', 'kg', and 'g/L'
+        Elements (keys) are suffixed with their oxidation state in parentheses, e.g.,
 
-        Returns
-        -------
-        The total amount of the element in the solution, in the specified units
+        {"Na(1.0)":["Na[+1]", "NaOH(aq)"]}
 
-        Notes
-        -----
-        There is currently no way to distinguish between different oxidation
-        states of the same element (e.g. TOTFe(II) vs. TOTFe(III)). This
-        is planned for a future release. (TODO)
+        Species associated with each element are sorted in descending order of the amount
+        present (i.e., the first species listed is the most abundant).
+        """
+        d = {}
+        # by sorting the components according to amount, we ensure that the species
+        # are sorted in descending order of concentration in the resulting dict
+        for s in self.components:
+            # determine the element and oxidation state
+            elements = self.get_property(s, "elements")
 
-        See Also
-        --------
-        get_amount
+            for el in elements:
+                try:
+                    oxi_states = self.get_property(s, "oxi_state_guesses")
+                    oxi_state = oxi_states.get(el, UNKNOWN_OXI_STATE)
+                except (TypeError, IndexError):
+                    self.logger.error(f"No oxidation state found for element {el}. Assigning '{UNKNOWN_OXI_STATE}'")
+                    oxi_state = UNKNOWN_OXI_STATE
+                key = f"{el}({oxi_state})"
+                if d.get(key):
+                    d[key].append(s)
+                else:
+                    d[key] = [s]
+
+        return d
+
+    def get_el_amt_dict(self):
         """
-        import pyEQL.chemical_formula as ch
+        Return a dict of Element: amount in mol.
 
-        TOT = 0 * unit(units)
+        Elements (keys) are suffixed with their oxidation state in parentheses,
+        e.g. "Fe(2.0)", "Cl(-1.0)".
+        """
+        d = {}
+        for s, mol in self.components.items():
+            elements = self.get_property(s, "elements")
+            pmg_ion_dict = self.get_property(s, "pmg_ion")
+            oxi_states = self.get_property(s, "oxi_state_guesses")
 
-        # loop through all the solutes, process each one containing element
-        for item in self.components:
-            # check whether the solute contains the element
-            if ch.contains(item, element):
-                # start with the amount of the solute in the desired units
+            for el in elements:
+                # stoichiometric coefficient, mol element per mol solute
+                stoich = pmg_ion_dict.get(el)
+                try:
+                    oxi_states = self.get_property(s, "oxi_state_guesses")
+                    oxi_state = oxi_states.get(el, UNKNOWN_OXI_STATE)
+                except (TypeError, IndexError):
+                    self.logger.error(f"No oxidation state found for element {el}. Assigning '{UNKNOWN_OXI_STATE}'")
+                    oxi_state = UNKNOWN_OXI_STATE
+                key = f"{el}({oxi_state})"
+                if d.get(key):
+                    d[key] += stoich * mol
+                else:
+                    d[key] = stoich * mol
+
+        return d
+
+    def get_total_amount(self, element: str, units: str) -> Quantity:
+        """
+        Return the total amount of 'element' (across all solutes) in the solution.
+
+        Args:
+            element: The symbol of the element of interest. The symbol can optionally be followed by the
+                oxidation state in parentheses, e.g., "Na(1.0)", "Fe(2.0)", or "O(0.0)". If no oxidation state
+                is given, the total concentration of the element (over all oxidation states) is returned.
+            units : str
+                Units desired for the output. Any unit understood by `get_amount` can be used. Examples of valid
+                units are 'mol/L','mol/kg','mol', 'kg', and 'g/L'.
+
+        Returns:
+            The total amount of the element in the solution, in the specified units
+
+        See Also:
+            :meth:`get_amount`
+            :func:`pyEQL.utils.interpret_units`
+        """
+        TOT: Quantity = 0
+
+        # standardize the element formula and units
+        el = str(Element(element.split("(")[0]))
+        units = interpret_units(units)
+
+        # enumerate the species whose concentrations we need
+        comp_by_element = self.get_components_by_element()
+
+        # compile list of species in different ways depending whether there is an oxidation state
+        if "(" in element and UNKNOWN_OXI_STATE not in element:
+            ox = float(element.split("(")[-1].split(")")[0])
+            key = f"{el}({ox})"
+            species = comp_by_element.get(key)
+        else:
+            species = []
+            for k, v in comp_by_element.items():
+                if el in k:
+                    species.extend(v)
+
+        # loop through the species of interest, adding moles of element
+        for item, amt in self.components.items():
+            if item in species:
                 amt = self.get_amount(item, units)
+                ion = Ion.from_formula(item)
 
                 # convert the solute amount into the amount of element by
                 # either the mole / mole or weight ratio
-                if unit(units).dimensionality in (
+                if ureg.Quantity(units).dimensionality in (
                     "[substance]",
                     "[substance]/[length]**3",
                     "[substance]/[mass]",
                 ):
-                    TOT += amt * ch.get_element_mole_ratio(item, element)
+                    TOT += amt * ion.get_el_amt_dict()[el]  # returns {el: mol per formula unit}
 
-                elif unit(units).dimensionality in (
+                elif ureg.Quantity(units).dimensionality in (
                     "[mass]",
                     "[mass]/[length]**3",
                     "[mass]/[mass]",
                 ):
-                    TOT += amt * ch.get_element_weight_fraction(item, element)
+                    TOT += amt * ion.to_weight_dict[el]  # returns {el: wt fraction}
 
         return TOT
 
-    def add_amount(self, solute, amount):
+    def add_solute(self, formula: str, amount: str):
+        """Primary method for adding substances to a pyEQL solution.
+
+        Args:
+            formula (str): Chemical formula for the solute. Charged species must contain a + or - and
+            (for polyvalent solutes) a number representing the net charge (e.g. 'SO4-2').
+            amount (str): The amount of substance in the specified unit system. The string should contain
+            both a quantity and a pint-compatible representation of a ureg. e.g. '5 mol/kg' or '0.1 g/L'.
         """
-        Add the amount of 'solute' to the parent solution.
+        # if units are given on a per-volume basis,
+        # iteratively solve for the amount of solute that will preserve the
+        # original volume and result in the desired concentration
+        if ureg.Quantity(amount).dimensionality in (
+            "[substance]/[length]**3",
+            "[mass]/[length]**3",
+        ):
+            # store the original volume for later
+            orig_volume = self.volume
 
-        Parameters
-        ----------
-        solute : str
-                    String representing the name of the solute of interest
-        amount : str quantity
-                    String representing the concentration desired, e.g. '1 mol/kg'
-                    If the units are given on a per-volume basis, the solution
-                    volume is not recalculated
-                    If the units are given on a mass, substance, per-mass, or
-                    per-substance basis, then the solution volume is recalculated
-                    based on the new composition
-
-        Returns
-        -------
-        Nothing. The concentration of solute is modified.
+            # add the new solute
+            quantity = ureg.Quantity(amount)
+            mw = self.get_property(formula, "molecular_weight")  # returns a quantity
+            target_mol = quantity.to("moles", "chem", mw=mw, volume=self.volume, solvent_mass=self.solvent_mass)
+            self.components[formula] = target_mol.to("moles").magnitude
 
+            # calculate the volume occupied by all the solutes
+            solute_vol = self._get_solute_volume()
+
+            # determine the volume of solvent that will preserve the original volume
+            target_vol = orig_volume - solute_vol
 
-        See Also
-        --------
-        Solute.add_moles
+            # adjust the amount of solvent
+            # density is returned in kg/m3 = g/L
+            target_mass = target_vol * ureg.Quantity(self.water_substance.rho, "g/L")
+            # mw = ureg.Quantity(self.get_property(self.solvent_name, "molecular_weight"))
+            mw = self.get_property(self.solvent, "molecular_weight")
+            if mw is None:
+                raise ValueError(f"Molecular weight for solvent {self.solvent} not found in database. Cannot proceed.")
+            target_mol = target_mass.to("g") / mw.to("g/mol")
+            self.components[self.solvent] = target_mol.magnitude
+
+        else:
+            # add the new solute
+            quantity = ureg.Quantity(amount)
+            mw = ureg.Quantity(self.get_property(formula, "molecular_weight"))
+            target_mol = quantity.to("moles", "chem", mw=mw, volume=self.volume, solvent_mass=self.solvent_mass)
+            self.components[formula] = target_mol.to("moles").magnitude
+
+            # update the volume to account for the space occupied by all the solutes
+            # make sure that there is still solvent present in the first place
+            if self.solvent_mass <= ureg.Quantity(0, "kg"):
+                self.logger.error("All solvent has been depleted from the solution")
+                return
+            # set the volume recalculation flag
+            self.volume_update_required = True
+
+    # TODO - deprecate this method. Solvent should be added to the dict like anything else
+    # and solvent_name will track which component it is.
+    def add_solvent(self, formula: str, amount: str):
+        """Same as add_solute but omits the need to pass solvent mass to pint."""
+        quantity = ureg.Quantity(amount)
+        mw = self.get_property(formula, "molecular_weight")
+        target_mol = quantity.to("moles", "chem", mw=mw, volume=self.volume, solvent_mass=self.solvent_mass)
+        self.components[formula] = target_mol.to("moles").magnitude
+
+    def add_amount(self, solute: str, amount: str):
         """
+        Add the amount of 'solute' to the parent solution.
+
+        Args:
+            solute : str
+                String representing the name of the solute of interest
+            amount : str quantity
+                String representing the concentration desired, e.g. '1 mol/kg'
+                If the units are given on a per-volume basis, the solution
+                volume is not recalculated
+                If the units are given on a mass, substance, per-mass, or
+                per-substance basis, then the solution volume is recalculated
+                based on the new composition
 
+        Returns:
+            Nothing. The concentration of solute is modified.
+        """
         # if units are given on a per-volume basis,
         # iteratively solve for the amount of solute that will preserve the
         # original volume and result in the desired concentration
-        if unit(amount).dimensionality in (
+        if ureg.Quantity(amount).dimensionality in (
             "[substance]/[length]**3",
             "[mass]/[length]**3",
         ):
-
             # store the original volume for later
-            orig_volume = self.get_volume()
+            orig_volume = self.volume
 
             # change the amount of the solute present to match the desired amount
-            self.get_solute(solute).add_moles(
-                amount, self.get_volume(), self.get_solvent_mass()
+            self.components[solute] += (
+                ureg.Quantity(amount)
+                .to(
+                    "moles",
+                    "chem",
+                    mw=self.get_property(solute, "molecular_weight"),
+                    volume=self.volume,
+                    solvent_mass=self.solvent_mass,
+                )
+                .magnitude
             )
 
             # set the amount to zero and log a warning if the desired amount
             # change would result in a negative concentration
             if self.get_amount(solute, "mol").magnitude < 0:
-                logger.warning(
-                    "Attempted to set a negative concentration for solute %s. Concentration set to 0"
-                    % solute
+                self.logger.error(
+                    "Attempted to set a negative concentration for solute %s. Concentration set to 0" % solute
                 )
                 self.set_amount(solute, "0 mol")
 
@@ -960,87 +1320,93 @@ class Solution:
             target_vol = orig_volume - solute_vol
 
             # adjust the amount of solvent
-            target_mass = target_vol * h2o.water_density(self.get_temperature())
-            mw = self.get_solvent().get_molecular_weight()
+            # volume in L, density in kg/m3 = g/L
+            target_mass = target_vol * ureg.Quantity(self.water_substance.rho, "g/L")
+
+            mw = self.get_property(self.solvent, "molecular_weight")
             target_mol = target_mass / mw
-            self.get_solvent().moles = target_mol
+            self.components[self.solvent] = target_mol.magnitude
 
         else:
-
             # change the amount of the solute present
-            self.get_solute(solute).add_moles(
-                amount, self.get_volume(), self.get_solvent_mass()
+            self.components[solute] += (
+                ureg.Quantity(amount)
+                .to(
+                    "moles",
+                    "chem",
+                    mw=self.get_property(solute, "molecular_weight"),
+                    volume=self.volume,
+                    solvent_mass=self.solvent_mass,
+                )
+                .magnitude
             )
 
             # set the amount to zero and log a warning if the desired amount
             # change would result in a negative concentration
             if self.get_amount(solute, "mol").magnitude < 0:
-                logger.warning(
-                    "Attempted to set a negative concentration for solute %s. Concentration set to 0"
-                    % solute
+                self.logger.error(
+                    "Attempted to set a negative concentration for solute %s. Concentration set to 0" % solute
                 )
                 self.set_amount(solute, "0 mol")
 
             # update the volume to account for the space occupied by all the solutes
             # make sure that there is still solvent present in the first place
-            if self.get_solvent_mass() <= unit("0 kg"):
-                logger.error("All solvent has been depleted from the solution")
-                return None
-            else:
-                # set the volume recalculation flag
-                self.volume_update_required = True
+            if self.solvent_mass <= ureg.Quantity(0, "kg"):
+                self.logger.error("All solvent has been depleted from the solution")
+                return
+
+            # set the volume recalculation flag
+            self.volume_update_required = True
 
-    def set_amount(self, solute, amount):
+    def set_amount(self, solute: str, amount: str):
         """
         Set the amount of 'solute' in the parent solution.
 
-        Parameters
-        ----------
-        solute : str
-                    String representing the name of the solute of interest
-        amount : str Quantity
-                    String representing the concentration desired, e.g. '1 mol/kg'
-                    If the units are given on a per-volume basis, the solution
-                    volume is not recalculated and the molar concentrations of
-                    other components in the solution are not altered, while the
-                    molal concentrations are modified.
-
-                    If the units are given on a mass, substance, per-mass, or
-                    per-substance basis, then the solution volume is recalculated
-                    based on the new composition and the molal concentrations of
-                    other components are not altered, while the molar concentrations
-                    are modified.
-
-        Returns
-        -------
-        Nothing. The concentration of solute is modified.
+        Args:
+            solute : str
+                String representing the name of the solute of interest
+            amount : str Quantity
+                String representing the concentration desired, e.g. '1 mol/kg'
+                If the units are given on a per-volume basis, the solution
+                volume is not recalculated and the molar concentrations of
+                other components in the solution are not altered, while the
+                molal concentrations are modified.
+
+                If the units are given on a mass, substance, per-mass, or
+                per-substance basis, then the solution volume is recalculated
+                based on the new composition and the molal concentrations of
+                other components are not altered, while the molar concentrations
+                are modified.
 
+        Returns:
+            Nothing. The concentration of solute is modified.
 
-        See Also
-        --------
-        Solute.set_moles
         """
         # raise an error if a negative amount is specified
-        if unit(amount).magnitude < 0:
-            logger.error(
-                "Negative amount specified for solute %s. Concentration not changed."
-                % solute
-            )
+        if ureg.Quantity(amount).magnitude < 0:
+            raise ValueError(f"Negative amount specified for solute {solute}. Concentration not changed.")
 
         # if units are given on a per-volume basis,
         # iteratively solve for the amount of solute that will preserve the
         # original volume and result in the desired concentration
-        elif unit(amount).dimensionality in (
+        if ureg.Quantity(amount).dimensionality in (
             "[substance]/[length]**3",
             "[mass]/[length]**3",
         ):
-
             # store the original volume for later
-            orig_volume = self.get_volume()
+            orig_volume = self.volume
 
             # change the amount of the solute present to match the desired amount
-            self.get_solute(solute).set_moles(
-                amount, self.get_volume(), self.get_solvent_mass()
+            self.components[solute] = (
+                ureg.Quantity(amount)
+                .to(
+                    "moles",
+                    "chem",
+                    mw=ureg.Quantity(self.get_property(solute, "molecular_weight")),
+                    volume=self.volume,
+                    solvent_mass=self.solvent_mass,
+                )
+                .magnitude
             )
 
             # calculate the volume occupied by all the solutes
@@ -1050,105 +1416,85 @@ class Solution:
             target_vol = orig_volume - solute_vol
 
             # adjust the amount of solvent
-            target_mass = target_vol * h2o.water_density(self.get_temperature())
-            mw = self.get_solvent().get_molecular_weight()
+            target_mass = target_vol * ureg.Quantity(self.water_substance.rho, "g/L")
+            mw = self.get_property(self.solvent, "molecular_weight")
             target_mol = target_mass / mw
-            self.get_solvent().moles = target_mol
+            self.components[self.solvent] = target_mol.to("mol").magnitude
 
         else:
-
             # change the amount of the solute present
-            self.get_solute(solute).set_moles(
-                amount, self.get_volume(), self.get_solvent_mass()
+            self.components[solute] = (
+                ureg.Quantity(amount)
+                .to(
+                    "moles",
+                    "chem",
+                    mw=ureg.Quantity(self.get_property(solute, "molecular_weight")),
+                    volume=self.volume,
+                    solvent_mass=self.solvent_mass,
+                )
+                .magnitude
             )
 
             # update the volume to account for the space occupied by all the solutes
             # make sure that there is still solvent present in the first place
-            if self.get_solvent_mass() <= unit("0 kg"):
-                logger.error("All solvent has been depleted from the solution")
-                return None
-            else:
-                self._update_volume()
+            if self.solvent_mass <= ureg.Quantity(0, "kg"):
+                self.logger.critical("All solvent has been depleted from the solution")
+                return
 
-    def get_osmolarity(self, activity_correction=False):
-        """Return the osmolarity of the solution in Osm/L
+            self._update_volume()
 
-        Parameters
-        ----------
-        activity_correction : bool
+    def get_total_moles_solute(self) -> Quantity:
+        """Return the total moles of all solute in the solution."""
+        tot_mol = 0
+        for item in self.components:
+            if item != self.solvent:
+                tot_mol += self.components[item]
+        return ureg.Quantity(tot_mol, "mol")
+
+    def get_moles_solvent(self) -> Quantity:
+        """
+        Return the moles of solvent present in the solution.
+
+        Returns:
+            The moles of solvent in the solution.
+
+        """
+        return self.get_amount(self.solvent, "mol")
+
+    def get_osmolarity(self, activity_correction=False) -> Quantity:
+        """Return the osmolarity of the solution in Osm/L.
+
+        Args:
+            activity_correction : bool
                 If TRUE, the osmotic coefficient is used to calculate the
                 osmolarity. This correction is appropriate when trying to predict
                 the osmolarity that would be measured from e.g. freezing point
                 depression. Defaults to FALSE if omitted.
         """
-        if activity_correction is True:
-            factor = self.get_osmotic_coefficient()
-        else:
-            factor = 1
-        return factor * self.get_total_moles_solute() / self.get_volume().to("L")
+        factor = self.get_osmotic_coefficient() if activity_correction is True else 1
+        return factor * self.get_total_moles_solute() / self.volume.to("L")
 
-    def get_osmolality(self, activity_correction=False):
-        """Return the osmolality of the solution in Osm/kg
+    def get_osmolality(self, activity_correction=False) -> Quantity:
+        """Return the osmolality of the solution in Osm/kg.
 
-        Parameters
-        ----------
-        activity_correction : bool
+        Args:
+            activity_correction : bool
                 If TRUE, the osmotic coefficient is used to calculate the
                 osmolarity. This correction is appropriate when trying to predict
                 the osmolarity that would be measured from e.g. freezing point
                 depression. Defaults to FALSE if omitted.
         """
-        if activity_correction is True:
-            factor = self.get_osmotic_coefficient()
-        else:
-            factor = 1
-        return factor * self.get_total_moles_solute() / self.get_solvent_mass().to("kg")
-
-    def get_total_moles_solute(self):
-        """Return the total moles of all solute in the solution"""
-        tot_mol = 0
-        for item in self.components:
-            if item != self.solvent_name:
-                tot_mol += self.components[item].get_moles()
-        return tot_mol
-
-    def get_mole_fraction(self, solute):
-        """
-        Return the mole fraction of 'solute' in the solution
-
-        Notes
-        -----
-        This function is DEPRECATED and will raise a warning when called.
-        Use get_amount() instead and specify 'fraction' as the unit type.
-        """
-        logger.warning("get_mole_fraction is DEPRECATED! Use get_amount() instead.")
-        return self.get_amount(solute, "fraction")
-
-    def get_moles_solvent(self):
-        """
-        Return the moles of solvent present in the solution
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        Quantity
-            The moles of solvent in the solution.
-
-        """
-
-        return self.get_amount(self.solvent_name, "mol")
+        factor = self.get_osmotic_coefficient() if activity_correction is True else 1
+        return factor * self.get_total_moles_solute() / self.solvent_mass.to("kg")
 
-    def get_salt(self):
+    def get_salt(self) -> Salt:
         """
         Determine the predominant salt in a solution of ions.
 
         Many empirical equations for solution properties such as activity coefficient,
         partial molar volume, or viscosity are based on the concentration of
         single salts (e.g., NaCl). When multiple ions are present (e.g., a solution
-        containing Na+, Cl-, and Mg+2), it is generally not possible to direclty model
+        containing Na+, Cl-, and Mg+2), it is generally not possible to directly model
         these quantities. pyEQL works around this problem by treating such solutions
         as single salt solutions.
 
@@ -1156,1444 +1502,1201 @@ class Solution:
         an object that identifies the single most predominant salt in the solution, defined
         by the cation and anion with the highest mole fraction. The Salt object contains
         information about the stoichiometry of the salt to enable its effective concentration
-        to be calculated (e.g., 1 M MgCl2 yields 1 M Mg+2 and 2 M Cl-).
+        to be calculated (e.g., if a solution contains 0.5 mol/kg of Na+ and Cl-, plus traces
+        of H+ and OH-, the matched salt is 0.5 mol/kg NaCl).
 
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        Salt
+        Returns:
             Salt object containing information about the parent salt.
 
-        See Also
-        --------
-        get_activity
-        get_activity_coefficient
-        get_water_activity
-        get_osmotic_coefficient
-        get_osmotic_pressure
-        get_viscosity_kinematic
-
-        Examples
-        --------
-        >>> s1 = Solution([['Na+','0.5 mol/kg'],['Cl-','0.5 mol/kg']])
-        >>> s1.get_salt()
-        <pyEQL.salt_ion_match.Salt object at 0x7fe6d3542048>
-        >>> s1.get_salt().formula
-        'NaCl'
-        >>> s1.get_salt().nu_cation
-        1
-        >>> s1.get_salt().z_anion
-        -1
-
-        >>> s2 = pyEQL.Solution([['Na+','0.1 mol/kg'],['Mg+2','0.2 mol/kg'],['Cl-','0.5 mol/kg']])
-        >>> s2.get_salt().formula
-        'MgCl2'
-        >>> s2.get_salt().nu_anion
-        2
-        >>> s2.get_salt().z_cation
-        2
-        """
-        # identify the predominant salt in the solution
-        import pyEQL.salt_ion_match as salt
-
-        return salt.identify_salt(self)
-
-    def get_salt_list(self):
+        See Also:
+            :py:meth:`get_activity`
+            :py:meth:`get_activity_coefficient`
+            :py:meth:`get_water_activity`
+            :py:meth:`get_osmotic_coefficient`
+            :py:attr:`osmotic_pressure`
+            :py:attr:`viscosity_kinematic`
+
+        Examples:
+            >>> s1 = Solution([['Na+','0.5 mol/kg'],['Cl-','0.5 mol/kg']])
+            >>> s1.get_salt()
+            <pyEQL.salt_ion_match.Salt object at 0x7fe6d3542048>
+            >>> s1.get_salt().formula
+            'NaCl'
+            >>> s1.get_salt().nu_cation
+            1
+            >>> s1.get_salt().z_anion
+            -1
+
+            >>> s2 = pyEQL.Solution([['Na+','0.1 mol/kg'],['Mg+2','0.2 mol/kg'],['Cl-','0.5 mol/kg']])
+            >>> s2.get_salt().formula
+            'MgCl2'
+            >>> s2.get_salt().nu_anion
+            2
+            >>> s2.get_salt().z_cation
+            2
         """
-        Determine the predominant salt in a solution of ions.
+        d = self.get_salt_dict()
+        first_key = next(iter(d.keys()))
+        return Salt(d[first_key]["cation"], d[first_key]["anion"])
+
+    # TODO - modify? deprecate? make a salts property?
+    def get_salt_dict(self, cutoff: float = 0.01, use_totals: bool = True) -> dict[str, dict]:
+        """
+        Returns a dict of salts that approximates the composition of the Solution. Like `components`, the dict is
+        keyed by formula and the values are the total moles present in the solution, e.g., {"NaCl(aq)": 1}. If the
+        Solution is pure water, the returned dict contains only 'HOH'.
+
+        Args:
+            cutoff: Lowest salt concentration to consider. Analysis will stop once the concentrations of Salts being
+                analyzed goes below this value. Useful for excluding analysis of trace anions.
+            use_totals: Whether to base the analysis on total element concentrations or individual species
+                concentrations.
+
+        Notes:
+            Salts are identified by pairing the predominant cations and anions in the solution, in descending order
+            of their respective equivalent amounts.
 
         Many empirical equations for solution properties such as activity coefficient,
         partial molar volume, or viscosity are based on the concentration of
         single salts (e.g., NaCl). When multiple ions are present (e.g., a solution
-        containing Na+, Cl-, and Mg+2), it is generally not possible to direclty model
+        containing Na+, Cl-, and Mg+2), it is generally not possible to directly model
         these quantities.
 
-        The get_salt_list() method examines the ionic composition of a solution and
-        simplifies it into a list of salts. The method retuns a dictionary of
+        The get_salt_dict() method examines the ionic composition of a solution and
+        simplifies it into a list of salts. The method returns a dictionary of
         Salt objects where the keys are the salt formulas (e.g., 'NaCl'). The
         Salt object contains information about the stoichiometry of the salt to
         enable its effective concentration to be calculated
         (e.g., 1 M MgCl2 yields 1 M Mg+2 and 2 M Cl-).
 
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        dict
-            A dictionary of Salt objects, keyed to the salt formula
-
-        See Also
-        --------
-        get_activity
-        get_activity_coefficient
-        get_water_activity
-        get_osmotic_coefficient
-        get_osmotic_pressure
-        get_viscosity_kinematic
-
-        """
-        # identify the predominant salt in the solution
-        import pyEQL.salt_ion_match as salt
-
-        return salt.generate_salt_list(self, unit="mol/kg")
-
-    # Activity-related methods
-    def get_activity_coefficient(self, solute, scale="molal", verbose=False):
-        """Return the activity coefficient of a solute in solution.
-
-        Whenever the appropriate parameters are available, the Pitzer model [#]_ is used.
-        If no Pitzer parameters are available, then the appropriate equations are selected
-        according to the following logic: [#]_
-
-        I <= 0.0005: Debye-Huckel equation
-        0.005 < I <= 0.1:  Guntelberg approximation
-        0.1 < I <= 0.5: Davies equation
-        I > 0.5: Raises a warning and returns activity coefficient = 1
-
-        The ionic strength, activity coefficients, and activities are all
-        calculated based on the molal (mol/kg) concentration scale. If a different
-        scale is given as input, then the molal-scale activity coefficient :math:`\\gamma_\\pm` is
-        converted according to [#]_
-
-        .. math:: f_\\pm = \\gamma_\\pm * (1 + M_w \\sum_i \\nu_i \\m_i)
-
-        .. math:: y_\\pm = m \\rho_w / C \\gamma_\\pm
-
-        where :math:`f_\\pm` is the rational activity coefficient, :math:`M_w` is
-        the molecular weight of water, the summation represents the total molality of
-        all solute  species, :math:`y_\\pm` is the molar activity coefficient,
-        :math:`\\rho_w` is the density of pure water, :math:`m` and :math:`C` are
-        the molal and molar concentrations of the chosen salt (not individual solute),
-        respectively.
-
-        Parameters
-        ----------
-        solute : str
-                    String representing the name of the solute of interest
-        scale : str, optional
-                    The concentration scale for the returned activity coefficient.
-                    Valid options are "molal", "molar", and "rational" (i.e., mole fraction).
-                    By default, the molal scale activity coefficient is returned.
-        verbose : bool, optional
-                    If True, pyEQL will print a message indicating the parent salt
-                    that is being used for activity calculations. This option is
-                    useful when modeling multicomponent solutions. False by default.
-
-        Returns
-        -------
-        The mean ion activity coefficient of the solute in question on  the selected scale.
-
-        See Also
-        --------
-        get_ionic_strength
-        get_salt
-        activity_correction.get_activity_coefficient_debyehuckel
-        activity_correction.get_activity_coefficient_guntelberg
-        activity_correction.get_activity_coefficient_davies
-        activity_correction.get_activity_coefficient_pitzer
-
-        Notes
-        -----
-        For multicomponent mixtures, pyEQL implements the "effective Pitzer model"
-        presented by Mistry et al. [#]_. In this model, the activity coefficient
-        of a salt in a multicomponent mixture is calculated using an "effective
-        molality," which is the molality that would result in a single-salt
-        mixture with the same total ionic strength as the multicomponent solution.
-
-        .. math:: m_effective = 2 I \\over (\\nu_+ z_+^2 + \\nu_- z_- ^2)
-
-        References
-        ----------
-        .. [#] May, P. M., Rowland, D., Hefter, G., & Königsberger, E. (2011).
-               A Generic and Updatable Pitzer Characterization of Aqueous Binary Electrolyte Solutions at 1 bar and
-               25 °C. *Journal of Chemical & Engineering Data*, 56(12), 5066–5077. doi:10.1021/je2009329
-
-        .. [#] Stumm, Werner and Morgan, James J. *Aquatic Chemistry*, 3rd ed,
-               pp 165. Wiley Interscience, 1996.
-
-        .. [#] Robinson, R. A.; Stokes, R. H. Electrolyte Solutions: Second Revised
-               Edition; Butterworths: London, 1968, p.32.
-
-        """
-        ion = self.components[solute]
-        temperature = str(self.get_temperature())
-
-        # return zero activity if the concentration of the solute is zero
-        if self.get_amount(solute, "mol").magnitude == 0:
-            return unit("1 dimensionless")
+        Returns:
+            dict
+                A dictionary of Salt objects, keyed to the salt formula
+
+        See Also:
+            :py:attr:`osmotic_pressure`
+            :py:attr:`viscosity_kinematic`
+            :py:meth:`get_activity`
+            :py:meth:`get_activity_coefficient`
+            :py:meth:`get_water_activity`
+            :py:meth:`get_osmotic_coefficient`
+        """
+        """
+        Returns a dict of salts that approximates the composition of the Solution. Like `components`, the dict is
+        keyed by formula and the values are the total moles of salt present in the solution, e.g., {"NaCl(aq)": 1}
+
+        Notes:
+            Salts are identified by pairing the predominant cations and anions in the solution, in descending order
+            of their respective equivalent amounts.
+
+        See Also:
+            :attr:`components`
+            :attr:`cations`
+            :attr:`anions`
+        """
+        salt_dict: dict[str, float] = {}
+
+        if use_totals:
+            # # use only the predominant species for each element
+            components = {}
+            for el, lst in self.get_components_by_element().items():
+                components[lst[0]] = self.get_total_amount(el, "mol").magnitude
+            # add H+ and OH-, which would otherwise be excluded
+            for k in ["H[+1]", "OH[-1]"]:
+                if self.components.get(k):
+                    components[k] = self.components[k]
         else:
+            components = self.components
+        components = dict(sorted(components.items(), key=lambda x: x[1], reverse=True))
+
+        # warn if something other than water is the predominant component
+        if next(iter(components)) != "H2O(aq)":
+            self.logger.warning("H2O(aq) is not the most prominent component in this Solution!")
+
+        # equivalents (charge-weighted moles) of cations and anions
+        cations = set(self.cations.keys()).intersection(components.keys())
+        anions = set(self.anions.keys()).intersection(components.keys())
+
+        # calculate the charge-weighted (equivalent) concentration of each ion
+        cation_equiv = {k: self.get_property(k, "charge") * components[k] for k in cations}
+        anion_equiv = {
+            k: -1 * self.get_property(k, "charge") * components[k] for k in anions
+        }  # make sure amounts are positive
+
+        # sort in descending order of equivalent concentration
+        cation_equiv = dict(sorted(cation_equiv.items(), key=lambda x: x[1], reverse=True))
+        anion_equiv = dict(sorted(anion_equiv.items(), key=lambda x: x[1], reverse=True))
+
+        len_cat = len(cation_equiv)
+        len_an = len(anion_equiv)
+
+        # Only ions are H+ and OH-; return a Salt represnting water (with no amount)
+        if len_cat <= 1 and len_an <= 1 and self.solvent == "H2O(aq)":
+            x = Salt("H[+1]", "OH[-1]")
+            salt_dict.update({x.formula: x.as_dict()})
+            salt_dict[x.formula]["mol"] = self.get_amount("H2O", "mol")
+            return salt_dict
+
+        # start with the first cation and anion
+        index_cat = 0
+        index_an = 0
+
+        # list(dict) returns a list of [(key, value), ]
+        cation_list = list(cation_equiv.items())
+        anion_list = list(anion_equiv.items())
+
+        # calculate the equivalent concentrations of each ion
+        c1 = cation_list[index_cat][-1]
+        a1 = anion_list[index_an][-1]
+
+        while index_cat < len_cat and index_an < len_an:
+            # if the cation concentration is greater, there will be leftover cations
+            if c1 > a1:
+                # create the salt
+                x = Salt(cation_list[index_cat][0], anion_list[index_an][0])
+                # there will be leftover cation, so use the anion amount
+                salt_dict.update({x.formula: x.as_dict()})
+                salt_dict[x.formula]["mol"] = a1 / abs(x.z_anion * x.nu_anion)
+                # adjust the amounts of the respective ions
+                c1 = c1 - a1
+                # move to the next anion
+                index_an += 1
+                try:
+                    a1 = anion_list[index_an][-1]
+                    if a1 < cutoff:
+                        continue
+                except IndexError:
+                    continue
+            # if the anion concentration is greater, there will be leftover anions
+            if c1 < a1:
+                # create the salt
+                x = Salt(cation_list[index_cat][0], anion_list[index_an][0])
+                # there will be leftover anion, so use the cation amount
+                salt_dict.update({x.formula: x.as_dict()})
+                salt_dict[x.formula]["mol"] = c1 / x.z_cation * x.nu_cation
+                # calculate the leftover cation amount
+                a1 = a1 - c1
+                # move to the next cation
+                index_cat += 1
+                try:
+                    a1 = cation_list[index_cat][-1]
+                    if a1 < cutoff:
+                        continue
+                except IndexError:
+                    continue
+            if np.isclose(c1, a1):
+                # create the salt
+                x = Salt(cation_list[index_cat][0], anion_list[index_an][0])
+                # there will be nothing leftover, so it doesn't matter which ion you use
+                salt_dict.update({x.formula: x.as_dict()})
+                salt_dict[x.formula]["mol"] = c1 / x.z_cation * x.nu_cation
+                # move to the next cation and anion
+                index_an += 1
+                index_cat += 1
+                try:
+                    c1 = cation_list[index_cat][-1]
+                    a1 = anion_list[index_an][-1]
+                    if (c1 < cutoff) or (a1 < cutoff):
+                        continue
+                except IndexError:
+                    continue
 
-            # identify the predominant salt that this ion is a member of
-            Salt = None
-            salt_list = salt.generate_salt_list(self, unit="mol/kg")
-            for item in salt_list:
-                if solute == item.cation or solute == item.anion:
-                    Salt = item
-
-            # show an error if no salt can be found that contains the solute
-            if Salt is None:
-                logger.warning(
-                    "No salts found that contain solute %s. Returning unit activity coefficient."
-                    % solute
-                )
-                return unit("1 dimensionless")
-
-            # search the database for pitzer parameters for 'Salt'
-            db.search_parameters(Salt.formula)
-
-            # use the Pitzer model for higher ionic strength, if the parameters are available
-
-            # search for Pitzer parameters
-            if db.has_parameter(Salt.formula, "pitzer_parameters_activity"):
-                if verbose is True:
-                    print(
-                        "Calculating activity coefficient based on parent salt %s"
-                        % Salt.formula
-                    )
-
-                param = db.get_parameter(Salt.formula, "pitzer_parameters_activity")
-
-                # determine alpha1 and alpha2 based on the type of salt
-                # see the May reference for the rules used to determine
-                # alpha1 and alpha2 based on charge
-                if Salt.nu_cation >= 2 and Salt.nu_anion <= -2:
-                    if Salt.nu_cation >= 3 or Salt.nu_anion <= -3:
-                        alpha1 = 2
-                        alpha2 = 50
-                    else:
-                        alpha1 = 1.4
-                        alpha2 = 12
-                else:
-                    alpha1 = 2
-                    alpha2 = 0
-
-                # determine the average molality of the salt
-                # this is necessary for solutions inside e.g. an ion exchange
-                # membrane, where the cation and anion concentrations may be
-                # unequal
-                # molality = (self.get_amount(Salt.cation,'mol/kg')/Salt.nu_cation+self.get_amount(Salt.anion,'mol/kg')
-                # /Salt.nu_anion)/2
-
-                # determine the effective molality of the salt in the solution
-                molality = Salt.get_effective_molality(self.get_ionic_strength())
-
-                activity_coefficient = ac.get_activity_coefficient_pitzer(
-                    self.get_ionic_strength(),
-                    molality,
-                    alpha1,
-                    alpha2,
-                    param.get_value()[0],
-                    param.get_value()[1],
-                    param.get_value()[2],
-                    param.get_value()[3],
-                    Salt.z_cation,
-                    Salt.z_anion,
-                    Salt.nu_cation,
-                    Salt.nu_anion,
-                    temperature,
-                )
-
-                logger.info(
-                    "Calculated activity coefficient of species %s as %s based on salt %s using Pitzer model"
-                    % (solute, activity_coefficient, Salt)
-                )
-                molal = activity_coefficient
-
-            # for very low ionic strength, use the Debye-Huckel limiting law
-            elif self.get_ionic_strength().magnitude <= 0.005:
-                logger.info(
-                    "Ionic strength = %s. Using Debye-Huckel to calculate activity coefficient."
-                    % self.get_ionic_strength()
-                )
-                molal = ac.get_activity_coefficient_debyehuckel(
-                    self.get_ionic_strength(), ion.get_formal_charge(), temperature
-                )
-
-            # use the Guntelberg approximation for 0.005 < I < 0.1
-            elif self.get_ionic_strength().magnitude <= 0.1:
-                logger.info(
-                    "Ionic strength = %s. Using Guntelberg to calculate activity coefficient."
-                    % self.get_ionic_strength()
-                )
-                molal = ac.get_activity_coefficient_guntelberg(
-                    self.get_ionic_strength(), ion.get_formal_charge(), temperature
-                )
-
-            # use the Davies equation for 0.1 < I < 0.5
-            elif self.get_ionic_strength().magnitude <= 0.5:
-                logger.info(
-                    "Ionic strength = %s. Using Davies equation to calculate activity coefficient."
-                    % self.get_ionic_strength()
-                )
-                molal = ac.get_activity_coefficient_davies(
-                    self.get_ionic_strength(), ion.get_formal_charge(), temperature
-                )
-
-            else:
-                logger.warning(
-                    "Ionic strength too high to estimate activity for species %s. Specify parameters for Pitzer model."
-                    "Returning unit activity coefficient" % solute
-                )
-
-                molal = unit("1 dimensionless")
-
-            # if necessary, convert the activity coefficient to another scale, and return the result
-            if scale == "molal":
-                return molal
-            elif scale == "molar":
-                total_molality = self.get_total_moles_solute() / self.get_solvent_mass()
-                total_molarity = self.get_total_moles_solute() / self.get_volume()
-                return (
-                    molal
-                    * h2o.water_density(self.get_temperature())
-                    * total_molality
-                    / total_molarity
-                ).to("dimensionless")
-            elif scale == "rational":
-                return molal * (
-                    1
-                    + unit("0.018 kg/mol")
-                    * self.get_total_moles_solute()
-                    / self.get_solvent_mass()
-                )
-            else:
-                logger.warning(
-                    "Invalid scale argument. Returning molal-scale activity coefficient"
-                )
-                return molal
-
-    def get_activity(self, solute, scale="molal", verbose=False):
-        """
-        Return the thermodynamic activity of the solute in solution on the molal scale.
-
-        Parameters
-        ----------
-        solute : str
-                    String representing the name of the solute of interest
-        scale : str, optional
-                    The concentration scale for the returned activity.
-                    Valid options are "molal", "molar", and "rational" (i.e., mole fraction).
-                    By default, the molal scale activity is returned.
-        verbose : bool, optional
-                    If True, pyEQL will print a message indicating the parent salt
-                    that is being used for activity calculations. This option is
-                    useful when modeling multicomponent solutions. False by default.
-
-        Returns
-        -------
-        The thermodynamic activity of the solute in question (dimensionless)
-
-        See Also
-        --------
-        get_activity_coefficient
-        get_ionic_strength
-        get_salt
-
-        Notes
-        -----
-        The thermodynamic activity depends on the concentration scale used [#].
-        By default, the ionic strength, activity coefficients, and activities are all
-        calculated based on the molal (mol/kg) concentration scale.
-
-        References
-        ----------
-        .. [#] Robinson, R. A.; Stokes, R. H. Electrolyte Solutions: Second Revised
-               Edition; Butterworths: London, 1968, p.32.
-
-        """
-        # switch to the water activity function if the species is H2O
-        if solute == "H2O" or solute == "water":
-            activity = self.get_water_activity()
-        else:
-            # determine the concentration units to use based on the desired scale
-            if scale == "molal":
-                unit = "mol/kg"
-            elif scale == "molar":
-                unit = "mol/L"
-            elif scale == "rational":
-                unit = "fraction"
-            else:
-                logger.error("Invalid scale argument. Returning molal-scale activity.")
-                unit = "mol/kg"
-                scale = "molal"
-
-            activity = (
-                self.get_activity_coefficient(solute, scale=scale, verbose=verbose)
-                * self.get_amount(solute, unit).magnitude
-            )
-            logger.info(
-                "Calculated %s scale activity of solute %s as %s"
-                % (scale, solute, activity)
-            )
-
-        return activity
-
-    def get_osmotic_coefficient(self, scale="molal"):
-        """
-        Return the osmotic coefficient of an aqueous solution.
-
-        Osmotic coefficient is calculated using the Pitzer model.[#]_ If appropriate parameters for
-        the model are not available, then pyEQL raises a WARNING and returns an osmotic
-        coefficient of 1.
-
-        If the 'rational' scale is given as input, then the molal-scale osmotic
-        coefficient :math:`\\phi` is converted according to [#]_
-
-        .. math:: g = - \\phi * M_w \\sum_i \\nu_i \\m_i) / \\ln x_w
-
-        where :math:`g` is the rational osmotic coefficient, :math:`M_w` is
-        the molecular weight of water, the summation represents the total molality of
-        all solute  species, and :math:`x_w` is the mole fraction of water.
-
-        Parameters
-        ----------
-        scale : str, optional
-                    The concentration scale for the returned osmotic coefficient.
-                    Valid options are "molal", "rational" (i.e., mole fraction),
-                    and "fugacity".  By default, the molal scale osmotic coefficient is returned.
-        Returns
-        -------
-        Quantity :
-            The osmotic coefficient
-
-        See Also
-        --------
-        get_water_activity
-        get_ionic_strength
-        get_salt
-
-        Notes
-        -----
-        For multicomponent mixtures, pyEQL adopts the "effective Pitzer model"
-        presented by Mistry et al. [#]_. In this approach, the osmotic coefficient of
-        each individual salt is calculated using the normal Pitzer model based
-        on its respective concentration. Then, an effective osmotic coefficient
-        is calculated as the concentration-weighted average of the individual
-        osmotic coefficients.
-
-        For example, in a mixture of 0.5 M NaCl and 0.5 M KBr, one would calculate
-        the osmotic coefficient for each salt using a concentration of 0.5 M and
-        an ionic strength of 1 M. Then, one would average the two resulting
-        osmotic coefficients to obtain an effective osmotic coefficient for the
-        mixture.
-
-        (Note: in the paper referenced below, the effective
-        osmotic coefficient is determined by weighting using the "effective molality"
-        rather than the true molality. Subsequent checking and correspondence with
-        the author confirmed that the weight factor should be the true molality, and
-        that is what is implemented in pyEQL.)
-
-        References
-        ----------
-        .. [#] May, P. M., Rowland, D., Hefter, G., & Königsberger, E. (2011).
-               A Generic and Updatable Pitzer Characterization of Aqueous Binary Electrolyte Solutions at 1 bar
-               and 25 °C. *Journal of Chemical & Engineering Data*, 56(12), 5066–5077. doi:10.1021/je2009329
-
-        .. [#] Robinson, R. A.; Stokes, R. H. Electrolyte Solutions: Second Revised
-               Edition; Butterworths: London, 1968, p.32.
-
-        .. [#] Mistry, K. H.; Hunter, H. a.; Lienhard V, J. H. Effect of composition and nonideal solution behavior on
-               desalination calculations for mixed
-               electrolyte solutions with comparison to seawater. Desalination 2013, 318, 34–47.
-
-        Examples
-        --------
-        >>> s1 = pyEQL.Solution([['Na+','0.2 mol/kg'],['Cl-','0.2 mol/kg']])
-        >>> s1.get_osmotic_coefficient()
-        <Quantity(0.9235996615888572, 'dimensionless')>
-
-        >>> s1 = pyEQL.Solution([['Mg+2','0.3 mol/kg'],['Cl-','0.6 mol/kg']],temperature='30 degC')
-        >>> s1.get_osmotic_coefficient()
-        <Quantity(0.891154788474231, 'dimensionless')>
-
-        """
-        temperature = str(self.get_temperature())
-        ionic_strength = self.get_ionic_strength()
-
-        effective_osmotic_sum = 0
-        molality_sum = 0
-
-        # organize the composition into a dictionary of salts
-        salt_list = self.get_salt_list()
-
-        # loop through all the salts in the solution, calculate the osmotic
-        # coefficint for reach, and average them into an effective osmotic
-        # coefficient
-        for item in salt_list:
-
-            # ignore HOH in the salt list
-            if item.formula == "HOH":
-                continue
-
-            # determine alpha1 and alpha2 based on the type of salt
-            # see the May reference for the rules used to determine
-            # alpha1 and alpha2 based on charge
-            if item.z_cation >= 2 and item.z_anion <= -2:
-                if item.z_cation >= 3 or item.z_anion <= -3:
-                    alpha1 = 2
-                    alpha2 = 50
-                else:
-                    alpha1 = 1.4
-                    alpha2 = 12
-            else:
-                alpha1 = 2
-                alpha2 = 0
-
-            # set the concentration as the average concentration of the cation and
-            # anion in the salt, accounting for stoichiometry
-            # concentration = (self.get_amount(Salt.cation,'mol/kg')/Salt.nu_cation + \
-            # self.get_amount(Salt.anion,'mol/kg')/Salt.nu_anion)/2
-
-            # get the effective molality of the salt
-            concentration = salt_list[item]
-
-            molality_sum += concentration
-
-            # search the database for pitzer parameters for 'salt'
-            db.search_parameters(item.formula)
-
-            if db.has_parameter(item.formula, "pitzer_parameters_activity"):
-
-                param = db.get_parameter(item.formula, "pitzer_parameters_activity")
-
-                osmotic_coefficient = ac.get_osmotic_coefficient_pitzer(
-                    ionic_strength,
-                    concentration,
-                    alpha1,
-                    alpha2,
-                    param.get_value()[0],
-                    param.get_value()[1],
-                    param.get_value()[2],
-                    param.get_value()[3],
-                    item.z_cation,
-                    item.z_anion,
-                    item.nu_cation,
-                    item.nu_anion,
-                    temperature,
-                )
-
-                logger.info(
-                    "Calculated osmotic coefficient of water as %s based on salt %s using Pitzer model"
-                    % (osmotic_coefficient, item.formula)
-                )
-                effective_osmotic_sum += concentration * osmotic_coefficient
-
-            else:
-                logger.warning(
-                    "Cannot calculate osmotic coefficient because Pitzer parameters for salt %s "
-                    "are not specified. Returning unit osmotic coefficient"
-                    % item.formula
-                )
-                effective_osmotic_sum += concentration * unit("1 dimensionless")
-
-        molal_phi = effective_osmotic_sum / molality_sum
-
-        if scale == "molal":
-            return molal_phi
-        elif scale == "rational":
-            solvent = self.get_solvent().formula
-            return (
-                -molal_phi
-                * unit("0.018 kg/mol")
-                * self.get_total_moles_solute()
-                / self.get_solvent_mass()
-                / math.log(self.get_amount(solvent, "fraction"))
-            )
-        elif scale == "fugacity":
-            solvent = self.get_solvent().formula
-            return math.exp(
-                -molal_phi
-                * unit("0.018 kg/mol")
-                * self.get_total_moles_solute()
-                / self.get_solvent_mass()
-                - math.log(self.get_amount(solvent, "fraction"))
-            )
-        else:
-            logger.warning(
-                "Invalid scale argument. Returning molal-scale osmotic coefficient"
-            )
-            return molal_phi
+        return salt_dict
 
-    def get_water_activity(self):
+    def equilibrate(self, **kwargs) -> None:
         """
-        Return the water activity.
-
-        Returns
-        -------
-        Quantity :
-            The thermodynamic activity of water in the solution.
-
-        See Also
-        --------
-        get_osmotic_coefficient
-        get_ionic_strength
-        get_salt
-
-        Notes
-        -----
-        Water activity is related to the osmotic coefficient in a solution containing i solutes by: [#]_
+        Update the composition of the Solution using the thermodynamic engine.
 
-        .. math:: \ln a_w = - \\Phi M_w \\sum_i m_i
+        Any kwargs specified are passed through to self.engine.equilibrate()
 
-        Where :math:`M_w` is the molar mass of water (0.018015 kg/mol) and :math:`m_i` is the molal concentration
-        of each species.
-
-        If appropriate Pitzer model parameters are not available, the
-        water activity is assumed equal to the mole fraction of water.
-
-        References
-        ----------
-        .. [#] Blandamer, Mike J., Engberts, Jan B. F. N., Gleeson, Peter T., Reis, Joao Carlos R., 2005. "Activity of \
-        water in aqueous systems: A frequently neglected property." *Chemical Society Review* 34, 440-458.
-
-        Examples
-        --------
-        >>> s1 = pyEQL.Solution([['Na+','0.3 mol/kg'],['Cl-','0.3 mol/kg']])
-        >>> s1.get_water_activity()
-        <Quantity(0.9900944932888518, 'dimensionless')>
-        """
+        Returns:
+            Nothing. The .components attribute of the Solution is updated.
         """
-        pseudo code
-
-        identify predominant salt for coefficients
-        check if coefficients exist for that salt
-        if so => calc osmotic coefficient and log an info message
-
-        if not = > return mole fraction and log a warning message
+        self.engine.equilibrate(self, **kwargs)
 
+    # Activity-related methods
+    def get_activity_coefficient(
+        self,
+        solute: str,
+        scale: Literal["molal", "molar", "fugacity", "rational"] = "molal",
+    ) -> Quantity:
         """
-        osmotic_coefficient = self.get_osmotic_coefficient()
-
-        if osmotic_coefficient == 1:
-            logger.warning(
-                "Pitzer parameters not found. Water activity set equal to mole fraction"
-            )
-            return self.get_amount("H2O", "fraction").to("dimensionless")
-        else:
-            concentration_sum = unit("0 mol/kg")
-            for item in self.components:
-                if item == "H2O":
-                    pass
-                else:
-                    concentration_sum += self.get_amount(item, "mol/kg")
+        Return the activity coefficient of a solute in solution.
 
-            logger.info("Calculated water activity using osmotic coefficient")
+        The model used to calculate the activity coefficient is determined by the Solution's equation of state
+        engine.
 
-            return math.exp(
-                -osmotic_coefficient * 0.018015 * unit("kg/mol") * concentration_sum
-            ) * unit("1 dimensionless")
+        Args:
+            solute: The solute for which to retrieve the activity coefficient
+            scale:  The activity coefficient concentration scale
+            verbose: If True, pyEQL will print a message indicating the parent salt
+                     that is being used for activity calculations. This option is
+                     useful when modeling multicomponent solutions. False by default.
 
-    def get_ionic_strength(self):
+        Returns:
+            Quantity: the activity coefficient as a dimensionless pint Quantity
         """
-        Return the ionic strength of the solution.
+        # return unit activity coefficient if the concentration of the solute is zero
+        if self.get_amount(solute, "mol").magnitude == 0:
+            return ureg.Quantity(1, "dimensionless")
 
-        Return the ionic strength of the solution, calculated as 1/2 * sum ( molality * charge ^2) over all the ions.
-        Molal (mol/kg) scale concentrations are used for compatibility with the activity correction formulas.
+        try:
+            # get the molal-scale activity coefficient from the EOS engine
+            molal = self.engine.get_activity_coefficient(solution=self, solute=solute)
+        except (ValueError, ZeroDivisionError):
+            self.logger.error("Calculation unsuccessful. Returning unit activity coefficient.", exc_info=True)
+            return ureg.Quantity(1, "dimensionless")
 
-        Returns
-        -------
-        Quantity :
-            The ionic strength of the parent solution, mol/kg.
-
-        See Also
-        --------
-        get_activity
-        get_water_activity
-
-        Notes
-        -----
-        The ionic strength is calculated according to:
-
-        .. math:: I = \sum_i m_i z_i^2
-
-        Where :math:`m_i` is the molal concentration and :math:`z_i` is the charge on species i.
-
-        Examples
-        --------
-        >>> s1 = pyEQL.Solution([['Na+','0.2 mol/kg'],['Cl-','0.2 mol/kg']])
-        >>> s1.get_ionic_strength()
-        <Quantity(0.20000010029672785, 'mole / kilogram')>
-
-        >>> s1 = pyEQL.Solution([['Mg+2','0.3 mol/kg'],['Na+','0.1 mol/kg'],['Cl-','0.7 mol/kg']],temperature='30 degC')
-        >>> s1.get_ionic_strength()
-        <Quantity(1.0000001004383303, 'mole / kilogram')>
-        """
-        self.ionic_strength = 0
-        for solute in self.components.keys():
-            self.ionic_strength += (
-                0.5
-                * self.get_amount(solute, "mol/kg")
-                * self.components[solute].get_formal_charge() ** 2
+        # if necessary, convert the activity coefficient to another scale, and return the result
+        if scale == "molal":
+            return molal
+        if scale == "molar":
+            total_molality = self.get_total_moles_solute() / self.solvent_mass
+            total_molarity = self.get_total_moles_solute() / self.volume
+            return (molal * ureg.Quantity(self.water_substance.rho, "g/L") * total_molality / total_molarity).to(
+                "dimensionless"
             )
+        if scale == "rational":
+            return molal * (1 + ureg.Quantity(0.018015, "kg/mol") * self.get_total_moles_solute() / self.solvent_mass)
 
-        return self.ionic_strength
+        raise ValueError("Invalid scale argument. Pass 'molal', 'molar', or 'rational'.")
 
-    def get_charge_balance(self):
+    def get_activity(
+        self,
+        solute: str,
+        scale: Literal["molal", "molar", "rational"] = "molal",
+    ) -> Quantity:
         """
-        Return the charge balance of the solution.
+        Return the thermodynamic activity of the solute in solution on the chosen concentration scale.
 
-        Return the charge balance of the solution. The charge balance represents the net electric charge
-        on the solution and SHOULD equal zero at all times, but due to numerical errors will usually
-        have a small nonzero value.
+        Args:
+            solute:
+                String representing the name of the solute of interest
+            scale:
+                The concentration scale for the returned activity.
+                Valid options are "molal", "molar", and "rational" (i.e., mole fraction).
+                By default, the molal scale activity is returned.
+            verbose:
+                If True, pyEQL will print a message indicating the parent salt
+                that is being used for activity calculations. This option is
+                useful when modeling multicomponent solutions. False by default.
 
-        Returns
-        -------
-        float :
-            The charge balance of the solution, in equivalents.
+        Returns:
+            The thermodynamic activity of the solute in question (dimensionless Quantity)
 
-        Notes
-        -----
-        The charge balance is calculated according to:
+        Notes:
+            The thermodynamic activity depends on the concentration scale used [rs]_ .
+            By default, the ionic strength, activity coefficients, and activities are all
+            calculated based on the molal (mol/kg) concentration scale.
 
-        .. math:: CB = F \sum_i n_i z_i
+        References:
+            .. [rs] Robinson, R. A.; Stokes, R. H. Electrolyte Solutions: Second Revised
+                Edition; Butterworths: London, 1968, p.32.
 
-        Where :math:`n_i` is the number of moles, :math:`z_i` is the charge on species i, and :math:`F` is the Faraday
-        constant.
+        See Also:
+            :attr:`ionic_strength`
+            :py:meth:`get_activity_coefficient`
+            :py:meth:`get_salt`
 
         """
-        self.charge_balance = 0
-        for solute in self.components.keys():
-            self.charge_balance += (
-                self.get_amount(solute, "mol")
-                * self.components[solute].get_formal_charge()
-                * unit.e
-                * unit.N_A
-            )
+        # switch to the water activity function if the species is H2O
+        if solute in ["H2O(aq)", "water", "H2O", "HOH"]:
+            activity = self.get_water_activity()
+        else:
+            # determine the concentration units to use based on the desired scale
+            if scale == "molal":
+                units = "mol/kg"
+            elif scale == "molar":
+                units = "mol/L"
+            elif scale == "rational":
+                units = "fraction"
+            else:
+                raise ValueError("Invalid scale argument. Pass 'molal', 'molar', or 'rational'.")
 
-        return self.charge_balance.magnitude
+            activity = (self.get_activity_coefficient(solute, scale=scale) * self.get_amount(solute, units)).magnitude
+            self.logger.debug(f"Calculated {scale} scale activity of solute {solute} as {activity}")
 
-    def get_alkalinity(self):
+        return ureg.Quantity(activity, "dimensionless")
+
+    # TODO - engine method
+    def get_osmotic_coefficient(self, scale: Literal["molal", "molar", "rational"] = "molal") -> Quantity:
         """
-        Return the alkalinity or acid neutralizing capacity of a solution
+        Return the osmotic coefficient of an aqueous solution.
 
-        Returns
-        -------
-        Quantity :
-            The alkalinity of the solution in mg/L as CaCO3
+        The method used depends on the Solution object's equation of state engine.
 
-        Notes
-        -----
-        The alkalinity is calculated according to: [#]_
+        """
+        molal_phi = self.engine.get_osmotic_coefficient(self)
 
-        .. math:: Alk = F \sum_i z_i C_B - \sum_i z_i C_A
+        if scale == "molal":
+            return molal_phi
+        if scale == "rational":
+            return (
+                -molal_phi
+                * ureg.Quantity(0.018015, "kg/mol")
+                * self.get_total_moles_solute()
+                / self.solvent_mass
+                / np.log(self.get_amount(self.solvent, "fraction"))
+            )
+        if scale == "fugacity":
+            return np.exp(
+                -molal_phi * ureg.Quantity(0.018015, "kg/mol") * self.get_total_moles_solute() / self.solvent_mass
+                - np.log(self.get_amount(self.solvent, "fraction"))
+            ) * ureg.Quantity(1, "dimensionless")
 
-        Where :math:`C_B` and :math:`C_A` are conservative cations and anions, respectively
-        (i.e. ions that do not participate in acid-base reactions), and :math:`z_i` is their charge.
-        In this method, the set of conservative cations is all Group I and Group II cations, and the conservative anions
-        are all the anions of strong acids.
+        raise ValueError("Invalid scale argument. Pass 'molal', 'rational', or 'fugacity'.")
 
-        References
-        ----------
-        .. [#] Stumm, Werner and Morgan, James J. Aquatic Chemistry, 3rd ed,
-               pp 165. Wiley Interscience, 1996.
-        """
-        alkalinity = 0 * unit("mol/L")
-        equiv_wt_CaCO3 = 100.09 / 2 * unit("g/mol")
-
-        base_cations = [
-            "Li+",
-            "Na+",
-            "K+",
-            "Rb+",
-            "Cs+",
-            "Fr+",
-            "Be+2",
-            "Mg+2",
-            "Ca+2",
-            "Sr+2",
-            "Ba+2",
-            "Ra+2",
-        ]
-        acid_anions = ["Cl-", "Br-", "I-", "SO4-2", "NO3-", "ClO4-", "ClO3-"]
+    def get_water_activity(self) -> Quantity:
+        r"""
+        Return the water activity.
 
-        for item in self.components:
-            if item in base_cations:
-                z = self.get_solute(item).get_formal_charge()
-                alkalinity += self.get_amount(item, "mol/L") * z
-            if item in acid_anions:
-                z = self.get_solute(item).get_formal_charge()
-                alkalinity -= self.get_amount(item, "mol/L") * z
+        Returns:
+            Quantity:
+                The thermodynamic activity of water in the solution.
 
-        # convert the alkalinity to mg/L as CaCO3
-        return (alkalinity * equiv_wt_CaCO3).to("mg/L")
+        See Also:
+            :attr:`ionic_strength`
+            :py:meth:`get_activity_coefficient`
+            :py:meth:`get_salt`
 
-    def get_hardness(self):
-        """
-        Return the hardness of a solution.
+        Notes:
+            Water activity is related to the osmotic coefficient in a solution containing i solutes by:
 
-        Hardness is defined as the sum of the equivalent concentrations
-        of multivalent cations as calcium carbonate.
+            .. math:: \ln a_{w} = - \Phi M_{w} \sum_{i} m_{i}
 
-        NOTE: at present pyEQL cannot distinguish between mg/L as CaCO3
-        and mg/L units. Use with caution.
+            Where :math:`M_{w}` is the molar mass of water (0.018015 kg/mol) and :math:`m_{i}` is the molal
+            concentration of each species.
 
-        Parameters
-        ----------
-        None
+            If appropriate Pitzer model parameters are not available, the
+            water activity is assumed equal to the mole fraction of water.
 
-        Returns
-        -------
-        Quantity
-            The hardness of the solution in mg/L as CaCO3
+        References:
+            Blandamer, Mike J., Engberts, Jan B. F. N., Gleeson, Peter T., Reis, Joao Carlos R., 2005. "Activity of
+            water in aqueous systems: A frequently neglected property." *Chemical Society Review* 34, 440-458.
 
+        Examples:
+            >>> s1 = pyEQL.Solution([['Na+','0.3 mol/kg'],['Cl-','0.3 mol/kg']])
+            >>> s1.get_water_activity()
+            <Quantity(0.9900944932888518, 'dimensionless')>
         """
-        hardness = 0 * unit("mol/L")
-        equiv_wt_CaCO3 = 100.09 / 2 * unit("g/mol")
-
-        for item in self.components:
-            z = self.get_solute(item).get_formal_charge()
-            if z > 1:
-                hardness += z * self.get_amount(item, "mol/L")
+        osmotic_coefficient = self.get_osmotic_coefficient()
 
-        # convert the hardness to mg/L as CaCO3
-        return (hardness * equiv_wt_CaCO3).to("mg/L")
+        if osmotic_coefficient == 1:
+            self.logger.warning("Pitzer parameters not found. Water activity set equal to mole fraction")
+            return self.get_amount("H2O", "fraction")
 
-    def get_debye_length(self):
-        """
-        Return the Debye length of a solution
+        concentration_sum = np.sum([mol for item, mol in self.components.items() if item != "H2O(aq)"])
+        concentration_sum /= self.solvent_mass.to("kg").magnitude  # converts to mol/kg
 
-        Debye length is calculated as [#]_
+        self.logger.debug("Calculated water activity using osmotic coefficient")
 
-        .. math::
+        return ureg.Quantity(np.exp(-osmotic_coefficient * 0.018015 * concentration_sum), "dimensionless")
 
-            \\kappa^{-1} = \\sqrt({\\epsilon_r \\epsilon_o k_B T \\over (2 N_A e^2 I)})
+    def get_chemical_potential_energy(self, activity_correction: bool = True) -> Quantity:
+        r"""
+        Return the total chemical potential energy of a solution (not including
+        pressure or electric effects).
 
-        where :math:`I` is the ionic strength, :math:`epsilon_r` and :math:`epsilon_r`
-        are the relative permittivity and vacuum permittivity, :math:`k_B` is the
-        Boltzmann constant, and :math:`T` is the temperature, :math:`e` is the
-        elementary charge, and :math:`N_A` is Avogadro's number.
+        Args:
+            activity_correction : bool, optional
+                If True, activities will be used to calculate the true chemical
+                potential. If False, mole fraction will be used, resulting in
+                a calculation of the ideal chemical potential.
 
-        Parameters
-        ----------
-        None
+        Returns:
+            Quantity
+                The actual or ideal chemical potential energy of the solution, in Joules.
 
-        Returns
-        -------
-        Quantity
-            The Debye length, in nanometers.
+        Notes:
+            The chemical potential energy (related to the Gibbs mixing energy) is
+            calculated as follows: [koga]_
 
-        References
-        ----------
-        .. [#] https://en.wikipedia.org/wiki/Debye_length#Debye_length_in_an_electrolyte
+            .. math::      E = R T \sum_i n_i  \ln a_i
 
-        See Also
-        --------
-        get_ionic_strength
-        get_dielectric_constant
+            or
 
-        """
-        temperature = self.get_temperature()
+            .. math::      E = R T \sum_i n_i \ln x_i
 
-        # to preserve dimensionality, convert the ionic strength into mol/L units
-        ionic_strength = self.get_ionic_strength().magnitude * unit("mol/L")
-        dielectric_constant = self.get_dielectric_constant()
+            Where :math:`n` is the number of moles of substance, :math:`T` is the temperature in kelvin,
+            :math:`R` the ideal gas constant, :math:`x` the mole fraction, and :math:`a` the activity of
+            each component.
 
-        debye_length = (
-            dielectric_constant
-            * unit.epsilon_0
-            * unit.k
-            * temperature
-            / (2 * unit.N_A * unit.e ** 2 * ionic_strength)
-        ) ** 0.5
+            Note that dissociated ions must be counted as separate components,
+            so a simple salt dissolved in water is a three component solution (cation,
+            anion, and water).
 
-        return debye_length.to("nm")
+        References:
+            .. [koga] Koga, Yoshikata, 2007. *Solution Thermodynamics and its Application to Aqueous Solutions:
+            A differential approach.* Elsevier, 2007, pp. 23-37.
 
-    def get_bjerrum_length(self):
         """
-        Return the Bjerrum length of a solution
-
-        Bjerrum length representes the distance at which electrostatic
-        interactions between particles become comparable in magnitude
-        to the thermal energy.:math:`\\lambda_B` is calculated as [#]_
+        E = ureg.Quantity(0, "J")
 
-        .. math::
+        # loop through all the components and add their potential energy
+        for item in self.components:
+            try:
+                if activity_correction is True:
+                    E += (
+                        ureg.R
+                        * self.temperature.to("K")
+                        * self.get_amount(item, "mol")
+                        * np.log(self.get_activity(item))
+                    )
+                else:
+                    E += (
+                        ureg.R
+                        * self.temperature.to("K")
+                        * self.get_amount(item, "mol")
+                        * np.log(self.get_amount(item, "fraction"))
+                    )
+            # If we have a solute with zero concentration, we will get a ValueError
+            except ValueError:
+                continue
 
-            \\lambda_B = {e^2 \\over (4 \\pi \\epsilon_r \\epsilon_o k_B T)}
+        return E.to("J")
 
-        where :math:`e` is the fundamental charge, :math:`epsilon_r` and :math:`epsilon_r`
-        are the relative permittivity and vacuum permittivity, :math:`k_B` is the
-        Boltzmann constant, and :math:`T` is the temperature.
+    def _get_property(self, solute: str, name: str) -> Any | None:
+        """Retrieve a thermodynamic property (such as diffusion coefficient)
+        for solute, and adjust it from the reference conditions to the conditions
+        of the solution.
+
+        Args:
+            solute: str
+                String representing the chemical formula of the solute species
+            name: str
+                The name of the property needed, e.g.
+                'diffusion coefficient'
+
+        Returns:
+            Quantity: The desired parameter or None if not found
+
+        """
+        base_temperature = ureg.Quantity(25, "degC")
+        # base_pressure = ureg.Quantity("1 atm")
+
+        # query the database using the standardized formula
+        rform = standardize_formula(solute)
+        # TODO - there seems to be a bug in mongomock / JSONStore wherein properties does
+        # not properly return dot-notation fields, e.g. size.molar_volume will not be returned.
+        # also $exists:True does not properly return dot notated fields.
+        # for now, just set properties=[] to return everything
+        # data = list(self.database.query({"formula": rform, name: {"$ne": None}}, properties=["formula", name]))
+        data = list(self.database.query({"formula": rform, name: {"$ne": None}}))
+        # formulas should always be unique in the database. len==0 indicates no
+        # data. len>1 indicates duplicate data.
+        if len(data) > 1:
+            self.logger.warning(f"Duplicate database entries for solute {solute} found!")
+        if len(data) == 0:
+            # TODO - add molar volume of water to database?
+            if name == "size.molar_volume" and rform == "H2O(aq)":
+                # calculate the partial molar volume for water since it isn't in the database
+                vol = ureg.Quantity(self.get_property("H2O", "molecular_weight")) / (
+                    ureg.Quantity(self.water_substance.rho, "g/L")
+                )
 
-        Parameters
-        ----------
-        None
+                return vol.to("cm **3 / mol")
 
-        Returns
-        -------
-        Quantity
-            The Bjerrum length, in nanometers.
+            # try to determine basic properties using pymatgen
+            doc = Solute.from_formula(rform).as_dict()
+            data = [doc]
 
-        References
-        ----------
-        .. [#] https://en.wikipedia.org/wiki/Bjerrum_length
+        doc: dict = data[0]
 
-        Examples
-        --------
-        >>> s1 = pyEQL.Solution()
-        >>> s1.get_bjerrum_length()
-        <Quantity(0.7152793009386953, 'nanometer')>
+        try:
+            # perform temperature-corrections or other adjustments for certain
+            # parameter types
+            if name == "transport.diffusion_coefficient":
+                data = doc["transport"]["diffusion_coefficient"]
+                if data is not None:
+                    return ureg.Quantity(data["value"]).to("m**2/s")
+
+            # just return the base-value molar volume for now; find a way to adjust for concentration later
+            if name == "size.molar_volume":
+                data = doc["size"]["molar_volume"]
+                if data is not None:
+                    base_value = ureg.Quantity(doc["size"]["molar_volume"].get("value"))
+                    if self.temperature != base_temperature:
+                        self.logger.warning(f"Partial molar volume for species {solute} not corrected for temperature")
+                    return base_value
+                return data
 
-        See Also
-        --------
-        get_dielectric_constant
+            if name == "model_parameters.dielectric_zuber":
+                return ureg.Quantity(doc["model_parameters"]["dielectric_zuber"]["value"])
 
-        """
-        temperature = self.get_temperature()
-        dielectric_constant = self.get_dielectric_constant()
+            if name == "model_parameters.activity_pitzer":
+                # return a dict
+                if doc["model_parameters"]["activity_pitzer"].get("Beta0") is not None:
+                    return doc["model_parameters"]["activity_pitzer"]
+                return None
 
-        bjerrum_length = unit.e ** 2 / (
-            4 * math.pi * dielectric_constant * unit.epsilon_0 * unit.k * temperature
-        )
-        return bjerrum_length.to("nm")
+            if name == "model_parameters.molar_volume_pitzer":
+                # return a dict
+                if doc["model_parameters"]["molar_volume_pitzer"].get("Beta0") is not None:
+                    return doc["model_parameters"]["molar_volume_pitzer"]
+                return None
 
-    def get_transport_number(self, solute, activity_correction=False):
-        """
-        Calculate the transport number of the solute in the solution
+            if name == "molecular_weight":
+                return ureg.Quantity(doc.get(name))
 
-        Parameters
-        ----------
-        solute : str
-            String identifying the solute for which the transport number is
-            to be calculated.
+            if name == "elements":
+                return doc.get(name)
 
-        activity_correction: bool
-            If True, the transport number will be corrected for activity following
-            the same method used for solution conductivity. Defaults to False
-            if omitted.
+            if name == "oxi_state_guesses":
+                # ensure that all oxi states are returned as floats
+                return {k: float(v) for k, v in doc.get(name).items()}
 
-        Returns
-        -------
-        float
-            The transport number of `solute`
+            # for parameters not named above, just return the base value
+            if name == "pmg_ion" or not isinstance(doc.get(name), dict):
+                # if the queried value is not a dict, it is a root level key and should be returned as is
+                return doc.get(name)
 
-        Notes
-        -----
-        Transport number is calculated according to [#]_ :
+            val = doc[name].get("value")
+            # self.logger.warning("%s has not been corrected for solution conditions" % name)
+            if val is not None:
+                return ureg.Quantity(val)
 
-        .. math::
+        except KeyError:
+            self.logger.error(f"Property {name} for solute {solute} not found in database. Returning None.")
+            return None
 
-            t_i = {D_i z_i^2 C_i \\over \\sum D_i z_i^2 C_i}
+        if name == "model_parameters.molar_volume_pitzer":
+            # return a dict
+            if doc["model_parameters"]["molar_volume_pitzer"].get("Beta0") is not None:
+                return doc["model_parameters"]["molar_volume_pitzer"]
+            return None
 
-        Where :math:`C_i` is the concentration in mol/L, :math:`D_i` is the diffusion
-        coefficient, and :math:`z_i` is the charge, and the summation extends
-        over all species in the solution.
+        if name == "molecular_weight":
+            return ureg.Quantity(doc.get(name))
 
-        If `activity_correction` is True, the contribution of each ion to the
-        transport number is corrected with an activity factor. See the documentation
-        for get_conductivity() for an explanation of this correction.
+        if name == "oxi_state_guesses":
+            return doc.get(name)
 
-        References
-        ----------
-        .. [#] Geise, G. M.; Cassady, H. J.; Paul, D. R.; Logan, E.; Hickner, M. A. "Specific
-               ion effects on membrane potential and the permselectivity of ion exchange membranes.""
-               *Phys. Chem. Chem. Phys.* 2014, 16, 21673–21681.
+        # for parameters not named above, just return the base value
+        if name == "pmg_ion" or not isinstance(doc.get(name), dict):
+            # if the queried value is not a dict, it is a root level key and should be returned as is
+            return doc.get(name)
 
-        """
-        denominator = 0
-        numerator = 0
+        val = doc[name].get("value")
+        # self.logger.warning("%s has not been corrected for solution conditions" % name)
+        if val is not None:
+            return ureg.Quantity(val)
+        return None
 
-        for item in self.components:
+    def get_transport_number(self, solute: str) -> Quantity:
+        r"""Calculate the transport number of the solute in the solution.
 
-            z = self.get_solute(item).get_formal_charge()
-            term = (
-                self.get_property(item, "diffusion_coefficient")
-                * z ** 2
-                * self.get_amount(item, "mol/L")
-            )
+        Args:
+            solute: Formula of the solute for which the transport number is
+                to be calculated.
 
-            if activity_correction is True:
-                gamma = self.get_activity_coefficient(item)
+        Returns:
+                The transport number of `solute`, as a dimensionless Quantity.
 
-                if self.get_ionic_strength().magnitude < 0.36 * z:
-                    alpha = 0.6 / z ** 0.5
-                else:
-                    alpha = self.get_ionic_strength().magnitude ** 0.5 / z
+        Notes:
+            Transport number is calculated according to :
 
-                if item == solute:
-                    numerator = term * gamma ** alpha
+                .. math::
 
-                denominator += term * gamma ** alpha
+                    t_i = {D_i z_i^2 C_i \over \sum D_i z_i^2 C_i}
 
-            else:
-                if item == solute:
-                    numerator = term
+                Where :math:`C_i` is the concentration in mol/L, :math:`D_i` is the diffusion
+                coefficient, and :math:`z_i` is the charge, and the summation extends
+                over all species in the solution.
 
-                denominator += term
+                Diffusion coefficients :math:`D_i` are adjusted for the effects of temperature
+                and ionic strength using the method implemented in PHREEQC >= 3.4.
+                See `get_diffusion_coefficient for` further details.
 
-        return (numerator / denominator).to("dimensionless")
 
-    def get_molar_conductivity(self, solute):
+        References:
+                Geise, G. M.; Cassady, H. J.; Paul, D. R.; Logan, E.; Hickner, M. A. "Specific
+                ion effects on membrane potential and the permselectivity of ion exchange membranes.""
+                *Phys. Chem. Chem. Phys.* 2014, 16, 21673-21681.
 
+        See Also:
+            :py:meth:`get_diffusion_coefficient`
+            :py:meth:`get_molar_conductivity`
         """
-        Calculate the molar (equivalent) conductivity for a solute
-
-        Parameters
-        ----------
-        solute : str
-            String identifying the solute for which the molar conductivity is
-            to be calculated.
+        solute = standardize_formula(solute)
+        denominator = numerator = 0
 
-        Returns
-        -------
-        float
-                The molar or equivalent conductivity of the species in the solution.
-                Zero if the solute is not charged.
+        for item, mol in self.components.items():
+            # the molar conductivity of each species is F/RT D * z^2, and the F/RT factor
+            # cancels out
+            # using species amounts in mol is equivalent to using concentrations in mol/L
+            # since there is only one solution volume, and it's much faster.
+            term = self.get_molar_conductivity(item).magnitude * mol
 
-        Notes
-        -----
-        Molar conductivity is calculated from the Nernst-Einstein relation [#]_
+            if item == solute:
+                numerator = term
 
-        .. math::
+            denominator += term
 
-            \\kappa_i = {z_i^2 D_i F^2 \\over RT}
+        return ureg.Quantity(numerator / denominator, "dimensionless")
 
-        Note that the diffusion coefficient is strongly variable with temperature.
+    def _get_molar_conductivity(self, solute: str) -> Quantity:
+        r"""
+        Calculate the molar (equivalent) conductivity for a solute.
 
-        References
-        ----------
+        Args:
+            solute: String identifying the solute for which the molar conductivity is
+                to be calculated.
 
-        .. [#] Smedley, Stuart. The Interpretation of Ionic Conductivity in Liquids, pp 1-9. Plenum Press, 1980.
+        Returns:
+            The molar or equivalent conductivity of the species in the solution.
+            Zero if the solute is not charged.
 
-        Examples
-        --------
-        TODO
+        Notes:
+            Molar conductivity is calculated from the Nernst-Einstein relation [smed]_
 
-        """
-        temperature = self.get_temperature()
+            .. math::
 
-        D = self.get_property(solute, "diffusion_coefficient")
+                \lambda_i = \frac{F^2}{RT} D_i z_i^2
 
-        molar_cond = (
-            D
-            * (unit.e * unit.N_A) ** 2
-            * self.get_solute(solute).get_formal_charge() ** 2
-            / (unit.R * temperature)
-        )
+            Diffusion coefficients :math:`D_i` are adjusted for the effects of temperature
+            and ionic strength using the method implemented in PHREEQC >= 3.4.  See `get_diffusion_coefficient`
+            for further details.
 
-        logger.info(
-            "Computed molar conductivity as %s from D = %s at T=%s"
-            % (molar_cond, str(D), temperature)
-        )
+        References:
+            1. .. [smed] Smedley, Stuart. The Interpretation of Ionic Conductivity in Liquids, pp 1-9. Plenum Press, 1980.
 
-        return molar_cond.to("mS / cm / (mol/L)")
+            2. https://www.hydrochemistry.eu/exmpls/sc.html
 
-    def get_mobility(self, solute):
-        """
-        Calculate the ionic mobility of the solute
+            3. Appelo, C.A.J. Solute transport solved with the Nernst-Planck equation for concrete pores with `free'
+               water and a double layer. Cement and Concrete Research 101, 2017.
+               https://dx.doi.org/10.1016/j.cemconres.2017.08.030
 
-        Parameters
-        ----------
-        solute : str
-            String identifying the solute for which the mobility is
-            to be calculated.
+            4. CRC Handbook of Chemistry and Physics
 
-        Returns
-        -------
-        float : The ionic mobility. Zero if the solute is not charged.
+        See Also:
+            :py:meth:`get_diffusion_coefficient`
+        """
+        D = self.get_diffusion_coefficient(solute)
 
+        if D != 0:
+            molar_cond = (
+                D * (ureg.e * ureg.N_A) ** 2 * self.get_property(solute, "charge") ** 2 / (ureg.R * self.temperature)
+            )
+        else:
+            molar_cond = ureg.Quantity(0, "mS / cm / (mol/L)")
 
-        Notes
-        -----
-        This function uses the Einstein relation to convert a diffusion coefficient
-        into an ionic mobility [#]_
+        self.logger.debug(f"Calculated molar conductivity as {molar_cond} from D = {D!s} at T={self.temperature}")
 
-        .. math::
+        return molar_cond.to("mS / cm / (mol/L)")
 
-            \\mu_i = {F |z_i| D_i \\over RT}
+    def _get_diffusion_coefficient(self, solute: str, activity_correction: bool = True) -> Quantity:
+        r"""
+        Get the **temperature-adjusted** diffusion coefficient of a solute.
 
-        References
-        ----------
-        .. [#] Smedley, Stuart I. The Interpretation of Ionic Conductivity in Liquids. Plenum Press, 1980.
+        Args:
+            solute: the solute for which to retrieve the diffusion coefficient.
+            activity_correction: If True (default), adjusts the diffusion coefficient for the effects of ionic
+                strength using a model from Ref 2.
 
-        """
-        temperature = self.get_temperature()
+        Notes:
+            This method is equivalent to self.get_property(solute, "transport.diffusion_coefficient")
+            ONLY when the Solution temperature is the same as the reference temperature for the diffusion coefficient
+            in the database (usually 25 C).
 
-        D = self.get_property(solute, "diffusion_coefficient")
+            Otherwise, the reference D value is adjusted based on the Solution temperature and (optionally),
+            ionic strength. The adjustments are
 
-        mobility = (
-            unit.N_A
-            * unit.e
-            * abs(self.get_solute(solute).get_formal_charge())
-            * D
-            / (unit.R * temperature)
-        )
+            .. math::
 
-        logger.info(
-            "Computed ionic mobility as %s from D = %s at T=%s"
-            % (mobility, str(D), temperature)
-        )
+                D_T = D_{298} \exp(\frac{d}{T} - \frac{d}{298}) \frac{\nu_{298}}{\nu_T}
 
-        return mobility.to("m**2/V/s")
+            .. math::
 
-    def get_property(self, solute, name):
-        """Retrieve a thermodynamic property (such as diffusion coefficient)
-        for solute, and adjust it from the reference conditions to the conditions
-        of the solution
+                D_{\gamma} = D^0 \exp(\frac{-a1 A |z_i| \sqrt{I}}{1+\kappa a}
 
-        Parameters
-        ----------
-        solute: str
-            String representing the chemical formula of the solute species
-        name: str
-            The name of the property needed, e.g.
-            'diffusion coefficient'
+            .. math::
 
-        Returns
-        -------
-        Quantity: The desired parameter
+                 \kappa a = B \sqrt{I} \frac{a2}{1+I^{0.75}}
 
-        """
-        # retrieve the base value and the conditions of measurement from the
-        # database
+            where a1, a2, and d are parameters from Ref. 2, A and B are the parameters used in the Debye Huckel
+            equation, and I is the ionic strength. If the model parameters for a particular solute are not available,
+            default values of d=0, a1=1.6, and a2=4.73 (as recommended in Ref. 2) are used instead.
 
-        if db.has_parameter(solute, name):
-            base_value = self.get_solute(solute).get_parameter(name)
-        else:
-            base_value = None
-
-        base_temperature = unit("25 degC")
-        base_pressure = unit("1 atm")
-
-        # perform temperature-corrections or other adjustments for certain
-        # parameter types
-        if name == "diffusion_coefficient":
-            if base_value is not None:
-                # correct for temperature and viscosity
-                # .. math:: D_1 \\over D_2 = T_1 \\over T_2 * \\mu_2 \\over \\mu_1
-                # where :math:`\\mu` is the dynamic viscosity
-                # assume that the base viscosity is that of pure water
-                return (
-                    base_value
-                    * self.get_temperature()
-                    / base_temperature
-                    * h2o.water_viscosity_dynamic(base_temperature, base_pressure)
-                    / self.get_viscosity_dynamic()
-                )
-            else:
-                logger.warning(
-                    "Diffusion coefficient not found for species %s. Assuming zero."
-                    % (solute)
-                )
-                return unit("0 m**2/s")
-
-        # just return the base-value molar volume for now; find a way to adjust for
-        # concentration later
-        if name == "partial_molar_volume":
-            # calculate the partial molar volume for water since it isn't in the database
-            if solute == "H2O":
-                vol = self.get_solute("H2O").get_molecular_weight() / h2o.water_density(
-                    self.get_temperature()
-                )
-                return vol.to("cm **3 / mol")
-            else:
-                if base_value is not None:
-                    return base_value
-                    if self.get_temperature() != base_temperature:
-                        logger.warning(
-                            "Partial molar volume for species %s not corrected for temperature"
-                            % solute
-                        )
-                else:
-                    logger.warning(
-                        "Partial molar volume not found for species %s. Assuming zero."
-                        % solute
-                    )
-                    return unit("0 cm **3 / mol")
+        References:
+            1. https://www.hydrochemistry.eu/exmpls/sc.html
+            2. Appelo, C.A.J. Solute transport solved with the Nernst-Planck equation for concrete pores with `free'
+               water and a double layer. Cement and Concrete Research 101, 2017.
+               https://dx.doi.org/10.1016/j.cemconres.2017.08.030
+            3. CRC Handbook of Chemistry and Physics
 
-        # for parameters not named above, just return the base value
-        else:
-            logger.warning("%s has not been corrected for solution conditions" % name)
-            return base_value
+        See Also:
+            pyEQL.activity_correction._debye_parameter_B
+            pyEQL.activity_correction._debye_parameter_activity
 
-    def get_chemical_potential_energy(self, activity_correction=True):
         """
-        Return the total chemical potential energy of a solution (not including
-        pressure or electric effects)
-
-        Parameters
-        ----------
-        activity_correction : bool, optional
-            If True, activities will be used to calculate the true chemical
-            potential. If False, mole fraction will be used, resulting in
-            a calculation of the ideal chemical potential.
-
-        Returns
-        -------
-        Quantity
-            The actual or ideal chemical potential energy of the solution, in Joules.
+        D = self.get_property(solute, "transport.diffusion_coefficient")
+        rform = standardize_formula(solute)
+        if D is None or D.magnitude == 0:
+            self.logger.warning(
+                f"Diffusion coefficient not found for species {rform}. Using default value of "
+                f"{self.default_diffusion_coeff} m**2/s."
+            )
+            D = ureg.Quantity(self.default_diffusion_coeff, "m**2/s")
 
-        Notes
-        -----
+        # assume reference temperature is 298.15 K (this is the case for all current DB entries)
+        T_ref = 298.15
+        mu_ref = 0.0008900225512925807  # water viscosity from IAPWS97 at 298.15 K
+        T_sol = self.temperature.to("K").magnitude
+        mu = self.water_substance.mu
 
-        The chemical potential energy (related to the Gibbs mixing energy) is
-        calculated as follows: [#]_
+        # skip temperature correction if within 1 degree
+        if abs(T_sol - T_ref) > 1 or activity_correction is True:
+            # get the a1, a2, and d parameters required by the PHREEQC model
+            try:
+                doc = self.database.query_one({"formula": rform})
+                d = doc["model_parameters"]["diffusion_temp_smolyakov"]["d"]["value"]
+                a1 = doc["model_parameters"]["diffusion_temp_smolyakov"]["a1"]["value"]
+                a2 = doc["model_parameters"]["diffusion_temp_smolyakov"]["a2"]["value"]
+                # values will be a str, e.g. "1 dimensionless"
+                d = float(d.split(" ")[0])
+                a1 = float(a1.split(" ")[0])
+                a2 = float(a2.split(" ")[0])
+            except TypeError:
+                # this means the database doesn't contain a d value.
+                # according to Ref 2, the following are recommended default parameters
+                self.logger.warning(
+                    f"Temperature and ionic strength correction parameters for solute {rform} diffusion "
+                    "coefficient not in database. Using recommended default values of a1=1.6, a2=4.73, and d=0."
+                )
+                d = 0
+                a1 = 1.6
+                a2 = 4.73
+
+            # use the PHREEQC model from Ref 2 to correct for temperature
+            D_final = D * np.exp(d / T_sol - d / T_ref) * mu_ref / mu
+
+            if activity_correction:
+                A = _debye_parameter_activity(str(self.temperature)).to("kg**0.5/mol**0.5").magnitude / 2.303
+                B = _debye_parameter_B(str(self.temperature)).to("1/angstrom * kg**0.5/mol**0.5").magnitude
+                z = self.get_property(solute, "charge")
+                IS = self.ionic_strength.magnitude
+                kappaa = B * IS**0.5 * a2 / (1 + IS**0.75)
+                # correct for ionic strength
+                D_final *= np.exp(-a1 * A * abs(z) * IS**0.5 / (1 + kappaa))
+            # else:
+            #     # per CRC handbook, D increases by 2-3% per degree above 25 C
+            #     return D * (1 + 0.025 * (T_sol - T_ref))
+        else:
+            D_final = D
 
-        .. math::      E = R T \\sum_i n_i  \\ln a_i
+        return D_final
 
-        or
+    def _get_mobility(self, solute: str) -> Quantity:
+        r"""
+        Calculate the ionic mobility of the solute.
 
-        .. math::      E = R T \\sum_i n_i \\ln x_i
+        Args:
+            solute (str): String identifying the solute for which the mobility is to be calculated.
 
-        Where :math:`n` is the number of moles of substance, :math:`T` is the temperature in kelvin,
-        :math:`R` the ideal gas constant, :math:`x` the mole fraction, and :math:`a` the activity of
-        each component.
+        Returns:
+            float: The ionic mobility. Zero if the solute is not charged.
 
-        Note that dissociated ions must be counted as separate components,
-        so a simple salt dissolved in water is a three component solution (cation,
-        anion, and water).
+        Note:
+            This function uses the Einstein relation to convert a diffusion coefficient into an ionic mobility [smed]_
 
-        References
-        ----------
-        .. [#] Koga, Yoshikata, 2007. *Solution Thermodynamics and its Application to Aqueous Solutions: A differential
-               approach.* Elsevier, 2007, pp. 23-37.
+            .. math::
 
-        Examples
-        --------
+                \mu_i = {F |z_i| D_i \over RT}
 
+        References:
+            Smedley, Stuart I. The Interpretation of Ionic Conductivity in Liquids. Plenum Press, 1980.
         """
-        temperature = self.get_temperature()
+        D = self.get_diffusion_coefficient(solute)
 
-        E = unit("0 J")
+        mobility = ureg.N_A * ureg.e * abs(self.get_property(solute, "charge")) * D / (ureg.R * self.temperature)
 
-        # loop through all the components and add their potential energy
-        for item in self.components:
-            try:
-                if activity_correction is True:
-                    E += (
-                        unit.R
-                        * temperature.to("K")
-                        * self.get_amount(item, "mol")
-                        * math.log(self.get_activity(item))
-                    )
-                else:
-                    E += (
-                        unit.R
-                        * temperature.to("K")
-                        * self.get_amount(item, "mol")
-                        * math.log(self.get_amount(item, "fraction"))
-                    )
-            # If we have a solute with zero concentration, we will get a ValueError
-            except ValueError:
-                continue
+        self.logger.debug(f"Calculated ionic mobility as {mobility} from D = {D!s} at T={self.temperature}")
 
-        return E.to("J")
+        return mobility.to("m**2/V/s")
 
-    def get_lattice_distance(self, solute):
-        """
-        Calculate the average distance between molecules
+    def get_lattice_distance(self, solute: str) -> Quantity:
+        r"""
+        Calculate the average distance between molecules.
 
         Calculate the average distance between molecules of the given solute,
         assuming that the molecules are uniformly distributed throughout the
         solution.
 
-        Parameters
-        ----------
-        solute : str
-                    String representing the name of the solute of interest
+        Args:
+            solute : str
+                String representing the name of the solute of interest
 
-        Returns
-        -------
-        Quantity : The average distance between solute molecules
+        Returns:
+            Quantity: The average distance between solute molecules
 
-        Examples
-        --------
-        >>> soln = Solution([['Na+','0.5 mol/kg'],['Cl-','0.5 mol/kg']])
-        >>> soln.get_lattice_distance('Na+')
-        1.492964.... nanometer
+        Examples:
+            >>> soln = Solution([['Na+','0.5 mol/kg'],['Cl-','0.5 mol/kg']])
+            >>> soln.get_lattice_distance('Na+')
+            1.492964.... nanometer
 
-        Notes
-        -----
-        The lattice distance is related to the molar concentration as follows:
+        Notes:
+            The lattice distance is related to the molar concentration as follows:
 
-        .. math:: d = ( C_i N_A ) ^ {-{1\\over3}}
+            .. math:: d = ( C_i N_A ) ^ {-{1 \over 3}}
 
         """
         # calculate the volume per particle as the reciprocal of the molar concentration
         # (times avogadro's number). Take the cube root of the volume to get
         # the average distance between molecules
-        distance = (self.get_amount(solute, "mol/L") * unit.N_A) ** (-1 / 3)
+        distance = (self.get_amount(solute, "mol/L") * ureg.N_A) ** (-1 / 3)
 
         return distance.to("nm")
 
     def _update_volume(self):
-        """
-        Recalculate the solution volume based on composition
-
-        """
-        self.volume = self._get_solvent_volume() + self._get_solute_volume()
+        """Recalculate the solution volume based on composition."""
+        self._volume = self._get_solvent_volume() + self._get_solute_volume()
 
     def _get_solvent_volume(self):
-        """
-        Return the volume of the pure solvent
-
-        """
+        """Return the volume of the pure solvent."""
         # calculate the volume of the pure solvent
-        solvent_vol = self.get_solvent_mass() / h2o.water_density(
-            self.get_temperature(), self.get_pressure()
-        )
+        solvent_vol = self.solvent_mass / ureg.Quantity(self.water_substance.rho, "g/L")
 
         return solvent_vol.to("L")
 
     def _get_solute_volume(self):
-        """
-        Return the volume of only the solutes
-
-        """
-        temperature = str(self.get_temperature())
-
-        # identify the predominant salt in the solution
-        Salt = self.get_salt()
-
-        # search the database for pitzer parameters for 'salt'
-        db.search_parameters(Salt.formula)
-
-        solute_vol = 0 * unit("L")
-
-        # use the pitzer approach if parameters are available
-
-        pitzer_calc = False
-
-        if db.has_parameter(Salt.formula, "pitzer_parameters_volume"):
-
-            param = db.get_parameter(Salt.formula, "pitzer_parameters_volume")
-
-            # determine the average molality of the salt
-            # this is necessary for solutions inside e.g. an ion exchange
-            # membrane, where the cation and anion concentrations may be
-            # unequal
-            molality = (
-                self.get_amount(Salt.cation, "mol/kg")
-                + self.get_amount(Salt.anion, "mol/kg")
-            ) / 2
+        """Return the volume of only the solutes."""
+        return self.engine.get_solute_volume(self)
 
-            # determine alpha1 and alpha2 based on the type of salt
-            # see the May reference for the rules used to determine
-            # alpha1 and alpha2 based on charge
-            if Salt.nu_cation >= 2 and Salt.nu_anion >= 2:
-                if Salt.nu_cation >= 3 or Salt.nu_anion >= 3:
-                    alpha1 = 2
-                    alpha2 = 50
-                else:
-                    alpha1 = 1.4
-                    alpha2 = 12
-            else:
-                alpha1 = 2
-                alpha2 = 0
-
-            apparent_vol = ac.get_apparent_volume_pitzer(
-                self.get_ionic_strength(),
-                molality,
-                alpha1,
-                alpha2,
-                param.get_value()[0],
-                param.get_value()[1],
-                param.get_value()[2],
-                param.get_value()[3],
-                param.get_value()[4],
-                Salt.z_cation,
-                Salt.z_anion,
-                Salt.nu_cation,
-                Salt.nu_anion,
-                temperature,
-            )
-
-            solute_vol += (
-                apparent_vol
-                * (
-                    self.get_amount(Salt.cation, "mol") / Salt.nu_cation
-                    + self.get_amount(Salt.anion, "mol") / Salt.nu_anion
-                )
-                / 2
+    def as_dict(self) -> dict:
+        """Convert the Solution into a dict representation that can be serialized to .json or other format."""
+        # clear the volume update flag, if required
+        if self.volume_update_required:
+            self._update_volume()
+        d = super().as_dict()
+        for k, v in d.items():
+            # convert all Quantity to str
+            if isinstance(v, Quantity):
+                d[k] = str(v)
+        # replace solutes with the current composition
+        d["solutes"] = {k: f"{v} mol" for k, v in self.components.items()}
+        # replace the engine with the associated str
+        d["engine"] = self._engine
+        # d["logger"] = self.logger.__dict__
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Solution:
+        """Instantiate a Solution from a dictionary generated by as_dict()."""
+        # because of the automatic volume updating that takes place during the __init__ process,
+        # care must be taken here to recover the exact quantities of solute and volume
+        # first we store the volume of the serialized solution
+        orig_volume = ureg.Quantity(d["volume"])
+        # then instantiate a new one
+        decoded = {k: MontyDecoder().process_decoded(v) for k, v in d.items() if not k.startswith("@")}
+        new_sol = cls(**decoded)
+        # now determine how different the new solution volume is from the original
+        scale_factor = (orig_volume / new_sol.volume).magnitude
+        # reset the new solution volume to that of the original. In the process of
+        # doing this, all the solute amounts are scaled by new_sol.volume / volume
+        new_sol.volume = str(orig_volume)
+        # undo the scaling by diving by that scale factor
+        for sol in new_sol.components:
+            new_sol.components[sol] /= scale_factor
+        # ensure that another volume update won't be triggered by these changes
+        # (this line should in principle be unnecessary, but it doesn't hurt anything)
+        new_sol.volume_update_required = False
+        return new_sol
+
+    @classmethod
+    def from_preset(
+        cls, preset: Literal["seawater", "rainwater", "wastewater", "urine", "normal saline", "Ringers lactate"]
+    ) -> Solution:
+        """Instantiate a solution from a preset composition.
+
+        Args:
+            preset (str): String representing the desired solution.
+              Valid entries are 'seawater', 'rainwater', 'wastewater',
+              'urine', 'normal saline' and 'Ringers lactate'.
+
+        Returns:
+            A pyEQL Solution object.
+
+        Raises:
+            FileNotFoundError: If the given preset file doesn't exist on the file system.
+
+        Notes:
+            The following sections explain the different solution options:
+
+            - 'rainwater' - pure water in equilibrium with atmospheric CO2 at pH 6
+            - 'seawater' or 'SW'- Standard Seawater. See Table 4 of the Reference for Composition [1]_
+            - 'wastewater' or 'WW' - medium strength domestic wastewater. See Table 3-18 of [2]_
+            - 'urine' - typical human urine. See Table 3-15 of [2]_
+            - 'normal saline' or 'NS' - normal saline solution used in medicine [3]_
+            - 'Ringers lacatate' or 'RL' - Ringer's lactate solution used in medicine [4]_
+
+        References:
+            .. [1] Millero, Frank J. "The composition of Standard Seawater and the definition of
+                   the Reference-Composition Salinity Scale." *Deep-sea Research. Part I* 55(1), 2008, 50-72.
+
+            .. [2] Metcalf & Eddy, Inc. et al. *Wastewater Engineering: Treatment and Resource Recovery*, 5th Ed.
+                   McGraw-Hill, 2013.
+
+            .. [3] https://en.wikipedia.org/wiki/Saline_(medicine)
+
+            .. [4] https://en.wikipedia.org/wiki/Ringer%27s_lactate_solution
+        """
+        # preset_dir = files("pyEQL") / "presets"
+        # Path to the YAML and JSON files corresponding to the preset
+        yaml_path = files("pyEQL") / "presets" / f"{preset}.yaml"
+        json_path = files("pyEQL") / "presets" / f"{preset}.json"
+
+        # Check if the file exists
+        if yaml_path.exists():
+            preset_path = yaml_path
+        elif json_path.exists():
+            preset_path = json_path
+        else:
+            raise FileNotFoundError(f"Invalid preset! File '{yaml_path}' or '{json_path} not found!")
+
+        # Create and return a Solution object
+        return cls().from_file(preset_path)
+
+    def to_file(self, filename: str | Path) -> None:
+        """Saving to a .yaml or .json file.
+
+        Args:
+            filename (str | Path): The path to the file to save Solution.
+              Valid extensions are .json or .yaml.
+        """
+        str_filename = str(filename)
+        if not ("yaml" in str_filename.lower() or "json" in str_filename.lower()):
+            self.logger.error("Invalid file extension entered - %s" % str_filename)
+            raise ValueError("File extension must be .json or .yaml")
+        if "yaml" in str_filename.lower():
+            solution_dict = self.as_dict()
+            solution_dict.pop("database")
+            dumpfn(solution_dict, filename)
+        else:
+            dumpfn(self, filename)
+
+    @classmethod
+    def from_file(self, filename: str | Path) -> Solution:
+        """Loading from a .yaml or .json file.
+
+        Args:
+            filename (str | Path): Path to the .json or .yaml file (including extension) to load the Solution from.
+              Valid extensions are .json or .yaml.
+
+        Returns:
+            A pyEQL Solution object.
+
+        Raises:
+            FileNotFoundError: If the given filename doesn't exist on the file system.
+        """
+        if not os.path.exists(filename):
+            raise FileNotFoundError(f"File '{filename}' not found!")
+        str_filename = str(filename)
+        if "yaml" in str_filename.lower():
+            true_keys = [
+                "solutes",
+                "volume",
+                "temperature",
+                "pressure",
+                "pH",
+                "pE",
+                "balance_charge",
+                "solvent",
+                "engine",
+                # "database",
+            ]
+            solution_dict = loadfn(filename)
+            keys_to_delete = [key for key in solution_dict if key not in true_keys]
+            for key in keys_to_delete:
+                solution_dict.pop(key)
+            return Solution(**solution_dict)
+        return loadfn(filename)
+
+    # arithmetic operations
+    def __add__(self, other: Solution) -> Solution:
+        """
+        Solution addition: mix two solutions together.
+
+        Args:
+            other: The Solutions to be mixed with this solution.
+
+        Returns:
+            A Solution object that represents the result of mixing this solution and other.
+
+        Notes:
+            The initial volume of the mixed solution is set as the sum of the volumes of this solution and other.
+            The pressure and temperature are volume-weighted averages. The pH and pE values are currently APPROXIMATE
+            because they are calculated assuming H+ and e- mix conservatively (i.e., the mixing process does not
+            incorporate any equilibration reactions or buffering). Such support is planned in a future release.
+        """
+        # check to see if the two solutions have the same solvent
+        if self.solvent != other.solvent:
+            raise ValueError("Cannot add Solution with different solvents!")
+
+        if self._engine != other._engine:
+            raise ValueError("Cannot add Solution with different engines!")
+
+        if self.database != other.database:
+            raise ValueError("Cannot add Solution with different databases!")
+
+        # set the pressure for the new solution
+        p1 = self.pressure
+        t1 = self.temperature
+        v1 = self.volume
+        p2 = other.pressure
+        t2 = other.temperature
+        v2 = other.volume
+
+        # set the initial volume as the sum of the volumes
+        mix_vol = v1 + v2
+
+        # check to see if the solutions have the same temperature and pressure
+        if p1 != p2:
+            self.logger.info(
+                "Adding two solutions of different pressure. Pressures will be averaged (weighted by volume)"
             )
 
-            pitzer_calc = True
+        mix_pressure = (p1 * v1 + p2 * v2) / (mix_vol)
 
-            logger.info(
-                "Updated solution volume using Pitzer model for solute %s"
-                % Salt.formula
+        if t1 != t2:
+            self.logger.info(
+                "Adding two solutions of different temperature. Temperatures will be averaged (weighted by volume)"
             )
 
-        # add the partial molar volume of any other solutes, except for water
-        # or the parent salt, which is already accounted for by the Pitzer parameters
-        for item in self.components:
+        # do all temperature conversions in Kelvin to avoid ambiguity associated with "offset units". See pint docs.
+        mix_temperature = (t1.to("K") * v1 + t2.to("K") * v2) / (mix_vol)
+
+        # retrieve the amount of each component in the parent solution and
+        # store in a list.
+        mix_species = FormulaDict({})
+        for sol, amt in self.components.items():
+            mix_species.update({sol: f"{amt} mol"})
+        for sol2, amt2 in other.components.items():
+            if mix_species.get(sol2):
+                orig_amt = float(mix_species[sol2].split(" ")[0])
+                mix_species[sol2] = f"{orig_amt+amt2} mol"
+            else:
+                mix_species.update({sol2: f"{amt2} mol"})
 
-            solute = self.get_solute(item)
+        # TODO - call equilibrate() here once the method is functional to get new pH and pE, instead of the below
+        warnings.warn(
+            "The pH and pE value of the mixed solution is approximate! More accurate addition (mixing) of"
+            "this property is planned for a future release."
+        )
+        # calculate the new pH and pE (before reactions) by mixing
+        mix_pH = -np.log10(float(mix_species["H+"].split(" ")[0]) / mix_vol.to("L").magnitude)
 
-            # ignore water
-            if item in ["H2O", "HOH"]:
-                continue
+        # pE = -log[e-], so calculate the moles of e- in each solution and mix them
+        mol_e_self = 10 ** (-1 * self.pE) * self.volume.to("L").magnitude
+        mol_e_other = 10 ** (-1 * other.pE) * other.volume.to("L").magnitude
+        mix_pE = -np.log10((mol_e_self + mol_e_other) / mix_vol.to("L").magnitude)
 
-            # ignore the salt cation and anion, if already accounted for by Pitzer
-            if pitzer_calc is True and item in [Salt.anion, Salt.cation]:
-                continue
+        # create a new solution
+        return Solution(
+            mix_species.data,  # pass a regular dict instead of the FormulaDict
+            volume=str(mix_vol),
+            pressure=str(mix_pressure),
+            temperature=str(mix_temperature.to("K")),
+            pH=mix_pH,
+            pE=mix_pE,
+        )
 
-            if db.has_parameter(item, "partial_molar_volume"):
-                solute_vol += (
-                    solute.get_parameter("partial_molar_volume") * solute.get_moles()
-                )
-                logger.info(
-                    "Updated solution volume using direct partial molar volume for solute %s"
-                    % item
-                )
+    def __sub__(self, other: Solution) -> None:
+        raise NotImplementedError("Subtraction of solutions is not implemented.")
 
-            else:
-                logger.warning(
-                    "Partial molar volume data not available for solute %s. Solution volume will not be corrected."
-                    % item
-                )
+    def __mul__(self, factor: float) -> None:
+        """
+        Solution multiplication: scale all components by a factor. For example, Solution * 2 will double the moles of
+        every component (including solvent). No other properties will change.
+        """
+        self.volume *= factor
+        return self
 
-        return solute_vol.to("L")
+    def __truediv__(self, factor: float) -> None:
+        """
+        Solution division: scale all components by a factor. For example, Solution / 2 will remove half of the moles
+        of every compoonents (including solvent). No other properties will change.
+        """
+        self.volume /= factor
+        return self
 
-    def copy(self):
-        """Return a copy of the solution
+    # informational methods
 
-        TODO - clarify whether this is a deep or shallow copy
-        """
-        # prepare to copy the bulk properties
-        new_temperature = str(self.get_temperature())
-        new_pressure = str(self.pressure)
-        new_solvent = self.solvent_name
-        new_solvent_mass = str(self.get_solvent_mass())
+    def print(
+        self,
+        mode: Literal["all", "ions", "cations", "anions", "neutrals"] = "all",
+        units: Literal["ppm", "mol", "mol/kg", "mol/L", "%", "activity"] = "mol",
+        places=4,
+    ):
+        """
+        Print details about the Solution.
+
+        Args:
+            mode: Whether to list the amounts of all solutes, or only anions, cations, any ion, or any neutral solute.
+            units: The units to list solute amounts in. "activity" will list dimensionless activities instead of
+                concentrations.
+            places: The number of decimal places to round the solute amounts.
+        """
+        print(self)
+        str1 = "Activities" if units == "activity" else "Amounts"
+        str2 = f" ({units})" if units != "activity" else ""
+        header = f"\nComponent {str1}{str2}:"
+        print(header)
+        print("=" * (len(header) - 1))
+        for i in self.components:
+            if mode != "all":
+                z = self.get_property(i, "charge")
+                if (
+                    (z != 0 and mode == "neutrals")
+                    or (z >= 0 and mode == "anions")
+                    or (z <= 0 and mode == "cations")
+                    or (z == 0 and mode == "ions")
+                ):
+                    continue
 
-        # create a list of solutes
-        new_solutes = []
-        for item in self.components:
-            # ignore the solvent
-            if item == self.solvent_name:
-                pass
-            else:
-                new_solutes.append([item, str(self.get_amount(item, "mol"))])
+            amt = self.get_activity(i).magnitude if units == "activity" else self.get_amount(i, units).magnitude
 
-        # create the new solution
-        return Solution(
-            new_solutes,
-            solvent=[new_solvent, new_solvent_mass],
-            temperature=new_temperature,
-            pressure=new_pressure,
-        )
+            print(f"{i}:\t {amt:0.{places}f}")
 
-    # informational methods
+    def __str__(self) -> str:
+        # set output of the print() statement for the solution
+        l1 = f"Volume: {self.volume:.3f~}"
+        l2 = f"Temperature: {self.temperature:.3f~}"
+        l3 = f"Pressure: {self.pressure:.3f~}"
+        l4 = f"pH: {self.pH:.1f}"
+        l5 = f"pE: {self.pE:.1f}"
+        l6 = f"Solvent: {self.solvent}"
+        l7 = f"Components: {self.list_solutes():}"
+        return f"{l1}\n{l2}\n{l3}\n{l4}\n{l5}\n{l6}\n{l7}"
 
-    def list_solutes(self):
-        """
-        List all the solutes in the solution.
+    """
+    Legacy methods to be deprecated in a future release.
+    """
 
-        """
+    @deprecated(
+        message="list_salts() is deprecated and will be removed in the next release! Use Solution.get_salt_dict() instead.)"
+    )
+    def list_salts(self, unit="mol/kg", decimals=4):  # pragma: no cover
+        for k, v in self.get_salt_dict().items():
+            print(k + "\t {:0.{decimals}f}".format(v, decimals=decimals))
+
+    @deprecated(
+        message="list_solutes() is deprecated and will be removed in the next release! Use Solution.components.keys() instead.)"
+    )
+    def list_solutes(self):  # pragma: no cover
+        """List all the solutes in the solution."""
         return list(self.components.keys())
 
-    def list_concentrations(self, unit="mol/kg", decimals=4, type="all"):
+    @deprecated(
+        message="list_concentrations() is deprecated and will be removed in the next release! Use Solution.print() instead.)"
+    )
+    def list_concentrations(self, unit="mol/kg", decimals=4, type="all"):  # pragma: no cover
         """
         List the concentration of each species in a solution.
 
         Parameters
         ----------
         unit: str
-            String representing the desired concentration unit.
+            String representing the desired concentration ureg.
         decimals: int
             The number of decimal places to display. Defaults to 4.
         type     : str
@@ -2601,11 +2704,11 @@ class Solution:
             solutes. Other valid arguments are 'cations' and 'anions' which
             return lists of cations and anions, respectively.
 
-        Returns
+        Returns:
         -------
         dict
             Dictionary containing a list of the species in solution paired with their amount in the specified units
-
+        :meta private:
         """
         result_list = []
         # populate a list with component names
@@ -2616,47 +2719,30 @@ class Solution:
             for item in self.components:
                 amount = self.get_amount(item, unit)
                 result_list.append([item, amount])
-                print(
-                    item
-                    + ":"
-                    + "\t {0:0.{decimals}f~}".format(amount, decimals=decimals)
-                )
+                print(item + ":" + "\t {0:0.{decimals}f~}".format(amount, decimals=decimals))
         elif type == "cations":
             print("Cation Concentrations:\n")
             print("========================\n")
             for item in self.components:
-                if self.components[item].get_formal_charge() > 0:
+                if self.components[item].charge > 0:
                     amount = self.get_amount(item, unit)
                     result_list.append([item, amount])
-                    print(
-                        item
-                        + ":"
-                        + "\t {0:0.{decimals}f~}".format(amount, decimals=decimals)
-                    )
+                    print(item + ":" + "\t {0:0.{decimals}f~}".format(amount, decimals=decimals))
         elif type == "anions":
             print("Anion Concentrations:\n")
             print("========================\n")
             for item in self.components:
-                if self.components[item].get_formal_charge() < 0:
+                if self.components[item].charge < 0:
                     amount = self.get_amount(item, unit)
                     result_list.append([item, amount])
-                    print(
-                        item
-                        + ":"
-                        + "\t {0:0.{decimals}f~}".format(amount, decimals=decimals)
-                    )
+                    print(item + ":" + "\t {0:0.{decimals}f~}".format(amount, decimals=decimals))
 
         return result_list
 
-    def list_salts(self, unit="mol/kg", decimals=4):
-        list = salt.generate_salt_list(self, unit)
-        for item in list:
-            print(
-                item.formula
-                + "\t {:0.{decimals}f}".format(list[item], decimals=decimals)
-            )
-
-    def list_activities(self, decimals=4):
+    @deprecated(
+        message="list_activities() is deprecated and will be removed in the next release! Use Solution.print() instead.)"
+    )
+    def list_activities(self, decimals=4):  # pragma: no cover
         """
         List the activity of each species in a solution.
 
@@ -2665,27 +2751,14 @@ class Solution:
         decimals: int
             The number of decimal places to display. Defaults to 4.
 
-        Returns
+        Returns:
         -------
         dict
             Dictionary containing a list of the species in solution paired with their activity
 
+        :meta private:
         """
         print("Component Activities:\n")
         print("=====================\n")
-        for i in self.components.keys():
-            print(
-                i
-                + ":"
-                + "\t {0.magnitude:0.{decimals}f}".format(
-                    self.get_activity(i), decimals=decimals
-                )
-            )
-
-    def __str__(self):
-        # set output of the print() statement for the solution
-        str1 = "Volume: {0:.3f~}\n".format(self.get_volume())
-        str2 = "Pressure: {0:.3f~}\n".format(self.get_pressure())
-        str3 = "Temperature: {0:.3f~}\n".format(self.get_temperature())
-        str4 = "Components: {0:}\n".format(self.list_solutes())
-        return str1 + str2 + str3 + str4
+        for i in self.components:
+            print(i + ":" + "\t {0.magnitude:0.{decimals}f}".format(self.get_activity(i), decimals=decimals))