////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the appllyConstraints method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the updateState method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the updateTrips method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Electrical User Load Switch link model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model construction of configuration.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model construction of input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model nominal initialization with
///           user loads.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model access methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model step method with user loads.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model step method without user loads.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model step method without user loads
///           and output connected to the Ground node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model step method with user loads and
///           the loads voltage override is active.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model computeFlows method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model computeFlows method with user
///           loads and the loads override mode active.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model computeFlows method with no
///           user loads, connected to a non-Ground output node, and the loads override mode active.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model checkSpecificPortRules method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model non-linear link functions
///           including switch trips.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model restart method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch link model initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Electrical User Load Switch Variant 2 link model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link construction of config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link construction of input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model nominal initialization
///           with user loads.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model access methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model step method with user
///           loads.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model step method without
///           user loads.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model step method without
///           user loads and output connected to the Ground node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model step method with user
///           loads and the loads voltage override is active.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model computeFlows method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model computeFlows method
///           with user loads and the loads override mode active.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model computeFlows method
///           with no user loads, connected to a non-Ground output node, and the loads override mode
///           active.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model checkSpecificPortRules
///           method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model non-linear link
///           functions including switch trips.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model restart method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical User Load Switch Variant 2 link model initialization
///           exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Electrical Selector link model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model construction of configuration.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model construction of input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model nominal initialization without
///           exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model accessors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model modifiers.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model step method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model computeFlows method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model restart method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Selector link model initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS ResistiveLoadConfigData
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name              (--)  user load name
/// @param[in] loadType          (--)  type of user load resistive or constant power
/// @param[in] underVoltageLimit (V)   lower limit for the voltage at which the voltage trips
/// @param[in] resistanceNormal  (ohm) resistance value for this load when operating in Normal or ON mode
/// @param[in] resistanceStandby (ohm) resistance value for this load when operating in Standby mode
/// @param[in] fuseCurrentLimit  (amp) Current above which the fuse blows.
///
/// @details  Default User Load constant resistor load Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    that  --  Object to copy
///
/// @details  Default User Load constant resistor load Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS ResistiveLoadInputData
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] lOverwritePowerFlag (--) Flag to overwrite the Load power value
/// @param[in] lOverwritePower     (--) Overwrite power value
/// @param[in] loadOperMode        (--) user load is set to one of these modes - ON/OFF/STANDBY
/// @param[in] initialVoltage      (v)  Initial input voltage to the user load from the power supply.
///
/// @details  Default User Load constant resistor load Input Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS ResistiveLoad
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details   Default Constant Resistance User Load Electrical Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    configData    --  Resistive Load Electrical Config Data
/// @param    networkLoads  --  vector of all user loads to which this object will be added.
/// @param    cardID        --  ID of the load switch card
/// @param    loadSwitchId  --  ID of the current user load object
///
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Resistive User Load Electrical with configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    configData  --  Constant Resistance User Load Electric Config Data
///
/// @throws   TsInitializationException
///
/// @details  Validates this Constant Resistance User Load Electrical initial state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   voltage  (v)  per Integration time step
///
/// @details Method to update the user load during a time step. For a constant resistance load
/// the input parameter is not "dt" but the voltage passed by the load switch class.
///
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
///
/// @details Method to calculate the user load during a time step. For a constant resistance load
/// the input parameter is the voltage from the load switch class.
///
////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////
///
///// @details Method: setPower - calculate power for the Equivalent resistance.
/////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS ConstantPowerLoadConfigData
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name              (--)  user load name
/// @param[in] loadType          (--)  type of user load constant resistance or constant power
/// @param[in] underVoltageLimit (V)   lower limit for the voltage at which the voltage trips
/// @param[in] powerNormal       (W)   power for this user load when operating in the normal or ON mode
/// @param[in] powerStandby      (W)   power for this user load when operating in the Standby mode
/// @param[in] loadOperMode      (--)  flag to verify if the load is set to ON
/// @param[in] fuseCurrentLimit  (amp) Current above which the fuse blows.
///
/// @details  Default User Load constant power load Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    that  --  Object to copy
///
/// @details  Default User Load constant power load Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS ConstantPowerLoadInputData
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] lOverwritePowerFlag (--) Flag to overwrite the Load power value
/// @param[in] lOverwritePower     (--) Overwrite power value
/// @param[in] loadOperMode        (--) user load is set to one of these modes - ON/OFF/STANDBY
/// @param[in] initialVoltage      (v)  Initial input voltage to the user load from the power supply.
///
/// @details  Default User Load constant resistor load Input Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS ConstantPowerLoad
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// @details   Default Constant Power User Load Electrical Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]    configData    --  Constant Resistance User Load Electric Config Data
/// @param[in]    networkLoads  --  User load vector to collect all the user loads
/// @param[in]    cardId         --  Switch Card ID on which this user load is configured
/// @param[in]    loadSwitchId   --  User Load ID.
///
/// @return   void
/// @details  Initializes this Constant Power User Load Electrical with configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    configData  --  Constant Power Load Electric Config Data
///
/// @throws   TsInitializationException
///
/// @details  Validates this Constant Power Load Electrical initial state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   voltage  (v)  voltage at each time step
///
/// @details Method to update the user load during a time step. For a constant power load
/// the input parameter is not "dt" but the voltage at which the load operates.
///
////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////////
///
/// @details Method to compute the current and resistance based on the voltage supplied.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name              (--)  Instance name for self-identification in messages.
/// @param[in] underVoltageLimit (v)   Low voltage limit for operation.
/// @param[in] resistanceNormal  (ohm) Resistance for normal mode.
/// @param[in] resistanceStandby (ohm) Resistance for standby mode.
/// @param[in] fuseCurrentLimit  (amp) Current above which the fuse blows.
/// @param[in] dutyCycleFraction (--)  Fraction of time the load spends in the on state in its duty cycle.
/// @param[in] dutyCyclePeriod   (s)   Duration of each duty cycle.
///
/// @details  Default constructs this GUNNS Electrical Resistive User Load Spotter configuration
///           data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  initialMode     (--)  Initial mode.
/// @param[in]  initialVoltage  (v)   Initial input voltage.
/// @param[in]  dutyCycleTimer  (s)   Initial duty cycle elapsed time.
///
/// @details  Default constructs this GUNNS Electrical Resistive User Load Spotter input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @paaram[in]  configData  (--)  Optional pointer to the config data.
/// @paaram[in]  inputData   (--)  Optional pointer to the input data.
///
/// @details  Default constructs this GUNNS Electrical Resistive User Load Spotter.  The config &
///           input data arguments are optional.  They can either be set here or left defaulted to
///           NULL here and set by a later call to the initialize method.  A GunnShow network, for
///           example, will leave these NULL here and set them with an initialize call later.  Use
///           this constructor to set them from a simple container class for which you desire no
///           init jobs, etc.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  This validates the supplied config & input data objects.  If they fail validation, an
///           exception is thrown.  If they pass, these pointers are stored in the class for later
///           use by the initLoad method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Initializes this spotter and the contained resistive User Load with config & input
///           data.  The config & input data pointers should have been set by now, either in the
///           constructor or the initialize method.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name              (--)  Instance name for self-identification in messages.
/// @param[in] underVoltageLimit (V)   Low voltage limit for operation.
/// @param[in] fuseCurrentLimit  (amp) Current above which the fuse blows.
/// @param[in] dutyCycleFraction (--)  Fraction of time the load spends in the on state in its duty cycle.
/// @param[in] dutyCyclePeriod   (s)   Duration of each duty cycle.
///
/// @details  Default constructs this GUNNS Electrical User Load Base Spotter configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  initialMode      (--)  Initial mode.
/// @param[in]  initialVoltage   (V)   Initial input voltage.
/// @param[in]  dutyCycleTimer   (s)   Initial duty cycle elapsed time.
///
/// @details  Default constructs this GUNNS Electrical User Load Base Spotter input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Default constructs this GUNNS Electrical User Load Base Spotter.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  This validates the supplied config & input data objects.  If they fail validation, an
///           exception is thrown.  If they pass, the object state is initialized from the config
///           and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Execution time step.
///
/// @details  This updates the optional duty cycle function.  This function is enabled by setting
///           the period > 0.  This function should be called once per network update.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name              (--)  Name of the User Load object for fault messaging
/// @param[in] loadType          (--)  Type of the user load.
/// @param[in] underVoltageLimit (V)   Minimum Under voltage limit set.
/// @param[in] fuseCurrentLimit  (amp) Current above which the fuse blows.
///
/// @details  Constructs the UserLoadBaseConfigData.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    that  --  Object to copy
///
/// @details  Copy constructs the UserLoadBaseConfigData.
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] lOverwritePowerFlag (--) Flag to overwrite the Load power value
/// @param[in] lOverwritePower     (--) Overwrite power value
/// @param[in] loadOperMode        (--) user load is set to one of these modes - ON/OFF/STANDBY
/// @param[in] initialVoltage      (V)  Initial input voltage to the user load from the power supply.
///
/// @details  Constructs the UserLoadBase Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    mName                 --  Name of the User Load object for fault messaging
/// @param    mCurrent          -- The total current calculated
/// @param    mActualPower      --  The Actual Power through the load
/// @param    mEquivalentResistance    --  The actual resistance for the load
/// @param    mUnderVoltage     --  Minimum Under voltage limit set.
/// @param    mLoadOperMode         --  enum to verify the mode of operation of the load.
/// @param    mUserLoadType     --  Type of the user load.
///
/// @details  Default constructs this UserLoadBase object with default values.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param  &theStringVector  [out]  vector of the split up string
/// @param  &theString        [in]   the string to be split up
/// @param  &theDelimiter     [in]   the character to split the string up by
///
/// @details utility function to tokenize a string based on an arbitrary delimiter
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    configData  -- Input configuration data
/// @param    loadsVector -- Input network loads vector. The loads object is pushed to the vector stack.
/// @param    cardId      -- The Load Switch card on which this User Load is part of
/// @param    loadSwitchId -- The id for this user load.
///
///
/// @details  Initializes this UserLoadBase object with configuration data, under voltage trip limit.
///           Allocates memory for the load vectors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    configData  -- Input configuration data
///
///
/// @details  Validates this UserLoadBase configuration data for load name, operation mode and load type.
///
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    voltage  -- Input voltage data for the step method
///
///
/// @details  Step this UserLoadBase object. Assign the voltage and power valid values.
///           Check for under voltage limit. Initialize the current, actual power and
///           equivalent resistance members.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] voltage (V) Input voltage to the load.
///
/// @returns  bool (--) True if the fuse has blown during this update.
///
/// @details  Determines whether the given input voltage causes the fuse to blow, based on the
///           equivalent load resistance as I = V/R.  Sets the fuse blown state if the fuse limit
///           is exceeded, and returns whether the fuse has blown during this update.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name              (--)  Instance name for self-identification in messages.
/// @param[in] underVoltageLimit (v)   Low voltage limit for operation.
/// @param[in] powerNormal       (W)   Power for normal mode.
/// @param[in] powerStandby      (W)   Power for standby mode.
/// @param[in] fuseCurrentLimit  (amp) Current above which the fuse blows.
/// @param[in] dutyCycleFraction (--)  Fraction of time the load spends in the on state in its duty cycle.
/// @param[in] dutyCyclePeriod   (s)   Duration of each duty cycle.
///
/// @details  Default constructs this GUNNS Electrical Constant-Power User Load Spotter
///           configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  initialMode     (--)  Initial mode.
/// @param[in]  initialVoltage  (v)   Initial input voltage.
///
/// @details  Default constructs this GUNNS Electrical Constant-Power User Load Spotter input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @paaram[in]  configData  (--)  Optional pointer to the config data.
/// @paaram[in]  inputData   (--)  Optional pointer to the input data.
///
/// @details  Default constructs this GUNNS Electrical Constant-Power User Load Spotter.  The config
///           & input data arguments are optional.  They can either be set here or left defaulted to
///           NULL here and set by a later call to the initialize method.  A GunnShow network, for
///           example, will leave these NULL here and set them with an initialize call later.  Use
///           this constructor to set them from a simple container class for which you desire no
///           init jobs, etc.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests updateState() method, called within BasicLink::step().
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests ComputeActualPower() method to test actual power equal to zero
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests updateFuse method.
////////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS DerivedResistanceLoadExampleConfigData
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    name                  --    user load name
/// @param    loadType              --    type of user load constant resistance or conatant power
/// @param    underVoltageLimit     --    lower limit for the voltage at which the voltage trips
/// @param    resistance            --    resistance for this user load
///
/// @details  Default User Load constant resistor load Config Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS DerivedResistanceLoadExampleInputData
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    lOverwriteResistanceFlag    --    Flag to over write the cumulative power of this load
/// @param    lOverwriteResistance              --    Value to assign for the power
/// @details  Default User Load constant resistor load Input Data Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


