////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Adds the nominal sensor bias to the sensor output.  Also adds the bias malfunction
///           value if the malf is active.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Increments the total drift amount by the drift malfunction rate multiplied by the
///           simulation time step.  Only adds this drift to the sensor output when the malf is
///           active.  The total drift amount is only zeroed when the malfunction is removed.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method calls the external noise generator function given by function pointer from
///           the config data.  This allows individual sensors to be configured to use noise
///           functions that have different distributions, such as Gaussian vs. uniform, etc.  The
///           noise has two components applied in this order: 1) a noise that scales with the input,
///           as input varies from the 'off' (zero signal) value of the sensor, and 2) a constant-
///           amplitude noise.  Both components have nominal scale values defined by config data,
///           and both scale values can be overridden by malfunction.  Each component is applied
///           with a different output of the noise generator function.
///
/// @note     Unlike the sensor bias & scale malfunctions, which are activated with separate flags,
///           a single activation flag activates the malf overrides of both noise components
///           simultaneously.
///
/// @note     The units definition of the 2 component scales are different.  The constant-scale
///           component is given in sensed output units, whereas the input-scaling component is in
///           fraction of total sensor output range.
///
/// @note     The input value used in the input-scaling component is after sensor bias, scale &
///           drift are applied.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  This method rounds the sensor output to the nearest multiple of the resolution value.
///           This models the accuracy of the sensor and is useful for damping model noise or
///           discretizing the sensor output as desired.  Unlike the other malfunctions, if the
///           resolution malfunction is active, it is used by itself as the resolution amount,
///           rather than being in some combination with the nominal amount.
///
/// @note     The absolute value of the nominal & malfunction resolution is used.  It doesn't make
///           sense to use negative values, but the method allows it since we use the absolute value
///           anyway.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  a test
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  test accessors
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Iss Fan Speed Sensors model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Iss Fan Speed Sensors model construction of configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Iss Fan Speed Sensors model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Iss Fan Speed Sensors model nominal initialization without exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Iss Fan Speed Sensors model accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Iss Fan Speed Sensors model modifiers.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Iss Fan Speed Sensors model update state (nominal).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Iss Fan Speed Sensors model update state (off-nominal).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Iss Fan Speed Sensors model initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  unit test infrastructure
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Analog Input Boolean Sensor config data
///         class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Analog Input Boolean Sensor input data
///         class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the construction of the Analog Input Boolean Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests nominal initialization of the Analog Input Boolean Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests initialization exceptions of the Analog Input Boolean Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the various setter & getter methods of the Analog Input Boolean Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the update method of the Analog Input Boolean Sensor class under nominal
///         operation with good power and no malfs.  Since the sensor class reuses the base class
///         update method, we are really focusing on the conversion of the analog input into the
///         boolean output here.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Test the sense convenience method.
////////////////////////////////////////////////////////////////////////////////////////////////////


/// @brief initialization test


