////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Showmate curve fit model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    a     (--) First coefficient for curve fit model.
/// @param[in]    b     (--) Second coefficient for curve fit model.
/// @param[in]    c     (--) Third coefficient for curve fit model.
/// @param[in]    d     (--) Fourth coefficient for curve fit model.
/// @param[in]    e     (--) Fifth coefficient for curve fit model.
/// @param[in]    minX  (--) Curve fit model valid range lower limit for first variable.
/// @param[in]    maxX  (--) Curve fit model valid range upper limit for first variable.
/// @param[in]    name  (--) name for the instance.
///
/// @throws   TsInitializationException
///
/// @note     The coefficients are for an input argument that will be scaled by 0.001.
///
/// @details  Constructs this Showmate curve fit model taking coefficient, range and name arguments.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    a     (--) First coefficient for curve fit model.
/// @param[in]    b     (--) Second coefficient for curve fit model.
/// @param[in]    c     (--) Third coefficient for curve fit model.
/// @param[in]    d     (--) Fourth coefficient for curve fit model.
/// @param[in]    e     (--) Fifth coefficient for curve fit model.
/// @param[in]    minX  (--) Curve fit model valid range lower limit for first variable.
/// @param[in]    maxX  (--) Curve fit model valid range upper limit for first variable.
/// @param[in]    name  (--) name for the instance.
///
/// @throws   TsInitializationException
///
/// @note     The coefficients are for an input argument that will be scaled by 0.001.
///
/// @details  Initializes this Showmate curve fit model taking coefficient, range and name arguments.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Inverse Quadratic fit model taking coefficient and range
///           arguments.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    a     (--) First coefficient for curve fit model.
/// @param[in]    b     (--) Second coefficient for curve fit model.
/// @param[in]    c     (--) Third coefficient for curve fit model.
/// @param[in]    minX  (--) Curve fit model valid range lower limit for first variable.
/// @param[in]    maxX  (--) Curve fit model valid range upper limit for first variable.
/// @param[in]    name  (--) name for the instance.
///
/// @throws   TsInitializationException
///
/// @details  Constructs this Inverse Quadratic fit model taking coefficient, range arguments and a name.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    a     (--) First coefficient for curve fit model.
/// @param[in]    b     (--) Second coefficient for curve fit model.
/// @param[in]    c     (--) Third coefficient for curve fit model.
/// @param[in]    minX  (--) Curve fit model valid range lower limit for first variable.
/// @param[in]    maxX  (--) Curve fit model valid range upper limit for first variable.
/// @param[in]    name  (--) name for the instance.
///
/// @throws   TsInitializationException
///
///
/// @details  Initializes this Inverse Quadratic fit model taking coefficient, range arguments and a name.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Interpolator unit-test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Linear Interpolator.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Bilinear Interpolator.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test initialization exception for an unordered array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Linear curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Quadratic curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Cubic curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Quartic curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Quintic curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Exponential curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Rational curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Power curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Inverse Linear curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Inverse Quadratic curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Showmate curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Sutherland curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Bivariate Quotient curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Bivariate Product curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Bivariate Quadratic, Linear curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Bivariate Quadratic, Linear Inverse curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Quadratic Root curve fit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Linear fit coefficient accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Exponential curve fit initialization exception on range that contains
///           a divide by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Rational curve fit initialization exception on range that contains a
///           divide by zero or square root of a negative number.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Inverse Linear curve fit initialization exception on range that
///           contains a divide by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Inverse Quadratic curve fit initialization exception on range that
///           contains a divide by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details   Test Univariate Showmate curve fit initialization exception on range that contains a
///            divide by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Univariate Sutherland curve fit initialization exception on range that contains a
///           divide by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Bivariate Quotient curve fit initialization exception on range that contains
///           a divide by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Bivariate Quadratic Linear Inverse fit initialization exception on range that
///           contains a divide by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details   Test Univariate Quadratic Root curve fit initialization exception on range that
///            contains a negative square root.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] input       (--) Given input to the W function.
/// @param[in] convergence (--) The minimum convergence delta between iterations at which to stop iterating.
///
/// @returns  double (--) The Lambert W function principal branch result for the given input.
///
/// @throws   TsOutOfBoundsException, for invalid input ranges.
///
/// @details  Checks for valid range of input, computes the initial value for the iteration method,
///           calls the improve function to iterate on the initial value until convergence, and
///           returns its result.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] input       (--) Given input to the W function.
/// @param[in] convergence (--) The minimum convergence delta between iterations at which to stop iterating.
///
/// @returns  double (--) The Lambert W function non-principal branch result for the given input.
///
/// @throws   TsOutOfBoundsException, for invalid input ranges.
///
/// @details  Checks for valid range of input, computes the initial value for the iteration method,
///           calls the improve function to iterate on the initial value until convergence, and
///           returns its result.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] input (--) Given input to the W function.
///
/// @throws   TsOutOfBoundsException, for invalid input ranges.
///
/// @details  Throws exception if the given input value is less then -1/e.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     input       (--) Given input to the W function.
/// @param[in]     initial     (--) Initial value on the desired branch.
/// @param[in]     convergence (--) The minimum convergence delta between iterations at which to stop iterating.
///
/// @returns  double (--) The converged Lambert W function result.
///
/// @details  Iterates on the initial value until the desired convergence is reached or the max
///           iteration limit is reached.  This uses the quadratic-rate recursive formula of Iacono
///           and Boyd (see reference), which converges to the W function on either branch, provided
///           an initial value on the desired branch.  This assumes the caller avoids troublesome
///           input ranges: near zero for either branch, very large values for the principal branch,
///           and invalid range (< -1/e) for either branch.  Convergence is assured everywhere else,
///           except near -1/e.  For inputs near -1/e for both branches, the method doesn't converge
///           so once the max iterations has been reached, stop and return the last best value.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] input (--) Given input to the W function.
///
/// @returns  double (--) The Lambert W function principal branch result for the given input.
///
/// @throws   TsOutOfBoundsException, for invalid input ranges.
///
/// @details  Checks for valid range of input, computes and returns approximate principal branch
///           solution for the given input.  Approximations are accurate to within 3% error or
///           better (see comments below for accuracy in each region).  For the input < -0.01, we
///           don't have an approximation and instead fall back on the exact solution from solveW0.
///
///           These approximations, when used, should use less compute than the solveW0 function.
///
/// @note  We have a lot of magic numbers and violate the coding standard of no magic numbers here,
///        because these are specific curve fits to a specific function, and defining constant class
///        attributes for these would be silly.  Risk is mitigated by the unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] input (--) Given input to the W function.
///
/// @returns  double (--) The Lambert W function non-principal branch result for the given input.
///
/// @throws   TsOutOfBoundsException, for invalid input ranges.
///
/// @details  Checks for valid range of input, computes and returns approximate principal branch
///           solution for the given input.  Approximations are accurate to within 1% error or
///           better (see comments below for accuracy in each region).  For the input > -1e-20, we
///           don't have an approximation and instead fall back on the exact solution from solveW1.
///
///           These approximations, when used, should use less compute than the solveW1 function.
///
/// @note  We have a lot of magic numbers and violate the coding standard of no magic numbers here,
///        because these are specific curve fits to a specific function, and defining constant class
///        attributes for these would be silly.  Risk is mitigated by the unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] input       (--) Test input value.
/// @param[in] expected    (--) Expected test result.
/// @param[in] convergence (--) Test convergence value and tolerance.
///
/// @details  Default constructs this Lambert W Function Unit Test Input Set.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the solveW0 function will return the correct solution of the Lambert W
///           principal branch.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the response of the W0 functions given invalid inputs.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the solveW1 function will return the correct solution of the Lambert W
///           non-principal branch.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the response of the W1 functions given invalid inputs.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the response of the fastSolveW0 function given valid inputs.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the response of the fastSolveW1 function given valid inputs.
////////////////////////////////////////////////////////////////////////////////////////////////////