//=================================================================================================
//
// BEGIN CLASS DerivedResistanceLoadExample
//
//=================================================================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details   Default Constant Resistance User Load Electrical Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param    configData    --  Constant Resistance User Load Electric Config Data
/// @param    networkLoads  --  vector of all user loads to which this object will be added.
/// @param    cardID        --  ID of the load switch card
/// @param    loadSwitchId  --  ID of the current user load object
///
/// @return   void
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Constant Resistance User Load Electrical with configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////
///
///// @details Method: updateLoad - method to be overwritten by the derived classes.
/////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Electrical Resistive User Load Spotter link model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter construction of configuration.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter construction of input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter nominal construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter initialization method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter nominal initLoad method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter access methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter step methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Resistive User Load Spotter stepDutyCycle function.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests ComputeActualPower() method to test overwrite power less than zero
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests ComputeActualPower() method to test normal power equal to zero
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests ComputeActualPower() method to test setters
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Electrical Constant-Power User Load Spotter link model unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter construction of configuration.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter construction of input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter nominal construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter initialization method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter nominal initLoad method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter access methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter step methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant-Power User Load Spotter initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Electrical Constant Power User Load Spotter stepDutyCycle function.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Command On the IPS
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details Command Off the IPS
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param   [in] power  (W) New power value for the IPS
///
/// @details Change the Power Supply Load
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param  [in]  underVoltage  (V) New under voltage limit for IPS
///
/// @details Set the voltage trip limit
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param  [in]  power  (W) New power load for Auxiliary item two
///
/// @details Set the output power for Auxiliary item one
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param  [in]  power  (W) New power load for Auxiliary item two
///
/// @details Set the output power for Auxiliary item two
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @return  double power consumed  of IPS
///
/// @details Gets the output power.
////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////
/// @details Calculates the heat transfer to TCS
///////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////
/// @return bool true if the conductance needs to be updated.
///
/// @details Checks to see if the conductance has changed outside of tolerance value.
///////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Calculates the total input power to be applied to the selected input channel.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param [in]     name                       (--)    Name of this link
/// @param [in,out] nodes                      (--)    Network list of nodes
/// @param [in]     backuUpPowerImplemented    (--)    Back up power logic is implemented
/// @param [in]     powerConsumedOn            (W)     Power consumed when the box is on
/// @param [in]     auxillaryOnePowerOn        (W)     Power consumed by extra number one load
/// @param [in]     auxillaryTwoPowerOn        (W)     Power consumed by extra number two load
/// @param [in]     underVoltageLimit          (V)     Minimum voltage the IPS will operate
/// @param [in]     backUpVoltageThreshold     (V)     Take over voltage for the back up power
/// @param [in]     potentialOnTolerance       (V)     Voltage tolerance to switch between sources
/// @param [in]     thermalFraction            (--)    Fraction of power load output as waste heat
/// @param [in]     backupVoltageMin           (V)     Backup minimum operating voltage
/// @param [in]     backupVoltageMax           (V)     Backup maximum operating voltage
/// @param [in]     conductanceTolerance       (--)    Conductance tolerance for change
/// @param [in]     unselectedInputConductance (1/ohm) Conductance on un-selected input channels
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param [in]   that  --  Object to copy
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param [in]   malfBlockageFlag    -- Blockage malfunction flag
/// @param [in]   malfBlockageValue   -- Blockage malfunction fractional value (0-1)
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param [in]  that  --  Object to copy
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param [in]   numPorts   --  Number of Nodes to connect this class to.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param [in] sourceToUse (--) The index of the voltage source to use.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param  [in]  TimeStep  --  Time delta
////////////////////////////////////////////////////////////////////////////////////////////////////


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