/// @brief update test


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Analog Sensor config data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Analog Sensor input data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the construction of the Analog Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests nominal initialization of the Analog Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests initialization exceptions of the Analog Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the various setter & getter methods of the Analog Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the processInputs method of the Analog Sensor class including numerical underflow
///         and units conversion function.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the applyScale method of the Analog Sensor class including nominal operation and
///         scale malfunction.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the applyBias method of the Analog Sensor class including nominal operation and
///         bias malfunction.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the applyDrift method of the Analog Sensor class including nominal operation and
///         drift malfunction.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the applyNoise method of the Analog Sensor class including nominal operation and
///         noise malfunction.  This only tests the application of the noise generator output to the
///         sensor output, not the actual noise generator.  We assume the noise generator, which is
///         an external method, is already verified.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the applyResolution method of the Analog sensor class including nominal and
///         malfunction.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the update method of the Analog Sensor class under nominal operation with good
///         power and no malfs.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the update method of the Analog Sensor class under nominal operation with no power
///         and no malfs.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the fail-to malfunction in the Analog Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the stuck malfunction in the Analog Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the perfect sensor malfunction in the Analog Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests interactions of malfunctions in the Analog Sensor class that have not been covered
///         in previous tests.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests compatibility of the Analog Sensor class with established external noise
///         functions.  This method is intended to be updated with new noise functions as they
///         become available.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Test update of the truth output with units conversion.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the distribution range.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the distribution mean.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the repeatability.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the randomness.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the accessor functions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Boolean Input Boolean Sensor config data
///         class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Boolean Input Boolean Sensor input data
///         class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the construction of the Boolean Input Boolean Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests nominal initialization of the Boolean Input Boolean Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests initialization exceptions of the Boolean Input Boolean Sensor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the various setter & getter methods of the Boolean Input Boolean Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the update method of the Boolean Input Boolean Sensor class under nominal
///         operation with good power and no malfs.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the update method of the Boolean Input Boolean Sensor class under nominal
///         operation with no power and no malfs.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0021: TS21 vehicle subsystem models shall provide sensed and actual data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the fail-to malfunction in the Boolean Input Boolean Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the stuck malfunction in the Boolean Input Boolean Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the perfect sensor malfunction in the Boolean Input Boolean Sensor class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests interactions of malfunctions in the Boolean Input Boolean Sensor class that have
///         not been covered in previous tests.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Sensor Base config data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Sensor Base input data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the construction of the Sensor Base class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests nominal initialization of the Sensor Base class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests initialization exceptions of the Sensor Base class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the various setter & getter methods of the Sensor Base class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0011: TS21 vehicle subsystem models shall receive the current state of the
///                          electrical network system.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the determinePower method of the Sensor Base class.
///
/// @details Verifies the following TS21 requirements as they pertain to the sensor model:
///          - R.TS210-0004: TS21 vehicle subsystem models shall provide an override for nominal
///                          component functionality regardless of power availability.
///          - R.TS210-0005: TS21 vehicle subsystem models shall provide an override for preventing
///                          nominal component functionality regardless of power availability.
///          - R.TS210-0009: TS21 vehicle subsystem sensor models shall have fail, scale, noise,
///                          drift and bias malfunctions.
///          - R.TS210-0011: TS21 vehicle subsystem models shall receive the current state of the
///                          electrical network system.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests initialization of the mDegradedFlag attribute of the Sensor Base class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  test update
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Test Initialize method.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when no smoke detector name was specified.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when not configuring min and max obscuration values properly.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when not configuring min and max scatter values properly.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when not configuring min and nominal obscuration properly.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when not configuring min and nominal scatter properly.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when not configuring bitOnMaxScatterValue properly.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when bit recovery time is less than tolerance.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when smoke level's value is not entered correctly.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when bit Timer's value is not entered correctly.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Verify Exception is thrown when calling update prior calling initialize.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Run update at nominal conditions, no malfunctions. Verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Run update with Smoke and nominal conditions, no malfunctions. Verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Run update at with power malfunction conditions. Verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Run update with no power available. Verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Run update with smoke detector fail-as-a-whole command is set. Verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Run update with obscuration sensor failed. Verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Run update with scatter sensor failed. Verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Perform Active bit Test Sequence and verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Perform Active bit Test Sequence with Smoke present and verify outputs.
///////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] pulseWasteFraction (--)                 (0-1) Fraction of power wasted during PWM off-time.
/// @param[in] stallTorqueCoeff1  (N*m/V)              Stall torque curve 1st-order coefficient.
/// @param[in] stallTorqueCoeff2  (N*m/V)              Stall torque curve 2nd-order coefficient.
/// @param[in] frictionTorque     (N*m)                Friction torque (constant).
/// @param[in] bemfConstant       (V*min/revolution)   Back-EMF constant.
/// @param[in] armatureResistance (ohm)                Electrical resistance of motor armature.
/// @param[in] inertia            (kg*m2)              Inertia of the motor+load mass.
/// @param[in] speedLoadRatio     (revolution/min/N/m) Slope of motor speed/torque line.
///
/// @details  Default constructs this Motor configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] voltage     (V)              Initial supply voltage.
/// @param[in] pulseWidth  (--)             (0-1) Initial pulse width.
/// @param[in] motorSpeed  (revolution/min) Initial motor speed.
/// @param[in] loadTorque1 (N*m)            1st initial external load torque.
/// @param[in] loadTorque2 (N*m)            2nd initial external load torque.
/// @param[in] loadTorque3 (N*m)            3rd initial external load torque.
/// @param[in] loadTorque4 (N*m)            4th initial external load torque.
///
/// @details  Default constructs this Motor input data.  Malfunction parameters are provided as
///           class attributes to support unit testing, but are not needed to be specified in the
///           constructor, thus no arguments are provided.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     This should be followed by a call to the initialize method before calling the step
///           method.
///
/// @details  Default constructs this Motor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Configuration data.
/// @param[in] inputData  (--) Input data.
/// @param[in] name       (--) Name of the motor for output messages.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Motor with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Configuration data.
/// @param[in] inputData  (--) Input data.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Validates this Motor's configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Time step.
///
/// @returns  void
///
/// @details  Updates all motor parameters over the time step.  The called virtual methods are meant
///           to be overridden by derived classes to implement extra features as needed.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Stall torque is the maximum torque the motor can produce with the given input voltage,
///           which occurs at speed zero (stall) and full pulse width.  It generally increases
///           linearly with voltage, but ours is a 2nd-order polynomial, useful for tuning the motor
///           to match empirical data at design points, etc.
///
///           The degradation malfunction reduces the torque the motor can produce, caused by brush
///           contactor erosion or broken rotor windings, etc.
///
///           The torque actually produced by the motor decreases from stall torque linearly with
///           speed, and is scaled by the power-on time fraction represented by the pulse width.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  The motor supports up to 4 external loads, which can come from simbus or setter
///           method.  The jam malfunction applies an extra external torque, calculated as a
///           fraction of stall torque, such that at 100% jam the motor cannot accelerate even if
///           all other external loads are removed.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  The balance of all torques is divided by motor inertia to accelerate decelerate the
///           motor.  Our motor cannot spin backwards.  Friction is assumed constant.  All torques
///           are signed relative to the forward rotation of the motor, so torque produced by the
///           motor is positive, while loads and friction are negative.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Maximum current & power occurs at stall, and is reduced as speed increases by the
///           back-EMF effect.  The degradation malfunction effectively increases the electrical
///           resistance, reducing current & power.  Pulse Width Modulation scales the current &
///           power in proportion to the on-time, but mPulseWasteFraction causes current during the
///           off-time as well, to simulate losses in the PWM chopper circuit.
///
///           The actual output to the electrical aspect Resistive User Load object is the total
///           motor resistance, although power can be used with a Constant Power User Load if
///           desired.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  All power produced by the motor that is not absorbed by the external load is assumed
///           to become waste heat.  Further losses in the external load model are not included in
///           our waste heat or efficiency.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] torque1 (N*m) 1st external torque load.
/// @param[in] torque2 (N*m) 2nd external torque load.
/// @param[in] torque3 (N*m) 3rd external torque load.
/// @param[in] torque4 (N*m) 4th external torque load.
///
/// @details  Sets the external load torques to the Motor.  The input arguments default to zero, for
///           convenience when not all of them are needed.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] windingResistance (ohm)                Electrical resistance of motor winding.
/// @param[in] torqueConstant    (N*m/amp)            Torque and back-EMF (v*s/r) constant.
/// @param[in] frictionConstant  (N*m*min/revolution) Dynamic friction torque constant.
/// @param[in] frictionMinSpeed  (revolution/min)     Minimum speed for dynamic friction.
/// @param[in] inertia           (kg*m2)              Inertia of the motor+load mass.
///
/// @details  Default constructs this Motor configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] voltage      (V)              Initial control voltage.
/// @param[in] currentLimit (amp)            Initial current limit.
/// @param[in] motorSpeed   (revolution/min) Initial motor speed.
/// @param[in] loadTorque1  (N*m)            1st initial external load torque.
/// @param[in] loadTorque2  (N*m)            2nd initial external load torque.
/// @param[in] loadTorque3  (N*m)            3rd initial external load torque.
/// @param[in] loadTorque4  (N*m)            4th initial external load torque.
///
/// @details  Default constructs this Motor input data.  Malfunction parameters are provided as
///           class attributes to support unit testing, but are not needed to be specified in the
///           constructor, thus no arguments are provided.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Maximum current & power occurs at stall, and is reduced as speed increases by the
///           back-EMF effect.  The degradation malfunction effectively increases the electrical
///           resistance, reducing current, power and drive torque, caused by brush contactor
///           erosion or broken rotor windings, etc.
///
///           Current and resistive load on the power supply are relative to the input control
///           voltage.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Stall torque is the maximum torque the motor can produce with the given input voltage,
///           which occurs at speed zero (stall).  The drive torque actually produced by the motor
///           is directly proportional to current, which decreases from stall current linearly with
///           speed due to the back-EMF effect, and is further reduced by the degrade malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  The balance of all torques is divided by motor inertia to accelerate decelerate the
///           motor.  Our motor cannot spin backwards.  All torques are signed relative to the
///           forward rotation of the motor, so torque produced by the motor is positive, while
///           loads and friction are negative.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the constructors & destructors of the Motor config data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Motor input data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the initialization of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the initialization exceptions of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the setter & getter methods of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the generateMotorTorque method of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the gatherExternalLoads method of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the computeMotorSpeed method of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the computeElectricalOutputs method of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the computeWasteHeat method of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  End-to-end test of the Motor step method with all effects.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  aPath  (--)  A path valve controller configuration data.
/// @param[in]  bPath  (--)  B path valve controller configuration data.
///
/// @details    Default constructs this TS21 Fluid Controller Manual T-Valve (3 way, 3 position)
///             Controller Model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that  (--)  Source to copy.
///
/// @details    Copy constructs this TS21 Fluid Controller Manual T-Valve (3 way, 3 position)
///             Controller Model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  position  (--)  Position selection input data (NONE, A_PATH or B_PATH).
/// @param[in]  aPath     (--)  A path valve controller input data.
/// @param[in]  bPath     (--)  B path valve controller input data.
///
/// @details    Default constructs this TS21 Fluid Controller Manual T-Valve (3 way, 3 position)
///             Controller Model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that   (--)  Source to copy.
///
/// @details    Copy constructs this TS21 Fluid Controller Manual T-Valve (3 way, 3 position)
///             Controller Model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Default constructs this TS21 Fluid Controller Manual T-Valve (3 way, 3 position)
///             Controller Model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config        (--)  Object configuration data.
/// @param[in]  input         (--)  Object input data.
/// @param[in]  name          (--)  Object name (non-empty).
///
/// @return     void
///
/// @throws     TsInitializationException
///
/// @details    Initializes this TS21 Fluid Controller Manual T-Valve (3 way, 3 position)
///             Controller Model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt        (s)   Time step.
///
/// @return     void
///
/// @details    Updates this TS21 Fluid Controller Manual T-Valve (3 way, 3 position) Controller
///             Model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Default constructs this Speed Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config  (--)  Configuration data.
/// @param[in]  input   (--)  Input data.
/// @param[in]  name    (--)  Object name.
///
/// @return     void
///
/// @throws     TsInitializationException
///
/// @details    Initializes this Speed Valve Controller model with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt                 (s)   Time step.
///
/// @return   void
///
/// @details  Updates this Speed Valve Controller model position and power consumption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   supplyVoltageFlag  (--)  Supply voltage flag.
/// @param[in]   command            (--)  Composite command.
/// @param[in]   dt                 (s)   Time step.
///
/// @return   void
///
/// @details  Updates this Speed Valve Controller model position and power consumption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   supplyVoltageFlag  (--)  Supply voltage flag.
/// @param[in]   command            (--)  Composite command.
/// @param[in]   sensed             (--)  Composite sensed position.
/// @param[in]   dt                 (s)   Time step.
///
/// @return   void
///
/// @details  Updates this Speed Valve Controller model position and power consumption with
///           end of travel interruption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Default constructs this Toggle Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config  (--)  Configuration data.
/// @param[in]  input   (--)  Input data.
/// @param[in]  name    (--)  Object name.
///
/// @return     void
///
/// @throws     TsInitializationException
///
/// @details    Initializes this Toggle Valve Controller model with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt  (s)   Time step.
///
/// @return      void
///
/// @details     Updates this Toggle Valve Controller model position and power consumption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt  (s)   Time step.
///
/// @return      void
///
/// @details     Updates this Toggle Valve Controller model position and power consumption without
///              end of travel interruption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt  (s)   Time step.
///
/// @return      void
///
/// @details     Updates this Toggle Valve Controller model position and power consumption with
///              end of travel interruption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Default constructs this Open/Close Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config  (--)  Configuration data.
/// @param[in]  input   (--)  Input data.
/// @param[in]  name    (--)  Object name.
///
/// @return     void
///
/// @throws     TsInitializationException
///
/// @details    Initializes this Open/Close Valve Controller model with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt                 (s)   Time step.
///
/// @return   void
///
/// @details  Updates this Open/Close Valve Controller model position and power consumption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   supplyVoltageFlag  (--)  Supply voltage flag.
/// @param[in]   command            (--)  Composite command.
/// @param[in]   dt                 (s)   Time step.
///
/// @return   void
///
/// @details  Updates this Open/Close Valve Controller model position and power consumption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   supplyVoltageFlag  (--)  Supply voltage flag.
/// @param[in]   command            (--)  Composite command.
/// @param[in]   sensed             (--)  Composite sensed position.
/// @param[in]   dt                 (s)   Time step.
///
/// @return   void
///
/// @details  Updates this Open/Close Valve Controller model position and power consumption with
///           end of travel interruption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  enable  (--)  Enable command flag.
/// @param[in]  speed   (--)  Speed command value.
///
/// @details    Default constructs this Powered Speed Valve command.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that   (--)  Source to copy.
///
/// @details    Copy constructs this Powered Speed Valve command.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  enable  (--)             Enable command flag.
/// @param[in]  toggle  (--)             Toggle command flag.
///
/// @details    Default constructs this Powered Toggle Valve command.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Updates the state of this Powered Toggle Valve command.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  minCmdPosition    (--)  Minimum valid valve position.
/// @param[in]  maxCmdPosition    (--)  Maximum valid valve position.
/// @param[in]  minFluidPosition  (--)  Minimum valid valve flow area fraction.
/// @param[in]  maxFluidPosition  (--)  Maximum valid valve flow area fraction.
///
/// @details    Default constructs this Valve Controller model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  cmdPosition             (--)  Valve position.
/// @param[in]  manualPositionFlag      (--)  Manual override valve position flag.
/// @param[in]  manualPositionValue     (--)  Manual override valve position value.
///
/// @details    Default constructs this Valve Controller model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Default constructs this Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config  (--)  Configuration data.
/// @param[in]  input   (--)  Input data.
/// @param[in]  name    (--)  Object name.
///
/// @return     voidunused
///
/// @throws     TsInitializationException
///
/// @details    Initializes this Valve Controller model with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config  (--)  Configuration data.
/// @param[in]  input   (--)  Input data.
///
/// @return     void
///
/// @throws     TsInitializationException
///
/// @details    Validates this Valve Controller model initialization data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  position  (--)  Fractional valve position.
///
/// @details    Updates the fractional valve position of this Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] motor                (--)             Motor configuration data.
/// @param[in] forcingGain          (--)             (0-1) Control filter forcing gain.
/// @param[in] dampingGain          (--)             (0-1) Control filter damping gain.
/// @param[in] dampingCutoff        (--)             (0-1) Control filter damping cutoff error.
/// @param[in] temperatureTripLimit (K)              Temperature trip limit.
/// @param[in] temperatureTripReset (K)              Temperature trip reset.
/// @param[in] minVoltage           (V)              Minimum voltage for operation.
/// @param[in] maxVoltage           (V)              Maximum voltage for operation.
/// @param[in] controllerPowerLoad  (W)              Controller circuitry power load.
/// @param[in] noiseAmplitude       (revolution/min) Amplitude of speed bias function.
/// @param[in] noiseFrequency       (Hz)             Frequency of speed bias function.
/// @param[in] startupCurrentLimit  (amp)            Limited motor current during startup.
///
/// @details  Default constructs this Controller configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] motor             (--)             Motor input data.
/// @param[in] voltage           (V)              Initial supply voltage.
/// @param[in] sensedSpeed       (revolution/min) Initial sensed speed.
/// @param[in] sensedTemperature (K)              Initial sensed temperature.
/// @param[in] startupState      (--)             Initially limiting startup current.
/// @param[in] commandEnable     (--)             Initial enable command.
/// @param[in] commandSpeed      (revolution/min) Initial commanded speed.
/// @param[in] noisePhase        (rad)            Initial phase of speed bias function.
///
/// @details  Default constructs this Controller input data.  Malfunction parameters are provided as
///           class attributes to support unit testing, but are not needed to be specified in the
///           constructor, thus no arguments are provided.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @note     This should be followed by a call to the initialize method before calling the step
///           method.
///
/// @details  Default constructs this Controller.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Configuration data.
/// @param[in] inputData  (--) Input data.
/// @param[in] name       (--) Object name.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Controller with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData (--) Configuration data.
/// @param[in] inputData  (--) Input data.
///
/// @returns  void
///
/// @throws   TsInitializationException
///
/// @details  Validates this Controller's configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Time step.
///
/// @returns  void
///
/// @details  Updates all controller parameters over the time step.  The called virtual methods are
///           meant to be overridden by derived classes to implement extra features as needed.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt            (s)              Time step.
/// @param[in] voltage       (V)              Supply voltage.
/// @param[in] speed         (revolution/min) Sensed motor speed.
/// @param[in] temperature   (K)              Sensed motor temperature.
/// @param[in] speedCommand  (revolution/min) Motor speed command.
/// @param[in] enableCommand (--)             Motor command enable flag.
///
/// @returns  void
///
/// @details  Convenience method to update the controller with one call, providing all inputs as
///           calling arguments.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Determines if the controller and motor buses is adequately powered.  Order of
///           precedence for the controller bus is:
///              (fail power malf) > (voltage override malf) > (voltage in limits).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Performs trip logic for motor temperature.  This acts like a thermostat - the trip is
///           acitvated when temperature exceeds a maximum setpoint, and resets when temperature
///           falls below a minimum setpoint.  The trip can also be reset by cycling controller
///           power, or manually reset by the user.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Time step.
///
/// @returns  void
///
/// @details  Updates the control filter for a new pulse width to control the motor to the commanded
///           speed.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Time step.
///
/// @returns  void
///
/// @details  Updates the motor with a control voltage.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Updates the total motor + controller power load and waste heat, for output to the
///           electrical & thermal aspects.  Power load is sent to the electrical aspect as a
///           resistance, since the majority of the load usually comes from the motor, which is not
///           a constant-power device.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  enable   (--)  Enable command flag.
/// @param[in]  open     (--)  Open command flag.
/// @param[in]  close    (--)  Close command flag.
///
/// @details    Default constructs this Powered Open/Close Valve command.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that   (--)  Source to copy.
///
/// @details    Copy constructs this Powered Open/Close Valve command.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  enable   (--)  Enable command flag.
/// @param[in]  position (--)  Position command value.
///
/// @details    Default constructs this Powered Position Valve command.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that   (--)  Source to copy.
///
/// @details    Copy constructs this Powered Position Valve command.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  minCmdPosition    (--)  Minimum valid valve position.
/// @param[in]  maxCmdPosition    (--)  Maximum valid valve position.
/// @param[in]  minFluidPosition  (--)  Minimum valid valve flow area fraction.
/// @param[in]  maxFluidPosition  (--)  Maximum valid valve flow area fraction.
/// @param[in]  latch             (--)  Latching direction when power is removed.
///
/// @details  Default constructs this Dual Solenoid Valve Controller configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that  (--)  Object to copy.
///
/// @details  Copy constructs this Dual Solenoid Valve Controller configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  cmdPosition          (--)  Initial valve position.
/// @param[in]  manualPositionFlag   (--)  Manual override valve position flag.
/// @param[in]  manualPositionValue  (--)  Manual override valve position value.
/// @param[in]  openSolenoidCmd      (--)  Initial open channel powered flag.
/// @param[in]  closeSolenoidCmd     (--)  Initial close channel powered flag.
///
/// @details  Default constructs this Dual Solenoid Valve Controller input data.  Malfunction
///           argument terms in the base class constructor are defaulted to inactive.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Dual Solenoid Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] configData  (--)  Configuration data.
/// @param[in] inputData   (--)  Input data.
/// @param[in] name        (--)  Object name.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Dual Solenoid Valve Controller model with configuration and input
///           data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inputData   (--)  Input data.
///
/// @throws   TsInitializationException
///
/// @details  Throws exceptions and H&S errors on bad input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Execution time step (not used).
///
/// @details  Updates this Dual Solenoid Valve Controller during run-time.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  cmd   (--)  Solenoid power input flag from user load.
/// @param[in]  malf  (--)  Solenoid power malfunction flag.
///
/// @returns  UserLoadMode  (--)  LoadON if the solenoid is drawing power, otherwise LoadOFF
///
/// @details  Updates this Dual Solenoid Valve Controller during run-time.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  minCmdPosition    (--)  Minimum valid valve position.
/// @param[in]  maxCmdPosition    (--)  Maximum valid valve position.
/// @param[in]  minFluidPosition  (--)  Minimum valid valve flow area fraction.
/// @param[in]  maxFluidPosition  (--)  Maximum valid valve flow area fraction.
/// @param[in]  transitTime       (s)   Reference transit time.
/// @param[in]  refCmd            (--)  Reference speed command (always 1).
/// @param[in]  holdPower         (W)   Power consumption when valve is holding.
/// @param[in]  movePower         (W)   Power consumption when valve is moving.
/// @param[in]  stuckPower        (W)   Power consumption when valve is stuck.
/// @param[in]  refVoltage        (v)   Reference voltage for power consumption.
/// @param[in]  eotInterrupt      (--)  End of travel interrupting flag.
/// @param[in]  latch             (--)  Latching type.
/// @param[in]  tolerance         (--)  Position command tolerance.
///
/// @details    Default constructs this Position Valve Controller model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Default constructs this Position Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config  (--)  Configuration data.
/// @param[in]  input   (--)  Input data.
/// @param[in]  name    (--)  Object name.
///
/// @return     void
///
/// @throws     TsInitializationException
///
/// @details    Initializes this Position Valve Controller model with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   supplyVoltageFlag  (--)  Supply voltage flag.
/// @param[in]   command            (--)  Composite command.
/// @param[in]   sensed             (--)  Sensed position.
/// @param[in]   dt                 (s)   Time step.
///
/// @return   void
///
/// @details  Updates this Position Valve Controller model position and power consumption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  open     (--)  Open sensed position flag.
/// @param[in]  close    (--)  Close sensed position flag.
///
/// @details    Default constructs this powered Open/Close Valve sensed position.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  that   (--)  Source to copy.
///
/// @details    Copy constructs this powered Open/Close Valve sensed position.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   flag   (--)  Valve manual control enable flag.
/// @param[in]   value  (--)  Valve manual control position value.
///
/// @return   void
///
/// @details  Sets the valve manual position controls for this Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  minCmdPosition    (--)  Minimum valid valve position.
/// @param[in]  maxCmdPosition    (--)  Maximum valid valve position.
/// @param[in]  minFluidPosition  (--)  Minimum valid valve flow area fraction.
/// @param[in]  maxFluidPosition  (--)  Maximum valid valve flow area fraction.
/// @param[in]  transitTime       (s)   Reference transit time.
/// @param[in]  refCmd            (--)  Reference speed command.
/// @param[in]  holdPower         (W)   Power consumption when valve is holding.
/// @param[in]  movePower         (W)   Power consumption when valve is moving.
/// @param[in]  stuckPower        (W)   Power consumption when valve is stuck.
/// @param[in]  refVoltage        (V)   Reference voltage for power consumption.
/// @param[in]  eotInterrupt      (--)  End of travel interrupting flag.
/// @param[in]  latch             (--)  Latching type.
///
/// @details    Default constructs this Powered Valve Controller model configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  cmdPosition             (--)  Valve position.
/// @param[in]  manualPositionFlag      (--)  Manual override position flag.
/// @param[in]  manualPositionValue     (--)  Manual override position value.
/// @param[in]  supplyVoltageFlag       (--)  Supply voltage good flag.
/// @param[in]  enabledFlag             (--)  Controller enabled flag.
/// @param[in]  cmd                     (--)  Speed command.
///
/// @details    Default constructs this Powered Valve Controller model input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Default constructs this Powered Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config  (--)  Configuration data.
/// @param[in]  input   (--)  Input data.
/// @param[in]  name    (--)  Object name.
///
/// @return     void
///
/// @throws     TsInitializationException
///
/// @details    Initializes this Powered Valve Controller model with configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  config  (--)  Configuration data.
/// @param[in]  input   (--)  Input data (unused).
///
/// @return     void
///
/// @throws     TsInitializationException
///
/// @details    Validates this Powered Valve Controller model initialization data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   supplyVoltageFlag  (--)  Supply voltage flag.
/// @param[in]   enabledFlag        (--)  Enabled flag.
/// @param[in]   cmd                (--)  Speed command.
/// @param[in]   dt                 (s)   Time step.
///
/// @return   void
///
/// @details  Updates this Powered Valve Controller model position and power consumption.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Time step.
///
/// @return     void
///
/// @details    Updates this Powered Valve Controller model.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return     void
///
/// @details    Updates this Powered Valve Controller model power consumption and resistance
///             distinguishing four cases: stuck, moving, holding and unpowered.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Powered Open/Close Valve sensed unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Open/Close Valve sensed default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Open/Close Valve sensed nominal construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Open/Close Valve sensed copy construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Open/Close Valve sensed assignment.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Valve Controller model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model construction of configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model nominal initialization without exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model modifiers.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model update state (nominal).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model update state (off-nominal).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model update state (malfunctions).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Valve Controller model initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the constructors & destructors of the Controller config data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Controller input data class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the constructors & destructors of the Controller class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the initialization of the Controller class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the initialization exceptions of the Controller class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the setter & getter methods of the Controller class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the temperature trip logic of the Controller class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the current trip logic of the Controller class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the determinePower method of the Controller class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the noise component of the control filter.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the pulse width output of the control filter.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the updateMotor method of the Controller class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Tests the updatePowerLoad method of the Motor class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  End-to-end test of the Controller step method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  End-to-end test of the Controller stepWithArgs method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Open/Close Valve Controller model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Open/Close Valve Controller model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Open/Close Valve Controller model nominal initialization without exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Open/Close Valve Controller model accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Open/Close Valve Controller model modifiers.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Open/Close Valve Controller model update state (nominal).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Open/Close Valve Controller model update state (off-nominal).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Open/Close Valve Controller model update state (malfunctions).
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Open/Close Valve Controller model initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Powered Position Valve command unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Position Valve command default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Position Valve command nominal construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Position Valve command copy construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Position Valve command assignment.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this Powered Valve Controller model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Valve Controller model construction of configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Valve Controller model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Powered Valve Controller model nominal initialization without exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////