/// @param sa line endpoint 1
/// @param sb line endpoint 2
/// @param p center of circle face 1 on cylinder
/// @param q center of circle face 2 on cylinder
/// @param r cylinder radius
/// @param x output of intersection point
///
/// @details
///   Algorithm from:
///        _Real-Time Collision Detection_ by Christer Ericson
///        Section 5.3.7
///
/// @return intersection found is true|false


/// @param p line endpoint 1
/// @param q line endpoint 2
/// @param sc sphere center
/// @param sr sphere radius
/// @param x output of intersection point
///
/// @details
///   Algorithm from:
///        _Real-Time Collision Detection_ by Christer Ericson
///        Section 5.3.2
///
///   Added:
///         * take a segment instead of a ray
///         * extra case for both intersection points behind the start
///
/// @return intersection found is true|false


/// @param p line endpoint 1
/// @param q line endpoint 2
/// @param sc spheroid center
/// @param srx spheroid x radius
/// @param sry spheroid y radius
/// @param srz spheroid z radius
/// @param x output of intersection point
///
/// @details
///   Algorithm by Robert J. Paul (L-3):
///     Transform the euclidean space such that the spheroid becomes a unit sphere,
///     then perform a sphere intersection check.  The inverse transform can then
///     be applied to the intersection point on the sphere to obtain the true
///     intersection point on the spheroid.
///
/// @return intersection found is true|false


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] x    (--) The root solution
/// @param[in]  x1   (--) Lower bound for the root
/// @param[in]  x2   (--) Upper bound for the root
/// @param[in]  tol  (--) The tolerance for convergence
///
/// @returns  int (--) The number of iterations taken.
///
/// @throws   TsOutOfBoundsException, if the root is not bracketed by x1 & x2.
/// @throws   TsNumericalException,   if method fails to converge on a root.
///
/// @details  Uses Brent's method to return a zero of a function known to lie between x1 and x2,
///           refined until its accuracy is within the given tolerance.  The function used must be
///           implemented in an override of the virtual evaluate method in this class.
///           Taken from Numerical Recipes, http://wwww.nr.com
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out] x      (--) Given root to improve
/// @param[in]     coeffs (--) Array of complex coefficients of the polynomial
/// @param[in]     size   (--) Number of coefficients, equal to polynomial order + 1
///
/// @returns  int (--) The number of iterations taken
///
/// @throws   TsNumericalException, when no zero can be found.
///
/// @details  This method uses Laguerre's method to improve a given estimate of a complex root of
///           the given complex coefficients of a polynomial of given order.
///           Taken from Numerical Recipes, http://wwww.nr.com
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Uses a 5th-order polynomial with real coefficients and a known set of real and complex
///           roots to verify the Laguerre method's ability to improve roots.  The general test
///           method is to call Laguerre with the polynomial coefficients and an initial root guess,
///           then evaluate the polynomial with the returned root and verify the result is
///           sufficiently near zero, allowing for some round-off errors.  Further tests verify the
///           Laguerre's method returns specific roots.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Uses a 3rd-order polynomial with complex coefficients to verify Laguerre's Method
///           returns valid roots.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the Laguerre's method will return with an error code if it cannot converge on
///           a root within the allowed number of iterations.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the Brent's method will return the correct root of a given function with
///           sufficient accuracy and within an acceptable number of iterations.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verifies the Brent's method error return modes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Overrides the evaluate method in BrentMethod and implements a 5th-order polynomial for
///           the solve method to use.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                (--) Link name
/// @param[in] nodes               (--) Network nodes array
/// @param[in] defaultConductivity (W/K) Default conductivity of the link
///
/// @details  Constructs the Thermal Radiation Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] viewScalar        (--) scales effective conductivity based on changing view to space
/// @param[in] malfBlockageFlag  (--) Blockage malfunction flag
/// @param[in] malfBlockageValue (--) Blockage malfunction fractional value (0-1)
///
/// @details  Default Constructs this Thermal Radiation input data.
///////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Thermal Radiation Effect
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @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 GunnsThermalRadiation
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Derived classes should call their base class implementation too.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Integration time step
///
/// @details    Method for calculating the admittance of the radiation link and sending it to base
///             class buildConductance method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                      (--) Name of given ThermalSource object.
/// @param[in] nodes                     (--) Pointer to Gunns nodes to which object connects.
/// @param[in] tuningScalar              (--) Source's electrical-to-thermal tuning scalar.
/// @param[in] fluxDistributionFractions (--) Pointer to vector of fractions that describe the flux distribution to each port.
/// @param[in] absorptivity0             (--) Absorptivity (0-1) of exterior panel to 0th radiant source.
/// @param[in] absorptivity1             (--) Absorptivity (0-1) of exterior panel to 1st radiant source.
/// @param[in] absorptivity2             (--) Absorptivity (0-1) of exterior panel to 2nd radiant source.
/// @param[in] absorptivity3             (--) Absorptivity (0-1) of exterior panel to 3rd radiant source.
/// @param[in] absorptivity4             (--) Absorptivity (0-1) of exterior panel to 4th radiant source.
/// @param[in] surfaceArea               (m2) Surface area of panel object.
///
/// @details  Constructs the Thermal Multi-Panel Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag      (--)   Blockage malfunction flag
/// @param[in] malfBlockageValue     (--)   Blockage malfunction fractional value (0-1)
/// @param[in] demandedFlux          (W)    (not used)
/// @param[in] malfFluxOverrideFlag  (--)   Override flux malfunction flag
/// @param[in] malfFluxOverrideValue (W)    Override flux malfunction value
/// @param[in] viewScalar0           (--)   Initial view scalar (0-1) to account for occultation or facing to 0th radiant source.
/// @param[in] viewScalar1           (--)   Initial view scalar (0-1) to account for occultation or facing to 1st radiant source.
/// @param[in] viewScalar2           (--)   Initial view scalar (0-1) to account for occultation or facing to 2nd radiant source.
/// @param[in] viewScalar3           (--)   Initial view scalar (0-1) to account for occultation or facing to 3rd radiant source.
/// @param[in] viewScalar4           (--)   Initial view scalar (0-1) to account for occultation or facing to 4th radiant source.
/// @param[in] incidentFlux0         (W/m2) Initial flux of 0th radiant source.
/// @param[in] incidentFlux1         (W/m2) Initial flux of 1st radiant source.
/// @param[in] incidentFlux2         (W/m2) Initial flux of 2nd radiant source.
/// @param[in] incidentFlux3         (W/m2) Initial flux of 3rd radiant source.
/// @param[in] incidentFlux4         (W/m2) Initial flux of 4th radiant source.
///
/// @details  Default constructs this Thermal Multi-Panel input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Thermal Multi-Panel Object with default values.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   configData   (--)  Link Config Data
/// @param[in]   inputData    (--)  Link Input Data
/// @param[in]   networkLinks (--)  Reference to the Solver Links
/// @param[in]   portsVector  (--)  Vector of port numbers this Panel is linked to
///
/// @throw    TsInitializationException (by base class)
///
/// @details  This initializes the link and sets up its connectivity to the network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData  (--) Configuration data.
/// @param[in]      inputData   (--) Input data.
///
/// @throw    TsInitializationException
///
/// @details  Validates the initialization of this GUNNS Thermal Multi-Panel link model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt  (s)  Integration time step (not used)
///
/// @details  This updates the link during a calculation frame, creating a fixed flux onto one or
///           more nodes.
///
///           The flux is calculated by multiplying the incident fluxes and view scalar, set by the
///           SimBus, times the optical absorptivity config data for each radiant source, summing
///           all of those radiant source absorbed flux per area, and then multiplying the whole
///           thing by panel surface area.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   index  (--)  Array index for absorptivity
///
/// @return      double (--)  Current value of absorptivity with a specified array index.
///
/// @details  Returns the absorptivity with a specified array index.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   index  (--)  Array index for mViewScalar
///
/// @return      double (--)  Current value of mViewScalar with a specified array index.
///
/// @details  Returns the mViewScalar with a specified array index.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   index  (--)   Array index for mIncidentFlux
///
/// @return      double (W/m2) Current value of mIncidentFlux with a specified array index.
///
/// @details  Returns the mIncidentFlux with a specified array index.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] numThermocouples            (--)      Number of thermocouples in series.
/// @param[in] geometryFactor              (m)       Cross-sectional area over length of each thermocouple.
/// @param[in] electricalResistivityCoeff0 (ohm*m)   0th-order coefficient of electrical resistivity of material line function of temperature.
/// @param[in] electricalResistivityCoeff1 (ohm*m/K) 1st-order coefficient of electrical resistivity of material line function of temperature.
/// @param[in] seebeckCoeff0               (V/K)     0th-order coefficient of Seebeck coefficient of material polynomial of temperature.
/// @param[in] seebeckCoeff1               (V/K2)    1st-order coefficient of Seebeck coefficient of material polynomial of temperature.
/// @param[in] seebeckCoeff2               (V/K3)    2nd-order coefficient of Seebeck coefficient of material polynomial of temperature.
/// @param[in] thermalConductivityCoeff0   (W/m/K)   0th-order coefficient of thermal conductivity of material polynomial of temperature.
/// @param[in] thermalConductivityCoeff1   (W/m/K2)  1st-order coefficient of thermal conductivity of material polynomial of temperature.
/// @param[in] thermalConductivityCoeff2   (W/m/K3)  2nd-order coefficient of thermal conductivity of material polynomial of temperature.
/// @param[in] endPlateThermalConductance  (W/K)     Thermal conductance of one end plate.
/// @param[in] minTemperature              (K)       Minimum temperature for evaluating material properties functions.
/// @param[in] maxTemperature              (K)       Maximum temperature for evaluating material properties functions.
///
/// @details  Default constructs this Thermoelectric Effect Config Data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfThermoelectricEffectsFlag  (--)  Initial thermoelectric effects scalar malfunction flag.
/// @param[in] malfThermoelectricEffectsValue (--)  Initial thermoelectric effects scalar malfunction value.
/// @param[in] current                        (amp) Initial electrical current thru the device.
/// @param[in] temperatureHot                 (K)   Initial "hot" side temperature.
/// @param[in] temperatureCold                (K)   Initial "cold" side temperature.
///
/// @details  Default constructs this Thermoelectric Effect Input Data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs the Thermoelectric Effect Object with default values.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   configData   (--)  Model Config Data.
/// @param[in]   inputData    (--)  Model Input Data.
/// @param[in]   name         (--)  Instance name for output messages.
///
/// @throw    TsInitializationException
///
/// @details  This initializes the model and validates the initialization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData  (--) Configuration data.
/// @param[in]      inputData   (--) Input data.
///
/// @throw    TsInitializationException
///
/// @details  Validates the initialization of this GUNNS Thermoelectric Effect model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Updates the state of this GUNNS Thermoelectric Effect model.  Given input electrical
///           current and end-plate temperatures, outputs electrical & thermal conductivity, Seebeck
///           effect voltage, and Joule/Peltier/Thompson effects heat sources.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name                  --  Link name
/// @param[in]  nodes                 --  Network nodes array
/// @param[in]  editCapacitanceGroup  --  Identifier for capacitance edit grouping
///
/// @details  Constructs the GunnsThermalCapacitor ConfigData
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that  -- Input Source to Copy
///
/// @details  Copy Constructs the GunnsThermalCapacitor ConfigData
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag         (--)  Blockage malfunction flag
/// @param[in] malfBlockageValue        (--)  Blockage malfunction fractional value (0-1)
/// @param[in] capacitance              (J/K) Thermal capacitance of the link
/// @param[in] potential                (K)   Initial potential (temperature) of the capacitive node
/// @param[in] temperatureOverrideFlag  (--)  Flag to activate temperature override
/// @param[in] temperatureOverrideValue (K)   Value at which to override temperature
///
/// @details  Default constructs this GunnsThermalCapacitor input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that  --  Object to copy
///
/// @details  Copy constructs this GunnsThermalCapacitor InputData.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default GunnsThermalCapacitor 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 GunnsThermalCapacitor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      inputData   (--) Input data.
///
/// @throw   TsInitializationException
///
/// @details  Validates the GunnsThermalCapacitor's initialization data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    dt   (s)  Integration time step (not used)
///
/// @details  Updates the state of the GunnsThermalCapacitor, called from within
///           GunnsBasicCapacitor::step(). This method finds the sum of the entries in the
///           mExternalHeatFlux array. This sum is then used to update the link's
///           mPotentialVector[0], which is the temperature of the link's non-vacuum node. The
///           buildCapacitance() method in the parent-class computes the link's mSourceVector
///           based on the mPotentialVector, therefore the mSumExternalHeatFluxes is
///           communicated up into the source vector by the parent-class, for use later by GUNNS.
///
///           For the special case where the GunnsThermalCapacitor is in a "dummy" GUNNS
///           network, it must be able to solve for its own potential. When the link is in
///           a standard network, GUNNS will solve for this potential and overwrite the
///           value determined here. The effect of the ExternalHeatFluxes, however, will still be
///           accounted for in the mSourceVector array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Prepares the object for simbus write by updating the mTemperature of the capacitor.
///           The processOutputs() method is the very last call by the Gunns::step() method. It
///           overwrites the virtual method in the BasicLink base-class. When the
///           GunnsThermalCapacitor is in a real GUNNS network that gets solved, the simbus needs
///           an updated temperature that reflects the new value of PotentialVector[0].
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Sets the external heat flux at the given index to the given flux value.  An exception
///           is thrown if the index is out of range.
///
/// @throws   TsOutOfBoundsException
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  mPotentialVector[0]    (K)  potential of link's non-vacuum node
///
/// @details  A getter for the value of the temperature at the link's non-vacuum node.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Thermal Capacitor Heat Queue data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  capacitor  (--)  Reference to the thermal capacitor link.
///
/// @details Default constructs this GUNNS Thermal Capacitor Heat Queues Spotter.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  configData  (--)  Instance configuration data.
/// @param[in]  inputData   (--)  Instance input data.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this GUNNS Thermal Capacitor Heat Queues Spotter with its configuration
///           and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  configData  (--)  Instance configuration data.
///
/// @returns  GunnsThermalCapacitorHeatQueuesConfigData (--) 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  GunnsThermalCapacitorHeatQueuesInputData (--) Type-casted and validated input data pointer.
///
/// @throws   TsInitializationException
///
/// @details  Type-casts the base input data class pointer to this spotter's input data type,
///           checks for valid type-cast and validates contained data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Execution time step (not used).
///
/// @details  For each queue, if the queue has data in it then use the SimBusQutils to get the
///           average heat in the queue and give this average to the thermal capacitor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                   (--)    Instance name for output messages.
/// @param[in] nodes                  (--)    Network nodes array.
/// @param[in] phaseChangeTemperature (K)     Temperature at which the thermal battery medium changes phase.
/// @param[in] phaseChangeHeat        (J/g)   Heat of phase change of the thermal battery medium.
/// @param[in] hotPhaseSpecificHeat   (J/g/K) Specific heat of the thermal battery medium in the hotter phase.
/// @param[in] coldPhaseSpecificHeat  (J/g/K) Specific heat of the thermal battery medium in the colder phase.
/// @param[in] structureCapacitance   (J/K)   Thermal capacitance of non-phase changing structure.
///
/// @details  Default constructs this Thermal Phase Change Battery link Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] mass                 (kg)   Initial mass of the phase-changing thermal battery medium.
/// @param[in] temperature          (K)    Initial temperature of the thermal battery medium.
/// @param[in] hotPhaseFraction     (--)   Initial mass fraction (0-1) of the phase-changing thermal battery medium in the hotter phase.
/// @param[in] malfHotPhaseLeakFlag (--)   Initial hot phase mass leak malfunction activation flag.
/// @param[in] malfHotPhaseLeakRate (kg/s) Initial hot phase mass leak malfunction leak rate.
///
/// @details  Default constructs this Thermal Phase Change Battery link input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Thermal Phase Change Battery link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Reference to Link Config Data.
/// @param[in,out] inputData    (--) Reference to Link Input Data.
/// @param[in,out] networkLinks (--) Reference to the Network Link Vector.
/// @param[in]     port0        (--) Port 0 Mapping.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Thermal Phase Change Battery link with config and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Reference to Link Config Data.
/// @param[in,out] inputData    (--) Reference to Link Input Data.
///
/// @throws   TsInitializationException
///
/// @details  Checks config & input values for valid ranges and throws exceptions for out of range.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step.
///
/// @details  Updates this Thermal Phase Change Battery link's contributions to the network system
///           of equations.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step.
///
/// @details  Updates the link admittance depending on the battery material phase.  When in single-
///           phase, this link acts like a normal thermal capacitor on the Port 0 node.  When in
///           mixed-phase, this link acts like an ideal potential source to constrain the Port 0
///           node to the phase-change temperature.
///
///           This also integrates heat fluxes into the new battery temperature for when the network
///           is in DUMMY mode.  This is overwritten by the network solution in NORMAL network mode.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  double (J/K) Link capacitance.
///
/// @details  If the battery is in mixed-phase, then this returns just the structural capacitance.
///           If in single-phase, then it adds the thermal capacitance of all of the phase-change
///           mass in that phase.  The caller can cmopare the result to the structural capacitance
///           to determine whether the battery is in single- or mixed-phase.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] temperature (K) Desired temperature to set.
///
/// @details  The link's temperature and Port 0 potential vector are set to the given value.  The
///           attached node's potential is also set if this is not the network Ground node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step.
///
/// @details  Updates the link state in response to flows resulting from the network solution.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] fromPort (--) Not used.
/// @param[in] toPort   (--) Not used.
///
/// @details This updates the flux values in the attached node, so the node can check that KCL is
///          satisfied.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt   (s) Integration time step.
/// @param[in] flux (W) Not used.
///
/// @details  Updates the hot phase mass fraction, total mass and actual leak rate in response to
///           heat fluxes and the hot phase leak malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step.
///
/// @details  Updates the hot phase mass fraction during phase change.
///
/// @note     The caller must ensure that mPhaseChangeHeat and mMass are > 0 to avoid dividing by
///           zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step.
///
/// @details  Models the hot phase leak malfunction and updates the phase-change mass in response.
///
/// @note     The caller must ensure that mMass is > 0 to avoid dividing by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Zeroes the external heat fluxes array and the sum.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Sums the external heat fluxes array into the mSumExternalHeatFluxes term.
////////////////////////////////////////////////////////////////////////////////////////////////////