///////////////////////////////////////////////////////////////////////////////////////////////
/// @return  double  new voltage value minus the tolerance value.
/// @param [in] voltage (V) the voltage
///////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] input (--) Identifies which power supply input to apply the malfunction value to.
/// @param[in] value (--) Malfunction value (true fails the power supply input off).
///
/// @details  Sets the malf parameters to the given values.  Calling this method with default value
///           argument resets the malfunction for the given power input.  The input argument is not
///           optional.
///
/// @note     Attempting to control an input index out of bounds of the power supply input array
///           will cause a H&S warning to be sent and the method will return with no effect.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction of IPS Link configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the constructor of the GunnsElectIps class.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link nominal initialization without exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link step methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link setter & getter methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link confirmSolutionAcceptable method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link computeFlows method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link validate method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link getVoltagePrimarySourceGreaterThanBackupThreshold method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link getVoltagePrimarySourceGreaterUnderVoltageLimit method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link testGetVoltageSourceToUseWithBackup method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for IPS Link testGetVoltageSourceToUseWithoutBackup method.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Trip Logic.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] limit     (--) Trip limit value.
/// @param[in] priority  (--) Network converged step trip priority.
/// @param[in] isTripped (--) Initial tripped state.
///
/// @details  Initializes this GUNNS Trip Logic.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in, out] result        (--) Caller's network solution assessment to be updated.
/// @param[in]      param         (--) The value to be checked against the trip limit.
/// @param[in]      convergedStep (--) The network's current converged minor step number.
///
/// @returns  bool (--) True if a trip just occurred during this call, false otherwise.
///
/// @details  Checks the trip condition, sets the tripped state at the appropriate time, and updates
///           the caller's network solution assessment.  This returns whether a trip just occurred
///           during this call, which allows the caller to take action when the trip occurs.
///
/// @note This does NOT set result = CONFIRM if not in the trip condition.  The caller should
///       initialize result before checking for trips.
///
/// @note If result is already REJECT when passed in, we still check for the trip.  This allows a
///       link to have multiple trip logics that can occur in the same minor step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Trip Greater Than Logic.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Trip Less Than Logic.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for default construction of a GunnsTripLogic.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Trip Logic model initialization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the checkForTrip method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the isTripped method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the resetTrip method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the access methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name              (--)    Link name.
/// @param[in] nodes             (--)    Network nodes array.
/// @param[in] isPairPrimary     (--)    This is the primary side of the interface, defaults to Supply role.
/// @param[in] conductance       (1/ohm) Output channel conductance of the internal voltage source.
/// @param[in] netCapDvThreshold (V)     Network capacitance delta-voltage threshold.
///
/// @details  Default Distributed Bi-Directional Interface link configuration data constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Input source to copy.
///
/// @details  Copy constructs this Distributed Bi-Directional Interface link configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] forceDemandMode  (--)  Forces the interface to always be in Demand mode.
/// @param[in] forceSupplyMode  (--)  Forces the interface to always be in Supply mode.
///
/// @details  Default Distributed Bi-Directional Interface link input data constructor.  This link
///           does not implement the base class blockage malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Input source to copy.
///
/// @details  Copy constructs this Distributed Bi-Directional Interface link input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default Distributed Bi-Directional Interface link constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]     configData   (--) Distributed Bi-Directional Interface link config data.
/// @param[in]     inputData    (--) Distributed Bi-Directional Interface link input data.
/// @param[in,out] networkLinks (--) Network links.
/// @param[in]     port0        (--) Network port 0.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Distributed Bi-Directional Interface link with configuration and
///           input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Throws exceptions if configuration and input data are outside of valid range.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step (not used).
///
/// @details  Calls the interface utility to update its frame counters, then performs a minor step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step (not used).
///
/// @details  Updates the child link enable flags and input power demand based on interface mode.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  For each registered voltage supply, updates the interface utility with its controlled
///           voltage and whether it is available to supply power to this location.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Confirms or rejects the network solution after each minor step.  We update the
///           interface utility to check if it switches from Supply to Demand roles, which may
///           occur if local voltage supplies have dropped out in the most recent solution.  If it
///           has switched to Demand mode, then we reject the solution and force the network to
///           re-solve with our link in Demand mode.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step.
///
/// @details  Calls the child links to compute and transport their flows to the node.  This link has
///           no direct contributions to the system of equations and has no flows of its own.
///           Updates the interface utility with the final node voltage and power demand for this
///           major step.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  bool (--) True if the interface was in Demand role prior to this update.
///
/// @details  Updates the local voltage supply data, updates the interface with the latest local
///           node voltage and power demand, processes notifications from the interface, and returns
///           whether the interface was in Demand role prior to this update.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] isInit (--) If this should throw initialization errors, currently not used.
///
/// @details  Pops all notifications from the interface utility's queue and translates them to H&S
///           messages.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Sets the supply data monitor object pointer to the supply data object at the given
///           index.
///
/// @note  Since this feature is just for debugging we don't ensure that mSupplyMonitorIndex is in
///        bounds.  User beware!
////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   malfBlockageFlag                (--)     flag to enable/disable the malfunction
/// @param[in]   malfBlockageValue               (--)     amount of blockage to add to the network link
/// @param[in]   maxConductance                  (1/ohm)  max conductance value allowed throught the power bus
/// @param[in]   minConductance                  (1/ohm)  min conductance value allowed throughout the power bus
/// @details  Constructs the PowerBusElect Input data
//////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////
/// @param  that    (--)  source to copy
/// @details  Copy Construct the PowerBusElect Input Data Object
///////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the PowerBusElect
///////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   configData   (--) Reference to Link Config Data
/// @param[in]   inputData    (--) Reference to Link Input Data
/// @param[in]   networkLinks (--) Reference to the Network Link Vector
/// @param[in]   loads        (--) Pointer to UserLoads
/// @param[in]   ports        (--) GUNNS network I/O Port Mapping
/// @throw TsInitializationException
/// @details  Initialize the PowerBusElect with config and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Method that determines whether or not the Power Bus is a Linear or Non Linear Link.
/// @return bool
//////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]   dt  (s)  model iteration period
/// @details  Method for updating the link for the network
/////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  void
///
/// @details  Updates the jumper's conductivity based on the plug connection states and whether the
///           plugs are self-sealing.
////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Method that ensures Load conductance is within desired bounds.
//////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction of Electrical Distributed Interface Link configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for construction of Electrical Distributed Interface Link input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Electrical Distributed Interface Link nominal initialization without
///           exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Electrical Distributed Interface Link nominal initialization with exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Electrical Distributed Interface Link restart method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for Electrical Distributed Interface Link step method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the Electrical Distributed Interface Link minorStep method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the Electrical Distributed Interface Link getter and setter methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the Electrical Distributed Interface Link confirmSolutionAcceptable method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                (--) Link name
/// @param[in] nodes               (--) Network nodes array
/// @param[in] defaultResistance (ohm) Default resistance of the link
///
/// @details  Constructs the Electrical Resistor Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Electrical Resistor Object
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Validates the link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Override updateState so that resistance can be converted to conductivity and updated
///           in the solver.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Override computeFlows so that this link can set its voltage, current, and calculate
///           its electrical waste heat.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name            (--)  Link name.
/// @param[in] nodes           (--)  Network nodes array.
/// @param[in] resistance      (--)  Resistance to flow.
/// @param[in] exponent        (--)  Exponent on the power function.
/// @param[in] useTangentLine  (--)  Flag to enable tangent-line approximation.
///
/// @details  Constructs the Resistor With Power Function Config data.  The base class default
///           conductivity term is not used.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy from.
///
/// @details  Copy Constructs the Resistor With Power Function Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy from.
///
/// @details  Copy constructs this Resistor With Power Function input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Resistor With Power Function Object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Validates the link initialization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Integration time step
///
/// @details  Calls minorStep every pass, since this non-linear link doesn't do anything different
///           between the 1st & subsequent minor steps.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt        (s)  Not used.
/// @param[in] minorStep (--) Not used.
///
/// @details  Updates this link's contributions to the network system of equations.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Sets the link source vector for inclusion into the network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  convergedStep  (--)  Not used.
/// @param[in]  absoluteStep   (--)  Not used.
///
/// @returns  GunnsBasicLink::SolutionResult  (--)  Always returns CONFIRM.
///
/// @details  This link never has a reason to reject or delay the solution so it always confirms.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                (--) Link name
/// @param[in] nodes               (--) Network nodes array
/// @param[in] defaultResistance   (ohm) Default resistance of the link
///
/// @details  Constructs the Resistive Load Config data
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Resistive Load Object
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Override processOutputs method. This is called by solver after solution converges.
///           It is used here to set PowerValid.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name   (--)  Link name.
/// @param[in] nodes  (--)  Network nodes array.
///
/// @details  Constructs the Electrical Short Config data.  The base class default conductivity term
///           is zeroed and isn't used.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag         (--)  Initial blockage malfunction flag.
/// @param[in] malfBlockageValue        (--)  Initial blockage malfunction fractional value (0-1).
/// @param[in] malfMinimumVoltage       (V)   Initial minimum voltage for all malfunction modes to flow.
/// @param[in] malfConstantPowerFlag    (--)  Initial constant power short malfunction activation flag.
/// @param[in] malfConstantPowerValue   (W)   Initial constant power short malfunction value.
/// @param[in] malfConstantCurrentFlag  (--)  Initial constant current short malfunction activation flag.
/// @param[in] malfConstantCurrentValue (amp) Initial constant current short malfunction value.
/// @param[in] malfInitialPowerFlag     (--)  Initial initial power short malfunction activation flag.
/// @param[in] malfInitialPowerValue    (W)   Initial initial power short malfunction value.
/// @param[in] malfInitialCurrentFlag   (--)  Initial initial current short malfunction activation flag.
/// @param[in] malfInitialCurrentValue  (amp) Initial initial current short malfunction value.
/// @param[in] malfResistanceFlag       (--)  Initial constant resistance short malfunction activation flag.
/// @param[in] malfResistanceValue      (ohm) Initial constant resistance short malfunction value.
///
/// @details  Default constructs this Electrical Short input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Electrical Short Object.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfMinimumVoltage       (V)   Initial minimum voltage for all malfunction modes to flow.
/// @param[in] malfConstantPowerFlag    (--)  Initial constant power short malfunction activation flag.
/// @param[in] malfConstantPowerValue   (W)   Initial constant power short malfunction value.
/// @param[in] malfConstantCurrentFlag  (--)  Initial constant current short malfunction activation flag.
/// @param[in] malfConstantCurrentValue (amp) Initial constant current short malfunction value.
/// @param[in] malfInitialPowerFlag     (--)  Initial initial power short malfunction activation flag.
/// @param[in] malfInitialPowerValue    (W)   Initial initial power short malfunction value.
/// @param[in] malfInitialCurrentFlag   (--)  Initial initial current short malfunction activation flag.
/// @param[in] malfInitialCurrentValue  (amp) Initial initial current short malfunction value.
/// @param[in] malfResistanceFlag       (--)  Initial constant resistance short malfunction activation flag.
/// @param[in] malfResistanceValue      (ohm) Initial constant resistance short malfunction value.
///
/// @details  Default constructs this Electrical Short Utility input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the Electrical Short Utility object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  inputData  (--) Reference to the model input data.
///
/// @details  Initializes the Electrical Short Utility object with input data.
////////////////////////////////////////////////////////////////////////////////////////////////////