Convert example PDF's to markdown, additional docs cleanup

Author: RyanDavies19

docs/drivers.rst

@@ -8,6 +8,10 @@ MoorDyn-F contains a driver script that has a :ref:`separate input file <MDF_dri
 and MoorDyn-F compiles in OpenFAST as moordyn_driver. The MoorDyn-F driver follows all 
 the same principles as the examples below. See :ref:`compiling <compiling>` and 
 :ref:`inputs <inputs>` sections for instructions on how to use the MoorDyn-F driver. 
+Additionally, MoorDyn-F has a c-bindings interface, which allows it (along with the rest 
+of OpenFAST) to be coupled with other languages. The MoorDyn-F C interface is set up using 
+the MoorDyn V1 approach (single 6 DOF coupling), thus it requires a single coupled body to 
+be used in the MoorDyn input file.
 
 Currently MoorDyn-C v2 can be used in Python, C/C++, Fortran, and Matlab. You can
 read more on how to install MoorDyn for each different language in
@@ -129,11 +133,9 @@ control:
         for node_id in range(n_segs+1):
             print("  node {}:".format(node_id))
             pos = moordyn.GetLineNodePos(line, node_id)
-            printf("  pos = {}".format(pos))
+            print("  pos = {}".format(pos))
             ten = moordyn.GetLineNodeTen(line, node_id)
-            printf("  ten = {}".format(ten))
-        }
-    }
+            print("  ten = {}".format(ten))
 
     # Alright, time to finish!
     moordyn.Close(system)

docs/inputs.rst

@@ -1004,8 +1004,8 @@ data.
  0.0             0.9          0.0
  150             0.5          0.0
  1000            0.25         0.0
- 1500		         0.2	        0.0
- 5000            0.15	        0.0
+ 1500            0.2          0.0
+ 5000            0.15         0.0
  --------------------- need this line ------------------
 
 MoorDyn-F with FAST.Farm - Inputs

docs/integration_moordyn.png

@@ -69,6 +69,26 @@ However, in contrast to the damping, which can be selected line by line, the
 time step is a constant of the whole system, and thus should be selected
 considering the minimum natural period of all lines.
 
+Catenary Solve Unsuccessful
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+One of the most common issues encountered when using MoorDyn is the failure of the 
+catenary solver to converge. The catenary solver is the first step in solving the 
+initial conditions of the system. This approach tries to use the properties and geometry 
+of the mooring lines to solve for a catenary shape. 
+
+If this routine fails, you will see a "Catenary solve unsuccessful" message in the
+the console and the log file. This means that MoorDyn will initialize the lines
+as linear between the two defined end locations. After this, the ICgen process begins,
+which runs a simulation with no external forcing, allowing the lines to 'fall' into
+place. If the lines initialize as linear, then the initialization process will just take
+longer, requiring a larger `TmaxIC` value. Explanations about the different initial 
+condition generating methods can be found in the :ref:`initialization section <initialization>`.
+
+The "Catenary Solve Unsuccessful" message does not impact the performance of MoorDyn or 
+the results it produces, provided the initialization process converges before the simulation 
+begins.
+
 Python errors
 ^^^^^^^^^^^^^
 

docs/troubleshooting.rst

@@ -0,0 +1,50 @@
+<!-- Copilot generated markdown files from hmtl exports of the instructions word docs -->
+
+# OpenFAST and MoorDyn-F
+
+MoorDyn-F is the core mooring dynamics module in OpenFAST. It is structured to seamlessly fit into the OpenFAST code structure, and thus is less suitable for external couplings than MoorDyn-C. The steps for running MoorDyn with OpenFAST and FAST.Farm are very similar to running any of the other OpenFAST modules. First, enable the module in the main input file, then provide the path to the module input file, and then configure the module input file for your simulation. Finally, run your simulation.
+
+## Running OpenFAST with MoorDyn-F
+
+See the instructions in the `Running OpenFAST.pdf` from the OpenFAST co-calc demonstration for details on setting up OpenFAST more broadly. Additional OpenFAST information can be found in the [OpenFAST documentation](https://openfast.readthedocs.io/en/main/). The general steps for running OpenFAST with MoorDyn-F are as follows:
+
+- Obtain the OpenFAST executables
+  - Compile from source code
+  - Download executables from [GitHub releases](https://github.com/OpenFAST/openfast/releases)
+- Configure the OpenFAST input files for your system
+  - Set `CompMooring = 3` in the main OpenFAST `.fst` input file
+  - Set the `MooringFile` variable in the main OpenFAST `.fst` input file to the MoorDyn input file path
+- Configure the MoorDyn input file for your system
+  - Note that coupled MoorDyn objects (bodies, rods, and points) are rigidly attached to the ElastoDyn object instance
+- Execute `openfast <input_file>.fst`
+
+## Running MoorDyn-F with the MoorDyn Driver
+
+The MoorDyn driver allows for MoorDyn-F to be run as a stand-alone module, enabling debugging of OpenFAST simulations and MoorDyn-only simulations. To run the driver, an additional input file is required that fills in the information normally provided to MoorDyn by the OpenFAST input file. Information on this file can be found in the [MoorDyn documentation](https://moordyn.readthedocs.io/en/latest/inputs.html#moordyn-f-driver-input-file). The general steps for running MoorDyn-F with the MoorDyn driver are as follows:
+
+- Obtain the driver executable
+  - Compile from source code
+  - Download executable from [GitHub releases](https://github.com/OpenFAST/openfast/releases)
+- Configure the MoorDyn driver input file `.dvr` following the formatting described in the [MoorDyn documentation](https://moordyn.readthedocs.io/en/latest/inputs.html#moordyn-f-driver-input-file).
+  - A time series input file is needed for providing motion to coupled MoorDyn objects. The path to this input file is set as the `InputsFile` variable in the MoorDyn driver input file (note that if `InputsMode = 0` all coupled objects positions will be fixed at 0 and the time series file will be ignored)
+- Configure the MoorDyn input file
+  - Coupled objects will be driven by a time series file provided in the driver input file
+- Execute `moordyn_driver <input_file>.dvr`
+
+## Running FAST.Farm with MoorDyn-F
+
+FAST.Farm, the wind farm simulation tool built on OpenFAST, can also be run with MoorDyn. More information on FAST.Farm can be found in the [OpenFAST documentation](https://openfast.readthedocs.io/en/main/source/user/fast.farm/index.html#fast-farm-user-s-guide-and-theory-manual). FAST.Farm runs an OpenFAST instance for each turbine in the farm and thus can have a MoorDyn instance for each turbine. Additionally, there can be a farm level MoorDyn instance, which allows for the simulation of shared mooring lines. Instructions for using MoorDyn with FAST.Farm can be found in the [MoorDyn documentation](https://moordyn.readthedocs.io/en/latest/inputs.html#moordyn-f-with-fast-farm-inputs). The general steps for running FAST.Farm with MoorDyn-F are as follows:
+
+- Obtain the FAST.Farm executables
+  - Compile from source code
+  - Download executable from [GitHub releases](https://github.com/OpenFAST/openfast/releases)
+- Configure the FAST.Farm input files for your system
+  - `Mod_SharedMooring = 3` in the main FAST.Farm `.fstf` input file
+  - Set the `SharedMoorFile` variable in the main FAST.Farm `.fstf` input file to the MoorDyn input file path
+- For each turbine in your system, configure the OpenFAST input files for your system
+  - If using MoorDyn at the turbine scale as well, set `CompMooring = 3` in the main OpenFAST `.fst` input file for each turbine. Otherwise set `CompMooring = 0`
+  - Set the `MooringFile` variable in the main OpenFAST `.fst` input file to the MoorDyn input file path if using the turbine level MoorDyn instance
+- Configure the MoorDyn input files
+  - At the turbine level, coupled MoorDyn objects (bodies, rods, and points) are rigidly attached to the ElastoDyn object instance
+  - At the farm level MoorDyn instance, the object attachment `Turbine#` is rigidly coupled to the ElastoDyn instance of the given turbine. Coupled objects are not allowed in the farm level MoorDyn input file.
+- Execute `fast.farm <input_file>.fstf`

