////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests link update using a network step() method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Makes sure the net sum of the external heat fluxes is communicated into the link's
///           mSourceVector, which is used as an input to GUNNS.
////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////////////
///// @details  Tests correct recording of mTemperature from the link's mPotentialVector.
//////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


/**************************************************************************************************/
/* ConfigData class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  nodeFile  (--)  xml file with node & capacitance link data
/// @param[in]  condFile  (--)  xml file with conduction link data
/// @param[in]  radFile   (--)  xml file with radiation link data
/// @param[in]  htrFile   (--)  xml file with heater link data
/// @param[in]  panFile   (--)  xml file with thermal-panel data
/// @param[in]  etcFile   (--)  xml file with other thermal link data (potentials, sources, etc)
///
/// @details    Constructs this ThermalNetwork configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


/**************************************************************************************************/
/* InputData class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  thermInputFile  (--)  xml file with thermal input override data
///
/// @details    Constructs this ThermalNetwork input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


/**************************************************************************************************/
/* ThermalNetwork class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Default ThermalNetwork constructor. Defaults all pointers to zero.
///             Stores the name of the network.  The base network is constructed with zero node
///             count and null pointer to the nodes array -- these must be set during network
///             initialization.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name  (--)  string representing the name of this thermal network
///
/// @details  Tells the network's ThermFileParser object to parse the configuration files and
///           populate its vectors with the data found.  The appropriate space on the heap is
///           allocated based on the number of links of each type.  Config/Input data objects are
///           constructed with the corresponding data from the config-files.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Initializes the links with their node map assignments and Config/Input data, and
///           initializes the built-in network island analyzer spotter.  If this is not a sub-
///           network in a super-network the network solver is initialized with default Config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Performs "pre" logic prior to loading a checkpoint.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Restarts the ThermalNetwork by calling the GUNNS restart() function.
///
/// @note   Super-networks will not call this function when they restart, so the only way to get the
///         restartCapacitanceGroups() function to run is to add a separate restart job for each
///         ThermalNetwork sub-network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  timeStep  (s)  integration time step
///
/// @details    Updates the pre-solution functions including heater power, capacitor group edits,
///             and spotters.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  timeStep  (s)  integration time step
///
/// @details    Updates the post-solution functions including spotters.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Allocates and initializes the network's nodes objects.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Builds config/input data arrays for each link-type. The data stored in the network's
///           ThermFileParser object is passed into the constructor of each link's
///           config or input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Initializes arrays for links of each type. A Gunns object is created for every link
///           listed in the config-files. Each object is then initialized with its appropriate
///           port numbers and config/input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  i  (--)  index of specific link within Capacitance arrays
///
/// @details  Sub-function to initialize a specific Capacitance link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  i  (--)  index of specific link within Conduction arrays
///
/// @details  Sub-function to initialize a specific Conduction link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  i  (--)  index of specific link within Radiation arrays
///
/// @details  Sub-function to initialize a specific Radiation link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  i  (--)  index of specific link within Heater arrays
///
/// @details  Sub-function to initialize a specific Heater link. As an argument to its initialize()
///           method, a GunnsThermalHeater takes a pointer to a vector of ints. This vector should
///           contain the numbers of all the nodes to which the heater is connected. The size of
///           the vector should match the size of the power-draw fraction loaded into config data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  i  (--)  index of specific link within Panel arrays
///
/// @details  Sub-function to initialize a specific Panel link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  i  (--)  index of specific link within Potential arrays
///
/// @details  Sub-function to initialize a specific Potential link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  i  (--)  index of specific link within Source arrays
///
/// @details  Sub-function to initialize a specific Source link
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throw    TsInitializationException if there is a null pointer
///
/// @details  Validates this Thermal Network initial state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Loops through each heater, setting its electrical power. If the HtrMiswire malf is
///           active, a heater might receive power from the incorrect electrical circuit.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  For each capacitance edit group, detects a change in the capacitance scale factor
///           control, and for each capacitor link in that group, scales its capacitance by the
///           ratio of the new control value over the old value.  This allows entire groups of
///           capacitors to be edited simultaneously.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  For each capacitance edit group, revert the applicable capacitance links back to
///           default capacitances prior to loading checkpoint.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  For each capacitance edit group, Apply current scale factor to capacitive links
///           after loading checkpoint.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  For the given capacitance edit group, apply capacitance ratio to capacitance of
///           applicable links
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Deletes allocated arrays and config/input objects
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] flag  (--) Malfunction activation flag, true activates.
/// @param[in] index (--) Array of heater wiring indices during active malfunction.
///
/// @details  Sets the malf parameters to the given values.  Calling this method with default
///           arguments resets the malfunction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsParseException
///
/// @details  This calls the file parser to do a pre-count of the number of nodes, stores it in
///           the base network's number of nodes, and finally returns the value.
////////////////////////////////////////////////////////////////////////////////////////////////////


/**************************************************************************************************/
/* ThermFileParser class */
////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Constructs the ThermFileParser with the name of the network as an argument.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throw    TsParseException
///
/// @details  This is intended to be called prior to the initialize method, to count and store the
///           number of nodes for a ThermalNetwork to access prior to its initialization when used
///           in a super-network.
///
/// @note  This leaves numNodes != 0, so the readNodeFile method must reset it to zero prior to
///        counting nodes again.
///
/// @note  Since this function is intended to be called prior to initialization, H&S errors thrown
///        from the call to readFile won't have an instance name.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  name  (--)  Name of object, usually the same as the associated ThermalNetwork.
///
/// @details  Parses thermal xml files and builds data vectors.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throw      TsParseException if mNodeFile member is null
///
/// @details    Builds data vectors by parsing a node config-file. The node file contains
///             an XML inventory of all nodes and their associated data.
///             The list of nodes is also used to build a vector of capacitive links, since a
///             capacitive link is simply a connection between one node and vacuum.
///
/// @note       The node file should be in the following format. It should end with a SPACE node
///             that has zero capacitance.
///             \verbatim
///             <?xml version="1.0" ?>
///             <list>
///                 <node>
///                     <name>LAB_1</name>
///                     <temperature units='K'>300.00</temperature>
///                     <capacitance units='J/K'>2256.10</capacitance>
///                 </node>
///                 <node>
///                     <name>SPACE_1</name>
///                     <temperature units='K'>0.00</temperature>
///                     <capacitance units='J/K'>0.00</capacitance>
///                 </node>
///             </list>
///             \endverbatim
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Builds data vectors by parsing a conduction-link config-file. The cond-file contains
///             an XML inventory of all conduction links and their associated data.
///
/// @note       The conduction-link file should be in the following format.
///             \verbatim
///             <?xml version="1.0" ?>
///             <list>
///                 <conduction>
///                     <node0>LAB_CVIU_1</node0>
///                     <node1>LAB_STRUCT_D_1</node1>
///                     <conductivity units='W/K'>1.000000</conductivity>
///                 </conduction>
///                 <conduction>
///                     <node0>LAB_CP_D0_7</node0>
///                     <node1>LAB_MDM_1</node1>
///                     <conductivity units='W/K'>1.000000</conductivity>
///                 </conduction>
///             </list>
///             \endverbatim
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Builds data vectors by parsing a radiation-link config-file. The rad-file contains
///             an XML inventory of all radiation links and their associated data.
///
/// @note       The radiation-link file should be in the following format.
///             \verbatim
///             <?xml version="1.0" ?>
///             <list>
///                 <radiation>
///                     <node0>P1_ATA_PALLET_1</node0>
///                     <node1>SPACE_1</node1>
///                     <coefficient units='m2'>4.079400</coefficient>
///                 </radiation>
///                 <radiation>
///                     <node0>S1_RAD_11</node0>
///                     <node1>SPACE_1</node1>
///                     <coefficient units='m2'>13.843000</coefficient>
///                 </radiation>
///             </list>
///             \endverbatim
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Builds data vectors by parsing a heater registry config-file. The htr-file contains
///             an XML inventory of all heaters and source links  and their associated data.
///
/// @note       The heater file should be in the following format. Only the <name>, <node>, and
///             <tune> data is parsed by this class. The other data is relevant to the electrical
///             and signal aspects.
///             \verbatim
///             <?xml version="1.0" ?>
///             <list>
///                 <source name='src_AL_dissipation'>
///                     <node>AL_DISSIPATION_1</node>
///                     <flux units='W'>20.0</flux>
///                 </source>
///                 <heater name='htr_AL_shell_1P'>
///                     <node>AL_SHELL_11<frac>0.143</frac></node>
///                     <node>AL_SHELL_12<frac>0.357</frac></node>
///                     <node>AL_SHELL_13<frac>0.143</frac></node>
///                     <node>AL_SHELL_14<frac>0.357</frac></node>
///                     <scalar>1.0</scalar>
///                     <control type='MDM'>
///                         <lower units='K'>270</lower>
///                         <upper units='K'>280</upper>
///                     </control>
///                     <elec isRegistered='true'>
///                         <powerSource>rpcm AL1A4A B</powerSource>
///                         <rpc>7</rpc>
///                         <ohms>41.46</ohms>
///                     </elec>
///                     <info>RTD 1: W031RT001; RTD 2: W031RT002</info>
///                 </heater>
///                 <heater name='htr_AL_shell_1S'>
///                     <node>AL_SHELL_11<frac>0.00</frac></node>
///                     <node>AL_SHELL_12<frac>0.4285</frac></node>
///                     <node>AL_SHELL_13<frac>0.143</frac></node>
///                     <node>AL_SHELL_14<frac>0.4285</frac></node>
///                     <scalar>1.0</scalar>
///                     <control type='thermostat'>
///                         <instance isInstantiated='true'>tstatAlShell1S</instance>
///                         <sensors>2</sensors>
///                         <logicType>OR</logicType>
///                         <lower units='K'>290</lower>
///                         <upper units='K'>300</upper>
///                     </control>
///                     <elec isRegistered='true'>
///                         <powerSource>rpcm N1RS1 B</powerSource>
///                         <rpc>1</rpc>
///                         <ohms>41.46</ohms>
///                     </elec>
///                     <info>RTD 1: W019RT011; RTD 2: W019RT012</info>
///                 </heater>
///             </list>
///             \endverbatim
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Builds data vectors by parsing a thermal-panel config-file. The pan-file contains
///             an XML inventory of all thermal-panels and their associated data.
///
/// @note       The panel file should be in the following format. Only the <name>, <node>, <area>,
///             and <absorp> data is parsed by this class. The other data is relevant to the
///             environment aspect.
///             \verbatim
///             <panel name='pan_CUP_WIN_1'>
///                 <node>CUP_WIN_1</node>
///                 <des>cupola panel win1</des>
///                 <area units='m2'>0.298</area>
///                 <absorp>0.22</absorp>
///                 <frame>N3</frame>
///                 <position units='m'>
///                     <x>-0.734</x>
///                     <y>-0.001</y>
///                     <z>-2.966</z>
///                 </position>
///                 <surfaceNormal units='m'>
///                     <x>-0.866</x>
///                     <y>0</y>
///                     <z>-0.5</z>
///                 </surfaceNormal>
///             </panel>
///             \endverbatim
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Builds data vectors by parsing an etc-file, the thermal config-file that contains
///             all remaining link types ("et cetera"). The etc-file contains
///             an XML inventory of all potential links and their associated data.
///
/// @note       The etc-file should be in the following format.
///             \verbatim
///             <?xml version="1.0" ?>
///             <list>
///                 <potential>
///                     <name>Airlock air</name>
///                     <node>AL_AIR_1</node>
///                     <temperature units='K'>296.0</temperature>
///                     <conductivity units='W/K'>1e12</conductivity>
///                 </potential>
///                 <potential>
///                     <name>sublimator</name>
///                     <node>AL_EMU_SUB_1</node>
///                     <temperature units='K'>296.00</temperature>
///                     <conductivity units='W/K'>1e12</conductivity>
///                 </potential>
///             </list>
///             \endverbatim
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details    Edits existing link data by reading overrides described in the ThermInput file.
///
/// @note       The ThermInput-file should be in the following format.
///             \verbatim
///             <?xml version="1.0" ?>
///             <list>
///                 <node name='CECLSS_26'>
///                     <initTemp units='K'>12.34</initTemp>
///                 </node>
///                 <node name='CECLSS_46'>
///                     <initTemp units='K'>56.78</initTemp>
///                 </node>
///             </list>
///             \endverbatim
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out]  doc      (--) TiXmlDocument object to load XML file data into
/// @param[in]      xmlFile  (--) path and name of XML file
///
/// @throw      TsParseException if unable to access file or if XML load fails
///
/// @details    Loads given xml file into TiXmlDocument member.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Clears Node name vector and map object. Resets the number of Nodes count.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Clears Capacitance link temperature, capacitance, and name vectors. Resets the
///           number of Capacitance links count.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Clears Conduction link name, port0, port1, and conductivity vectors. Resets the
///           number of Conduction links count.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Clears Radiation link port0, port1, coefficient, and name vectors. Resets the
///           number of Radiation links count.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Clears Heater ports, efficiency, name, and fraction vectors. Resets the
///           number of Heaters count.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Clears ThermalPanel port1, name, surface area, absorptivity, and view factor vectors.
///           Resets the number of ThermalPanels count.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Clears Potential link node, name, temperature, and conductivity vectors. Resets the
///           number of Potential links count.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Clears Source port, flux, and name vectors. Resets the
///           number of Sources count.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  node  (--)  TiXmlElement pointer to a set of <node> data
///
/// @details  Adds the node name to the map key, assigning to it the value of the numNodes count,
///           which is later incremented. Also pushes the node onto the node names vector.
///           Populates Capacitance link vectors with the strings stored in the tags
///           from the node-file. The Capacitance links count is then incremented as well.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  conduction  (--)  TiXmlElement pointer to a set of <conduction> data
///
/// @details  Populates conduction link vectors with the strings stored in the tags
///           from the cond-file. The conduction links count is then incremented.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  radiation  (--)  TiXmlElement pointer to a set of <radiation> data
///
/// @details  Populates radiation link vectors with the strings stored in the tags
///           from the rad-file. The radiation links count is then incremented.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  heater  (--)  TiXmlElement pointer to a set of <heater> data
///
/// @details  Populates heater link vectors with the strings stored in the tags
///           from the htr-file. The heater links count is then incremented.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  panel  (--)  TiXmlElement pointer to a set of <panel> data
///
/// @details  Populates panel link vectors with the strings stored in the tags
///           from the pan-file. The panel links count is then incremented.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  potential  (--)  TiXmlElement pointer to a set of <potential> data
///
/// @details  Populates potential link vectors with the strings stored in the tags
///           from the etc-file. The potential links count is then incremented.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  source  (--)  TiXmlElement pointer to a set of <source> data
///
/// @details  Populates source link vectors with the strings stored in the tags
///           from the etc-file. The source links count is then incremented.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  node  (--)  TiXmlElement pointer to a set of <node> input data
///
/// @details  Edits data on the previously registered node.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  radiation  (--)  TiXmlElement pointer to a set of <radiation> input data
///
/// @details  Edits data on the previously registered radiation link object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] parent   (--)  pointer to parent XML element
/// @param[in] linkType (--)  the type of link (rad,pot,htr,etc.) currently being processed
///
/// @return   name (--) string with text from the "name" attribute within the XML element
///
/// @details  Private method used to get the name attribute of a TinyXML element.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] parent  (--) pointer to parent XML element
/// @param[in] tag     (--) name of tag interested in getting
///
/// @throw    TsParseException if no text is given within the XML tag
///
/// @return   text (--) string with text from XML element
///
/// @details  Private method used to safely get the text from a tag in an XML element.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] parent               (--) pointer to parent XML element
/// @param[in] tag                  (--) name of tag interested in getting
/// @param[in] raiseErrorIfNotFound (--) optional, default true; if true, method throws exception
///                                      if the tag cannot be found
///
/// @throw    TsParseException if cannot find the given tag within the parent element
///
/// @return    child   (--) pointer to child XML element
///
/// @details  Private method used to return an element in an XML tree.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  parent  (--) pointer to parent XML element
/// @param[in]  tag     (--) name of tag interested in counting
///
/// @details  Private method used to count elements.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  node  (--)  TiXmlElement pointer to a set of <node> config data
///
/// @return   groupId (--)  integer identifying the capacitance-edit-group identifier
///
/// @details  Private method used to determine the index of a cap-edit-group name within the
///           vCapEditGroupList vector.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out]  vectorInt    (--)  pointer to vector<int> holding port numbers for a multi-port link
/// @param[in,out]  vectorDouble (--)  pointer to vector<double> holding flux-application-fractions for a multi-port link
/// @param[in]      parent       (--)  pointer to XML element
/// @param[in]      linkType     (--)  the type of link (rad,pot,htr,etc.) currently being processed
/// @param[in]      name         (--)  the name of the specific link currently being processed
///
/// @details  Builds ports and fractions vectors for multi-port links.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  nodeName  (--)  name of node in question
///
/// @return     The index of the node within the node map object. If the node is not valid,
///             an exception is thrown.
///
/// @throw      TsParseException on a node that is not valid.
///
/// @details    Verifies that a node name provided in a config-file is valid.
///             A node would NOT be valid if
///               (A) a node/capacitance link is requesting a node that is blank or
///                   has already been registered, or
///               (B) any other type of link is requesting a node that is not found in the node
///                   map. This happens if the node was not included in the node-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  nodeName  (--)  the name of a node (e.g. "LAB_STRUCT_1")
///
/// @return     The value of the node name within the node map object. If the node is not found,
///             the method returns a NOT_FOUND.
///
/// @details    Returns the location of the node within the node map. This method is used to
///             determine the nodes that a Gunns link connects to. Thermal Desktop describes
///             a node with a string, and Gunns needs to reference that node with an integer.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throw    TsParseException if the capacitance vector is empty
///
/// @details  Checks whether the space/ground/vacuum node is given at the end of the node list.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  count    (--)  number of links found after file parsing
/// @param[in]  fileType (--)  the type of file (rad,pot,htr,etc.) currently being processed
/// @param[in]  xmlFile  (--)  XML file path and name
///
/// @throw    TsParseException if the count is zero
///
/// @details  Checks whether the parsed file contained the expected data.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for appropriate handling of off-nominal file parsing.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct build of Node data from node-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct build of Capacitance link data from node-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct build of Conduction link data from cond-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct build of Radiation link data from rad-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct build of Heater data from htr-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct build of ThermalPanel data from pan-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct build of Potential link data from etc-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct build of Source link data from etc-file.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct edit of data by reading of ThermInput file.
////////////////////////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for appropriate configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for appropriate input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for appropriate initialization of ThermalNetwork. Since initialize() takes up to
///           three config-files as arguments, there are several different combinations to test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for appropriate building of link configuration data. The test makes sure that
///           the config data matches up with the data vectors in the parser object.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for appropriate building of link configuration data. The test makes sure that
///           the link input data matches up with the default input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for appropriate link initialization. The test makes sure that the NodeMap
///           for each link matches up with the port numbers described in the config-files.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for correct handling of null pointers.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for appropriate updating of ThermalNetwork.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests access to link members.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests ability to temporarily edit a group of capacitance links.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests the ThermalNetwork as a sub-network in a super-network.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics Euler Angles Factory.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default destructs this GUNNS Dynamics Euler Angles Factory.  Also deletes all objects
///           that this factory has created.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  sequence  (--)  The desired Euler rotation sequence, either as an enumeration (XYZ)
///                             or as an integer (123).
///
/// @throws   TsOutOfBoundsException
///
/// @returns  GunnsDynEulerBase* (--) Base class pointer to the desired Euler sequence type.
///
/// @details  Creates an Euler sequence object of the given sequence, returns a pointer to that
///           object, and stores the pointer in a vector for later use in the destructor.  Throws an
///           exception if an invalid sequence is given.
///
/// @note  The caller should not delete the actual object being pointed to, as this factory will
///        delete the actual object during its destruction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] position      (m)     Pointer to initial position vector of body frame in inertial frame, expressed in inertial frame.
/// @param[in] velocity      (m/s)   Pointer to initial velocity vector of body frame in inertial frame, expressed in inertial frame.
/// @param[in] eulerSequence (--)    Euler rotation sequence to use.
/// @param[in] eulerAngles   (rad)   Pointer to initial Euler rotations of the body frame in the inertial frame, in the given sequence.
/// @param[in] angVelocity   (rad/s) Pointer to initial angular velocity vector of body frame in inertial frame, expressed in body frame.
/// @param[in] massProps     (--)    Pointer to initial body mass properties.
///
/// @details  Constructs this input data with optional arguments.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics Single Rigid-Body Equations of Motion.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name      (--) Instance name for error messaging.
/// @param[in] inputData (--) Input data.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this GUNNS Dynamics Single Rigid-Body Equations of Motion.  This should be
///           called with input data before calling any other functions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] inputData (--) Input data.
///
/// @throws   TsInitializationException
///
/// @details  Validates the input data and throws a H&S error message and an exception on any
///           failures.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Updates the state derivative.  This should be called from a Trick derivative job or
///           equivalent, before integ() in each cycle.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsInitializationException
///
/// @details  Updates the state.  This should be called from a Trick integration job or equivalent,
///           after update() in each cycle.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] sequence (--) The axis sequence (123, etc) of Euler rotations.
///
/// @details  Default constructs this GUNNS Dynamics Euler Angles Base.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] quat  (--) Pointer to the quaternion to be updated.
/// @param[in] euler (--) Optional pointer to new Euler angles to use and store.
///
/// @details  Updates the currently stored Euler angles if new angles are provided, then updates the
///           given quaternion from the currently stored angles.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] quat (--) Pointer to the quaternion to compute from.
///
/// @throws   TsNumericalException
///
/// @details  This updates the Euler angles from the given quaternion.  This method is best used
///           when the previous angle values are not up-to-date.  This throws an exception and sets
///           the Euler angles to nan for a bad quaternion at a singularity condition.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics Euler Angles 132-Sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] quat (--) Pointer to the quaternion to be set.
/// @param[in]  s1   (--) Sine of the X-axis half-rotation.
/// @param[in]  c1   (--) Coine of the X-axis half-rotation.
/// @param[in]  s2   (--) Sine of the Y-axis half-rotation.
/// @param[in]  c2   (--) Coine of the Y-axis half-rotation.
/// @param[in]  s3   (--) Sine of the Z-axis half-rotation.
/// @param[in]  c3   (--) Coine of the Z-axis half-rotation.
///
/// @details  Computes the quaternion elements for this sequence given the sines and cosines of the
///           half-angle rotations.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] quat    (--) The quaternion to compute the angles from from.
/// @param[in] rot2sin (--) The sine of the 2nd rotation.
///
/// @details  Computes Euler angles for this sequence, assuming we are not near a singularity
///           condition.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] quat    (--) The quaternion to compute the angles from from.
///
/// @details  Computes Euler angles for this sequence, assuming we are near the +pi/2 singularity
///           condition.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] quat    (--) The quaternion to compute the angles from from.
///
/// @details  Computes Euler angles for this sequence, assuming we are near the -pi/2 singularity
///           condition.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics Euler Angles 123-Sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vA   (--) Pointer to the vector (an array) to be set.
/// @param[in]  vB   (--) Pointer to the Vector (an array) to be set equal to.
/// @param[in]  size (--) Size of the vector to set.
///
/// @details  Sets each element of vA equal to that element in vB, up to the given array size.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vA   (--) Pointer to the vector (an array) to be cleared.
/// @param[in]  size (--) Size of the vector to clear.
///
/// @details  Zeroes every element in the given array up to the given size.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vA   (--) Pointer to the resulting sum (an array).
/// @param[in]  vB   (--) Pointer to the first vector (an array) to be summed.
/// @param[in]  vC   (--) Pointer to the second vector (an array) to be summed.
/// @param[in]  size (--) Size of the vectors.
///
/// @details  Adds each element of the two given arrays up to the given array size.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vA   (--) Pointer to the resulting sum (an array).
/// @param[in]  vB   (--) Pointer to the vector (an array) to be subtracted from.
/// @param[in]  vC   (--) Pointer to the vector (an array) to be subtracted.
/// @param[in]  size (--) Size of the vectors.
///
/// @details  Subtracts each element of the second given array from the first, up to the given array
///           size.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vA   (--) Pointer to the resulting scaled vector (an array).
/// @param[in]  vB   (--) Pointer to the vector (an array) to scale.
/// @param[in]  sC   (--) The scalar value in the multiplication.
/// @param[in]  size (--) Size of the vectors.
///
/// @details  Multiplies every element of the given vector by the given scalar, up to the given
///           array size.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vA   (--) Pointer to the resulting vector cross product (an array).
/// @param[in]  vB   (--) Pointer to the left-side vector (an array) in the operation.
/// @param[in]  vC   (--) Pointer to the right-side vector (an array) in the operation.
///
/// @details  Does the vector cross product of two size 3 vectors.  The vA can also be used as
///           either or both inputs, e.g. {A} = {A} X {C}, {A} = {B} X {A} or {A} = {A} X {A}.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vA   (--) Pointer to the resulting product vector (an array).
/// @param[in]  mB   (--) Pointer to the square matrix (a single-dimension array) to be multiplied.
/// @param[in]  vC   (--) Pointer to the vector (an array) to be multiplied.
/// @param[in]  size (--) Size of the vector and the number of matrix rows.
///
/// @details  mC must be square.  Multiplies matrix mC by vector vC.  Result vA can also point to
///           the same array as vC, e.g. {A} = [B] * {A}.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] vA   (--) Pointer to the resulting product vector (an array).
/// @param[in]  mB   (--) Pointer to the square matrix (a single-dimension array) to be multiplied.
/// @param[in]  vC   (--) Pointer to the vector (an array) to be multiplied.
/// @param[in]  size (--) Size of the vector and the number of matrix rows.
///
/// @details  mC must be square.  Multiplies the transpose of matrix mC by vector vC.  Result vA can
///           also point to the same array as vC, e.g. {A} = [B] * {A}.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] mA (--) Pointer to the resulting skew matrix (a single-dimension array of size 9).
/// @param[in]  vA (--) Pointer to the vector (an array) to compute the skew of.
///
/// @details  Computes the skew-symmetric 3x3 matrix of the given 3-vector.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] vA   (--) The first vector (an array) in the dot product.
/// @param[in] vB   (--) The second vector (an array) in the dot product.
/// @param[in] size (--) Size of the vectors.
///
/// @returns  double (--) The scalar result of the vector dot product.
///
/// @details  Computes and returns the vector dot product, a scalar value.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] qDot (--) Pointer to the resulting quaternion derivative.
/// @param[in]  q    (--) Pointer to the quaternion to differentiate.
/// @param[in]  w    (--) Pointer to the angular velocity vector in the derivative.
///
/// @details  Computes the time derivative of the input quaternion q by the angular velocity vector
///           w.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] mA (--) Pointer to the 3x3 rotation transformation matrix (as a single-dimension array).
/// @param[in]  qA (--) Pointer to the quaternion.
///
/// @details  Computes the rotation transformation matrix corresponding to the given left-handed
///           scalar-first quaternion.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] qA (--) Pointer to the quaternion.
/// @param[in]  mA (--) Pointer to the 3x3 rotation transformation matrix (as a single-dimension array).
///
/// @throws   TsNumericalException
///
/// @details  Computes the left-handed scalar-first quaternion corresponding to the given rotation
///           transformation matrix.  This quaternion is not normalized.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out] q (--) The quaternion.
///
/// @details  Normalizes the given quaternion to have a magnitude of 1.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in,out] v (--) The vector.
///
/// @throws   TsNumericalException
///
/// @details  Normalizes the given vector to have a magnitude of 1.  If the vector magnitude is too
///           small, this throws an exception and leaves the vector unchanged.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in, out] v    (--) The vector.
/// @param[in]      size (--) Size of the vector.
///
/// @returns  bool (--) True if the normalize succeeded, false if it failed.
///
/// @details  If the given vector magnitude is sufficient for dividing, this normalizes the vector
///           to have a magnitude of 1, and returns true indicating success.  Otherwise leaves the
///           vector unchanged and returns false indicating failure.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] v    (--) Pointer to the vector (an array) to get the magnitude of.
/// @param[in] size (--) The number of elements in the vector.
///
/// @returns  double (--) The vector magnitude.
///
/// @details  Returns the magnitude as the sum of the squares of each array element.
////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] mA    (--) Pointer to the single-dimension array being set.
/// @param[in]  mB    (--) Pointer to the single-dimnesion array used to set.
/// @param[in]  size  (--) The number of rows of the square matrices, e.g. a 3x3 matrix is size 3.
///
/// @details  Sets mA to mB value by value.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] mA   (--) Pointer to the single-dimension array for the resulting product matrix.
/// @param[in]  mB   (--) Pointer to the single-dimension array for the left-side matrix in the multiplication.
/// @param[in]  mC   (--) Pointer to the single-dimension array for the right-side matrix in the multiplication.
/// @param[in]  size (--) The number of rows of the square matrices, e.g. a 3x3 matrix is size 3.
///
/// @details  All matrices must be square and have the same size.  The mA can also be used as either
///           or both inputs, e.g. [A] = [A] * [C], [A] = [B] * [A], or [A] = [A] * [A].
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] v    (--) Pointer to the vector (an array) to check.
/// @param[in] size (--) The number of elements in the vector.
///
/// @returns  bool (--) False when all vector elements are exactly zero, true otherwise.
///
/// @details  Returns true when any of the vector elements are non-zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] mass (kg)    Body mass.
/// @param[in] cm   (m)     Pointer to center of mass location in the body frame.
/// @param[in] ixx  (kg*m2) Body X moment of inertia about the center of mass in the body frame.
/// @param[in] ixy  (kg*m2) Body XY product of inertia about the center of mass in the body frame.
/// @param[in] ixz  (kg*m2) Body XZ product of inertia about the center of mass in the body frame.
/// @param[in] iyy  (kg*m2) Body Y moment of inertia about the center of mass in the body frame.
/// @param[in] iyz  (kg*m2) Body YZ product of inertia about the center of mass in the body frame.
/// @param[in] izz  (kg*m2) Body Z moment of inertia about the center of mass in the body frame.
///
/// @details  Contructs this mass properties with optional arguments.  Note this doesn't validate
///           the constructed state.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Mass properties object to be copied.
///
/// @details  Copy constructs this mass properties.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Mass properties object to be compared to.
///
/// @returns  bool (--) True if this mass properties is identical to that, false otherwise.
///
/// @details  Returns whether this mass properties is identical to that.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsOutOfBoundsException
///
/// @details  Checks this mass properties state for valid data and throws an exception if any terms
///           are out of valid range.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics Euler Angles 321-Sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics Euler Angles 213-Sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics Euler Angles 312-Sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics Euler Angles 231-Sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] state     (--) Reference to body rotational state.
/// @param[in] massProps (--) Reference to body mass properties.
///
/// @details  Default constructs this Single Rigid-Body EOM State Derivative link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name (--) Reference to instance name for output messages.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Single Rigid-Body EOM State Derivative link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @throws   TsOutOfBoundsException, TsNumericalException, TsInitializationException
///
/// @details  Validates the mass properties, computes total active forces & torques, uses the GUNNS
///           solver to compute new translational & angular accelerations, and updates the rate
///           quaternion.
///
///           This will throw exceptions if this object hasn't been initialized, or if given bad
///           mass properties.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Builds the link admittance matrix [A] for the GUNNS solver.  This is the 6x6 mass
///           matrix from Eqn. 2.5.5, with coupling between the translational and rotational DOF's
///           due to the CM offset in the body reference frame {cm}:
///           [A] = [  m[I]        -m[cm~]      ]   <-- 3 rows translational
///                 [ m[cm~]  [Icm]-m[cm~][cm~] ]   <-- 3 rows rotational
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Builds the link source vector for the GUNNS solver.  This includes all of the vector
///           terms in Eqn. 2.5.5, including applied & gyroscopic forces & torques.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Loops over all of the applied force objects, and for those that are active, adds their
///           force into the total mAppliedForce.  This does not include the torque from the forces'
///           offset from the center of mass.  That is included in sumAppliedTorques().
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Loops over all the applied torque objects, and for those that are active, adds their
///           torque into the total mAppliedTorque.  Also loops over active applied force objects
///           and adds their (location X force) torque.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Zeroes various internal arrays.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Single Rigid-Body EOM unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] p0 (--) Pointer to position state 0th element.
/// @param[in] p1 (--) Pointer to position state 1st element.
/// @param[in] p2 (--) Pointer to position state 2nd element.
/// @param[in] v0 (--) Pointer to velocity state 0th element.
/// @param[in] v1 (--) Pointer to velocity state 1st element.
/// @param[in] v2 (--) Pointer to velocity state 2nd element.
/// @param[in] q0 (--) Pointer to quaternion state 0th element.
/// @param[in] q1 (--) Pointer to quaternion state 1st element.
/// @param[in] q2 (--) Pointer to quaternion state 2nd element.
/// @param[in] q3 (--) Pointer to quaternion state 3rd element.
/// @param[in] w0 (--) Pointer to angular velocity state 0th element.
/// @param[in] w1 (--) Pointer to angular velocity state 1st element.
/// @param[in] w2 (--) Pointer to angular velocity state 2nd element.
///
/// @brief    Integrator load state global method.
///
/// @details  This takes the place of Trick infrastructure since we don't use Trick in our tests.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] p0 (--) Pointer to position state derivative 0th element.
/// @param[in] p1 (--) Pointer to position state derivative 1st element.
/// @param[in] p2 (--) Pointer to position state derivative 2nd element.
/// @param[in] v0 (--) Pointer to velocity state derivative 0th element.
/// @param[in] v1 (--) Pointer to velocity state derivative 1st element.
/// @param[in] v2 (--) Pointer to velocity state derivative 2nd element.
/// @param[in] q0 (--) Pointer to quaternion state derivative 0th element.
/// @param[in] q1 (--) Pointer to quaternion state derivative 1st element.
/// @param[in] q2 (--) Pointer to quaternion state derivative 2nd element.
/// @param[in] q3 (--) Pointer to quaternion state derivative 3rd element.
/// @param[in] w0 (--) Pointer to angular velocity state derivative 0th element.
/// @param[in] w1 (--) Pointer to angular velocity state derivative 1st element.
/// @param[in] w2 (--) Pointer to angular velocity state derivative 2nd element.
///
/// @brief    Integrator load state derivative global method.
///
/// @details  This takes the place of Trick infrastructure since we don't use Trick in our tests.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief    Integrator integrate global method.
///
/// @returns  int (--) Integration step counter.
///
/// @details  This takes the place of Trick infrastructure since we don't use Trick in our tests.
///           This implements an Euler integration.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out] p0 (--) Pointer to position state 0th element.
/// @param[out] p1 (--) Pointer to position state 1st element.
/// @param[out] p2 (--) Pointer to position state 2nd element.
/// @param[out] v0 (--) Pointer to velocity state 0th element.
/// @param[out] v1 (--) Pointer to velocity state 1st element.
/// @param[out] v2 (--) Pointer to velocity state 2nd element.
/// @param[out] q0 (--) Pointer to quaternion state 0th element.
/// @param[out] q1 (--) Pointer to quaternion state 1st element.
/// @param[out] q2 (--) Pointer to quaternion state 2nd element.
/// @param[out] q3 (--) Pointer to quaternion state 3rd element.
/// @param[out] w0 (--) Pointer to angular velocity state 0th element.
/// @param[out] w1 (--) Pointer to angular velocity state 1st element.
/// @param[out] w2 (--) Pointer to angular velocity state 2nd element.
///
/// @brief    Integrator unload state global method.
///
/// @details  This takes the place of Trick infrastructure since we don't use Trick in our tests.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM nominal initialization without
///           exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM restart method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM addAppliedForce and
///           addAppliedTorque methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM update method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM update method with an offset of
///           the center of mass in the body reference frame.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM update method exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Single Rigid-Body Mass Properties unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body Mass Properties default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body Mass Properties copy construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body Mass Properties assignment operator.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body Mass Properties equals operator.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body Mass Properties validate method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Single Rigid-Body EOM State Derivative unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM State Derivative default construction.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM State Derivative nominal initialization without
///           exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM State Derivative initialization exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM State Derivative restart method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM State Derivative addAppliedForce and
///           addAppliedTorque methods.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM State Derivative update method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM State Derivative update method with an offset of
///           the center of mass in the body reference frame.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Single Rigid-Body EOM State Derivative update method exceptions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Dynamics math utilities unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Dynamics math utilities dotV method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Dynamics math utilities MtoQ method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Dynamics math utilities normalizeQ method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Dynamics math utilities normalizeV method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Dynamics math utilities normalizeVSuccess method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Dynamics math utilities setM method.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Default constructs this GUNNS Euler Angles unit test.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Euler Angles Factory given an invalid sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Euler Angles update method handling singularity conditions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Tests for GUNNS Euler Angles update method in normal conditions, for all sequences.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                       (--) Link name
/// @param[in] nodes                      (--) Network nodes array
/// @param[in] inputVoltageSensor         (--) Pointer to the input voltage sensor spotter.
/// @param[in] inputCurrentSensor         (--) Pointer to the input current sensor spotter.
/// @param[in] tripPriority               (--) Priority of trips in the network.
/// @param[in] inputUnderVoltageTripLimit (--) Input under-voltage trip limit.
/// @param[in] inputOverVoltageTripLimit  (--) Input over-voltage trip limit.
/// @param[in] efficiencyTable            (--) Pointer to the converter efficiency vs. power fraction table.
///
/// @details  Default Electrical Converter Input link config data constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Electrical Converter Input link config data copy constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--) Initial blockage malfunction activation flag.
/// @param[in] malfBlockageValue (--) Initial blockage maflunction value.
/// @param[in] enabled           (--) Initial operation enabled state.
/// @param[in] inputVoltage      (V)  Initial input voltage.
/// @param[in] inputPower        (W)  Initial input power load.
/// @param[in] referencePower    (W)  Initial reference power load for efficiency calculation.
///
/// @details  Default Electrical Converter Input link input data constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy
///
/// @details  Electrical Converter Input link input data copy constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Electrical Converter Input link default constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData   (--) Reference to the link config data.
/// @param[in]      inputData    (--) Reference to the link input data.
/// @param[in,out]  networkLinks (--) Reference to the network links vector.
/// @param[in]      port0        (--) Port 0 default node mapping.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Electrical Converter Input link with configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  nodeList  (1)  Pointer to a node list.
///
/// @throws   TsInitializationException
///
/// @details  If this link has been initialized, then compare the given node list nodes array to
///           ours, and throw an exception if they differ.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData   (--) Reference to the link config data.
/// @param[in]      inputData    (--) Reference to the link input data (not used).
///
/// @throws   TsInitializationException
///
/// @details  Validates this Electrical Converter Input link configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt  (s)  Integration time step (unused).
///
/// @details  First step in a non-linear network.  We clear the overloaded state from last pass so
///           it can be re-checked this pass.  Update sensors with the timestep to advance their
///           drift malfunction.  Then call minorStep for the main update functions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]  dt         (s)   Not used.
/// @param[in]  minorStep  (--)  Not used.
///
/// @details  Minor step function in a non-linear network.  Updates the link admittance matrix and
///           source vector contributions to the system of equations based on converter state and
///           load.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] dt (s) Not used.
///
/// @details  Method for computing the flows across the link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] convergedStep (--) The count of minor steps since the network last converged.
/// @param[in] absoluteStep  (--) Not used.
///
/// @returns  SolutionResult  (--)  Whether this link confirms or rejects the network solution.
///
/// @details  This method determines whether to accept or reject the converged network solution.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] convergedStep (--) The minor step number since network convergence.
/// @param[in] absoluteStep  (--) Unused.
///
/// @returns  bool (--) Always returns true.
///
/// @details  In the minorStep function, it will hold a constant current pulling negative input
///           potential to help the network converge, so that we (or some other link) can then
///           reject the solution.  However, we need a way to snap us out of that mode once the
///           solution has been rejected.  So, here we reset the potential vector to zero if we are
///           in such a condition.  This function is only called by the solver when the previous
///           minor step solution was rejected.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[out]  inputVoltage  (V)  Input channel voltage.
///
/// @returns  bool  (--)  Whether the returned input voltage value is valid.
///
/// @details  Sets the input channel voltage as the input node voltage if the converter isn't
///           disabled, blocked or tripped on the input side, otherwise the input channel voltage is
///           zero.  If the node voltage is negative, the input voltage is set to zero.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Resets the tripped state of the contained trip logic functions.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @returns  double (%) Converter efficiency.
///
/// @details Returns what mConverterEfficiency would be at given load.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] name                        (--)    Link name.
/// @param[in] nodes                       (--)    Network nodes array.
/// @param[in] regulatorType               (--)    The type of output regulation.
/// @param[in] outputConductance           (1/ohm) Conductance of the output channel.
/// @param[in] converterEfficiency         (--)    The voltage conversion efficiency (0-1).
/// @param[in] outputVoltageSensor         (--)    Pointer to the output voltage sensor spotter.
/// @param[in] outputCurrentSensor         (--)    Pointer to the output current sensor spotter.
/// @param[in] tripPriority                (--)    Priority of trips in the network.
/// @param[in] outputOverVoltageTripLimit  (V)     Output over-voltage trip limit.
/// @param[in] outputOverCurrentTripLimit  (amp)   Output over-current trip limit.
/// @param[in] inputLink                   (--)    Pointer to the input side link.
/// @param[in] enableLimiting              (--)    Limits output current or voltage instead of tripping.
/// @param[in] outputUnderVoltageTripLimit (V)     Output under-voltage trip limit.
///
/// @details  Default Electrical Converter Output link config data constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy.
///
/// @details  Electrical Converter Output link config data copy constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] malfBlockageFlag  (--) Initial blockage malfunction activation flag.
/// @param[in] malfBlockageValue (--) Initial blockage maflunction value.
/// @param[in] enabled           (--) Initial operation enabled state.
/// @param[in] inputVoltage      (V)  Initial input voltage.
/// @param[in] inputPower        (W)  Initial input power load.
/// @param[in] setpoint          (--) Initial commanded setpoint.
///
/// @details  Default Electrical Converter Output link input data constructor.  The base class
///           blockage malfunction is disabled because it isn't used in this link.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in] that (--) Object to copy.
///
/// @details  Electrical Converter Output link input data copy constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @details  Electrical Converter Output link default constructor.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData   (--) Reference to the link config data.
/// @param[in]      inputData    (--) Reference to the link input data.
/// @param[in,out]  networkLinks (--) Reference to the network links vector.
/// @param[in]      port0        (--) Port 0 default node mapping.
///
/// @throws   TsInitializationException
///
/// @details  Initializes this Electrical Converter Output link with configuration data.
////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////
/// @param[in]      configData   (--) Reference to the link config data.
/// @param[in]      inputData    (--) Reference to the link input data.
///
/// @throws   TsInitializationException
///
/// @details  Validates this Electrical Converter Output link configuration and input data.
////////////////////////////////////////////////////////////////////////////////////////////////////