////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  timeStep  (s)  Integration time step.
///
/// @details  Propagates the super-network state in run-time.  This should be called by the Trick
///           scheduled job.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name (--) Name of this instance for H&S messages.
///
/// @details  Default constructs this GUNNS Basic Super-Network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Allocates the dynamic array of basic nodes for the super-network, registers the
///           memory with Trick, and sets the super-network node list nodes pointer to this array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Initializes the super-network GUNNS solver with the basic nodes array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  type  (--)  Not used.
///
/// @throws   TsInitializationException
///
/// @details  This implementation just throws an exception.  It should never be called since this
///           class can't create a joint network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name (--) Name of this instance for H&S messages.
///
/// @details  Default constructs this GUNNS Fluid Super-Network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Allocates the dynamic array of fluid nodes for the super-network, registers the
///           memory with Trick, and sets the super-network node list nodes pointer to this array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Checks all fluid sub-networks are using identical fluid configurations, and
///           initializes the super-network fluid Ground node to NULL fluid state (vacuum).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Initializes the super-network GUNNS solver with the fluid nodes array.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config1 (--) Pointer to the first fluid configuration data object.
/// @param[in]  config2 (--) Pointer to the second fluid configuration data object.
///
/// @returns  bool (--) True if the two configs are identical, false otherwise.
///
/// @details  Checks all of the properties of the given PolyFluidConfigData except for their
///           mProperties pointer.  If any of the other properties are different, returns false,
///           otherwise true.
///
///           We considered implementing this as overriding PolyFluidConfigData's comparison
///           operator==, but in our case we don't want to compare its mProperties member and that
///           would leave the comparison incomplete from PolyFluid's perspective.
///
///           The caller must ensure neither argument is NULL.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name (--) Instance name for H&S messages.
///
/// @details  Default constructs this test article.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name (--) Instance name for H&S messages.
///
/// @details  Implements the pure virtual base method for testability.  This mimics the recommended
///           functions of a real fluid network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Implements the pure virtual base method for testability.  This mimics some of the
///           recommended functions of a real fluid network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS network base class unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS network base class default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class registerSuperNodes method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class initialize method with sub-networks.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class initialize method error handling.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS fluid super network class catching missing fluid configurations in the
///           sub-networks.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS fluid super network class catching sub-networks having different
///           number of fluid types.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS fluid super network class catching sub-networks having different
///           fluid types.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS fluid super network class catching some but not all sub-networks
///           having trace compounds configurations.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS fluid super network class catching sub-networks with different number
///           of trace compounds.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS fluid super network class catches sub-networks with different trace
///           compounds.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this test link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @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  Increments a call count.  On specific calls, throws exceptions to test
///           handling by the test article.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt (s) Integration time step (not used).
///
/// @throws  TsInitializationException, 2
///
/// @details  Increments a call count.  On specific calls, throws exceptions to test
///           handling by the test article.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws  TsInitializationException
///
/// @details  Increments a call count.  On specific calls, throws exceptions to test
///           handling by the test article.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name (--) Instance name for H&S messages.
///
/// @details  Implements the pure virtual base method for testability.  This mimics the recommended
///           functions of a real network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Implements the pure virtual base method for testability.  This mimics some of the
///           recommended functions of a real network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS network base class sub-network setup methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS network base class initialize method when a sub-network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS network base class initialize method when a standalone network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS network base class restart method when a sub-network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS network base class restart method when a standalone network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS network base class update method when a sub-network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS network base class update method when a standalone network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] type (--) Records the given type argument for verification
///
/// @details  A custom implementation for the unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class addSubNetwork method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class addSubNetwork overloaded method for adding
///           a super-network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class initialize method error handling when there
///           is a duplicated sub-network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class initialize method with no sub-networks.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class restart method with sub-networks.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class restart method error handling.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class restart with no sub-networks.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class update method with sub-networks.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class update method error handling.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class update method with no sub-networks.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class joinLocations method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS super network base class getJointIndex method.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the initialize method of the GunnsMultiLinkConnector class.  This
///           also tests its stepPostSolver method since it is called by initialize.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the addConnection method of the GunnsMultiLinkConnector class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the connect method of the GunnsMultiLinkConnector class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method tests the methods related to the joint network of the
///           GunnsMultiLinkConnector class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Defaults constructs this GUNNS Optimizer Factory.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Defaults destructs this GUNNS Optimizer Factory.  Deletes the objects we created and
///           cleans up memory.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  type  (--) Enumeration of the desired optimizer type to create.
///
/// @return   GunnsOptimBase* (--) Base class pointer to the created optimizer object.
///
/// @details  Creates a GUNNS optimizer object of type specified by the argument, and returns the
///           base class pointer to the created object.  The available optimizer class types must
///           all derive from GunnsOptimBase.  Returns NULL if the given type argument is NONE or
///           invalid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Optimization Test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inStatesMaster (--) Pointer to the MC input variables description.
///
/// @details  Increments the initialize calls counter.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] cost          (--) The cost value to assign to the particle.
/// @param[in] runId         (--) Not used.
/// @param[in] runIdReturned (--) The run ID associated with this cost value.
///
/// @throws   std::runtime_error
///
/// @details  Sets the test object variables to the given values.
////////////////////////////////////////////////////////////////////////////////////////////////////


