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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default GUNNS Fluid Capacitor Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) GUNNS Fluid Capacitor Config Data
/// @param[in]     inputData    (--) GUNNS Fluid Capacitor 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 Capacitor with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] initialFluidState (--) Fluid Initial State
///
/// @details Protected Method for Initializing the Link Fluid State. All fluid capacitors must
///          initialize the fluid properties, so we force an implementation here.  The capacitor is
///          always defined to act upon the port 0 fluid, which is owned by the GunnsFluidNode.
///          The fluid object already exists, we just need to initialize its state.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details Method to update the link during a time step. For a fluid capacitor, like a Tank or
///          any volume, we define the actual capacitive node to be Nodes[0], and Nodes[1] is set
///          as a zero potential node.  Make sure to always map Nodes[0] as the volume object node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details  This method builds the link's mass capacitance into the admittance matrix, applied to
///           the node at port 0.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details  This method builds the link's mass capacitance, thermal capacitance, and compression
///           effect into the source vector, applied to the node at port 0.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] port (--) The port to be assigned
/// @param[in] node (--) The desired node to assign the port to
///
/// @returns  bool  (--) Returns true if all rules checks pass
///
/// @details  Checks the requested port & node arguments for validity against rules that apply to
///           this specific class.  These are:
///           - A GunnsFluidCapacitor must not map port 0 to the network's vacuum boundary node.
///           - A GunnsFluidCapacitor must map port 1 to the network's vacuum boundary node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name  (--) Link name
/// @param[in] nodes (--) Network nodes array
///
/// @details  Default GUNNS Basic External Supply Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  GUNNS Basic External Supply Config Data Copy Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--) Blockage malfunction flag
/// @param[in] malfBlockageValue (--) Blockage malfunction fractional value (0-1)
/// @param[in] sourceFlux        (--) Initial demanded flux of the link
///
/// @details  Default constructs this Basic External Supply input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy constructs this Basic External Supply input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData   (--) GUNNS Basic External Supply Config Data
/// @param[in]      inputData    (--) GUNNS Basic External Supply 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 Basic External Supply with configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] port (--) The port to be assigned
/// @param[in] node (--) The desired node to assign the port to
///
/// @returns  bool  (--) Returns true if all rules checks pass
///
/// @details  Checks the requested port & node arguments for validity against rules that apply to
///           this specific class.  These are:
///           - A GunnsBasicExternalSupply must not map port 0 to the network ground node.
///           - A GunnsBasicExternalSupply must map port 1 to the network ground node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Handles data read from the external network's demand link, via the sim bus.  Data is
///          moved from the sim but input queue into the link internal members.  The average of all
///          the queued demanded fluxes since last pass, when integrated over this network's time
///          step, produces the same net flux transfer in out network as the demand network, so
///          quantity is conserved.
///
///          If there is no queue, then it is assumed that the user is setting mSourceFlux directly
///          and we skip updating it here.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                 (--) Name of object.
/// @param[in] nodes                (--) Pointer to nodes.
/// @param[in] defaultConductivity  (--) Default maximum conductivity.
/// @param[in] nonLinear            (--) Flag to operate in non-linear network mode.
/// @param[in] enableReverseControl (--) Flag to enable control in reverse flow direction.
///
/// @details  Default constructs this GUNNS Basic Flow Controller link model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--) Blockage malfunction flag
/// @param[in] malfBlockageValue (--) Blockage malfunction fractional value (0-1)
/// @param[in] malfFluxFlag      (--) Malfunction flux rate flag.
/// @param[in] malfFluxValue     (--) Malfunction flux rate value.
/// @param[in] fluxCommand       (--) Initial commanded flux.
///
/// @details  Default constructs this GUNNS Basic Flow Controller link model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that  (--)  Source object to copy.
///
/// @details  Copy constructs this GUNNS Basic Flow Controller 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 Basic Flow Controller 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.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this GUNNS Basic Flow Controller link model with configuration and input
///           data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Not used.
///
/// @details  Updates this GUNNS Basic Flow Controller link model conductivity to cause flow through
///           the link that approaches the input commanded rate.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] flag   (--)  Malfunction activation flag.
/// @param[in] value  (--)  Desired mass flux.
///
/// @details  Arguments are defaulted to deactivate the malfunction, so you can conveniently turn
///           it off by calling setMalfFlux().
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name  (--)  Instance name for self-identification in messages.
///
/// @details  Default constructs this GUNNS Fluid Flow Integrator Spotter configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  nodeList  (--)  Reference to the network node list.
///
/// @details Default constructs this GUNNS Fluid Flow Integrator Spotter.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Execution time step.
///
/// @details  Integrate the constituent masses flowed through the link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Helper method to collect the fluid mass fractions out of the link's port 0 and port 1
///          nodes. Called by the stepPreSolver method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Helper method to assign the mass fractions that are used in the integration of the
///          flow rate. Called in the stepPostSolver method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] conductivity      (m2)           Link effective conductivity.
/// @param[in] minLinearizationP (kPa)          Minimum link delta-pressure for linearization.
/// @param[in] fluid0            (--)           Pointer to node content fluid at a link port
///                                                 (order doesn't matter).
/// @param[in] fluid1            (--)           Pointer to node content fluid at a link port
///                                                 (order doesn't matter).
/// @param[in] exponent          (--)           Exponent on the (rho/dP) term, default = 1/2.
///
/// @return                      (kgmol/kPa/s)  Linearized molar admittance.
///
/// @note     The minLinearizationP argument should be the calling link's mMinLinearizationPotential
///           attribute.
///
/// @details  Calculates and returns the link admittance as a function of conductivity and fluid
///           properties.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] fluid  (--) The fluid to compute the capacitance for
/// @param[in] volume (m3) The volume to compute the capacitance for
///
/// @return   (kg*mol/kPa) Node capacitance limited to >= 0
///
/// @details  Computes the fluid capacitance of the node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] expansionScaleFactor (--)  Scale factor for the isentropic cooling effect.
/// @param[in] p1                   (kPa) Initial fluid pressure.
/// @param[in] p2                   (kPa) Final fluid pressure.
/// @param[in] fluid                (--)  Pointer to fluid undergoing expansion.
///
/// @return                         (K)   Final temperature of the fluid after isentropic expansion.
///
/// @note     The expansionScaleFactor argument should be the calling link's mExpansionScaleFactor
///           attribute.
///
/// @details  Calculates and returns the final temperature of a fluid after isentropic expansion.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  mdot               (kg/s)  Desired mass flow rate across the link.
/// @param[in]  minLinearizationP  (--)    Minimum link delta-pressure for linearization.
/// @param[in]  fluid0             (--)    Pointer to node content fluid at a link port
///                                            (order doesn't matter).
/// @param[in]  fluid1             (--)    Pointer to node content fluid at a link port
///                                            (order doesn't matter).
/// @param[in]  exponent           (--)    Exponent on the (rho/dP) term, default = 1/2.
///
/// @return                        (--)    Predicted effective conductivity.
///
/// @note     This method returns zero if the link delta-pressure is < DBL_EPSILON.
///
/// @note     The minLinearizationP argument should be the calling link's mMinLinearizationPotential
///           attribute.
///
/// @details  Predicts the effective conductivity needed to produce the desired mass flow rate
///           across the link at this instant in time using current network conditions.  This uses
///           the inverse of the equation in the computeAdmittance method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  deltaTemperature  (K)   Desired temperature drop across the link.
/// @param[in]  fluid0            (--)  Pointer to node content fluid at a link port
///                                         (order doesn't matter).
/// @param[in]  fluid1            (--)  Pointer to node content fluid at a link port
///                                         (order doesn't matter).
///
/// @return                       (--)  Predicted expansion scale factor (0-1).
///
/// @note     The expansion scale factor is only used when the link has an internal fluid.
///
/// @note     This method returns zero for liquids.
///
/// @details  Predicts the expansion scale factor needed to produce the desired temperature drop
///           across the link at this instant in time using current network conditions.  The
///           resulting scale factor will be limited between 0 and 1.  This uses the inverse of the
///           equation in the computeIsentropicTemperature method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out]   transformMap   (--)  The output constituent transformation index map.
/// @param[in]    inConfig       (--)  Pointer to configuration data for the input fluid.
/// @param[in]    outConfig      (--)  Pointer to configuration data for the output fluid.
/// @param[in]    convertToType  (--)  The fluid type to convert missing constituents into.
///
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  This method builds an index to map the constituent configuration of an input fluid to
///           the config of the output fluid.  This is used to set up the interface between two
///           networks when they have a different fluid config.  The inConfig argument is the fluid
///           config of the external network, and outConfig is the config of our local network.
///           Think in terms of a fluid coming into our network from the external network.  inFluid
///           describes the config of the incoming external fluid, and outFluid describes the config
///           of the output of this process, which goes out to our local network.
///
///           The convertToType argument describes how to map constituents in the external network
///           (inConfig) that aren't present in our local network (outConfig).  The options are any
///           of the fluid constituents in outConfig (FluidProperties::GUNNS_N2, etc) or none of
///           them (FluidProperties::NO_FLUID).  An exception is thrown if none of these options are
///           specified.
///
///           If a local fluid type is specified, then any types in the external fluid that are not
///           present in our local network are converted into the specified type.  For instance, if
///           inConfig consists of (GUNNS_O2, GUNNS_N2, GUNNS_CO2) and outConfig consists of
///           (GUNNS_N2, GUNNS_O2) and convertToType is GUNNS_N2, then the CO2 from the external
///           network is converted into an equal number of moles of N2 when it enters our local
///           network.  Note that because of the difference in molecular weights, this means that
///           mass is NOT conserved during this transformation.  Moles are conserved instead, to
///           improve pressure stability between the networks.
///
///           If NO_FLUID is specified, then any types in the external fluid not present in our
///           local network are converted to ALL of the remaining types that are present, in the
///           same proportions that those types have in the mixture.  For instance, if in the above
///           example the external fluid's mixture was (0.2, 0.79, 0.01) and convertToType were
///           NO_FLUID, then the CO2 is converted into 0.2/0.99 parts O2 and 0.79/0.99 parts N2.
///           Again, moles are conserved, not mass.
///
///           This method just builds the transformation map.  The transformState method does the
///           actual fluid conversion in run-time.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] outFluid          (--)  Pointer to converted outgoing fluid.
/// @param[in]  inPressure        (kPa) Incoming fluid pressure.
/// @param[in]  inTemperature     (K)   Incoming fluid temprature.
/// @param[in]  inMassFractions   (--)  Incoming fluid mass fractions to be converted.
/// @param[in]  transformMap      (--)  Constituent transformation index map.
/// @param[in]  inTcMoleFractions (--)  Optional pointer to incoming trace compounds mole fractions.
///
/// @return     void
///
/// @throws   TsOutOfBoundsException
///
/// @details  This method converts the data describing a fluid in an external network into the
///           outFluid.  outFluid takes the incoming external fluid's pressure and temperature, but
///           the mass fractions are re-mapped into outFluid's constituents, using the transformMap.
///           This is used in external network interfaces between two networks that can have the
///           same or different fluid configurations.  See the comments for the buildTransformMap
///           method above.
///
///           We use mass fractions here, but we could have used either mass or mole fractions for
///           the purpose of this method.  The actual conservation of moles of fluid is done in the
///           GunnsFluidExternalSupply & Demand links, which transfer molar flux between them, not
///           mass rate.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  flowRate  (kg/s)    Mass flow rate.
/// @param[in]  fluid     (--)      Pointer to internal fluid.
/// @param[in]  rOverD    (--)      Ratio of pipe inner surface roughness to inner diameter.
/// @param[in]  diameter  (m)       Pipe inner diameter.
///
/// @returns    double    (W/m2/K)  Convective heat transfer coefficient.
///
/// @details  Computes the fluid convective heat transfer coefficient for forced convection in a
///           pipe with circular cross-section.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  fluid     (--)   Pointer to the fluid.
/// @param[in]  velocity  (m/s)  Mean fluid flow velocity.
/// @param[in]  length    (m)    Characteristic length.
///
/// @returns  double  (--)  Reynolds number
///
/// @details  Calculates Reynolds number given fluid density and dynamic viscosity (properties of
///           the given fluid), flow velocity and characteristic length.  Protection for divide by
///           zero is given since viscosity is never allowed to be zero in the fluid properties.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  fluid   (--)  Pointer to the fluid.
/// @param[in]  rOverD  (--)  The ratio of pipe surface roughness to inner diameter.
/// @param[in]  re      (--)  Reynolds number of the flow.
///
/// @returns  double  (--)  Nusselt number.
///
/// @details  Calculates the Nusselt number for forced convection in a pipe with circular cross-
///           section, for 0 < Re < 1E8.  Laminar flow is assumed to be fully developed with uniform
///           surface temperature, and returns 3.66. Turbulent flow uses the Gnielinski correlation.
///           For transition flow, the result is linearly interpolated between the max-Re laminar
///           and min-Re turbulent points.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  rOverD  (--)  The ratio of pipe surface roughness to inner diameter.
/// @param[in]  re      (--)  Reynolds number of the flow.
///
/// @returns  double  (--)  Darcy Friction Factor.
///
/// @details  Calculates the Darcy Friction Factor for a pipe with circular cross-section, for
///           0 < Re < 1E8.  Laminar flow returns 64/Re.  Turbulent flow uses an approximation to
///           the Colebrook-White Equation, including surface roughness.  For transition flow, the
///           result is linearly interpolated between the max-Re laminar and min-Re turbulent
///           points.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out]  fluid            (--)    Pointer to the fluid moving through the pipe.
/// @param[in]      flowRate         (kg/s)  The mass flow rate of the fluid through the pipe.
/// @param[in]      UA               (W/K)   Product of heat transfer coefficient & surface area.
/// @param[in]      wallTemperature  (K)     Pipe wall temperature, assumed constant at all points.
///
/// @returns  double  (W)  Heat flux from fluid to pipe wall.
///
/// @details  Computes the convective heat flux from a fluid moving through a pipe and updates the
///           fluid temperature resulting from the heat flux.
///
/// @note     This is an overloaded method.  This version receives a known heat transfer coefficient
///           times surface area product (commonly called UA).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out]  fluid            (--)    Pointer to the fluid moving through the pipe.
/// @param[in]      flowRate         (kg/s)  The mass flow rate of the fluid through the pipe.
/// @param[in]      rOverD           (--)    The ratio of pipe surface roughness to inner diameter.
/// @param[in]      diameter         (m)     Hydraulic (inner) diameter of the pipe.
/// @param[in]      surfaceArea      (m2)    Total inner surface area of the pipe length.
/// @param[in]      wallTemperature  (K)     Pipe wall temperature, assumed constant at all points.
///
/// @returns  double  (W)  Heat flux from fluid to pipe wall.
///
/// @details  Computes the convective heat flux from a fluid moving through a pipe and updates the
///           fluid temperature resulting from the heat flux.
///
/// @note     This is an overloaded method.  This version calculates its own heat transfer
///           coefficient from the given pipe geometry.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  area     (m2)  Open cross-sectional area of the interface.
/// @param[in]  fluid0   (--)  Pointer to port 0 node content fluid.
/// @param[in]  fluid1   (--)  Pointer to port 1 node content fluid.
/// @param[in]  length0  (m)   Distance from the interface to center of node 0 volume.
/// @param[in]  length1  (m)   Distance from the interface to center of node 1 volume.
///
/// @return              (W)   Conductive heat flux from port 0 to port 1.
///
/// @throws   TsOutOfBoundsException
///
/// @details  Computes the conductive heat flux between the fluid contents of the linked nodes,
///           given the geometry of the interface.  Flux is positive from port 0 to port 1, but can
///           go in either direction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out]  fluid          (--)   Pointer to the link internal fluid.
/// @param[in]      area           (m2)   Open cross-sectional area of the interface.
/// @param[in]      fluid0         (--)   Pointer to port 0 node fluid.
/// @param[in]      fluid1         (--)   Pointer to port 1 node fluid.
/// @param[in]      bulkFlowRate   (kg/s) Bulk flow rate through the link.
/// @param[in]      length0        (m)    Distance from the interface to center of node 0 volume.
/// @param[in]      length1        (m)    Distance from the interface to center of node 1 volume.
///
/// @return                   (kg/s) Net mass flow rate from port 0 to port 1.
///
/// @throws   TsOutOfBoundsException
///
/// @note     A mixture of ideal gases is assumed.
///
/// @note     As a simplification, we assume molecular diameter of all gases is that of diatomic
///           molecules (N2, O2, etc), since they constitute ~99% of air.
///
/// @note     As a simplification, we assume that diffusion rate is not affected by pressure flow
///           through the same interface.
///
/// @details  Computes the free gas diffusion between the fluid contents of the linked nodes, given
///           the geometry of the interface.  Net mass flow rate is positive from port 0 to port 1,
///           but can go in either direction.  This method returns the net mass flow rate, and
///           modifies the link's internal fluid such that, when combined with the net flow rate,
///           will exchange gas constituents in either or both directions, as appropriate.  Net
///           molar flow across the interface is not returned - although temperature differences
///           across the interface normally cause a net molar flow, the discrepancies caused by not
///           incorporating it in the Gunns system of equations are small, and are corrected for in
///           the node's pressure correction logic.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  fluid  (--)  Pointer to the fluid to calculate for
///
/// @returns  (--)  Fractional relative humidity
///
/// @throws   TsOutOfBoundsException
///
/// @details  Returned value of 1.0 represents 100% relative humidity, but the returned value can be
///           greater than 1.0.  If gaseous H2O is not present in the fluid config, an exception is
///           thrown by the PolyFluid object.  If H2O saturation vapor pressure is zero (as with a
///           super-cold fluid), return zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] outMixture  (--) The resulting mass fractions
/// @param[in]  inMixture   (--) The input mole fractions
/// @param[in]  fluidConfig (--) The input fluid configuration
///
/// @details  This method converts an array of mole fractions of a fluid mixture into mass
///           fractions.  If the sum of the mole fractions in the input array is zero, this method
///           will return without modifying the output array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] outMixture  (--) The resulting mole fractions
/// @param[in]  inMixture   (--) The input mass fractions
/// @param[in]  fluidConfig (--) The input fluid configuration
///
/// @details  This method converts an array of mass fractions of a fluid mixture into mole
///           fractions.  If the sum of the mass fractions in the input array is zero, this method
///           will return without modifying the output array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] outMixture  (--) The resulting mole fractions
/// @param[in]  inMixture   (--) The input partial pressures
/// @param[in]  fluidConfig (--) The input fluid configuration
///
/// @details  This method converts an array of partial pressures of a fluid mixture into mole
///           fractions.  If the sum of the partial pressures in the input array is zero, this
///           method will return without modifying the output array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] outMixture    (--) The resulting partial pressures
/// @param[in]  inMixture     (--) The input mole fractions
/// @param[in]  fluidConfig   (--) The input fluid configuration
/// @param[in]  totalPressure (--) The total pressure of the resulting fluid
///
/// @details  This method converts an array of mole fractions of a fluid mixture into partial
///           pressures.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out] fractions (--) The fractions array to normalize.
/// @param[in]     size      (--) The number of elements in the array.
///
/// @returns       bool      (--) True if normalization was necessary.
///
/// @details  Any elements with values less than DBL_EPSILON * DBL_EPSILON are zeroed, to prevent
///           arithmetic underflows from developing in the array.  If the resulting sum of the
///           fractions is not within FLT_EPSILON of 1.0, then the the array is normalized such that
///           it sums to 1.0 and the method returns a True.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out] outFluid      (--) Pointer to the fluid to be added to.
/// @param[in]     outMass       (kg) The original mass of outFluid prior to mixing.
/// @param[in]     inFluid       (--) Pointer to the fluid to be added to outFluid.
/// @param[in]     inMass        (kg) The mass of inFluid to be added to outFluid.
/// @param[in]     numFluidTypes (--) The number of fluid constituents in the fluid mixtures.
///
/// @throws        TsOutOfBoundsException
///
/// @returns       bool (--) True if normalization of outFluid mass fractions was necessary.
///
/// @details  Mixes a given mass of the inFluid mixture into a given mass of the outFluid mixture.
///           Only the outFluid is changed.  The resulting mixture of outFluid is normalized such
///           that each of its constituent's mass fractions cannot be less than zero and all the
///           fractions sum to 1.  The outFluid's total mass and mass fractions are set.  A returned
///           flag indicates whether normalization of the mass fractions was necessary.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  flag         (--)  Activation flag for the edit.
/// @param[in]  capacitance  (--)  New capacitance the link will take during the edit.
///
/// @details  Sets the capacitance edit controls to the given values.  The edit will be performed
///           and the edit flag reset during the next link step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default destructs this Basic Jumper Plug.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] socket (--) Reference to the socket object to be added to the list
///
/// @throws  TsInitializationException
///
/// @details If the list is not yet full, add the new socket's address to the pointer array and
///          update the number of sockets.  Otherwise, throw an exception.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] initNode   (--) Initial node prior to socket connection.
/// @param[in] initSocket (--) Index of the desired initial socket connection.
///
/// @returns  int (--) Index to the connected network node.
///
/// @throws   TsInitializationException
///
/// @details  Initializes the Plug's connection and validates the initial state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  currentNode (--) The network node number the link's port is currently connected to.
///
/// @returns  int (--) Index to the connected network node.
///
/// @throws   TsOutOfBoundsException
///
/// @details  Updates the connection state of the Plug and returns the connected node index.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] index (--) Position in the list of the socket to be returned
///
/// @returns GunnsBasicLink* (--) Pointer to the link at the requested index
///
/// @throws  TsOutOfBoundsException
///
/// @details The requested index is first checked to make sure it is in the range of the actual
///          socket in the list.  If it is in range and the socket's address is not null, the
///          address is returned, otherwise throw an exception.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @throws   TsOutOfBoundsException
///
/// @details  Processes a connect request for this Plug.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @throws   TsOutOfBoundsException
///
/// @details  Processes a disconnect request for this plug.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @throws   TsOutOfBoundsException
///
/// @details  Loops through each socket in the list and polls them for a connection to this plug.
///           Set the active connection status to the identified socket, or "no connection" if no
///           socket is connected.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  If logging is enabled, then advances the ring buffer to the next minor step by
///           increasing the head index, with wrap-around, and increments the count of valid steps.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Sets mIsRecording to true, enabling data recording functions and ring buffer head
///           advancing.  Also resets mHeadIndex and mNumValidSteps, which effectively clears the
///           buffer so recording will start with an empty buffer.   The old buffer is not actually
///           cleared, but those old data frames will not be output until new data is recorded in
///           them.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  flag    (--)  Activation flag for the edit.
/// @param[in]  volume  (--)  New volume the node will take during the edit.
///
/// @details  Sets the volume edit controls to the given values.  The edit will be performed and the
///           edit flag reset during the next link step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name  (--) Link name
/// @param[in] nodes (--) Network nodes array
///
/// @details  Constructs the Basic Capacitor Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Input Source to Copy
///
/// @details  Copy Constructs the Basic Capacitor Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--) Blockage malfunction flag
/// @param[in] malfBlockageValue (--) Blockage malfunction fractional value (0-1)
/// @param[in] capacitance       (--) Initial capacitance of the link
/// @param[in] potential         (--) Initial potential of the capacitive node
///
/// @details  Default constructs this Basic Capacitor input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy constructs this Basic Capacitor input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default Gunns Basic Capacitor Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Reference to Link Config Data
/// @param[in]     inputData    (--) Reference to LInk Input Data
/// @param[in,out] networkLinks (--) Reference to the Network Link Vector
/// @param[in]     port0        (--) Port 0 Mapping
/// @param[in]     port1        (--) Port 1 Mapping
///
/// @details  Initializes the Basic Capacitor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Validates the Basic Capacitor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details  Method for updating the link for the network
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details  Method for updating the link flows
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] toPotential (--) Initial potential of the capacitive node
///
/// @details  This method initializes the potential of the node that this capacitive link applies
///           its capacitance to.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details  Builds the admittance matrix and source vector of the link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                  (--) Link name
/// @param[in] nodes                 (--) Network nodes array
/// @param[in] defaultConductivity   (--) Default conductivity of the link
/// @param[in] filterMinConductivity (--) Minimum filtered effective conductivity
/// @param[in] filterMinDeltaP       (--) Minimum delta-potential for capacitance estimate
/// @param[in] filterCapacitanceGain (--) Gain for estimated capacitance filter (0-1)
///
/// @details  Default GUNNS Basic External Demand Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  GUNNS Basic External Demand Config Data Copy Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--) Blockage malfunction flag
/// @param[in] malfBlockageValue (--) Blockage malfunction fractional value (0-1)
/// @param[in] sourcePotential   (--) Initial potential rise of the link
///
/// @details  Default constructs this Basic External Demand input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy constructs this Basic External Demand input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default GUNNS Basic External Demand Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) GUNNS Basic External Demand Config Data
/// @param[in]     inputData    (--) GUNNS Basic Conductor Input Data
/// @param[in,out] networkLinks (--) Network links
/// @param[in]     port0        (--) Network port 0
/// @param[in]     port1        (--) Network port 1
///
/// @throws   TsInitializationException
///
/// @details  This overloaded method initializes this Basic External Demand link with configuration
///           and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] port (--) The port to be assigned
/// @param[in] node (--) The desired node to assign the port to
///
/// @returns  bool  (--) Returns true if all rules checks pass
///
/// @details  Checks the requested port & node arguments for validity against rules that apply to
///           this specific class.  These are:
///           - A GunnsBasicExternalDemand must map port 0 to the network ground node.
///           - A GunnsBasicExternalDemand must not map port 1 to the network ground node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  numLinks  (--)  The number of links in the network.
/// @param[in]  numNodes  (--)  The number of nodes in the network, including the Ground node.
///
/// @details  Default constructs this GUNNS Basic Flow Orchestrator.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Checks initialized states for validity and throws exceptions on faults.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Integration time step.
///
/// @details  Calls all links to compute & transport the flows associated with the new network
///           solution, and updates the nodes with their collected flows.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                 (--) Name of the Gunns object for fault messaging
/// @param[in] convergenceTolerance (--) Error tolerance for minor step convergence
/// @param[in] minLinearizationP    (--) Minimum potential for linearization in link admittances
/// @param[in] minorStepLimit       (--) Maximum allowed minor steps per major step
/// @param[in] decompositionLimit   (--) Maximum allowed matrix decompositions per major step
///
/// @details  Default constructs this Gunns configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Input source to copy
///
/// @details  Copy constructs this Gunns configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Gunns object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default destructs this Gunns object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  mode       (--)  GpuMode enumeration value to take.
/// @param[in]  threshold  (--)  Network/island size threshold value to take.
///
/// @details  Rejects any GPU modes and outputs an H&S warning if the compilation is not GPU
///           enabled.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out] A      (--) The admittance sub-matrix to be decomposed.
/// @param[in]     size   (--) The number of rows in the admittance sub-matrix.
/// @param[in]     island (--) Optional island # for error messages.
///
/// @throws   TsNumericalException
///
/// @details  Calls the CPU or GPU decomposition based on the matrix size relative to the CPU/GPU
///           cutoff.  In a Trick environment, also records the elapsed wall time of the
///           decomposition for timing analysis.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  This method checks the network's mode settings for validity and makes sure the
///           network has completed initialization prior to stepping.
///
/// @note     The TsInitializationException should be fatal to the load.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] minorStep (--) The absolute minor step # that the network is on
///
/// @return   bool (--) Returns true if the solution has converged, false otherwise
///
/// @details  This method checks for convergence of the system's potential vector solution.  The
///           delta between the previous minor step's solution and the current solution must be
///           below a defined tolerance, for each node individually.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] convergedStep (--) The # of minor steps since the network last converged
/// @param[in] absoluteStep  (--) The absolute minor step number that the network is on
///
/// @return   GunnsBasicLink::SolutionResult (--) The combined assessment of the solution from all
///                                               of the non-linear links in the network
///
/// @details  This method checks all non-linear links for acceptance of the solution.  An example
///           would be an open check valve seeing reverse pressure gradient indicating reverse flow,
///           in which case the link would need to change its state to closed and re-solve the
///           system.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method assembles the system admittance matrix from the individual link's
///           contributions.  Looping through the links, we use the link's admittance map to know
///           where to add its contribution terms into the main matrix.  Any out-of-bounds number in
///           the link's map denote that location doesn't map to anywhere in the network system of
///           equations, and we omit including the link's contribution at that location.  This will
///           usually be the Ground node, but might occur for spare terms in a link's compressed
///           matrix, or for bad link code that we must protect against, etc.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method searches through the admittance matrix and groups nodes into partitions,
///           or islands.  This allows the islands to be decomposed separately, which greatly speeds
///           up the total network solution if the largest island node count is significantly
///           smaller than the total network size.
///
///           All nodes in the same island are connected to each other by conductances (represented
///           in the matrix as non-zero off-diagonals).  Separate islands have no conductances
///           between them.
///
///           This method assembles vectors of node numbers for each island.  These are sorted by
///           ascending node number.  These are passed to the nodes, which can then be accessed by
///           incident links for their information about what else is in the island they are on.
///           This can be useful for implementing stability filters, etc.
///
///           Finding the islands incurs about 5% more CPU time than not doing it, more or less
///           depending on how large or sparse the matrix is.  This method only sweeps thru the
///           matrix once, and only does column searches when it hits off-diagonals, which takes
///           advantage of sparsity.  This should speed proportional to # nodes * # off-diagonals.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  from  (--)  Island number to be moved from.
/// @param[in]  to    (--)  Island number to be moved to.
///
/// @details  This method re-assigns all nodes belonging to one island to another island.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method assembles the system source vector from the individual link's
///           contributions.  Similarly to the admittance matrix, we use the link's node mapping to
///           know where to add its contribution terms into the main vector.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsNumericalException
///
/// @details  This method calls the Cholesky solve method to find a new network potential vector
///           solution.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] solver (--) Pointer to the linear algebra solver to call.
/// @param[in] A      (--) The admittance matrix to decompose.
/// @param[in] size   (--) The size N of the N x N admittance matrix.
/// @param[in] island (--) The optional network island number associated with this matrix.
///
/// @throws   TsNumericalException
///
/// @details  Performs the actual call to the linear algebra Decompose method, catches any returned
///           exceptions, reformats the error information to a H&S error message.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] solver (--) Pointer to the linear algebra solver to call.
/// @param[in] A      (--) The admittance matrix for the solution.
/// @param[in] w      (--) The source vector for the solution.
/// @param[in] p      (--) The solution vector for the solution.
/// @param[in] size   (--) The size N of the N x N admittance matrix.
/// @param[in] island (--) The optional network island number associated with this matrix.
///
/// @throws   TsNumericalException
///
/// @details  Performs the actual call to the linear algebra Solve method, catches any returned
///           exceptions, reformats the error information to a H&S error message.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Zeroes out potential vector values that are smaller than a minimum absolute value.
///           This prevents a network from approaching dirty zeroes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsNumericalException
///
/// @details  This method is the first half of the network capacitance computations.  For each node
///           that requests its network capacitance, requested flux is added to the node's source
///           vector and the system of equations solved using the last matrix decomposition.  The
///           computeNetworkCapacitances() method is called later to finish the computations.  Nodes
///           that do not request their value have it reset here.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  timeStep  (s)  Execution time step.
///
/// @details  This method is the second half of the network capacitance computations.  The
///           perturbed node potential in response to the requested flux computed in
///           perturbNetworkCapacitances() is compared to the actual network potential solution and
///           the capacitance computed from the delta.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method overrides the solution potential vector with inputs from the network links
////          or an externally supplied array, depending on the solver mode.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method makes sure the admittance matrix is adequately conditioned.  An
///           ill-conditioned matrix usually results from non-capacitive nodes that are isolated
///           from any other sources.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method outputs the potential vector solution to the nodes and link objects.
///           Similar to how we copy in the link's contributions to the system of equations, this
///           method uses the link's node mapping to know where in the potential vector solution to
///           copy to the link ports from.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] convergedStep (--) The # of minor steps since the network last converged
/// @param[in] minorStep     (--) The absolute minor step # that the network is on
///
/// @details  This method calls the non-linear links to adjust themselves in response to the network
///           reverting to the previous minor step solution.  The links can take action, if
///           necessary, to get a better solution on the next minor step.  Any link that reports a
///           problem with this action causes a counter to be incremented and warning message sent,
///           but there is no other affect on the network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method resets the potential vector to the last saved minor step solution.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method saves the new minor step potential solution for later.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method resets the potential vector to the last saved major step solution.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method saves the new major step potential solution for later.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method copies the diagonal or desired row of the admittance matrix into a saved
///           array for debugging.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] minorStep (--) The absolute minor step # that the network is on
///
/// @details  This method copies a node's potential for each minor step into a saved array for
///           debugging.  The 0'th position stores the node number for reference.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method clears the node minor step potentials debug array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws    TsOutOfBoundsException
///
/// @returns   std::string (--) The mSolverMode enumerated state as a descriptive string.
///
/// @details   Returns the current solver mode enumeration state as a string, or throws an exception
///            if the enumeration is an invalid state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws    TsOutOfBoundsException
///
/// @returns   std::string (--) The mIslandMode enumerated state as a descriptive string.
///
/// @details   Returns the current island mode enumeration state as a string, or throws an exception
///            if the enumeration is an invalid state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws    TsOutOfBoundsException
///
/// @returns   std::string (--) The mRunMode enumerated state as a descriptive string.
///
/// @details   Returns the current run mode enumeration state as a string, or throws an exception if
///            the enumeration is an invalid state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                  (--)  Link name
/// @param[in] nodes                 (--)  Network nodes array
/// @param[in] maxConductivity       (m2)  Maximum possible effective conductivity of the link
/// @param[in] expansionScaleFactor  (--)  Isentropic gas expansion scale factor
/// @param[in] filterMinConductivity (m2)  Minimum filtered effective conductivity of the link
/// @param[in] filterMinDeltaP       (kPa) Minimum filtered supply delta pressure
/// @param[in] filterCapacitanceGain (--)  Gain for estimated capacitance filter (0-1)
/// @param[in] externalConfig        (--)  Pointer to the external network fluid config
/// @param[in] convertToType         (--)  Fluid type to convert extra external constituents into
///
/// @details  Default GUNNS Fluid External Demand Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @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] supplyCapacitance     (kg*mol/kPa) Initial supply temperature
/// @param[in] supplyTemperature     (K)          Initial supply temperature
/// @param[in] supplyMassFractions   (--)         Initial supply mass fractions
/// @param[in] supplyTcMoleFractions (--)         Initial supply trace compounds mole fractions
///
/// @details  Default GUNNS Fluid External Demand Input Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Input source to copy
///
/// @details  Copy constructs this Fluid External Demand input data.
///
/// @note  This is a shallow copy, mSupplyMassFractions will point to the same address as the source
///        object's pointer.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default GUNNS Fluid External Demand Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default GUNNS Fluid External Demand Destructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Handles data read from the external network's supply link, via the sim bus.  Data is
///          moved from the sim bus input members into the link internal members.  If the supply
///          network runs at a different rate than this network, we always want the latest supply
///          properties regardless of how often it runs, therefore we don't use a queue in the sim
///          bus.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] port (--) The port to be assigned
/// @param[in] node (--) The desired node to assign the port to
///
/// @returns  bool  (--) Returns true if all rules checks pass
///
/// @details  Checks the requested port & node arguments for validity against rules that apply to
///           this specific class.  These are:
///           - A GunnsFluidExternalDemand must map port 0 to the network vacuum node.
///           - A GunnsFluidExternalDemand must not map port 1 to the network vacuum node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                 (--) Link name.
/// @param[in] nodes                (--) Network nodes array.
/// @param[in] maxConductivity      (m2) Maximum possible effective conductivity of the link.
/// @param[in] expansionScaleFactor (--) Scale factor for isentropic cooling across the link (0-1).
/// @param[in] plug0                (--) Pointer to jumper plug for port 0.
/// @param[in] plug1                (--) Pointer to jumper plug for port 1.
/// @param[in] selfSealing0         (--) Plug 0 self-seals when un-plugged.
/// @param[in] selfSealing1         (--) Plug 1 self-seals when un-plugged.
///
/// @details  Constructs the Fluid Jumper Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy from.
///
/// @details  Copy Constructs the Fluid Jumper Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--)   Blockage malfunction flag.
/// @param[in] malfBlockageValue (--)   Blockage malfunction fractional value (0-1).
/// @param[in] malfLeakRateFlag  (--)   Leak-thru malfunction flag.
/// @param[in] malfLeakRateValue (kg/s) Leak-thru malfunction value.
/// @param[in] connection0       (--)   Index of the initial plug 0 socket.
/// @param[in] connection1       (--)   Index of the initial plug 1 socket.
///
/// @details  Default constructs this Fluid Jumper input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy constructs this Fluid Jumper input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Fluid Jumper Object
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Reference to Link Config Data.
/// @param[in]     inputData    (--) Reference to Link Input Data.
/// @param[in,out] networkLinks (--) Reference to the Network Link Vector.
/// @param[in]     port0        (--) Port 0 Mapping.
/// @param[in]     port1        (--) Port 1 Mapping.
///
/// @throws   TsInitializationException
///
/// @details  Initializes the Fluid Jumper with config and input data.
//////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inputData (--) Link input data.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Validates the jumper input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] flag  (--)   Malfunction activation flag, true activates
/// @param[in] value (kg/s) Initial malfunction leak rate
///
/// @details  Sets the malf leak rate flag and value to given parameters.  Calling this method with
///           default arguments resets the malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                 (--) Link name
/// @param[in] nodes                (--) Network nodes array
/// @param[in] maxConductivity      (m2) Maximum possible effective conductivity of the link
/// @param[in] expansionScaleFactor (--) Scale factor for isentropic cooling across the link (0-1)
///
/// @details  Default GUNNS Fluid Potential Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @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
///
/// @details  Default GUNNS Fluid Potential Input Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Input source to copy
///
/// @details  Copy constructs this Fluid Potential input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default GUNNS Fluid Potential Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Reference to link Config Data
/// @param[in]     inputData    (--) Reference to link Input Data
/// @param[in,out] networkLinks (--) Network links
/// @param[in]     port0        (--) Network port 0
/// @param[in]     port1        (--) Network port 1
///
/// @throws   TsInitializationException
///
/// @details  This method initializes this Fluid Potential link with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Updates the Admittance and Source terms for the potential source
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name  (--) Link name
/// @param[in] nodes (--) Network nodes array
///
/// @details  Constructs the Basic Source Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy Constructs the Basic Source Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--) Blockage malfunction flag
/// @param[in] malfBlockageValue (--) Blockage malfunction fractional value (0-1)
/// @param[in] sourceFlux        (--) Initial demanded flux of the link
///
/// @details  Default constructs this Basic Source input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Constructs the Basic Source Object
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Link Config Data
/// @param[in]     inputData    (--) Link Input Data
/// @param[in,out] networkLinks (--) Reference to the Solver Links
/// @param[in]     port0        (--) Port 0 Node Mapping
/// @param[in]     port1        (--) Port 1 Node Mapping
///
/// @throws   TsInitializationException
///
/// @details This initializes the link and sets up its connectivity to the network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Computes the flows across the link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                (--) Link name
/// @param[in] nodes               (--) Network nodes array
/// @param[in] defaultConductivity (--) Default conductivity of the link
///
/// @details  Constructs the Basic Conductor Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy from
///
/// @details  Copy Constructs the Basic Conductor Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--) Blockage malfunction flag
/// @param[in] malfBlockageValue (--) Blockage malfunction fractional value (0-1)
///
/// @details  Default constructs this Basic Conductor input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Basic Conductor Object
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details  Updates the basic conductor during the time step
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Protected method for building the conductance into the system of equations.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                 (--) Link name.
/// @param[in] nodes                (--) Network nodes array.
/// @param[in] maxConductivity      (m2) Maximum possible effective conductivity of the link.
/// @param[in] expansionScaleFactor (--) Scale factor for isentropic cooling across the link (0-1).
/// @param[in] selfSealing          (--) Self-seals when disconnected.
///
/// @details  Constructs the Fluid Socket Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy from.
///
/// @details  Copy Constructs the Fluid Socket Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--)   Blockage malfunction flag.
/// @param[in] malfBlockageValue (--)   Blockage malfunction fractional value (0-1).
/// @param[in] malfLeakRateFlag  (--)   Leak-thru malfunction flag.
/// @param[in] malfLeakRateValue (kg/s) Leak-thru malfunction value.
///
/// @details  Default constructs this Fluid Socket input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy constructs this Fluid Socket input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Fluid Socket Object
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Reference to Link Config Data
/// @param[in]     inputData    (--) Reference to Link Input Data
/// @param[in,out] networkLinks (--) Reference to the Network Link Vector
/// @param[in]     port0        (--) Port 0 Mapping
/// @param[in]     port1        (--) Port 1 Mapping
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Initializes the Fluid Socket with config and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inputData (--) Link input data.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Validates the socket input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  During load initialization, there is an order dependency between GunnsFluidSocket and
///           GunnsFluidJumper objects.  The socket links must be initialized before the jumper
///           links, so that the sockets can return the proper nodes when the jumpers make their
///           initial socket requests.  To ensure that the order is correct, requestConnection and
///           requestDisconnection methods call this method before proceeding.  This method checks
///           the link's initialization flag and if it hasn't been set, an exception is thrown.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] plug (--) Pointer to the plug requesting the connection.
///
/// @returns  (--) Index of the Node to connect to.
///
/// @throws   TsInvalidStateTransitionException
///
/// @details  Processes a request from a GUNNS jumper plug to connect to the GUNNS Basic Node this
///           GUNNS Fluid Socket link is connected to on port 0.  If the request is granted (there
///           is not another plug already connected), the index of the port 0 Node is returned, and
///           the socket stores the address of the plug as its active connection, otherwise an
///           exception is thrown which will cause the jumper to fail to connect to the node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] plug (--) Pointer to the plug requesting the disconnection.
///
/// @returns  (--) Index of the Node to connect to.
///
/// @details  Processes a request from a GUNNS jumper plug to disconnect from the GUNNS Basic Node
///           this GUNNS Fluid Socket link is connected to on port 0.  The index of the ambient node
///           is always returned, so an unconnected plug may be moved from one ambient node to
///           another.  The socket's connection pointer is only reset to null if the plug was
///           the one actually connected.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Updates the socket's conductivity based on connection state, leak-thru malfunction and
///           whether it is self-sealing.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name              (--) Instance name for self-identification in messages.
/// @param[in] minRange          (--) Minimum sensed output value, in output units.
/// @param[in] maxRange          (--) Maximum sensed output value, in output units.
/// @param[in] offValue          (--) Sensed output value when the sensor is off, in output units.
/// @param[in] nominalBias       (--) Nominal bias in the sensed output, in output units.
/// @param[in] nominalScale      (--) Nominal scale factor applied to the sensed output.
/// @param[in] nominalNoiseScale (--) Nominal constant noise amplitude in the sensed output, in output units.
/// @param[in] nominalResolution (--) Nominal sensor resolution, in output units.
/// @param[in] noiseFunction     (--) Pointer to noise function for this sensor.
/// @param[in] unitConversion    (--) Unit conversion type to convert truth input to output units.
/// @param[in] nominalNoiseMult  (--) Nominal input-scaling noise amplitude in the sensed output, in fraction of total sensor output range.
///
/// @details  Default constructs this GUNNS Analog Sensor Wrapper Spotter configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] powerFlag  (--) Initial powered state of the sensor.
/// @param[in] truthInput (--) Initial value of the input truth value to sense.
///
/// @details  Default constructs this GUNNS Analog Sensor Wrapper Spotter input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Default constructs this GUNNS Analog Sensor Wrapper Spotter.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  configData  (--)  Instance configuration data.
///
/// @returns  GunnsSensorAnalogWrapperConfigData (--) 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  GunnsSensorAnalogWrapperInputData (--) 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.
///
/// @details  Updates the sensor prior to the network solver update and solution.  Only updates the
///           sensor if the pre-step control flag is set.  If the post-step flag is also set, the
///           post-step option takes priority over pre-step so we won't step here.  We don't allow
///           the sensor to be updated at both times because this would double up its drift malf
///           integration.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Execution time step.
///
/// @details  Updates the sensor after the network solver update and solution if the post-step
///           control flag is set.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Builds the source vector terms of the links contribution to the network.  This sign
///          convention creates positive flow from port 0 to port 1.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Class attribute resets common to both initialization and restart.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt   (s)  Integration time step
/// @param[in] flux (--) Generic flux through the link
///
/// @details  Dummy placeholder for derived classes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt        (s)  Frame delta time
/// @param[in] minorStep (--) The minor step number that the network is on
///
/// @details  Dummy placeholder for derived classes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] convergedStep (--) The # of minor steps since the network last converged
/// @param[in] absoluteStep  (--) The absolute minor step number that the network is on
///
/// @return SolutionResult (--) Returns whether the link confirms, rejects, or delays the solution.
///
/// @details  Dummy placeholder for derived classes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] convergedStep (--) The # of minor steps since the network last converged
/// @param[in] absoluteStep  (--) The absolute minor step number that the network is on
///
/// @return   bool  --  Returns true if the link successfully returned to the previous minor step
///
/// @details  Dummy placeholder for derived classes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] port (--) The port to be assigned
/// @param[in] node (--) The desired node to assign the port to
///
/// @return   bool  --  Returns true if all link-specific rules checks pass
///
/// @details  Dummy placeholder for derived classes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name  (--)  Instance name for self-identification in messages.
///
/// @details  Default constructs this GUNNS Network Spotter configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Network Spotter.
////////////////////////////////////////////////////////////////////////////////////////////////////