/**************************************************************************************************/
/* ConfigData class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name             (--)   name of given ThermalSource object
/// @param[in]  nodes            (--)   pointer to Gunns nodes to which object connects
/// @param[in]  tuningScalar     (--)   source's electrical-to-thermal tuning scalar
/// @param[in]  fluxDistributionFractions (--)   pointer to vector of fractions that describe the
///                                              flux distribution to each port
///
/// @details  Constructs this GunnsThermalSource ConfigData.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that  (--)   input source to copy
///
/// @details  Copy constructs this GunnsThermalSource ConfigData.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  fractions     (--)   new flux distribution fractions
/// @param[in]  numFractions  (--)   number of new flux distribution fractions
///
/// @details  Overrides the flux distribution fractions for this GunnsThermalSource ConfigData.
///           Intended to be called from input file.
////////////////////////////////////////////////////////////////////////////////////////////////////


/**************************************************************************************************/
/* InputData class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    malfBlockageFlag       (--)   Blockage malfunction flag
/// @param[in]    malfBlockageValue      (--)   Blockage malfunction fractional value (0-1)
/// @param[in]    demandedFlux           (W)    Initial demanded flux of the link
/// @param[in]    malfFluxOverrideFlag   (--)   Override flux malfunction flag
/// @param[in]    malfFluxOverrideValue  (W)    Override flux malfunction value
///
/// @details  Default constructs this GunnsThermalSource InputData.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that  (--)  Object to copy
///
/// @details  Copy constructs this GunnsThermalSource InputData.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Constructs the GunnsThermalSource with default values
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData   (--)  Configuration data.
/// @param[in]      inputData    (--)  Input data.
///
/// @throw   TsInitializationException
///
/// @details  Validates the initialization of this GUNNS ThermalSource link model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details This updates the link during a calculation frame.
///          This class creates a fixed flux between two nodes.  One of the nodes may be
///          GROUND, or both may be normal network nodes.  Flow direction is defined positive
///          from Port0 to Port1, so it is best to use Port0 as the GROUND node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    dt  (s)  Integration time step [not used]
///
/// @details  Updates the state of the GunnsThermalSource. This method does nothing but is a
///           placeholder for derived classes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Builds the source vector terms of the link's contribution to the network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    dt  (s)  Integration time step [not used]
///
/// @details  Makes calls to accumulate flux in the input/output terms of the receiving nodes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Loops through ports, finding the temperature at each node. These are averaged to
///           determine the AvgPortTemperature.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    port  (--)  The port to be assigned
/// @param[in]    node  (--)  The desired node to assign the port to
///
/// @return   boolean (--) 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 GunnsThermalSource must not map any port to the network vacuum boundary node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] flag  (--) Malfunction activation flag, true activates.
/// @param[in] index (W)  Malfunction value for heat flux override.
///
/// @details  Sets the malf parameters to the given values.  Calling this method with default
///           arguments resets the malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    name                 --  Link name
/// @param[in]    nodes                --  Network nodes array
/// @param[in]    defaultConductivity  --  Default conductivity of the link
///
/// @details  Constructs the Thermal Potential Config data
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   that -- Object to copy from
///
/// @details  Copy Constructs the Thermal Potential Config data
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @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 Thermal Potential input data.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that  --  Object to copy
///
/// @details  Copy constructs this Thermal Potential input data.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Thermal Potential 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 Thermal Potential link with config and input data.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] port  (--) The port to be assigned
/// @param[in] node  (--) The desired node to assign the port to
///
/// @returns   boolean -- 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 GunnsThermalPotential must map port 0 to the network's vacuum boundary node.
///            -A GunnsThermalPotential must not map port 1 to the network's vacuum boundary node.
///////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] flag  (--) Malfunction activation flag, true activates.
/// @param[in] value (--) Malfunction scale factor value.
///
/// @details Sets the thermoelectric effects scale malf to the given state.  Calling this method
///          with default arguments resets the malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


/**************************************************************************************************/
/* ConfigData class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name             (--)   name of given ThermalHeater object
/// @param[in]  nodes            (--)   pointer to Gunns nodes to which object connects
/// @param[in]  tuningScalar     (--)   heater's electrical-to-thermal tuning scalar
/// @param[in]  fluxDistributionFractions (--)   pointer to vector of fractions that describe the
///                                              flux distribution to each port
///
/// @details  Constructs this GunnsThermalHeater ConfigData
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that  (--)   input source to copy
///
/// @details  Copy Constructs this GunnsThermalHeater ConfigData
////////////////////////////////////////////////////////////////////////////////////////////////////


/**************************************************************************************************/
/* InputData class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    malfBlockageFlag      (--)   Blockage malfunction flag
/// @param[in]    malfBlockageValue     (--)   Blockage malfunction fractional value (0-1)
/// @param[in]    demandedFlux          (W)    Initial demanded flux of the link
/// @param[in]    malfFluxOverrideFlag  (--)   Heat flux override malfunction flag
/// @param[in]    malfFluxOverrideValue (W)    Heat flux override malfunction value
///
/// @details  Default constructs this GunnsThermalHeater InputData.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    that  (--)  Object to copy
///
/// @details  Copy constructs this GunnsThermalHeater InputData.
////////////////////////////////////////////////////////////////////////////////////////////////////


/**************************************************************************************************/
/* GunnsThermalHeater class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Constructs the GunnsThermalHeater with default values
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]        configData   (--)  Source configuration data
/// @param[in]        inputData    (--)  Source input data
/// @param[in,out]    networkLinks (--)  Network link vector
/// @param[in]        portsVector  (--)  Vector of port numbers this Heater is linked to
///
/// @throw    TsInitializationException by base class initialize() or validate()
///
/// @details  This initializes the GunnsThermalHeater and sets up its connectivity to the network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    dt  (s)  Integration time step [not used]
///
/// @details  Updates the state of the GunnsThermalHeater. If this heater is attached to a heater
///           control card, the network's HeaterCardInterface sets the electrical power using the
///           setPowerElectrical() method. Otherwise, the power should be written by the sim_bus.
///
///           The main purpose of the method is simply to set the link's flux to be equal to the
///           electric power in Watts times a electrical-to-thermal tuning scalar. The flux
///           demand is the actual heat rate in Watts that will be added to the thermal system.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                        (--)      Instance name for output messages.
/// @param[in] nodes                       (--)      Network nodes array.
/// @param[in] numThermocouples            (--)      Number of thermocouples in series.
/// @param[in] geometryFactor              (m)       Cross-sectional area over length of each thermocouple.
/// @param[in] electricalResistivityCoeff0 (ohm*m)   0th-order coefficient of electrical resistivity of material line function of temperature.
/// @param[in] electricalResistivityCoeff1 (ohm*m/K) 1st-order coefficient of electrical resistivity of material line function of temperature.
/// @param[in] seebeckCoeff0               (v/K)     0th-order coefficient of Seebeck coefficient of material polynomial of temperature.
/// @param[in] seebeckCoeff1               (v/K2)    1st-order coefficient of Seebeck coefficient of material polynomial of temperature.
/// @param[in] seebeckCoeff2               (v/K3)    2nd-order coefficient of Seebeck coefficient of material polynomial of temperature.
/// @param[in] thermalConductivityCoeff0   (W/m/K)   0th-order coefficient of thermal conductivity of material polynomial of temperature.
/// @param[in] thermalConductivityCoeff1   (W/m/K2)  1st-order coefficient of thermal conductivity of material polynomial of temperature.
/// @param[in] thermalConductivityCoeff2   (W/m/K3)  2nd-order coefficient of thermal conductivity of material polynomial of temperature.
/// @param[in] endPlateThermalConductance  (W/K)     Thermal conductance of one end plate.
/// @param[in] minTemperature              (K)       Minimum temperature for evaluating material properties functions.
/// @param[in] maxTemperature              (K)       Maximum temperature for evaluating material properties functions.
///
/// @details  Default constructs this Thermoelectric Device link Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag               (--)  Blockage malfunction flag.
/// @param[in] malfBlockageValue              (--)  Blockage malfunction fractional value (0-1).
/// @param[in] malfThermoelectricEffectsFlag  (--)  Initial thermoelectric effects scalar malfunction flag.
/// @param[in] malfThermoelectricEffectsValue (--)  Initial thermoelectric effects scalar malfunction value.
///
/// @details  Default constructs this Thermoelectric Device link input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Thermoelectric Device link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Reference to Link Config Data.
/// @param[in,out] 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 this Thermoelectric Device link with config and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step.
///
/// @details  Updates this Thermoelectric Device link during the time step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Applies the heat flux outputs of the embedded thermoeletric effect as heat sources on
///           the nodes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] fromPort (--) Not used.
/// @param[in] toPort   (--) Not used.
///
/// @details This updates the flux values in the attached nodes, so the nodes can check that KCL is
///          satisfied.  There are 3 separate fluxes to be transported:
///          - the normal thermal conduction mFlux, positive from port 0 to 1.  We call the base
///            class implementation for this.
///          - heat sources from thermoelectric and Joule heating effects added to the port 0 node.
///          - heat sources from thermoelectric and Joule heating effects added to the port 1 node.
////////////////////////////////////////////////////////////////////////////////////////////////////


/**************************************************************************************************/
/* ConfigData class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name             (--)   name of given ThermalSource object
/// @param[in]  nodes            (--)   pointer to Gunns nodes to which object connects
/// @param[in]  tuningScalar     (--)   source's electrical-to-thermal tuning scalar
/// @param[in]  fluxDistributionFractions (--)   pointer to vector of fractions that describe the
///                                              flux distribution to each port
/// @param[in]  absorptivity     (--)   panel's optical absorptivity (0-1)
/// @param[in]  area             (m2)   surface area of panel object
///
/// @details  Constructs the ThermalPanel Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


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


/**************************************************************************************************/
/* InputData class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    malfBlockageFlag       (--)   Blockage malfunction flag
/// @param[in]    malfBlockageValue      (--)   Blockage malfunction fractional value (0-1)
/// @param[in]    demandedFlux           (W)    Initial demanded flux of the link
/// @param[in]    malfFluxOverrideFlag   (--)   Override flux malfunction flag
/// @param[in]    malfFluxOverrideValue  (W)    Override flux malfunction value
///
/// @details  Default constructs this ThermalPanel input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


/**************************************************************************************************/
/* GunnsThermalPanel class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the ThermalPanel Object with default values
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData  (--) Configuration data.
///
/// @throw    TsInitializationException
///
/// @details  Validates the initialization of this GUNNS ThermalPanel link model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt  (s)  Integration time step (not used)
///
/// @details  This updates the link during a calculation frame, creating a fixed flux onto one or
///           more nodes.
///
///           The flux is calculated by multiplying the incident flux, set by the SimBus, times
///           scalars based on panel configuration data (optical absorptivity and surface area).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    inputElectricalPower   (W)   value to which mPowerElectrical will be set
///
/// @details  A setter for the Thermal Heater's electrical power.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction of input data.
///////////////////////////////////////////////////////////////////////////////////////////////////


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


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


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


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the restart method.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the update method.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the setter & getter methods.
///////////////////////////////////////////////////////////////////////////////////////////////////


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction of input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test that getters and setters are working correctly.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for nominal initialization of a GunnsThermalHeater with no Card Name given.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for correct updateState() functionality.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test the step() method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test that bad data produces the appropriate exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the overrideFluxDistributionFractions method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for nominal initialization of a GunnsThermalSource with no Card Name given.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test the computeFlows() method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test that the port rules check returns the correct booleans.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test for updateState().
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test the step method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test the accessor methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Sets the test articles' incident fluxes to test values.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests processOutputs method.
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests checkSpecificPortRules method.
///////////////////////////////////////////////////////////////////////////////////////////////////


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


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the step method.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the computeFlows method.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the hot phase leak malfunction.
///////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this TsSurfaceHeatFlux. Initializes radiance vectors to a small
///           trivial value. Actual values should be set from the environment sim_bus every time-
///           step. Default components of 1.0 were chosen so it could be determined whether or not
///           the radiance values were overridden, since a zero value could be caused by a vehicle
///           in eclipse.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    lightset   requested vehicle lighting fraction (range 0-1)
///
/// @details  Sets lighting, fraction of vehicle in sunlight (range 0-1), usu. read from env sim_bus
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    givenFluxVector[3]       (W/m2)    radiance vector to be used in vector comparison
///           givenSurfaceNormal[3]      --      the surface normal vector of an exterior surface
///                                              in structural coordinate frame
///
/// @return   directFlux           (W/m2)   component of flux in surf-normal direction
///
/// @details  Finds the component of a given flux that is in the direction of the given surface's
///           normal vector
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param   vector  --   pointer to a 3D vector
///
/// @details  Validates that the magnitude of a vector is not zero, so that a dot product
///           calculation will not divide by zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param   directFlux  (W/m2)   component of flux in surf-normal direction
/// @param   radianceMag (W/m2)   magnitude of radiance flux vector
///
/// @return  directFlux  (W/m2)   validated component of flux in surf-normal direction
///
/// @details  Validates that the direct flux calculation is within the correct bounds
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    givenSurfaceNormal[3]   the surface normal vector of an exterior surface
///                                   in structural reference frame
///
/// @return   totalHeatFlux    (W/m2)   total heat flux into the surface
///
/// @details  computes Heat flux in from the environment based on env radiance vectors and an input
///           surface normal vector
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  vect   (--)   An array of 3 doubles
///
/// @return   double  (--)  The magnitude of the 3-vector
///
/// @details  Computes the magnitude of a 3-vector.  This is identical to the trick_utils macro
///           except we use DBL_EPSILON for the minimum absolute value of each component instead of
///           GSL_SQRT_DBL_MIN.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the step method
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the computeFlows method
///////////////////////////////////////////////////////////////////////////////////////////////////


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


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


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests getter and setter methods.
///////////////////////////////////////////////////////////////////////////////////////////////////


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


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


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


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the stepPreSolver method of the GunnsThermalCapacitorHeatQueues class.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test the restart method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests link update using an updateState() method.
////////////////////////////////////////////////////////////////////////////////////////////////////