/// @returns double (--) The result of the constraint function for the current input values.
/// @brief  Computes and returns the constraint function Z = f(X, Y);


/**< (1) Optional constraints on this variable relative to others. */
/// @param[out] state (--) Model variable to be updated with the constraint value.
/// @brief  Sets the given variable equal to the sum of the constraint functions.
/// @details  If there are no constraints, this doesn't change the state argument.


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] size (--) The number of variables to be optimized.
///
/// @details  Default constructs this GUNNS Gradient Descent Optimizer State.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Gradient Descent Optimizer configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Gradient Descent Optimizer.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Pointer to the source configuration data object to copy.
///
/// @throws   std::runtime_error
///
/// @details  Checks the given configuration data is the correct type, then copies its values into
///           our internal config data object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inStatesMaster (--) Pointer to the MC input variables description.
///
/// @throws   std::range_error, std::runtime_error
///
/// @details  Initializes this Gradient Descent Optimizer.  Validates the configuration, initializes
///           the state and run counters.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   std::range_error
///
/// @details  Unlike the rest of GUNNS, here we don't use the H&S system or TsException types and
///           opt to just throw standard exceptions.  Because this MC stuff could be used to
///           optimize non-GUNNS models, the user might not want to bother setting up the H&S.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Initializes the state by copying its values from the configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   std::runtime_error
///
/// @details  Main update function for the Gradient Descent Optimizer.  Increments the run counters,
///           updates the gradient states and propagates the global state.  The update sequence:
///           0. Start with the initial Global State
///           1. Run Global State slave and get its cost: assignCost()
///           2. Compute delta-states for the Gradients: setGradientDeltaStates()
///           3. Run Gradient slaves and compute their cost gradients as each finishes: assignCosts()
///           4. Propagate the Global State: propagateState()
///           5. Go to 1 & repeat
///
///           So, for N MC variables, the MC batch run sizes alternate between 1 for the Global and
///           2N for the gradients, so for N=4:
///              1, 8, 1, 8, 1, 8, ...
///           Contrast to PSO which is always the same:
///              30, 30, 30, 30, ...
///           TODO Since this alternating batch size is more complicated, we won't bother to
///           parallelize it until the Trick MC upgrade, and for now this implementation assumes 1
///           Slave core, all runs in series.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] gain (--) The current propagation gain.
///
/// @details  Propagates the global state.  For each N optimized variables, this chooses which of
///           its gradients to propagate along, as the gradient that has the lowest delta-cost
///           (largest negative number) of the two.  If both delta-costs are zero, then the variable
///           has reached its final value and won't be improved further.  Then the global state is
///           updated as the integral, from its previous state, of the chosen gradients.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Computes the states used to determine the gradients for each variable being optimized.
///           Starting with the state from the previous propagation run, this adds and subtracts the
///           deltas to each optimizing variable, and computes the corresponding delta-states.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] cost          (--) The cost value to assign to the particle.
/// @param[in] runId         (--) Not used.
/// @param[in] runIdReturned (--) The run ID associated with this cost value.
///
/// @throws   std::runtime_error
///
/// @details  Sets the cost function value result from the MC Slave run to the particle state that
///           was the input to that run.  The results come back from the Slave runs in a different
///           order than they are launched, because of variability in timing of the Slave runs on
///           their cores.  So we have to actively correlate the returned value with the run ID and
///           particle it corresponds to.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Outputs the current particle states to the console.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   std::runtime_error
///
/// @details  Writes the final state to the output file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name (--) Instance name for console outputs.
///
/// @details  Constructs the Monte Carlo Manager Object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   std::runtime_error
///
/// @details  Initializes the Trick MC Master role.  Should be called by a "monte_master_init" Trick
///           job.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   std::runtime_error
///
/// @details  Initializes the Trick MC Slave role.  Should be called by a "monte_slave_init" Trick
///           job.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Updates the Trick MC Master role prior to starting each Slave run.  Should be called
///           by a "monte_master_pre" Trick job.  This updates the optimizer and Slave run ID.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Updates the Trick MC Master role when each Slave run is finished.  Should be called
///           by a "monte_master_post" Trick job.  This retrieves the Slave run ID and Slave cost
///           value result from the MC Master/Slave buffer and passes them to the optimizer.  The
///           Slave runs finish in a random order from when they are launched, so we must use their
///           returned run ID to correlate their results to the optimizer state that they ran.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] value  (--) The value for which to return the cost function.
/// @param[in] target (--) The target value to compare the given value against.
/// @param[in] weight (--) The weight scalar applied to the error for this cost.
///
/// @returns  double (--) The computed cost function result.
///
/// @details  Computes the cost as the square of weighted error,
///           where weighted error = weight * (value - target).
///           This virtual function can be overriden as needed to implement other functions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Computes and stores the cost function result for each scalar target.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Shuts down the Trick MC Master role after all Slave runs and their Master post jobs
///           have finished.  Should be called by a "monte_master_shutdown" Trick job.  This
///           updates the optimizer one last time, then calls its shutdown function.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Updates the Trick MC Slave role at the end of each Slave run.  Should be called by a
///           "trick_slave_post" Trick job.  This computes the final cost function result for this
///           run, and send the result and the run ID back to the Master role through the Trick MC
///           Master/Slave buffer.
///
///           The Trick MC Master/Slave buffer is a TCP port, which has a limited buffer size
///           (8 KB, default), so it's not appropriate to use this for large amounts of data, like
///           the model output trajectories for the run.  Some MC applications save the model output
///           to Trick DP log files, but we skip all that by just computing the cost function in the
///           Slave, so we only have to send the final cost value back.  Some future users of this
///           may want to use log files, but that implementation is TBD.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Drives the inputs to the model, prior to each model step in the Slave run.  This
///           should be called by either a "scheduled" Trick job prior to the model step, or by the
///           model itself at the start of its step, before any of these inputs are used.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Updates the cost function for the Slave run after each model step.  This should be
///           called by either a "scheduled" Trick job after to the model step, or by the model
///           itself at the end of its step.  This updates the cost for each target variable
///           separately.  They will be summed and weighted in updateMasterPost().  This cost value
///           grows with accumulated error after each model step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] varName    (--) The variable name, as a string, for reporting.
/// @param[in] address    (--) Memory address of the input variable.
/// @param[in] min        (--) Minimum value of the search range for this variable.
/// @param[in] max        (--) Maximum value of the search range for this variable.
/// @param[in] constraint (--) Optional constraint on this input.
///
/// @details  This adds a Monte Carlo input variable, one that we are trying to optimize.  These
///           define the state space of the optimization search.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] varName     (--) The variable name, as a string, for reporting.
/// @param[in] address     (--) Memory address of the output variable.
/// @param[in] targetValue (--) The optional scalar target value.
/// @param[in] costWeight  (--) The relative weight of this variable in the cost function.
///
/// @details  This adds a model output variable for which we are trying to achieve its target
///           values by optimizing the input variables.  This function adds an optional scalar
///           target value, for optimizing a steady-state model.  A target trajectory for a non-
///           steady-state model can be specified with the addOutputDataRow function.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] values (--) Comma-separated string of values of all output variables at the next time step.
///
/// @details  Adds the trajectory values for the output variables for the next time step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] address     (--) Memory address of the driver variable.
///
/// @details  Adds a driver variable which is a model variable that is driven along a trajectory
///           as the run progresses.  Values for the trajectory are given in the addDriverDataRow()
///           function.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] values (--) Comma-separated string of values of all driver variables at the next time step.
///
/// @details  Adds the trajectory values for the driver variables for the next time step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] data   (--) Reference to a vector of doubles to be added to.
/// @param[in]  values (--) Comma-separated string of values.
///
/// @details  Parses the given string of comma-separted floating point values, converts them to
///           double-precision floating point format, and adds them to the given vector.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Default constructs this GUNNS Particle Swarm Optimizer particle state.  We don't trust
///         the implicit constructor to zero the initial values.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] stateSize (--) Number of dimensions in the state space.
///
/// @details  Initializes this PSO particle.  Sizes the current and best states to the number of
///           dimensions of the state space, and zeroes them.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Particle Swarm Optimizer configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Particle Swarm Optimizer.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inStatesMaster (--) Pointer to the MC input variables description.
///
/// @throws   std::range_error, std::runtime_error
///
/// @details  Initializes this PSO.  Validates the configuration, initializes the swarm states,
///           establishes maximum velocity for each state parameter, writes header rows to the
///           output files.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   std::runtime_error, std::range_error
///
/// @details  Initializes the particle states to the desired distribution.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Initializes the global best state cost and all particle's best state cost to a high
///           number for improvement during the optimization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Sets each dimension of each particle's current state position to a random value
///           within the state's min & max range.  This is a uniform random distribution.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Sets the current state of the first half of the swarm particles to (min, min, ...),
///           and the second half to (max, max, ...).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] continuous (--) If true, also reads velocity and best state.
///
/// @throws   std::runtime_error
///
/// @details  Sets the global best state and particle current states to values read from the swarm
///           state file.  The continuous argument, if set, causes us to also read the particle
///           velocities and particle personal best state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Sets each dimension of each particle's current state velocity to a random value within
///           the +/- maximum velocity for that state..  This is a uniform random distribution.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   std::runtime_error
///
/// @details  Updates the swarm between each particle run.  Each epoch runs each particle once.
///           We update the active particle pointer so that when the MC manager calls getState, we
///           return the state for the particle that's next up to run.  At the start of a new epoch,
///           the entire swarm is propagated to its next state, and the results of the previous
///           epoch are written to the output files.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Updates the personal best state of each particle, and updates the global best state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inertiaWeight (--) The current swarm inertia weight.
///
/// @details  Propagates the swarm particle states.  Acceleration vector in the state space is set
///           to a new mix of the error vectors between the current state position and the personal
///           and global best positions, weighted and given random magnitudes.  Acceleration is
///           integrated into velocity and velocity into position, as you would in physics.
///           However, velocity in each state component is limited to its maximum range.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Applies the MC input variable constraints to all particle state positions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Outputs the current global best state to the console.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   std::runtime_error
///
/// @details  Writes the final states to the output files.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Monte Carlo Optimizer Base class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vec (--) Vector of doubles to be constrained by the MC input constraints.
///
/// @throws   std::range_error
///
/// @details  Applies the MC input variable constraints to the given vector.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS optimization monte carlo manager class unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class initMaster method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class initSlave method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class updateMasterPre method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class updateMasterPost method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class updateMasterShutdown method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class updateSlavePost method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class updateSlaveInputs method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class addOutputs, addOutputDataRow,
///           and updateSlaveOutputs methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo input variable constraints.  This only tests
///           a few things not already covered by other tests, to complete code coverage.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS optimization monte carlo manager class access methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS particle swarm optimization class unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for the GUNNS particle swarm optimization particle state structure.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for the GUNNS particle swarm optimization particle structure.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization configuration data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class initialize method using the min/max
///           corners option for the initial swarm state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class initialize method using the random
///           option for the initial swarm state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class initialization method validation of
///           initial configuration and error handling.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class update and propagateSwarm methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Additional tests for GUNNS particle swarm optimization class propagateSwarm and
///           applyConstraints methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class assignCost method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class shutdown method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class initialize method using the file
///           read option for the initial swarm state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class initialize method using the file
///           read option for the initial (continued) swarm state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS particle swarm optimization class access methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS gradient descent optimization class unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for the GUNNS gradient descent optimization descent state structure.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization configuration data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization class default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization class initialize method with nominal
///           initial data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization class initialization method validation
///           of initial configuration and error handling.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization class update and propagateSwarm methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization class update method in the special case
///           state value = 0.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization class assignCost method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization class shutdown method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS gradient descent optimization class access methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] iGUNNS_N2 (--) Mass fraction of the GUNNS_N2 constituent in the composite fluid.
/// @param[in] iGUNNS_O2 (--) Mass fraction of the GUNNS_O2 constituent in the composite fluid.
///
/// @details  Constructs the mass fraction union from the scalar mass fraction arguments.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name    (--) Name of the network for H&S messages.
/// @param[in] network (--) Pointer to the main network object.
///
/// @details  Default constructs the GunnsMcModelFluid Network Config Data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] network (--) Pointer to the main network object.
///
/// @details  Default constructs the GunnsMcModelFluid Network Input Data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name (--) Name of the network for H&S messages.
///
/// @details  Default constructs the GunnsMcModelFluid Network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Example Space Vehicle Signal Aspect model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Example Space Vehicle Signal Aspect model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     This should be followed by a call to the initialize method before calling an update
///           method.
///
/// @details  Default constructs this Example Space Vehicle Signal Aspect model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name    (--)  Object name (non-empty).
///
/// @return     void
///
/// @note       All exceptions are caught and replaced with an H&S fatal message making this method
///             suitable for use as a Trick initialization task.
///
/// @details    Initializes this Example Space Vehicle Signal Aspect from config and input data.
///             - Resets the initialization complete flag.
///             - Initializes the object name or issues an H&S fatal message and returns if empty.
///             - Calls initialize to initialize the object from the configuration and input data.
///             - Calls update with zero time step to initialize the outputs.
///             - Calls isInitialized to set the initialization complete flag based on component initialization completion.
///             - Sends an H&S info message on successful initialization.
///             - Sends an H&S fatal message and returns on a TsInitializationException.
///             - Sends an H&S fatal message and returns on an unexpected exception derived from std::exception.
///             - Sends an H&S fatal message and returns on an unexpected exception not derived from std::exception.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws     TsInitializationException
///
/// @details    Initializes this Example Space Vehicle Signal Aspect from config and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   bool  (--)  True if initialization completed successfully, false otherwise.
///
/// @details  Gets this Example Space Vehicle Signal Aspect initialization complete status.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Time step.
///
/// @note       All exceptions are caught and replaced with an H&S error message making this method
///             suitable for use as a Trick scheduled task.
///
/// @details    Updates this Example Space Vehicle Signal Aspect.
///             - Sends an H&S error message and returns on an uninitialized object.
///             - Calls update to update the models.
///             - Sends an H&S error message and returns on an unexpected exception derived from std::exception.
///             - Sends an H&S error message and returns on an unexpected exception not derived from std::exception.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt (s) Execution time step.
///
/// @details    Updates this Example Space Vehicle Signal Aspect.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name             (--) Name of the network for H&S messages.
/// @param[in] network          (--) Pointer to the main network object.
///
/// @details  Default constructs the TestGunsGasTurbine Network Config Data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs the TestGunsGasTurbine Network Input Data
/// @param[in] network          (--) Pointer to the main network object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name  (--)  Name of the network for H&S messages.
///
/// @return   void
/// @details  Default constructs the TestGunsGasTurbine Network. All input and config objects are
///           constructed with argument values and the network, node and link objects are default
///           constructed.
////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name  (--) Name of the network for H&S messages.
///
/// @return   void
///
/// @details  Initialization task for the TestGunsGasTurbine Network. The network, node,
///           and link objects are initialized with their config and input data objects.
/////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////
/// @return   void
///
/// @details  Restart task for the TestGunsGasTurbine Network.
/////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   timeStep    (s)   Integration time step
///
/// @return   void
///
/// @details  Update task for the TestGunsGasTurbine Network.
/////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param   iGUNNS_N2   (--) Mass fraction of the GUNNS_N2 constituent in the composite fluid
///
/// @details  Constructs the mass fraction union from the scalar mass fraction arguments.
////////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name    (--) Name of the network for H&S messages.
/// @param[in] network (--) Pointer to the main network object.
///
/// @details  Default constructs the PvArrayRegTest Network Config Data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] network (--) Pointer to the main network object.
///
/// @details  Default constructs the PvArrayRegTest Network Input Data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name (--) Name of the network for H&S messages.
///
/// @details  Default constructs the PvArrayRegTest Network.
////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name  (--)  Name of the network for H&S messages.
///
/// @details  Default constructs the TestFluidNetworkWrapper.
/////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Prints network node properties to cout.
/////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Config data Default constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Input data Default constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData  (--) configuration data
/// @param[in] inputData   (--) initialization data
/// @throws TsInitializaton error when tolerance is too small
/// @details initializes the member variables to config & init values.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] realValue (--) actual value
/// @param[in] isPowered (--) indicates if the sensor has sufficient power to function
/// @param[in] isFailed  (--) indicates if the sensor has failed
/// @details set the sensed value
///////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////////
// @param[in] open (--) open config data
// @param[in] close (--) close config data
// @details  Config data constructor
//////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] isPowered (--) power flag - apply to both sensors
/// @details  Input data Default constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] config (--) configuration data
/// @param[in] input  (--) input data
/// @param[in] name   (--) object name
/// @throw TsInitializationException
/// @details  initialization
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] deltaTime (s)  time step
/// @param[in] isPowered (--) flag indicating sensors has adequate power
/// @param[in] position  (--) valve position
/// @details updates the open & close sensor given the position, powered flag and internal
/// sensor failure flags.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] offValue  (--) Sensed output value of the sensor when off
/// @param[in] target    (--) Target value of truth input to trigger sensor
/// @param[in] tolerance (--) Tolerance range of truth input to target to trigger sensor
///
/// @details  Constructs Analog Input Boolean Sensor config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy constructs Analog Input Boolean Sensor config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] powerFlag        (--) Initial powered state of the sensor
/// @param[in] truthInput       (--) Initial value of the input truth value to sense (boolean)
/// @param[in] truthInputAnalog (--) Initial value of the input truth value to sense (analog)
///
/// @details  Default constructs this Analog Input Boolean Sensor input data.  The malfunction terms
///           are only present in the input data class to support unit testing of parent objects
///           that contain this sensor in an aggregate.  We deliberately omit them as arguments to
///           this constructor to reduce cluttering the method signature.  Users can still set the
///           malfunction input data after the object has been constructed and before the sensor is
///           initialized.
///
/// @note     In this class, truthInput is not used, use truthInputAnalog instead.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Analog Input Boolean Sensor object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Sensor Base config data.
/// @param[in] inputData  (--) Sensor Base input data.
/// @param[in] name       (--) Name of the sensor for output messages.
///
/// @throws TsInitializationException
///
/// @details  Initializes the Analog Input Boolean Sensor object with config and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This class currently has nothing to validate.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] timeStep   (s)  Execution time step.
/// @param[in] powerFlag  (--) Desired power state, true = powered, false = unpowered.
/// @param[in] truthInput (--) The truth input analog value to the sensor.
///
/// @returns  bool (--) The sensed output value.
///
/// @details  This is a convenience method intended to be used for sensors embedded in other
///           objects.  It combines the setPowerFlag, setTruthInput, update, and getSensedOutputs
///           methods together into one easy call.  This allows the parent object to provide the
///           input power flag and truth value to the sensor and receive the resulting sensed
///           output in one step.  Sensors that use the simbus for some or all of the inputs/outputs
///           should not use this method - they should use the update method instead.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method sets the truth input boolean term of the base boolean sensor class based
///           on whether the input analog value is within tolerance of a target real value.  Then
///           the base class update method performs the same processing on that boolean that the
///           normal boolean sensor does.  This method sets the boolean true when the input analog
///           is within tolerance, and false outside of it.
///
/// @note     If a logical inverse is desired, where the sensor outputs false when within the
///           tolerance and true otherwise, either extend this class and override this method, or
///           perform the inversion outside of the sensor.
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  powerFlag  (--)  Power flag.
///
/// @return   void
///
/// @details  Sets the power flag for each sensor in this Fan Speed Sensors Model.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  speed  (revolution/min)  Truth value speed.
///
/// @return   void
///
/// @details  Sets the truth value speed for each sensor in this Fan Speed Sensors Model.
///////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return     double  (--)  Gaussian noise.
///
/// @details    Gets noise.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] powerFlag (--) Initial powered state of the sensor
///
/// @details  Default constructs this Sensor Base input data.  The malfunction terms are only
///           present in the input data class to support unit testing of parent objects that contain
///           this sensor in an aggregate.  We deliberately omit them as arguments to this
///           constructor to reduce cluttering the method signature.  Users can still set the malf
///           input data after the object has been constructed and before the sensor is initialized.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Sensor Base object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] offValue (--) Sensed output value of the sensor when off
///
/// @details  Constructs Boolean Input Boolean Sensor config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy constructs Boolean Input Boolean Sensor config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] powerFlag  (--) Initial powered state of the sensor
/// @param[in] truthInput (--) Initial value of the input truth value to sense
///
/// @details  Default constructs this Boolean Input Boolean Sensor input data.  The malfunction
///           terms are only present in the input data class to support unit testing of parent
///           objects that contain this sensor in an aggregate.  We deliberately omit them as
///           arguments to this constructor to reduce cluttering the method signature.  Users can
///           still set the malfunction input data after the object has been constructed and before
///           the sensor is initialized.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Boolean Input Boolean Sensor object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Sensor Base config data.
/// @param[in] inputData  (--) Sensor Base input data.
/// @param[in] name       (--) Name of the sensor for output messages.
///
/// @throws TsInitializationException
///
/// @details  Initializes the Boolean Input Boolean Sensor object with config and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] timeStep (s) Execution time step (not used).
///
/// @details  Determines sensor output based on configuration, input, power, and malfunctions.  The
///           order of malf/effect precedence is as follows:
///
///                              perfect > fail-off > fail-on > fail-to > stuck
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] timeStep   (s)  Execution time step.
/// @param[in] powerFlag  (--) Desired power state, true = powered, false = unpowered.
/// @param[in] truthInput (--) The truth input boolean value to the sensor.
///
/// @returns  bool (--) The sensed output value.
///
/// @details  This is a convenience method intended to be used for sensors embedded in other
///           objects.  It combines the setPowerFlag, setTruthInput, update, and getSensedOutputs
///           methods together into one easy call.  This allows the parent object to provide the
///           input power flag and truth value to the sensor and receive the resulting sensed
///           output in one step.  Sensors that use the simbus for some or all of the inputs/outputs
///           should not use this method - they should use the update method instead.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   sensor  (--)  Common speed sensor configuration data.
///
/// @details     Default constructs this Fan Sensors Model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   that    (--)  Object to copy.
///
/// @details     Copy constructs this Fan Speed Sensors Model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   sensorA  (--)  Speed sensor A input data.
/// @param[in]   sensorB  (--)  Speed sensor B input data.
/// @param[in]   sensorC  (--)  Speed sensor C input data.
///
/// @details     Default constructs this Fan Sensors Model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details     Default constructs this Fan Speed Sensors Model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt  (s)  Time step.
///
/// @return      void
///
/// @details     Updates this Fan Speed Sensors Model using previously set power flag and
///              truth value.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt         (s)    Time step.
/// @param[in]   powerFlag  (--)   Power flag.
/// @param[in]   speed      (s)    Speed truth value.
///
/// @return      float      (rpm)  Average sensed speed.
///
/// @details     Updates this Fan Speed Sensors Model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructor for Config Data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructor for Input Data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws TsInitializationException
///
/// @details  Initialization method that initializes the input and config data of the SD.
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  The Optic Smoke Detector consist of two photoelectric sensors, the obscuration and
///           scatter sensors. The obscuration sensor measures the light intensity the light source
///           is producing. The scatter sensor measures the 'light scattering' of the light source
///           due to smoke or any other type of light obstruction. The smoke detector is capable of
///           performing an Active Bit test when ever it is commanded to do so. This is done to
///           verify the smoke detector is functioning properly. The smoke detector outputs are
///           obscuration and scatter percentages. Its inputs are a power command,a bit enable
///           command, and malfunctions. The malfunctions include malfunctioning the scatter and
///           obscuration telemetry, a power malfunction and a malfunction of the Smoke Detector
///           as a whole.
///
/// @return void
///////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Method that checks if input and config data were initialized properly.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Method that executes the smoke detector's Active Bit Test when ever the isBitEnable
///           flag is set to true. Nominal Bit Test neglecting noise performs the following:
///
///                    |                OBSCURATION BIT DIAGRAM
///         Max Obs.  _|_             _ _ _ _ _ _ _ _ _ _ _ _
///                    |             :                        :
///      Nominal Obs. _|_ _ _ _ _ _ _:                        :_ _ _ _ _
///                    |
///                    |_____________|_______|________________|_________
///                    |             |       |                |
///                    x0            x1      x2               x3
///
///
///                    |                  SCATTER BIT DIAGRAM
///   Bit-on Max Scat._|_             _ _ _ _
///                    |             :       :
///     Nominal Scat. _|_ _ _ _ _ _ _:       :_ _ _ _ _ _ _ _ _ _ _ _ _
///                    |
///                    |_____________|_______|________________|_________
///                    |             |       |                |
///                    x0            x1      x2               x3
///
///
///                                            LEGEND
///                x0 - Any time step the diagram starts at.
///                x1 - Time FSW sets Bit command; isBitEnable is set to true.
///                x2 - Time FSW removes the Bit command; isBitEnable is set to false.
///                x3 - Time smoke detector fully completes the Bit test; bitTimer exceeds bitRecoveryTime.
///                Y axis - Percentage (%).
///                X axis - Time (s).
///             * When Obscuration or Scatter telemetry is malfunctioned, dashed lines shift according
///               to the malfunction factor, hence causing Active Bit test to fail.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  The sensor is considered degraded if any malfunction that is usually used to degrade
///           the sensor output is active (regardless of whether the malfunction is actually
///           degrading the output at this time), but not if the perfect sensor malfunction is
///           active.  This method should be overridden to include further malfunctions in the
///           derived classes.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] trueValue   (--) initial true value
/// @param[in] sensedValue (--) initial sensed value
/// @param[in] failedValue (--) initial failed value
/// @details  Input data Default constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) configuration data
/// @param[in] inputData  (--) input data
/// @details  initialization
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] realValue  (--) actual position
/// @param[in] isPowered  (--) is power available
/// @param[in] isFailed   (--) is switch/sensor failed
/// @details  sets a sensed value based on if the switch/sensor has power, is failed and actual
/// value.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Copy constructs Analog Sensor config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] powerFlag  (--) Initial powered state of the sensor
/// @param[in] truthInput (--) Initial value of the input truth value to sense
///
/// @details  Default constructs this Analog Sensor input data.  The malfunction terms are only
///           present in the input data class to support unit testing of parent objects that contain
///           this sensor in an aggregate.  We deliberately omit them as arguments to this
///           constructor to reduce cluttering the method signature.  Users can still set the malf
///           input data after the object has been constructed and before the sensor is initialized.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Analog Sensor object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Sensor Base config data.
/// @param[in] inputData  (--) Sensor Base input data.
/// @param[in] name       (--) Name of the sensor for output messages.
///
/// @throws TsInitializationException
///
/// @details  Initializes the Analog Sensor object with config and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Checks for valid configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] timeStep (s) Execution time step.
///
/// @details  Determines sensor output based on configuration, input, power, and malfunctions.  The
///           order of malf/effect precedence is as follows:
///
///       perfect > fail-off > fail-on > fail-to > stuck > resolution > noise > drift > bias > scale
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] timeStep   (s)  Execution time step.
/// @param[in] powerFlag  (--) Desired power state, true = powered, false = unpowered.
/// @param[in] truthInput (--) The truth input analog value to the sensor.
///
/// @returns  float (--) The sensed output value.
///
/// @details  This is a convenience method intended to be used for sensors embedded in other
///           objects.  It combines the setPowerFlag, setTruthInput, update, and getSensedOutputs
///           methods together into one easy call.  This allows the parent object to provide the
///           input power flag and truth value to the sensor and receive the resulting sensed
///           output in one step.  Sensors that use the simbus for some or all of the inputs/outputs
///           should not use this method - they should use the update method instead.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method calls an optional conversion method to convert the truth input to the
///           desired internal units.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method limits the sensed output to be within the absolute sensor range, and
///           updates the truth output by converting the truth input to output units.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Multiplies the sensor output by the nominal scale.  Also multiplies by the scale
///           malfunction value if the malf is active.  Note that when the scale malf is active, the
///           sensor output is scaled by the product of both the scale malf and nominal scale.
////////////////////////////////////////////////////////////////////////////////////////////////////