example/Running MoorDyn-F (OpenFAST).md

@@ -0,0 +1,21 @@
+<!-- Copilot generated markdown files from hmtl exports of the instructions word docs -->
+
+# Running WEC-Sim with MoorDyn
+
+Instructions for running WEC-Sim with MoorDyn can be found in the README for the [WEC-Sim/MoorDyn repository](https://github.com/WEC-Sim/MoorDyn/blob/main/README.md). A short summary of those steps is detailed here:
+
+1. Obtain the MoorDyn libraries, header files, and the MoorDyn caller
+   - Download from the [WEC-Sim/MoorDyn repository](https://github.com/WEC-Sim/MoorDyn/blob/main/README.md)
+   - Compile MoorDyn-C from source following the [instructions in the documentation](https://moordyn.readthedocs.io/en/latest/compiling.html)
+     - This is only needed if libraries from the [WEC-Sim/MoorDyn repository](https://github.com/WEC-Sim/MoorDyn/blob/main/README.md) do not work
+2. Move the MoorDyn libraries, `.h` header files, and MoorDyn caller (all the files in the [WEC-Sim/MoorDyn repository](https://github.com/WEC-Sim/MoorDyn/blob/main/README.md)) from step 1 to the `WEC-Sim/source/functions/moorDyn` directory.
+   - To test the WEC-Sim MoorDyn setup, run the [WEC-Sim_Application/Mooring/MoorDyn example case](https://github.com/WEC-Sim/WEC-Sim_Applications/tree/main/Mooring/MoorDyn).
+3. Configure the MoorDyn input file for your system.
+   - Note that WEC-Sim requires a rigid 6 DOF body coupling for each mooring connection (a coupled MoorDyn body). Multiple bodies can be coupled to the WEC-Sim system, allowing the simulation of shared moorings for hydrokinetic devices.
+4. Configure the WEC-Sim Simulink model
+   - For each MoorDyn connection (a connection can consist of multiple lines and nodes but is between two distinct objects such as a floating body and the seafloor), there should be a MoorDyn Connection block in the Simulink model defining the relative motion between the objects.
+   - When using MoorDyn, there should always be exactly one MoorDyn Caller block in the Simulink model. See [WEC-Sim MoorDyn docs](https://wec-sim.github.io/WEC-Sim/dev/user/advanced_features.html#moordyn) for more details.
+5. Configure the WEC-Sim input file
+   - For each MoorDyn block in your system, you need to have a corresponding `mooring(i)` object, where `i` is the ID number of the body in the MoorDyn input file. Instructions for how to set up the mooring object are in the [WEC-Sim MoorDyn docs](https://wec-sim.github.io/WEC-Sim/dev/user/advanced_features.html#moordyn).
+   - The MoorDyn input file needs to be defined as `mooring(1).moorDynInputFile`, as WEC-Sim uses the file path defined in the first Mooring block to load the MoorDyn input file.
+6. Run the simulation by executing `wecSim` from the command window.