////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @details  Computes this MonoFluid derived state and properties from validated initialization
///           data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      src          --    Pointer to the MonoFluid to add in the state from
/// @param[in]      flowRate    (kg/s) Optional overriding source mass flow rate
///
/// @return   void
///
/// @note     This protected method is intended for use by PolyFluid whose validation includes
///           validation of its constituent MonoFluids, including type consistency.
///
/// @note     The computed temperature and pressure are simply mass flow rate weighted averages
///           which get overwritten by the PolyFluid of which MonoFluid is a constituent.
///
/// @details  Updates the state of this MonoFluid by adding in the specified MonoFluid state.
///           The flow rate is updated, but the mass and moles are not.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   mass  (kg)   Mass of this MonoFluid
///
/// @return   void
///
/// @details  Sets the mass and updates the moles of this MonoFluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   mole  (kg*mol)  Moles of this MonoFluid
///
/// @return   void
///
/// @details  Sets the moles and updates the mass of this MonoFluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @details  Resets (zeros) the state of this MonoFluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   src         --     Pointer to the MonoFluid to set the state from
///
/// @return   void
///
/// @details  Updates the state of this MonoFluid from the specified MonoFluid state.
///           The mass and moles are not updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   temperature   (K)    Temperature to compute specific enthalpy at
/// @param[in]   pressure      (kPa)  Pressure to compute specific enthalpy at
///
/// @return   (J/kg) The specific enthalpy this MonoFluid at the specified temperature and pressure.
///
/// @details  Returns the specific enthalpy for this type of MonoFluid at the specified temperature
///           and pressure. The state of this MonoFluid is not updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  types      (--)  Pointer to the array of compound types.
/// @param[in]  nTypes     (--)  Number of compound types.
/// @param[in]  name       (--)  Name of this object.
///
/// @throws   TsInitializationException
///
/// @details  Default constructs this GUNNS Fluid Trace Compounds model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default destructs this GUNNS Fluid Trace Compounds model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  types   (--)  Pointer to the array of compound types.
/// @param[in]  nTypes  (--)  Number of compound types.
///
/// @throws   TsInitializationException
///
/// @details  Validates the data provided to the constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  molecWeight (1/mol) Molecular weight of compound.
/// @param[in]  name        (--)    Name of compound.
/// @param[in]  fluidType   (--)    Optional fluid properties type associated with this compound.
/// @param[in]  type        (--)    Optional chemical compound type of this compound.
///
/// @throws   TsInitializationException
///
/// @details  Adds a new trace compound at run time, given its custom properties.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  type  (--)  The type of defined chemical compound to add.
///
/// @throws   TsInitializationException
///
/// @details  Adds a new trace compound at run time, of a defined type.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Fluid Trace Compounds model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     DO NOT use this constructor unless you know what you're doing.
//
/// @details  TS21 requires a no-argument default constructor for any classes that will be
///           dynamically allocated with their Trick memory macro's.  This particular example is
///           dangerous because no reference to an external fluid moles is provided, which is not
///           how this class is intended to be used.  We initialize the reference to an internal
///           static const which will cause an exception to be thrown if this object is initialized.
///           We would prefer to keep this private and not implemented to prevent users from calling
///           it at all.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  fluidMoles  (kg*mol)  Reference to the fluid moles term in the parent object.
///
/// @note     This should be followed by a call to the initialize method before calling an update
///           method.
///
/// @details  Default constructs this GUNNS Fluid Trace Compounds model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that        (--)      Source to copy.
/// @param[in]  fluidMoles  (kg*mol)  Reference to the fluid moles term in the parent object.
/// @param[in]  name        (--)      Instance name for messages.
///
/// @throws   TsInitializationException
///
/// @details  Copy constructs and initializes this GUNNS Fluid Trace Compounds model.  This is a
///           deep copy.
///
/// @note     The source to copy must have been initialized or this method will throw an exception.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Deletes allocated memory.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  configData  (--)  Configuration data.
/// @param[in]  inputData   (--)  Input data.
///
/// @throws   TsInitializationException
///
/// @details  Validates the initialization of this GUNNS Fluid Trace Compounds model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  i  (--)  Index in the compounds array to get the compound type of.
///
/// @returns  ChemicalCompound::Type  (--)  Type of the compound at the specified array index.
///
/// @throws   TsOutOfBoundsException
///
/// @details  Returns the type of the compound at the specified array index.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  type  (--)  Type of compound to find.
/// @param[in]  name  (--)  Name of compound to find (used for compounds added at run time).
///
/// @return   Index into the compounds array corresponding to the given compound type.
///
/// @throws   TsOutOfBoundsException
///
/// @details  Returns the array index in the compounds array corresponding to the given compound
///           type.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  compound  (--)  Type of the chemical compound to find.
///
/// @return   Index into the compounds array corresponding to the given compound type.
///
/// @details  Returns the array index in the compounds array corresponding to the given compound
///           type, or -1 if the given compound isn't found.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  masses  (kg)  An array of given compound masses.
///
/// @details  Sets the entire set of compound masses in this Trace Compound to the given mass array,
///           which is assumed to represent the same compounds and in the same order as this Trace
///           Compound.
///
/// @note     This method does not recompute the mole fractions resulting from the new masses.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  index  (--)  Specifies which index in the trace compounds the given mass represents.
/// @param[in]  mass   (kg)  The mass of the given compound type.
///
/// @throws   TsOutOfBoundsException
///
/// @details  Sets the mass of the given compound index in this Trace Compounds to the given value.
///
/// @note     This method does not recompute the mole fractions resulting from the new masses.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  moleFractions  (--)  An array of given compound mole fractions.
///
/// @details  Sets the entire set of compound mole fractions in this Trace Compound to the given
///           mole fraction array, which is assumed to represent the same compounds and in the same
///           order as this Trace Compound.
///
/// @note     This method does not recompute the masses resulting from the new mole fractions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  type         (--) Specifies which compound type the given mole fraction represents.
/// @param[in]  moleFraction (--) The mole fraction of the given compound type.
/// @param[in]  name  (--)  Name of compound to find (used for compounds added at run time).
///
/// @throws   TsOutOfBoundsException
///
/// @details  Sets the mole fraction of the given compound type in this Trace Compounds to the given
///           value.
///
/// @note     This method does not recompute the masses resulting from the new mole fractions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  index  (--)  Specifies which index the given mole fraction represents.
/// @param[in]  mass   (--)  The mole fraction of the given compound type.
///
/// @throws   TsOutOfBoundsException
///
/// @details  Sets the mole fraction of the given compound index in this Trace Compounds to the
///           given value.
///
/// @note     This method does not recompute the masses resulting from the new mole fractions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Recomputes the compound masses in this Trace Compounds from their mole fractions
///           relative to the total moles of the parent fluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Recomputes the compound mole fractions in this Trace Compounds from their masses
///           relative to the total moles of the parent fluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  source        (--)   The Trace Compounds object that is to be mixed in.
/// @param[in]  totalMolesIn  (mol)  The total number of fluid moles of the incoming parent fluid
///                                  that has flowed in.
///
/// @details  Performs the mixing of another Trace Compounds into this Trace Compounds resulting
///           from the bulk flow of the former's parent fluid into this Trace Compound's parent
///           fluid.  Updates the resulting compound masses and mole fractions.
///
/// @note     This assumes the incoming Trace Compounds has the same compound types and in the same
///           order as our compounds.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] rates (kg/s) Array of trace compound mass flow rates added.
/// @param[in] dt    (s)    Time step of integration.
///
/// @details   This overloaded version of flowIn input the trace compounds as an array of mass flow
///            rates integrated over a timestep.  This allows negative flow rates in, which are
///            positive flow rates out.  Updates the resulting mole fractions.
///
/// @notes     Resulting masses less than zero are quietly zeroed, and doesn't conserve mass.  The
///            caller should ensure not to remove more mass than the parent fluid has in order to
///            maintain conservation of mass.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  totalMolesOut  (mol)  The total number of fluid moles of the parent fluid that has
///                                   flowed out.
///
/// @details  Reduces the trace compound masses in this Trace Compounds resulting from the bulk
///           reduction in total moles of the parent fluid, such as when the parent fluid flows out
///           of a network node.  This does not recompute the mole fractions because a flow out
///           would not change them.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Zeroes negative trace compound masses and mole fractions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] properties     (--) Pointer to the defined fluid properties.
/// @param[in] types          (--) Pointer to array of constituent types in the PolyFluid.
/// @param[in] nTypes         (--) Number of constituent fluids in the PolyFluid.
/// @param[in] traceCompounds (--) Optional pointer to the trace compounds config data.
///
/// @details  Default constructs this PolyFluid configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that (--) Source to copy.
///
/// @details  Copy constructs this PolyFluid configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default destructs this PolyFluid configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] temperature    (K)    Temperature of the fluid.
/// @param[in] pressure       (kPa)  Pressure of the fluid.
/// @param[in] flowRate       (kg/s) Mass flow rate of the fluid.
/// @param[in] mass           (kg)   Mass of the fluid.
/// @param[in] massFraction   (--)   Array of mass fractions of constituent fluids in PolyFluid.
/// @param[in] traceCompounds (--)   Optional pointer to the trace compounds input data.
///
/// @note     The array of mass fractions must be of the same length and in the same order as the
///           array of types specified in the configuration data.
///
/// @details  Default constructs this PolyFluid input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that (--) Source to copy.
///
/// @details  Copy constructs this PolyFluid input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs a Constituent object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     This should be followed by a call to the initialize method before calling an update
///           method.
///
/// @details  Default constructs this PolyFluid with obviously invalid data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    configData   (--)    Configuration data.
/// @param[in]    inputData    (--)    Input data.
///
/// @throws   TsInitializationException
///
/// @details  Constructs and initializes this PolyFluid with input data.
///
/// @note     This method leaves the instance unnamed, so it's not good to use in Trick sims because
///           the Trick dynamic memory allocations will throw error messages.  We're only keeping
///           method because a lot of GUNNS unit tests use it to create test utility fluids.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that   (--) Source to copy.
/// @param[in] name   (--) Instance name for messages.
/// @param[in] copyTc (--) Copy the source's trace compounds if true, otherwise don't create a
///                        trace compounds.
///
/// @throws   TsInitializationException
///
/// @details  Copy constructs this PolyFluid.  The extra name argument is needed because Trick
///           requires all dynamic allocations to have a sim-unique name.  Therefore this fluid
///           object must be named when it is constructed.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default destructs this PolyFluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Cleans up this PolyFluid.  Deletes the mConstituents array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    configData   (--)    Configuration data.
/// @param[in]    inputData    (--)    Input data.
///
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Initializes this PolyFluid with input data.  This must be called after the
///           initializeName method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    name (--) Instance name for messages.
///
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Initializes this PolyFluid's instance name attribute.  This must be called before the
///           initialize method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Validates this PolyFluid input data.  The input data temperature and pressure must be
///           >= FLT_EPSILON, but we don't check it here since we rely on the constituent MonoFluid
///           to already have checked it.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @details  Computes this PolyFluid derived state and properties from validated input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   index (--) Index of fluid
///
/// @return  (--) Mass fraction of the specified constituent fluid in this PolyFluid
///
/// @throws   TsOutOfBoundsException
///
/// @details  Returns the mass fraction constituent fluid at the specified index in this PolyFluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   index (--) Index of fluid
///
/// @return  (--) Mole fraction of the specified constituent fluid in this PolyFluid
///
/// @throws   TsOutOfBoundsException
///
/// @details  Returns the mole fraction constituent fluid at the specified index in this PolyFluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    temperature  (K) Temperature
///
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Sets the temperature (K) of this PolyFluid. The constituent fluid temperatures and
///           pressures are updated from the composite temperature and pressure and then the
///           composite properties are updated from the constituent properties.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    pressure  (kPa) Pressure
///
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Sets the pressure (kPa) of this PolyFluid and updates the density. The constituent
///           fluid states and other PolyFluid properties are not updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      mass            (kg)   Mass of the PolyFluid
/// @param[in,out]  massFraction    (--)   Array of constituent fluid mass fractions
///
/// @return   void
///
/// @throws   TsOutOfBoundsException
///
/// @note     The composite properties are not updated until a subsequent call to setTemperature.
///
/// @note     The caller's massFraction array is normalized if necessary.
///
/// @note     The constituents with non-zero mass fractions should all have the same phase.
///
/// @note     The input mass fraction array should be of the same length and in the same order as
///           configuration data types array.
///
/// @details  Sets the mass of this PolyFluid and the mass fractions of its constituent fluids. The
///           constituent fluid mass, moles and mole fractions and PolyFluid properties are updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      mole            (kg*mol)  Moles of the PolyFluid
/// @param[in,out]  moleFraction    (--)      Array of constituent fluid mole fractions
///
/// @return   void
///
/// @throws   TsOutOfBoundsException
///
/// @note     The composite properties are not updated until a subsequent call to setTemperature.
///
/// @note     The caller's moleFraction array is normalized if necessary.
///
/// @note     The constituents with non-zero mole fractions should all have the same phase.
///
/// @note     The input mole fraction array should be of the same length and in the same order as
///           configuration data types array.
///
/// @details  Sets the moles of this PolyFluid and the mole fractions of its constituent fluids. The
///           constituent fluid mass, moles and mass fractions are updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   index           (--)   Constituent fluid index in composite fluid
/// @param[in]   mass            (kg)   Mass of the constituent fluid.
///
/// @return   void
///
/// @throws   TsOutOfBoundsException
///
/// @note     The other mass properties are not updated until a subsequent call updateMass.
///
/// @details  Sets the mass of the specified constituent fluid in this PolyFluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Sets the mass and moles of this PolyFluid and the mass and mole fractions of the
///           constituent fluids based on the mass of the constituent fluids.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Resets (zeros) the state of this PolyFluid.  The mass and moles are not updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    src        (--)    Pointer to the fluid to set the state from
///
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Updates the state of the PolyFluid by copying from the specified PolyFluid state.
///           The mass and moles are not updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    src         (--)   Pointer to the PolyFluid to add in the state from
/// @param[in]    flowRate    (kg/s) Optional overriding source mass flow rate
///
/// @return   void
///
/// @throws   TsInitializationException, TsOutOfBoundsException
///
/// @details  Updates the state of the PolyFluid by adding in the specified PolyFluid state. The
///           mass and moles are undefined and the pressure, partial pressure and density are
///           approximate.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    temperature  (K)   Temperature
/// @param[in]    pressure     (kPa) Pressure
///
/// @return   void
///
/// @details  Sets the temperature and pressure of this PolyFluid. The constituent fluid
///           temperatures and pressures are updated from the composite temperature and pressure and
///           then the composite properties are updated from the constituent properties.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    temperature      (K)   Temperature
/// @param[in]    partialPressure  (kPa) Partial pressure array
///
/// @return   void
///
/// @details  Sets the temperature and partial pressures of this PolyFluid. The constituent fluid
///           temperatures and composite pressure are updated from the composite temperature and
///           partial pressures and then the composite properties are updated from the constituent
///           properties.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    specificEnthalpy   (J/kg)     Specific enthalpy to compute temperature at
///
/// @return   (K) The temperature this PolyFluid at the specified specific enthalpy.
///
/// @throws   TsInitializationException
///
/// @details   Returns this PolyFluid temperature corresponding to the specified specific enthalpy.
///            -# The constituent and PolyFluid states are not updated.
///            -# computeTemperature(getSpecificEnthalpy(temperature)) == temperature
///              for energy conservation
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    temperature   (K)    Temperature to compute specific enthalpy at
/// @param[in]    pressure      (kPa)  Pressure to compute specific enthalpy at
///
/// @return   (J/kg) The specific enthalpy this PolyFluid at the specified temperature and pressure.
///
/// @throws   TsInitializationException
///
/// @details  Returns the PolyFluid specific enthalpy (as the mole fraction weighted average of
///           constituent specific enthalpies) computed at the specified temperature and pressure.
///           The constituent and PolyFluid states are not updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    temperature   (K)     Temperature to compute pressure at
/// @param[in]    density       (kg/m3) Density to compute pressure at
///
/// @return   (kPa) The pressure this PolyFluid at the specified temperature and density.
///
/// @note     computePressure(temperature, getDensity(temperature, pressure)) == pressure for mass
///           conservation
///
/// @details  Returns this PolyFluid pressure computed at the specified temperature and density.
///           The constituent and PolyFluid states are not updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    temperature   (K)    Temperature to compute density at
/// @param[in]    pressure      (kPa)  Pressure to compute density at
///
/// @return   (kg/m3) The density of this PolyFluid at the specified temperature and pressure.
///
/// @note     computeDensity(temperature, getPressure(temperature, density)) == density for mass
///           conservation
///
/// @details  Returns this PolyFluid density computed at the specified temperature and pressure.
///           The constituent and PolyFluid states are not updated.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    type  (--)   Type of constituent fluid
///
/// @return   Index into constituent array corresponding to specified constituent type.
///
/// @throws   TsOutOfBoundsException
///
/// @details  Returns the array index in the constituent array corresponding to the specified
///           constituent type.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] fluidIndex (--) Reference returned index of the compound in the bulk fluid constituents.
/// @param[out] tcIndex    (--) Reference returned index of the compound in the trace compounds.
/// @param[in]  compound   (--) Pointer to the properties of the chemical compound to find.
///
/// @details  Returns the fluid and trace compound indexes of the given chemical compound in this
///           PolyFluid.  This treats the given compound type as optional and indicates in the
///           returned values if compound is not found.
///
/// @note  The respective indexes for fluid constituents and trace compounds are returned a value of
///        -1 if the compound isn't found in them.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   mass  (kg)  Mass of the PolyFluid
///
/// @return   void
///
/// @details  Sets the mass and updates the moles of this PolyFluid and its constituent fluids, and
///           updates the masses of the trace compounds based on the new total moles and their
///           previous mole fractions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Fluid Fitting link model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction of config and init data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for construction without exceptions using nominal data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for copy construction without exceptions using nominal data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for multiple initialization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for state accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for property accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for state modifiers.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for state updaters.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for compute methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Fluid GunnsFluidTraceCompounds model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for nominal initialization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for copy construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for restart method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for getType method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for find methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for getMass method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for getMoleFraction method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setMasses method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setMass overloaded methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setMoleFraction overloaded methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for flowIn methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for flowOut method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for limitPositive method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for state updater method exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Fluid PolyFluid model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for nominal construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for composite state accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for composite property accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setFlowrate.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setPressure.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setMass.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setMole.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setMassAndMassFractions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for SetMoleAndMoleFractions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setTemperature.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for setting the mass of a constituent.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for updating mass properties from constituent masses.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for combining fluids.
///////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for combining opposite flows.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for computes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for set sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for edit methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for compute temperature.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for liquid pressure and density.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for fraction normalization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for init construction exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for nominal constructor exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for build method exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for state accessor method exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for state modifier method exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                 (--)   Instance name for self-identification in messages.
/// @param[in] fluidColumnX         (m)    X-axis component of the orientation vector of the fluid column in the structure reference frame.
/// @param[in] fluidColumnY         (m)    Y-axis component of the orientation vector of the fluid column in the structure reference frame.
/// @param[in] fluidColumnZ         (m)    Z-axis component of the orientation vector of the fluid column in the structure reference frame.
/// @param[in] acceleration         (m/s2) Pointer to the acceleration vector.
/// @param[in] mReverseAcceleration (--)   Reverse the acceleration vector direction.
/// @param[in] mRotationDcm         (--)   Pointer to the rotation direction cosine matrix.
/// @param[in] mTransposeRotation   (--)   Reverse the frame transformation direction.
///
/// @details  Default constructs this GUNNS Fluid Pressure Head Spotter configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Fluid Pressure Head Spotter input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  link  (--)  Reference to the connected link.
///
/// @details Default constructs this GUNNS Fluid Pressure Head Spotter.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  configData  (--)  Instance configuration data.
/// @param[in]  inputData   (--)  Instance input data.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this GUNNS Fluid Pressure Head Spotter with its configuration and
///           input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  configData  (--)  Instance configuration data.
///
/// @returns  GunnsFluidPressureHeadConfigData (--) Type-casted and validated config data pointer.
///
/// @throws   TsInitializationException
///
/// @details  Type-casts the base config data class pointer to this spotter's config data type,
///           checks for valid type-cast and validates contained data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  inputData  (--)  Instance input data.
///
/// @returns  GunnsFluidPressureHeadInputData (--) Type-casted and validated input data pointer.
///
/// @throws   TsInitializationException
///
/// @details  Type-casts the base input data class pointer to this spotter's input data type,
///           checks for valid type-cast and validates contained data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Execution time step (not used).
///
/// @details  Does the dP = rho*g*h calculation and sends dP to the attached link.  The incoming
///           acceleration vector is rotated from its own reference frame to the link's structure
///           reference frame, if the rotation DCM is provided.  This rotation can be flipped in
///           direction if the supplied DCM is in the opposite direction.  Likewise, the
///           acceleration vector itself can be flipped in direction.  These options accommodate
///           whatever vector & DCM convention the user supplies.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Gas Fan Curve object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out] realRoot   (m3/s) Root to improve
/// @param[in]     realCoeffs (kPa)  Polynomial coefficients to find the root for
/// @param[in]     maxQ       (m3/s) Maximum fan flow rate possible
///
/// @throws  TsNumericalException, if the curve has no real roots between zero and maxQ
///
/// @details Uses Laguerre's method to improve the given real positive root of the fan curve with
///          the given polynomial coefficients.  A well-conditioned fan curve will usually converge
///          within 2-3 Laguerre iterations in a normal network, peaking around 4-5 iterations for
///          large system or fan transients.  If Laguerre's converges on a complex or negative root,
///          then Brent's method is used to find the positive real root.  Brent's method takes
///          longer so is only used as a last resort.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] q    (m3/s) Volumetric flow rate to evaluate the fan-system curve delta-pressure for.
///
/// @returns  double (kPa) Delta-pressure produced by the fan at the given flow rate.
///
/// @details  Evaluates the n-order polynomial using stored coefficients.  Overrides the pure
///           virtual method in RootFinding, which provides a target function for the Brent's
///           method.  Although this is a generic implementation of a polynomial and could be
///           considered unit-less, it is only intended for use by the GunnsGasFan class.  The
///           coefficients should point to an array matching the previously given size.  We check
///           for null-pointer in case setCoeffs was never called.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     name                 (--)             Name of object.
/// @param[in,out] nodes                (--)             Pointer to nodes.
/// @param[in]     maxConductivity      (m2)             Max conductivity.
/// @param[in]     expansionScaleFactor (--)             Scale factor for isentropic gas cooling.
/// @param[in]     referenceDensity     (kg/m3)          Reference fluid density for power curve.
/// @param[in]     referenceSpeed       (revolution/min) Reference impeller speed for power curve.
/// @param[in]     referenceCoeff0      (kPa)            Reference performance curve 0th-order coefficient.
/// @param[in]     referenceCoeff1      (kPa)            Reference performance curve 1th-order coefficient.
/// @param[in]     referenceCoeff2      (kPa)            Reference performance curve 2th-order coefficient.
/// @param[in]     referenceCoeff3      (kPa)            Reference performance curve 3th-order coefficient.
/// @param[in]     referenceCoeff4      (kPa)            Reference performance curve 4th-order coefficient.
/// @param[in]     referenceCoeff5      (kPa)            Reference performance curve 5th-order coefficient.
/// @param[in]     bestEfficiency       (--)             (0-1) Efficiency at best efficiency point at reference.
/// @param[in]     referenceQBep        (m3/s)           Volume flow rate at best efficiency point at reference.
/// @param[in]     referencePBep        (kPa)            Pressure rise at best efficiency point at reference.
/// @param[in]     filterGain           (--)             (0-1) Flow filter gain for system curve estimate.
/// @param[in]     driveRatio           (--)             Gear ratio of motor to impeller speed.
/// @param[in]     thermalLength        (m)              Impeller length for thermal convection.
/// @param[in]     thermalDiameter      (m)              Impeller inner diameter for thermal convection.
/// @param[in]     surfaceRoughness     (m)              Impeller wall surface roughness for convection.
/// @param[in]     checkValveActive     (--)             Flag indicating that the built in check valve function is active.
///
/// @details  Default constructs this GUNNS Gas Fan link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Source object to copy.
///
/// @details  Copy constructs this GUNNS Gas Fan link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--)             Blockage malfunction flag.
/// @param[in] malfBlockageValue (--)             Blockage malfunction fractional value (0-1).
/// @param[in] sourcePressure    (kPa)            Initial pressure rise of the link.
/// @param[in] motorSpeed        (revolution/min) Initial speed of the motor.
/// @param[in] wallTemperature   (K)              Initial impeller wall temperature.
///
/// @details  Default constructs this GUNNS Gas Fan link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Source object to copy.
///
/// @details  Copy constructs this GUNNS Gas Fan link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     This should be followed by a call to the initialize method before calling an update
///           method.
///
/// @details  Default constructs this GUNNS Gas Fan link model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData (--) Configuration data.
/// @param[in]     inputData  (--) Input data.
/// @param[in,out] links      (--) Link vector.
/// @param[in]     port0      (--) Nominal inlet port map index.
/// @param[in]     port1      (--) Nominal outlet port map index.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Initializes this GUNNS Gas Fan link model with configuration and input data.  Some
///           validation of config data is needed before state data can be derived from it.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Validates this GUNNS Gas Fan Model link model initial state.  Some validation of
///           config data has already occurred in the initialize method, so this method just checks
///           the final state of the link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s)  Time step (not used).
///
/// @returns  void
///
/// @details  Updates this GUNNS Gas Fan link model source pressure. Also calculates check valve
///           position is active, and updates the effective conductivity.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt       (s)    Time step.
/// @param[in] flowRate (kg/s) Mass flow rate.
///
/// @return   void
///
/// @details  Updates this GUNNS Gas Fan link model internal fluid thermal state and fluid outputs
///           to the motor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @details  Calculates the pressure produced by the impeller as a function of impeller speed,
///           inlet density & flow rate.  Implements the fan performance (P-Q) curve as a 5th-order
///           polynomial.  Affects of inlet density & fan speed follow the fan Affinity Laws.
///
///           There is naturally an unstable feedback loop between fan pressure and flow rate, which
///           causes these parameters to oscillate wildly if undamped.  To prevent this, we estimate
///           the system's pressure curve and solve for the flow rate (Q) at which the system & fan
///           curves intersect, and fan pressure approaches that point.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     name                    (--)      Name of object.
/// @param[in,out] nodes                   (--)      Pointer to nodes.
/// @param[in]     maxConductivity         (m2)      Max conductivity.
/// @param[in]     expansionScaleFactor    (--)      Scale factor for isentropic gas cooling.
/// @param[in]     referenceDensity        (kg/m3)   Reference fluid density for power curve.
/// @param[in]     referenceSpeed          (rev/min) Reference impeller speed for power curve.
/// @param[in]     referenceCoeff0         (kPa)     Reference performance curve 0th-order coefficient.
/// @param[in]     referenceCoeff1         (kPa)     Reference performance curve 1th-order coefficient.
/// @param[in]     referenceCoeff2         (kPa)     Reference performance curve 2th-order coefficient.
/// @param[in]     referenceCoeff3         (kPa)     Reference performance curve 3th-order coefficient.
/// @param[in]     referenceCoeff4         (kPa)     Reference performance curve 4th-order coefficient.
/// @param[in]     referenceCoeff5         (kPa)     Reference performance curve 5th-order coefficient.
/// @param[in]     bestEfficiency          (--)      (0-1) Efficiency at best efficiency point at reference.
/// @param[in]     referenceQBep           (m3/s)    Volume flow rate at best efficiency point at reference.
/// @param[in]     filterGain              (--)      (0-1) Flow filter gain for system curve estimate.
/// @param[in]     driveRatio              (--)      Gear ratio of motor to impeller speed.
/// @param[in]     thermalLength           (m)       Impeller length for thermal convection.
/// @param[in]     thermalDiameter         (m)       Impeller inner diameter for thermal convection.
/// @param[in]     surfaceRoughness        (m)       Impeller wall surface roughness for convection.
/// @param[in]     liquidType              (--)      Type of the operating liquid.
/// @param[in]     autoCavitationDuration  (s)       Duration of auto-cavitation effect.
/// @param[in]     autoCavitationAmplitude (--)      Amplitude (0-1) of auto-cavitation pressure noise.
///
/// @details  Default constructs this GUNNS Liquid Centrifugal Pump link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Source object to copy.
///
/// @details  Copy constructs this GUNNS Liquid Centrifugal Pump link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag     (--)      Blockage malfunction flag.
/// @param[in] malfBlockageValue    (--)      Blockage malfunction fractional value (0-1).
/// @param[in] sourcePressure       (kPa)     Initial pressure rise of the link.
/// @param[in] motorSpeed           (rev/min) Initial speed of the motor.
/// @param[in] wallTemperature      (K)       Initial impeller wall temperature.
/// @param[in] enableAutoCavitation (--)      Enables the automatic cavitation model.
///
/// @details  Default constructs this GUNNS Liquid Centrifugal Pump link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Source object to copy.
///
/// @details  Copy constructs this GUNNS Liquid Centrifugal Pump link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     This should be followed by a call to the initialize method before calling an update
///           method.
///
/// @details  Default constructs this GUNNS Liquid Centrifugal Pump link model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData (--) Configuration data.
/// @param[in]     inputData  (--) Input data.
/// @param[in,out] links      (--) Link vector.
/// @param[in]     port0      (--) Nominal inlet port map index.
/// @param[in]     port1      (--) Nominal outlet port map index.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Initializes this GUNNS Liquid Centrifugal Pump link model with configuration and input
///           data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Configuration data.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Validates this GUNNS Liquid Centrifugal Pump Model link model initial state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Time step.
///
/// @returns  void
///
/// @details  Updates this GUNNS Liquid Centrifugal Pump link model source pressure.  Identical to a
///           GunnsGasFan, but then applies cavitation effects to the source pressure.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     This should be followed by a call to the initialize method before calling an update
///           method.
///
/// @details  Default constructs this Pump Cavitation object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] autoCavitationDuration  (s)  Duration of auto-cavitation effect.
/// @param[in] autoCavitationAmplitude (--) Amplitude of auto-cavitation noise.
/// @param[in] enableAutoCavitation    (--) Enables the automatic cavitation effect.
///
/// @returns  void
///
/// @details  Initializes this Pump Cavitation object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out] pumpSource (--) Reference to the pump flow source parameter to apply cavitation.
/// @param[in]     dt         (s)  Time step.
/// @param[in]     inletNode  (--) Pointer to the node at the pump flow inlet.
/// @param[in]     liquidType (--) Liquid fluid type to use for cavitation check.
///
/// @returns  void
///
/// @details  Calculates the effect of cavitation on the pump source parameter.  Models two types of
///           cavitation: partial and full.  Full cavitation is triggered by malfunction or low
///           inlet pressure (auto-cavitation).  Partial cavitation is triggered by malfunction and
///           also occurs during full cavitation.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inletNode  (--) Pointer to the node at the pump flow inlet.
/// @param[in] liquidType (--) Liquid fluid type to use for cavitation check.
///
/// @returns  void
///
/// @details  Calculate the vapor pressure at the pump inlet based on liquid type and inlet
///           temperature.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] flag     (--) Malfunction activation flag, true activates
/// @param[in] duration (s)  Duration of full cavitation malf effect
///
/// @details  Sets the malf parameters to the given values.  Calling this method with default
///           arguments resets the malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] flag      (--) Malfunction activation flag, true activates
/// @param[in] duration  (s)  Duration of partial cavitation wash-out
/// @param[in] amplitude (--) Amplitude of partial cavitation noise
///
/// @details  Sets the malf parameters to the given values.  Calling this method with default
///           arguments resets the malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Fluid Gas Fan link model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the construction of GUNNS Gas Fan link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction of GUNNS Gas Fan link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Gas Fan link model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Gas Fan link model nominal initialization without exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Gas Fan link model initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Gas Fan link model getter methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Gas Fan link model modifiers.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Gas Fan link model update state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Fluid Impeller link model update fluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Fluid Liquid Centrifugal Pump link model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the construction of GUNNS Liquid Centrifugal Pump link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction of GUNNS Liquid Centrifugal Pump link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Liquid Centrifugal Pump link model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Liquid Centrifugal Pump link model nominal initialization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Liquid Centrifugal Pump link model initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Liquid Centrifugal Pump link model getter methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Liquid Centrifugal Pump link setter methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Liquid Centrifugal Pump link model update state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This is the default constructor for the UtGunnsFluidPressureHead class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the GunnsFluidPressureHeadConfigData class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the default constructor of the GunnsFluidPressureHead class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the initialize method of the GunnsFluidPressureHead class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the initialize method of the GunnsFluidPressureHead with errors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the stepPreSolver method of the GunnsFluidPressureHead class, when
///           connected to a fluid potential link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the stepPreSolver method of the GunnsFluidPressureHead class, when
///           connected to a fluid accumulator link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the stepPostSolver method of the GunnsFluidPressureHead class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the setter & getter methods of the GunnsFluidPressureHead class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Gas Fan Curve unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the default construction of the GUNNS Gas Fan Curve class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the setCoeffs method of the GUNNS Gas Fan Curve class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the evaluate method of the GUNNS Gas Fan Curve class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the improveRoot method of the GUNNS Gas Fan Curve class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests exceptions thrown by the improveRoot method of the GUNNS Gas Fan Curve class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Gas Fan Curve getter methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Pump Cavitation unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the default construction of the GUNNS Pump Cavitation class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the initialize method of the GUNNS Pump Cavitation class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the computeVaporPressure method of the GUNNS Pump Cavitation class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the update method of the GUNNS Pump Cavitation class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return     void
///
/// @details    Updates source vector for the accumulator liquid chamber. Source vector [1]
///             is for port 1, which is the liquid side. Source vector [0] is for the pressurizer
///             if applicable and is zeroed out. If a gas pressurizer is used, then this source
///             vector must be set by the pressurizer after this function executes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   double (kg) The usable liquid mass.
///
/// @details  The usable mass is that which can be removed from the accumulator before it reaches
///           its minimum chamber volume.  So this is the internal liquid fluid mass (the total
///           liquid mass) minus the amount trapped in the minimum chamber volume.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  temperature  (K)  Desired temperature.
///
/// @details  Set accumulator temperature including pressurizer via the temperature edit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  coeff0  (kPa)  The 0th order coefficient for the spring pressure polynomial.
/// @param[in]  coeff1  (kPa)  The 1th order coefficient for the spring pressure polynomial.
/// @param[in]  coeff2  (kPa)  The 2th order coefficient for the spring pressure polynomial.
///
/// @details  Sets the mSpringCoeff0, 1, 2 terms to the given values.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    name                 (--)   Name of object
/// @param[in]    nodes                (--)   Pointer to nodes
/// @param[in]    expansionScaleFactor (--)   Scale factor for isentropic gas cooling
/// @param[in]    dpdtFilterGain       (--)   Gain for pressure rate filter
/// @param[in]    thermalDampingMass   (kg)   Thermal damping mass
/// @param[in]    editFluxTarget       (kg*mol/s)    Target threshold for edit completion
/// @param[in]    surfaceArea          (m2)   Inner surface area of tank shell
/// @param[in]    shellRadius          (m)    Distance from tank shell to center
///
/// @details  Default constructs this GUNNS Fluid Tank link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that   --  Source to copy.
///
/// @details  Copy constructs this GUNNS Fluid Tank link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    malfBlockageFlag        (--)  Blockage malfunction flag
/// @param[in]    malfBlockageValue       (--)  Blockage malfunction fractional value (0-1)
/// @param[in]    volume                  (m3)  Volume of the link
/// @param[in]    fluidState              (--)  State of the port 0 node contents
/// @param[in]    initialShellTemperature (K)   Initial temperature of the tank shell
/// @param[in]    biasHeatFlux;           (J/s) User bias heat flux added to fluid
///
/// @details  Default constructs this GUNNS Fluid Tank link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that   --  Source to copy.
///
/// @details  Copy constructs this GUNNS Fluid Tank link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     This should be followed by a call to the initialize method before calling an update
///           method.
///
/// @details  Default constructs this GUNNS Fluid Tank link model.
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default destructs this GUNNS Fluid Tank link model.
///////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    dt  (s)  Integration time step
///
/// @return   void
///
/// @details  Processes any temperature and pressure/partial pressure edits and applies them to
///           this GUNNS Fluid Tank link model port 0 node fluid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Check if the user forgot to set target temperature - a zero value will be interpreted
///           as they forgot because absolute zero is not really allowed in GUNNS.  In this case,
///           just use the current node temperature as the target.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   (kPa)  Target total pressure for the edit
///
/// @details  This method computes and returns the target total pressure for an edit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @details  This method calls the appropriate edit method in the fluid class for either a total
///           or partial pressure edit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    dt  (s)  Integration time step
///
/// @return   void
///
/// @details  This method computes the true delta-pressure/delta-time (dP/dt) in the node.  This is
///           useful in examining network stability and for validation of sensed dP/dt.  A low-pass
///           filter is used to smooth out noise in the network, if desired.  The filter gain can be
///           adjusted.  A zero value (the default) de-activates this calculation.  A value of 1.0
///           gives the true node dP/dt.  A value of 0.1 is a good typical value for seeing network
///           trends.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @details  This method stores the node's fluid composition information (partial pressures, mass
///           fractions, mole fractions and temperature) for output to the sim bus or display. This
///           happens after the node has updated so the fluid composition is fresh.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  flag         (--)   Edit activation flag
/// @param[in]  temperature  (K)    Edit temperature value
///
/// @details  This method sets the parameters associated with a temperature-only edit to the desired
///           values.  Calling the method with no arguments supplied deactivates the edit, leaving
///           the other control values alone.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  flag         (--)   Edit activation flag
/// @param[in]  temperature  (K)    Edit temperature value
/// @param[in]  pressure     (kPa)  Edit pressure value
///
/// @details  This method sets the parameters associated with a temperature and total pressure edit
///           to the desired values.  Calling the method with no arguments supplied deactivates the
///           edit, leaving the other control values alone.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  flag              (--)   Edit activation flag
/// @param[in]  temperature       (K)    Edit temperature value
/// @param[in]  partialPressures  (kPa)  Array of edit partial pressure values
///
/// @details  This method sets the parameters associated with a temperature and partial pressures
///           edit to the desired values.  Calling the method with no arguments supplied deactivates
///           the edit, leaving the other control values alone.
///
/// @note     The supplied partial pressures array size must be as large as the network number of
///           fluid constituents or very bad things can happen to the sim.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  type             (--)     The fluid constituent to be edited
/// @param[in]  flag             (--)     Edit activation flag
/// @param[in]  partialPressure  (kPa)    Edit partial pressure target value
/// @param[in]  rate             (kPa/s)  Edit partial pressure rate value
///
/// @throws   TsOutOfBoundsException
///
/// @details  This method sets the parameters associated with an individual constituent's partial
///           pressure rate edit.  Calling the method with no arguments supplied does nothing.
///           Supplying a fluid type but leaving the remaining arguments defaulted deactivates the
///           edit, leaving the other control values alone.  An exception is thrown by the fluid
///           class if the supplied constituent type is not present in the network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                 (--)       Link name.
/// @param[in] nodes                (--)       Network nodes array.
/// @param[in] expansionScaleFactor (--)       Scale factor for isentropic gas cooling (0-1).
/// @param[in] dpdtFilterGain       (--)       Gain for pressure rate filter.
/// @param[in] thermalDampingMass   (kg)       Thermal damping mass.
/// @param[in] editFluxTarget       (kg*mol/s) Target threshold for edit completion.
/// @param[in] surfaceArea          (m2)       Inner surface area of balloon wall.
/// @param[in] shellRadius          (m)        Distance from balloon wall to center.
/// @param[in] inflatability        (m3/kPa)   Inflatability of balloon.
/// @param[in] maxVolume            (m3)       Maximum balloon volume, at which wall becomes rigid.
///
/// @details  Default GUNNS Fluid Balloon Config Data Constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy.
///
/// @details  GUNNS Fluid Balloon Config Data Copy Constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfStuckFlag               (--)  Initial activation state of the stuck wall malfunction.
/// @param[in] malfInflatabilityScaleFlag  (--)  Initial activation state of the inflatability scale malfunction.
/// @param[in] malfInflatabilityScaleValue (--)  Initial value of the inflatability scale malfunction.
/// @param[in] initialFluidState           (--)  Initial state of the internal ballon (port 0 node) contents.
/// @param[in] initialShellTemperature     (K)   Initial temperature of the balloon wall.
/// @param[in] biasHeatFlux                (J/s) User bias heat flux added to fluid.
///
/// @details  Default GUNNS Fluid Balloon Input Data Constructor.  The base class blockage malf and
///           initial volume aren't used so we send zero values to its constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy.
///
/// @details  GUNNS Fluid Balloon Input Data Copy Constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default GUNNS Fluid Balloon Constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) GUNNS Fluid Balloon Config Data.
/// @param[in]     inputData    (--) GUNNS Fluid Balloon Input Data.
/// @param[in,out] networkLinks (--) Network links.
/// @param[in]     port0        (--) Network port 0.
/// @param[in]     port1        (--) Network port 1.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this GUNNS Fluid Balloon with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) GUNNS Fluid Balloon Config Data.
///
/// @throws   TsInitializationException
///
/// @details  Validates this GUNNS Fluid Balloon initial state.
////////////////////////////////////////////////////////////////////////////////////////////////////