/**

\page thermopage Thermodynamic Properties

Cantera can be used to compute thermodynamic properties of pure
substances, solutions, and mixtures of various types, including ones
containing multiple phases. The first step is to create an object that
represents each phase. 

A simple complete program that creates an object representing a gas mixture and prints its temperature is shown below.
\include ex1.cpp

Class ThermoPhase is the base class for Cantera classes that represent
phases of matter. It defines the public interface for all classes that
represent phases. For example, it specifies that they all have a
method \c temperature() that returns the current temperature, a method
\c setTemperature(double T) that sets the temperature, a method \c
getChemPotentials(double* mu) that writes the species chemical
potentials into array \c mu, and so on.

Class ThermoPhase can be used to represent the intensive state of any
single-phase solution of multiple species. The phase may be a bulk,
three-dimensional phase (a gas, a liquid, or a solid), or may be a
two-dimensional surface phase, or even a one-dimensional "edge"
phase. The specific attributes of each type of phase are specified by
deriving a class from ThemoPhase and providing implementations for the
virtual methods of ThermoPhase.

\section The Intensive Thermodynamic State

Class ThermoPhase and classes derived from it work only with the
intensive thermodynamic state. That is, all extensive properties
(enthalpy, entropy, internal energy, volume, etc.) are computed for a
unit quantity (on a mass or mole basis). For example, there is a
method enthalpy_mole() that returns the molar enthalpy (J/kmol), and a
method enthalpy_mass() that returns the specific enthalpy (J/kg), but
no method enthalpy() that would return the total enthalpy (J). This is
because class ThermoPhase does not store the total amount (mass or
mole) of the phase. 

From thermodynamics, it may be shown that the intensive state of a
single-component phase in equilibrium is fully specified by the values
of any r+1 independent thermodynamic properties, where r is the number
of reversible work modes. If the only reversible work mode is
compression (a "simple compressible substance"), then two properties
suffice to specify the intensive state. 

In principle, any two independent p

specified, the values of all other intensive properties may be
computed. For example, specifying the pressure and molar entropy

consisting of a solution of K species  
in equilibrium is fully specified by the values of any two independent 
thermodynamic properties, in addition to in
Class ThermoPhase stores internally the values of the temperature, the
mass density, and the mass fractions of all species. These values are
sufficient to fix the intensive thermodynamic state of the phase.  All
properties for a unit amount (on a mass or mole basis) are determined
once the intensive state is specified. For the extensive properties, class ThermoPhase provides methods that return property values on a molar basis (e.g. enthalpy_mole(), with units J/kmol) or on a mass basis (e.g. enthalpy_mass(), with units J/kg). Since the total mass or total number of moles is not stored, 

Note that the total mass or number of moles is not stored

Given these values, any other intensive thermodynamic property may 

Note that the total mass or total number of moles is not stored -- therefore the values of all extensive properties (mass, volume, energy) are 

This choice is arbitrary, and for most purposes you can't tell which properties are stored and which are computed. 

The classes that derive from ThermoPhase compute o

For example, suppose we want to create a class to use to compute the properties of ideal gas mixtures. 

Many of the methods of ThermoPhase are declared virtual, and are meant to be
overloaded in classes derived from ThermoPhase. For example, class IdealGasPhase derives from ThermoPhase, and represents ideal gas mixtures. 

Although class ThermoPhase defines the interface for all classes
representing phases, it only provides implementations for a few of the
methods. This is because ThermoPhase does not actually know the
equation of state of any phase -- this information is provided by
classes that derive from ThermoPhase. 
The methods implemented by ThermoPhase are ones that apply to all phases, independent of the equation of state. For example, it implements methods temperature() and setTemperature(), since the temperature value is stored internally. Also, the mass density is stored internally, so 

*/