diff --git a/.gitignore b/.gitignore index 8a3337ef1e..da5ea6ff03 100644 --- a/.gitignore +++ b/.gitignore @@ -44,3 +44,8 @@ vs-build/ # backup files *.asv + +# LaTeX compiling files +*.aux +*.nlo +*.log diff --git a/docs/OtherSupporting/DCM_Interpolation/DCM_Interpolation.pdf b/docs/OtherSupporting/DCM_Interpolation/DCM_Interpolation.pdf new file mode 100644 index 0000000000..c76aba8f12 Binary files /dev/null and b/docs/OtherSupporting/DCM_Interpolation/DCM_Interpolation.pdf differ diff --git a/docs/OtherSupporting/DCM_Interpolation/DCM_Interpolation.tex b/docs/OtherSupporting/DCM_Interpolation/DCM_Interpolation.tex new file mode 100644 index 0000000000..aab546d93e --- /dev/null +++ b/docs/OtherSupporting/DCM_Interpolation/DCM_Interpolation.tex @@ -0,0 +1,238 @@ +%---------------------------------------------------------- +% + +\documentclass[10pt,letterpaper,oneside,notitlepage]{article} +%\documentclass{report}% +\usepackage{algorithm} +\usepackage{algpseudocode} +\usepackage{enumitem} +\usepackage{nomencl} +\usepackage{amsmath}% +%\usepackage{amsfonts}% +%\usepackage{amssymb}% +%\usepackage{graphicx} +%---------------------------------------------------------- +\makenomenclature +%\theoremstyle{plain} +%\newtheorem{acknowledgement}{Acknowledgement} +%\newtheorem{definition}{Definition} +%\newtheorem{remark}{Remark} +%\numberwithin{equation}{section} +%----------------------------------------------------------- +\begin{document} +\title{Interpolation of DCMs} +\author{Bonnie Jonkman} +\maketitle + + +\section{Logarithmic maps for DCMs} + +For any direction cosine matrix (DCM), $\Lambda$, +the logarithmic map for the matrix is a skew-symmetric matrix, $\lambda$: + + +\begin{equation} +\label{EqLog} +\lambda += \log( \Lambda ) += \begin{bmatrix} + 0 & \lambda_3 & -\lambda_2 \\ + -\lambda_3 & 0 & \lambda_1 \\ + \lambda_2 & -\lambda_1 & 0 + \end{bmatrix} +\end{equation} + +\section{Matrix exponentials} + +The angle of rotation for the skew-symmetric matrix, $\lambda$ is +\begin{equation} +\label{EqRotationAng} +\theta = \left\|\lambda\right\| = \sqrt{{\lambda_1}^2+{\lambda_2}^2+{\lambda_3}^2} +\end{equation} + +The matrix exponential is +\begin{equation} +\label{EqExp} + \Lambda = \exp(\lambda) = + \left\{ + \begin{matrix} + I & \theta = 0 \\ + I + \frac{\sin\theta}{\theta}\lambda + \frac{1-\cos\theta}{\theta^2}\lambda^2 & \theta > 0 \\ + \end{matrix} + \right. +\end{equation} + + +\section{Solving for $\lambda$} + +If the logarithmic map and matrix exponential are truly inverses, we need +\begin{equation} +\exp(\log(\Lambda)) = \Lambda. +\end{equation} +Using the expression for $\lambda$ from Equation \ref{EqLog}, we get +\begin{equation} +\label{EqExpMatrix} + \exp\left( + \begin{bmatrix} + 0 & \lambda_3 & -\lambda_2 \\ + -\lambda_3 & 0 & \lambda_1 \\ + \lambda_2 & -\lambda_1 & 0 + \end{bmatrix} +\right) = \Lambda = + \begin{bmatrix} + \Lambda_{11} & \Lambda_{12} & \Lambda_{13} \\ + \Lambda_{21} & \Lambda_{22} & \Lambda_{23} \\ + \Lambda_{31} & \Lambda_{32} & \Lambda_{33} \\ + \end{bmatrix} +\end{equation} + +Doing a little algebra for $\theta > 0$, Equation \ref{EqExpMatrix} becomes +\begin{equation} +\label{EqMatrixAlgebra} +\Lambda = + \begin{bmatrix} + 1-\frac{1-\cos\theta}{\theta^2}\left( \lambda_3^2 + \lambda_2^2\right) +& \frac{\sin\theta}{\theta}\lambda_3+\frac{1-\cos\theta}{\theta^2}\lambda_1\lambda_2 +& -\frac{\sin\theta}{\theta}\lambda_2+\frac{1-\cos\theta}{\theta^2}\lambda_1\lambda_3 \\ + -\frac{\sin\theta}{\theta}\lambda_3+\frac{1-\cos\theta}{\theta^2}\lambda_1\lambda_2 +& 1-\frac{1-\cos\theta}{\theta^2}\left( \lambda_3^2 + \lambda_1^2\right) +& \frac{\sin\theta}{\theta}\lambda_1+\frac{1-\cos\theta}{\theta^2}\lambda_2\lambda_3 \\ + \frac{\sin\theta}{\theta}\lambda_2+\frac{1-\cos\theta}{\theta^2}\lambda_1\lambda_3 +& -\frac{\sin\theta}{\theta}\lambda_1+\frac{1-\cos\theta}{\theta^2}\lambda_2\lambda_3 +& 1-\frac{1-\cos\theta}{\theta^2}\left( \lambda_2^2 + \lambda_1^2\right) \\ + \end{bmatrix} +\end{equation} +It follows that the trace is +\begin{eqnarray*} +\mathrm{Tr}(\Lambda) &=& 3 - 2\frac{1-\cos\theta}{\theta^2}(\lambda_1^2 + \lambda_2^2 + \lambda_3^2) \\ + &=& 3 - 2\left(1-\cos\theta\right) \\ + &=& 1 + 2\cos\theta +\end{eqnarray*} or +\begin{equation} +\theta= \begin{matrix} \cos^{-1}\left(\frac{1}{2}\left(\mathrm{Tr}(\Lambda)-1\right)\right) & \theta \in \left[0,\pi\right]\end{matrix} +\end{equation} +It also follows that +\begin{equation} +\Lambda - \Lambda^T=\frac{2\sin\theta}{\theta} + \begin{bmatrix} + 0 & \lambda_3 & -\lambda_2 \\ + -\lambda_3 & 0 & \lambda_1 \\ + \lambda_2 & -\lambda_1 & 0 \\ + \end{bmatrix} +\end{equation} or, when $\sin\theta \neq 0$ +\begin{equation} +\label{EqLambdaSinNot0} +\lambda = \frac{\theta}{2\sin\theta} \left( \Lambda - \Lambda^T\right) +\end{equation} +We need an equation that works when $\sin\theta$ approaches 0, that is, when $\theta$ approaches 0 or $\theta$ approaches $\pi$. When $\theta$ approaches 0, Equation \ref{EqLambdaSinNot0} actually behaves well: +\begin{equation} +\lim_{\theta \to 0}\frac{\theta}{2\sin\theta} = \frac{1}{2} +\end{equation} +and since $\theta$ is the $l_2$ norm of the individual components of $\lambda$, it follows that they approach zero, and we get +\begin{equation} +\label{EqLambdaTheta0} +\lambda = 0 +\end{equation} +However, when $\theta$ approaches $\pi$, $\Lambda - \Lambda^T$ approaches 0, and +\begin{equation} +\lim_{\theta \to \pi}\frac{\theta}{2\sin\theta} = \infty +\end{equation} +We need a different method to find $\lambda$. Going back to Equations \ref{EqExpMatrix} and \ref{EqMatrixAlgebra}, we can compute the following: +\begin{equation} +\Lambda_{11}+\Lambda_{22}-\Lambda_{33} = 1 - \frac{2\lambda_3^2(1-\cos\theta)}{\theta^2} +\end{equation} +%\begin{equation} +%\Lambda_{11}-\Lambda_{22}+\Lambda{33} = 1 - \frac{1-\cos\theta}{\theta^2}\left( 2\lambda_2^2\right) +%\end{equation} +%\begin{equation} +%-\Lambda_{11}+\Lambda_{22}+\Lambda{33} = 1 - \frac{1-\cos\theta}{\theta^2}\left( 2\lambda_1^2\right) +%\end{equation} +or +\begin{equation} +\label{EqLambda3} +\lambda_3 = \pm \theta\sqrt{ \frac{\left(1 + \Lambda_{33} - \Lambda_{11} - \Lambda_{22}\right)}{2\left(1-\cos\theta\right)} } +\end{equation} +Equations for the other two components of $\lambda$ are similar: +\begin{equation} +\label{EqLambda1} +\lambda_1 = \pm \theta\sqrt{ \frac{\left(1 + \Lambda_{11} - \Lambda_{22} - \Lambda_{33}\right)}{2\left(1-\cos\theta\right)} } +\end{equation} +\begin{equation} +\label{EqLambda2} +\lambda_2 = \pm \theta\sqrt{ \frac{\left(1 + \Lambda_{22} - \Lambda_{11} - \Lambda_{33}\right)}{2\left(1-\cos\theta\right)} } +\end{equation} +Equations \ref{EqLambda3}-\ref{EqLambda2} give us the magnitude, not the sign of the vector we are looking for. Here is one possibility for choosing the sign: +If $(\lambda_1) \neq 0$, choose $\mathrm{sign}(\lambda_1)$ positive. +\begin{equation} +\Lambda_{12}+\Lambda_{21} = \frac{2\left(1-\cos\theta\right)}{\theta^2}\lambda_1\lambda_2 +\end{equation} +so +\begin{equation} +\mathrm{sign}(\lambda_2) = \mathrm{sign}(\Lambda_{12}+\Lambda_{21}) +\end{equation} +and similarly, +\begin{equation} +\mathrm{sign}(\lambda_3) = \mathrm{sign}(\Lambda_{13}+\Lambda_{31}) +\end{equation} +If $(\lambda_1) = 0$, similar arguments can be used to choose $\mathrm{sign}(\lambda_2)$ positive, and +\begin{equation} +\mathrm{sign}(\lambda_3) = \mathrm{sign}(\Lambda_{23}+\Lambda_{32}) +\end{equation} +At this point, the relationships between the components of $\lambda$ are set, so we have computed $\pm\lambda$. If $\theta=\pi$, both values are a solution, so this good enough. + +If $\theta$ is close to $\pi$, we will need to determine if we have the negative of the solution. This is required for numerical stability of the solution. +In this case, $\Lambda-\Lambda^T$ is not exactly zero, so we can look at the sign of the solution we would have computed if we had used Equation \ref{EqLambdaSinNot0}: +\begin{equation} +\Lambda_{23}-\Lambda_{32} = \left|\frac{2\sin\theta}{\theta}\right|\lambda_1 +\end{equation} +\begin{equation} +\Lambda_{31}-\Lambda_{13} = \left|\frac{2\sin\theta}{\theta}\right|\lambda_2 +\end{equation} +\begin{equation} +\Lambda_{12}-\Lambda_{21} = \left|\frac{2\sin\theta}{\theta}\right|\lambda_3 +\end{equation} +For numerical reasons, we don't want to use these equations to get the magnitude of the components of $\lambda$, but we can look at the sign of the element with largest magnitude and ensure our $\lambda$ has the same sign. + +\section{Interpolation} +\subsection{Periodicity of solutions} + +Given $\lambda_k = \lambda \left( 1 + \frac{2k\pi}{\left\| \lambda \right\|}\right)$ for any integer $k$, it follows that +\begin{equation} +\theta_k = \left| 1 + \frac{2k\pi}{\left\|\lambda\right\|}\right| \theta +\end{equation} +or +\begin{equation} +\theta_k = \left|\theta + 2k\pi\right| +\end{equation} + +\begin{eqnarray*} +\Lambda_k +&=& \exp(\lambda_k) \\ +&=& I + \frac{\sin\theta_k}{\theta_k}\lambda_k + \frac{1-\cos\theta_k}{\theta_k^2}\lambda_k^2 \\ +&=& I + \frac{\sin\left|\theta + 2k\pi\right|}{\left|\theta + 2k\pi\right|}\left( \frac{\theta+2k\pi}{\theta}\right)\lambda + \frac{1-\cos\left|\theta + 2k\pi\right|}{\left|\theta + 2k\pi\right|^2}\left(\frac{\theta+2k\pi}{\theta}\right)^2\lambda^2 \\ +&=& I + \frac{\sin\left|\theta + 2k\pi\right|}{\theta} + \frac{\theta + 2k\pi}{\left|\theta + 2k\pi\right|}\lambda + \frac{1-\cos\left|\theta + 2k\pi\right|}{\theta^2}\lambda^2\\ +&=& I + \frac{\sin\theta}{\theta} \lambda + \frac{1-\cos\theta}{\theta^2}\lambda^2\\ +&=& \exp(\lambda) \\ +&=& \Lambda \\ +\end{eqnarray*} + +Thus, if $\lambda$ is one solution to $\log(\Lambda)$, then so is +$\lambda_k = \lambda \left( 1 + \frac{2k\pi}{\left\| \lambda \right\|}\right)$ for any integer k. + +\subsection{Finding values of $\lambda$ for interpolation} +Given a set of $\lambda^j$ to be interpolated, find equivalent $\tilde{\lambda}^j$ for integers $j=1,2,...n$: +Set $\tilde{\lambda}^1 = \lambda^1$. +For each $j\in\left[2,n\right]$, +check to see if $\tilde{\lambda}^{j-1}$ is closer (in the $l_2$-norm sense) to +$\lambda^j$ or $\lambda^j \left( 1 + \frac{2\pi}{\left\| \lambda^j \right\|}\right)$. +If the latter, set $\tilde{\lambda}^{j}=\lambda^j \left( 1 + \frac{2\pi}{\left\| \lambda^j \right\|}\right)$ and continue checking if we need to add more $2\pi$ periods. +Otherwise, check to see if $\tilde{\lambda}^{j-1}$ is closer to +$\lambda^j$ or $\lambda^j \left( 1 - \frac{2\pi}{\left\| \lambda^j \right\|}\right)$. +If the latter, set $\tilde{\lambda}^{j}=\lambda^j \left( 1 - \frac{2\pi}{\left\| \lambda^j \right\|}\right)$ and continue checking if we need to subtract more $2\pi$ periods. +Otherwise set $\tilde{\lambda}^{j} = \lambda^j$. + + +Interpolation must occur on the $\tilde{\lambda}^{j}$ and not the $\lambda^j$. + +\end{document} \ No newline at end of file diff --git a/docs/OtherSupporting/OpenFAST_Algorithms/OpenFAST_Algorithms.pdf b/docs/OtherSupporting/OpenFAST_Algorithms/OpenFAST_Algorithms.pdf new file mode 100644 index 0000000000..7f2f80bfb8 Binary files /dev/null and b/docs/OtherSupporting/OpenFAST_Algorithms/OpenFAST_Algorithms.pdf differ diff --git a/docs/OtherSupporting/OpenFAST_Algorithms/OpenFAST_Algorithms.tex b/docs/OtherSupporting/OpenFAST_Algorithms/OpenFAST_Algorithms.tex new file mode 100644 index 0000000000..8894cd1030 --- /dev/null +++ b/docs/OtherSupporting/OpenFAST_Algorithms/OpenFAST_Algorithms.tex @@ -0,0 +1,564 @@ +%---------------------------------------------------------- +% + +\documentclass[10pt,letterpaper,oneside,notitlepage]{article} +%\documentclass{report}% +\usepackage{algorithm} +\usepackage{algpseudocode} +\usepackage{enumitem} +\usepackage{nomencl} +\usepackage{amsmath} +\usepackage{amssymb} +%\usepackage{amsfonts}% +%\usepackage{graphicx} +%---------------------------------------------------------- +\makenomenclature +%\theoremstyle{plain} +%\newtheorem{acknowledgement}{Acknowledgement} +%\newtheorem{definition}{Definition} +%\newtheorem{remark}{Remark} +%\numberwithin{equation}{section} +%----------------------------------------------------------- +\begin{document} +\title{Algorithms in OpenFAST v2} +\author{Bonnie Jonkman} +%\begin{abstract} +%This document is used to describe the algorithms implemented in FAST v8. +%\end{abstract} +\maketitle + +%\tableofcontents + +\section{Definitions and Nomenclature} + + +\begin{table}[h] + \centering + \begin{tabular}{c|c|c} + \textbf{Module} & \textbf{Abbreviation} & \textbf{Abbreviation}\\ + \textbf{Name} & \textbf{in Module} & \textbf{in this Document}\\ + \hline + ElastoDyn & ED & ED \\ + BeamDyn & BD & BD \\ + AeroDyn14 & AD14 & AD14 \\ + AeroDyn & AD & AD \\ + ServoDyn & SrvD & SrvD \\ + SubDyn & SD & SD \\ + HydroDyn & HydroDyn & HD \\ + MAP++ & MAPp & MAP \\ + FEAMooring & FEAM & FEAM \\ + MoorDyn & MD & MD \\ + OrcaFlexInterface & Orca & Orca \\ + InflowWind & IfW & IfW \\ + IceFloe & IceFloe & IceF \\ + IceDyn & IceD & IceD \\ + \end{tabular} + \caption{Abbreviations for modules in FAST v8} + \label{tab:Abbrev} +\end{table} + + +\nomenclature{$u\_ED$}{$ElastoDyn$ inputs} +\nomenclature{$u\_AD$}{$AeroDyn$ inputs} +\printnomenclature + +\section{Initializations} + + +\pagebreak %break here for now so that it doesn't look so strange +\section{Input-Output Relationships} +\subsection {Input-Output Solves (Option 2 Before 1)} +This algorithm documents the procedure for the Input-Output solves in FAST, assuming +all modules are in use. If an individual module is not in use during a particular +simulation, the calls to that module's subroutines are omitted and the module's +inputs and outputs are neither set nor used. + +%\begin{algorithm}[ht] +%\caption{Input-Output Solves (Option 2 Before 1)} +%\label{IOSolves21} +\begin{algorithmic}[1] +\Procedure{CalcOutputs\_And\_SolveForInputs}{\null} +\State $\mathit{y\_ED} \gets \Call{ED\_CalcOutput}{\mathit{p\_ED},\mathit{u\_ED},\mathit{x\_ED},\mathit{xd\_ED},\mathit{z\_ED}}$ + +\State + \State $\mathit{u\_AD}($not InflowWind$) \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED}}$ + + \State $\mathit{u\_IfW} \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED} at \mathit{u\_AD} nodes}$ + \State $\mathit{y\_IfW} \gets \Call{IfW\_CalcOutput}{\mathit{u\_IfW} and other \mathit{IfW} data structures}$ + + \State $\mathit{u\_AD}($InflowWind only$) \gets \Call{TransferOutputsToInputs}{\mathit{y\_IfW}}$ + \State $\mathit{y\_AD} \gets \Call{AD\_CalcOutput}{\mathit{p\_AD},\mathit{u\_AD},\mathit{x\_AD},\mathit{xd\_AD},\mathit{z\_AD}}$ + +\State + \State $\mathit{u\_SrvD} \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED},\mathit{y\_IfW}}$ + \State $\mathit{y\_SrvD} \gets \Call{SrvD\_CalcOutput}{}( \! + \begin{aligned}[t] + & \mathit{p\_SrvD},\mathit{u\_SrvD}, \\ + & \mathit{x\_SrvD},\mathit{xd\_SrvD},\mathit{z\_SrvD}) \\ + \end{aligned}$ + +\State + \State $\mathit{u\_ED}($not platform reference point$) \gets \Call{TransferOutputsToInputs}{y\_SrvD,y\_AD}$ %\Comment{sets all but platform reference point inputs} + + \State $\mathit{u\_HD} \gets \Call{TransferMeshMotions}{\mathit{y\_ED}}$ + \State $\mathit{u\_SD} \gets \Call{TransferMeshMotions}{\mathit{y\_ED}}$ + \State $\mathit{u\_MAP} \gets \Call{TransferMeshMotions}{\mathit{y\_ED}}$ + \State $\mathit{u\_FEAM} \gets \Call{TransferMeshMotions}{\mathit{y\_ED}}$ + +\State +\State \Call{ED\_HD\_SD\_Mooring\_Ice\_InputOutputSolve}{\null} +\State +\State $\mathit{u\_AD} \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED}}$ +\State $\mathit{u\_SrvD} \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED},\mathit{y\_AD}}$ + +\EndProcedure +\end{algorithmic} +%\end{algorithm} + +Note that inputs to $ElastoDyn$ before calling CalcOutput() in the first step are not set in CalcOutputs\_And\_SolveForInputs(). +Instead, the $ElastoDyn$ inputs are set depending on where CalcOutputs\_And\_SolveForInputs() is called: +\begin{itemize}[noitemsep] %i don't like the double spaces between bulleted items. + \item At time 0, the inputs are the initial guess from $ElastoDyn$; + \item On the prediction step, the inputs are extrapolated values from the time history of ElastoDyn inputs; + \item On the first correction step, the inputs are the values calculated in the prediction step; + \item On subsequent correction steps, the inputs are the values calculated in the previous correction step. +\end{itemize} + + +%\pagebreak %break here for now so that it doesn't look so strange +%\subsection {Input-Output Solve for $HydroDyn$, $SubDyn$, $MAP$, \\ +% $FEAMooring$, $IceFloe$, and the Platform Reference Point Mesh in $ElastoDyn$} +\subsection {Input-Output Solve for \textit{HydroDyn}, \textit{SubDyn}, \textit{MAP}, + \textit{FEAMooring}, \textit{IceFloe}, and the Platform Reference Point Mesh in \textit{ElastoDyn}} + +This procedure implements Solve Option 1 for the accelerations and loads in +$HydroDyn$, $SubDyn$, $MAP$, $FEAMooring$, and $ElastoDyn$ (at its platform reference point mesh). +The other input-output relationships for these modules are solved using Solve Option 2. + +%\begin{algorithm}[ht] +%\caption{Input-Output Solve for $HydroDyn$, $SubDyn$, $MAP$, $FEAMooring$, and the Platform Reference Point Mesh in $ElastoDyn$} +%\label{IOSolves_PlatformRef} +\begin{algorithmic}[1] + +\Procedure{ED\_HD\_SD\_Mooring\_Ice\_InputOutputSolve}{\null} + \State + \State $\mathit{y\_MAP} \gets \Call{CalcOutput}{\mathit{p\_MAP},\mathit{u\_MAP},\mathit{x\_MAP},\mathit{xd\_MAP},\mathit{z\_MAP}}$ + \State $\mathit{y\_FEAM} \gets \Call{CalcOutput}{\mathit{p\_FEAM},\mathit{u\_FEAM},\mathit{x\_FEAM},\mathit{xd\_FEAM},\mathit{z\_FEAM}}$ + \State $\mathit{y\_IceF} \gets \Call{CalcOutput}{\mathit{p\_IceF},\mathit{u\_IceF},\mathit{x\_IceF},\mathit{xd\_IceF},\mathit{z\_IceF}}$ + \State $\mathit{y\_IceD(:)} \gets \Call{CalcOutput}{\mathit{p\_IceD(:)},\mathit{u\_IceD(:)},\mathit{x\_IceD(:)},\mathit{xd\_IceD(:)},\mathit{z\_IceD(:)}}$ + \State + \State\Comment{Form $u$ vector using loads and accelerations from $\mathit{u\_HD}$, $\mathit{u\_SD}$, and platform reference input from $\mathit{u\_ED}$} + \State + \State $u \gets \Call{u\_vec}{\mathit{u\_HD},\mathit{u\_SD},\mathit{u\_ED}}$ + \State $k \gets 0$ + \Loop\Comment{Solve for loads and accelerations (direct feed-through terms)} + \State $y\_ED \gets \Call{ED\_CalcOutput}{\mathit{p\_ED},\mathit{u\_ED},\mathit{x\_ED},\mathit{xd\_ED},\mathit{z\_ED}}$ + \State $y\_SD \gets \Call{SD\_CalcOutput}{\mathit{p\_SD},\mathit{u\_SD},\mathit{x\_SD},\mathit{xd\_SD},\mathit{z\_SD}}$ + \State $y\_HD \gets \Call{HD\_CalcOutput}{\mathit{p\_HD},\mathit{u\_HD},\mathit{x\_HD},\mathit{xd\_HD},\mathit{z\_HD}}$ + + \If{ $k \geq k\_max$} + \State exit loop + \EndIf + + \State$\mathit{u\_MAP\_tmp} \gets \Call{TransferMeshMotions}{y\_ED}$ + \State$\mathit{u\_FEAM\_tmp} \gets \Call{TransferMeshMotions}{y\_ED}$ + \State$\mathit{u\_IceF\_tmp} \gets \Call{TransferMeshMotions}{y\_SD}$ + \State$\mathit{u\_IceD\_tmp(:)} \gets \Call{TransferMeshMotions}{y\_SD}$ + \State$\mathit{u\_HD\_tmp} \gets \Call{TransferMeshMotions}{y\_ED,y\_SD}$ + \State$\mathit{u\_SD\_tmp} \gets \! + \begin{aligned}[t] + & \Call{TransferMeshMotions}{\mathit{y\_ED}} \\ + & \cup \Call{TransferMeshLoads}{}(\! + \begin{aligned}[t] + & \mathit{y\_SD}, \\ + & \mathit{y\_HD},\mathit{u\_HD\_tmp}, \\ + & \mathit{y\_IceF},\mathit{u\_IceF\_tmp}) \\ + & \mathit{y\_IceD(:)},\mathit{u\_IceD\_tmp(:)}) \\ + \end{aligned} + \end{aligned}$ + \State$\mathit{u\_ED\_tmp} \gets \Call{TransferMeshLoads}{}( \! + \begin{aligned}[t] & \mathit{y\_ED}, \\ + & \mathit{y\_HD}, \mathit{u\_HD\_tmp}, \\ + & \mathit{y\_SD}, \mathit{u\_SD\_tmp}, \\ + & \mathit{y\_MAP}, \mathit{u\_MAP\_tmp}, \\ + & \mathit{y\_FEAM},\mathit{u\_FEAM\_tmp} ) + \end{aligned}$ + + \State + \State$\mathit{U\_Residual} \gets u - \Call{u\_vec}{\mathit{u\_HD\_tmp},\mathit{u\_SD\_tmp},\mathit{u\_ED\_tmp}}$ + \State + + \If{ last Jacobian was calculated at least $\mathit{DT\_UJac}$ seconds ago } + \State Calculate $\frac{\partial U}{\partial u}$ + \EndIf + + %\textit{ + %\State Perturb each input in $u$ + %\State Call $\Call{CalcOutput}{p,u,x,xd,z}$ for each module + %\State Transfer perturbed outputs to inputs + %\State Form new $u$ + %\State Compare new $u$ with $U\_Residual$ + %\State} + + \State Solve $\frac{\partial U}{\partial u} \Delta u = - \mathit{U\_Residual}$ for $\Delta u$ + + \State + \If{$\lVert \Delta u \rVert_2 < $ tolerance } \Comment{To be implemented later} + \State exit loop + \EndIf + \State + \State $u \gets u + \Delta u$ + \State Transfer $u$ to $\mathit{u\_HD}$, $\mathit{u\_SD}$, and $\mathit{u\_ED}$\Comment{loads and accelerations only} + \State $k=k+1$ + + \EndLoop + + \State\Comment{Transfer non-acceleration fields to motion input meshes} + \State + + \State$\mathit{u\_HD}($not accelerations$) \gets \Call{TransferMeshMotions}{\mathit{y\_ED},\mathit{y\_SD}}$ + \State$\mathit{u\_SD}($not accelerations$) \gets \Call{TransferMeshMotions}{\mathit{y\_ED}}$ + \State + \State $\mathit{u\_MAP} \gets \Call{TransferMeshMotions}{\mathit{y\_ED}}$ + \State $\mathit{u\_FEAM} \gets \Call{TransferMeshMotions}{\mathit{y\_ED}}$ + \State $\mathit{u\_IceF} \gets \Call{TransferMeshMotions}{\mathit{y\_SD}}$ + \State $\mathit{u\_IceD(:)} \gets \Call{TransferMeshMotions}{\mathit{y\_SD}}$ + +\EndProcedure + +\end{algorithmic} +%\end{algorithm} + +\subsection {Implementation of line2-to-line2 loads mapping} +The inverse-lumping of loads is computed by a block matrix solve for the distributed forces and moments, +using the following equation: + +\begin{equation} +\label{EqLump} + \begin{bmatrix} + F^{DL} \\ + M^{DL} \\ + \end{bmatrix} += + \begin{bmatrix} + A & 0 \\ + B & A \\ + \end{bmatrix} + \begin{bmatrix} + F^{D} \\ + M^{D} \\ + \end{bmatrix} +\end{equation} + +Because the forces do not depend on the moments, we first solve for the distributed forces, $F^D$: +\begin{equation} +\label{EqLumpF} + \begin{bmatrix} F^{DL} \\ \end{bmatrix} += + \left[ A \right] + \left[ F^{D} \right] +\end{equation} + +We then use the known values to solve for the distributed moments, $M^D$: +\begin{equation} +\label{EqLumpM1} + \left[ M^{DL} \right] += + \begin{bmatrix} B & A \\ \end{bmatrix} + \begin{bmatrix} + F^{D} \\ + M^{D} \\ + \end{bmatrix} += \left[ B \right] \left[ F^D \right] + \left[ A \right] \left[ M^D \right] +\end{equation} +or +\begin{equation} +\label{EqLumpM2} +\left[ M^{DL} \right] - \left[ B \right] \left[ F^D \right] = \left[ A \right] \left[ M^D \right] +\end{equation} +Rather than store the matrix $B$, we directly perform the cross products that the matrix $B$ represents. +This makes the left-hand side of Equation \ref{EqLumpM2} known, leaving us with one matrix solve. This +solve uses the same matrix $A$ used to obtain the distributed forces in Equation \ref{EqLumpF}; $A$ depends +only on element reference positions and connectivity. We use +the $LU$ factorization of matrix $A$ so that the second solve does not introduce much additional overhead. + + + +\pagebreak %break here for now so that it doesn't look so strange +\section{Solve Option 2 Improvements} +\subsection {Input-Output Solves inside AdvanceStates} +This algorithm documents the procedure for advancing states with option 2 +Input-Output solves in FAST, assuming +all modules are in use. If an individual module is not in use during a particular +simulation, the calls to that module's subroutines are omitted and the module's +inputs and outputs are neither set nor used. + +\begin{algorithmic}[1] +\Procedure{FAST\_AdvanceStates}{\null} +\State $\Call{ED\_UpdateStates}{\mathit{p\_ED},\mathit{u\_ED},\mathit{x\_ED},\mathit{xd\_ED},\mathit{z\_ED}}$ +\State $\mathit{y\_ED} \gets \Call{ED\_CalcOutput}{\mathit{p\_ED},\mathit{u\_ED},\mathit{x\_ED},\mathit{xd\_ED},\mathit{z\_ED}}$ +\State +\State $\mathit{u\_BD}($hub and root motions$) \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED}}$ +\State $\Call{BD\_UpdateStates}{\mathit{p\_BD},\mathit{u\_BD},\mathit{x\_BD},\mathit{xd\_BD},\mathit{z\_BD}}$ +\State $\mathit{y\_BD} \gets \Call{BD\_CalcOutput}{\mathit{p\_BD},\mathit{u\_BD},\mathit{x\_BD},\mathit{xd\_BD},\mathit{z\_BD}}$ +\State +\State $\mathit{u\_AD}($not InflowWind$) \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED},\mathit{y\_BD}}$ +\State $\mathit{u\_IfW} \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED},\mathit{y\_BD}$ at $\mathit{u\_AD}$ nodes$}$ +\State $\Call{IfW\_UpdateStates}{\mathit{p\_IfW},\mathit{u\_IfW},\mathit{x\_IfW},\mathit{xd\_IfW},\mathit{z\_IfW}}$ +\State $\mathit{y\_IfW} \gets \Call{IfW\_CalcOutput}{\mathit{u\_IfW}$ and other $\mathit{IfW}$ data structures$}$ +\State +\State $\mathit{u\_AD}($InflowWind only$) \gets \Call{TransferOutputsToInputs}{\mathit{y\_IfW}}$ +\State $\mathit{u\_SrvD} \gets \Call{TransferOutputsToInputs}{\mathit{y\_ED},\mathit{y\_BD},\mathit{y\_IfW}}$ +\State $\Call{AD\_UpdateStates}{\mathit{p\_AD},\mathit{u\_AD},\mathit{x\_AD},\mathit{xd\_AD},\mathit{z\_AD}}$ +\State $\Call{SrvD\_UpdateStates}{\mathit{p\_SrvD},\mathit{u\_SrvD},\mathit{x\_SrvD},\mathit{xd\_SrvD},\mathit{z\_SrvD}}$ +\State +\State All other modules (used in Solve Option 1) advance their states +\EndProcedure +\end{algorithmic} + +Note that AeroDyn and ServoDyn outputs get calculated inside the ${CalcOutputs\_And\_SolveForInputs}$ routine. ElastoDyn, BeamDyn, and +InflowWind outputs do not get recalculated in ${CalcOutputs\_And\_SolveForInputs}$ except for the first time the routine is called +(because CalcOutput is called before UpdateStates at time 0). + + + +\section {Linearization} +\subsection{Loads Transfer} +The loads transfer can be broken down into four components, all of which are used in the Line2-to-Line2 loads transfer: +\begin{enumerate} + \item Augment the source mesh with additional nodes. + \item Lump the distributed loads on the augmented Line2 source mesh to a Point mesh. + \item Perform Point-to-Point loads transfer. + \item Distribute (or "unlump") the point loads. +\end{enumerate} +The other loads transfers are just subsets of the Line2-to-Line2 transfer: +\begin{itemize} + \item Line2-to-Line2: Perform steps 1, 2, 3, and 4. + \item Line2-to-Point: Perform steps 1, 2, and 3. + \item Point-to-Line2: Perform steps 3 and 4. + \item Point-to-Point: Perform step 3. +\end{itemize} + + +Each of the four steps can be represented with a linear equation. The linearization of the loads transfers is just multiplying the +appropriate matrices generated in each of the steps. + + +\subsubsection{Step 1: Augment the source mesh} +The equation that linearizes mesh augmentation is +\begin{equation} +\label{Augment} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^{SA} \\ \vec{f}^{SA} \\ \vec{m}^{SA} \end{matrix} \right\} += + \begin{bmatrix} + I_{\mathit{N_D}} & 0 & 0 & 0 \\ + 0 & M^A & 0 & 0 \\ + 0 & 0 & M^A & 0 \\ + 0 & 0 & 0 & M^A \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^S \\ \vec{f}^S \\ \vec{m}^S \end{matrix} \right\} +\end{equation} +where $M^A \in \mathbb{R}^{ \mathit{N_{SA}},\mathit{N_{S}}}$ indicates the mapping of nodes from the source mesh (with $N_S$ nodes) to the augmented source mesh +(with $N_{SA}$ nodes). The destination mesh (with $N_D$ nodes) is unchanged, as is indicated by matrix $I_{\mathit{N_D}}$. + + + +\subsubsection{Step 2: Lump loads on a Line2 mesh to a Point mesh} +The equation that linearizes the lumping of loads is +\begin{equation} +\label{Lump} + \left\{ \begin{matrix} \vec{u}^{SA} \\ \vec{F}^{SAL} \\ \vec{M}^{SAL} \end{matrix} \right\} += + \begin{bmatrix} + I_{\mathit{N_{SA}}} & 0 & 0 \\ + 0 & M_{li}^{SL} & 0 \\ + M_{uS}^{SL} & M_{f}^{SL} & M_{li}^{SL} \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^{SA} \\ \vec{f}^{SA} \\ \vec{m}^{SA} \end{matrix} \right\} +\end{equation} +where $M_{li}^{SL}, M_{uS}^{SL}, M_{f}^{SL} \in \mathbb{R}^{ \mathit{N_{SA}},\mathit{N_{SA}}}$ are block matrices that indicate the mapping of the lumped values to distributed values. $M_{li}^{SL}$ is matrix $A$ in Equation \ref{EqLumpF}, which depends only on element reference positions and connectivity. Matrices $M_{uS}^{SL}$and $M_{f}^{SL}$ also depend on values at their operating point. + + +\subsubsection{Step 3: Perform Point-to-Point loads transfer} +The equation that performs Point-to-Point load transfer can be written as +\begin{equation} +\label{P2P} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^{S} \\ \vec{F}^{D} \\ \vec{M}^{D} \end{matrix} \right\} += + \begin{bmatrix} + I_{\mathit{N_D}} & 0 & 0 & 0 \\ + 0 & I_{\mathit{N_{S}}} & 0 & 0 \\ + 0 & 0 & M_{li}^{D} & 0 \\ + M_{uD}^{D} & M_{uS}^{D} & M_{f}^{D} & M_{li}^{D} \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^{S} \\ \vec{F}^{S} \\ \vec{D}^{S} \end{matrix} \right\} +\end{equation} +where $M_{li}^{D}, M_{uS}^{D}, M_{f}^{D} \in \mathbb{R}^{ \mathit{N_{D}},\mathit{N_{S}}}$ are block matrices that indicate the transfer of loads from one source +node to a node on the destination mesh. $M_{uD}^{D} \in \mathbb{R}^{ \mathit{N_{D}},\mathit{N_{D}}}$ is a diagonal matrix that indicates how the destination mesh's displaced position effects the transfer. + + +\subsubsection{Step 4: Distribute Point loads to a Line2 mesh} +Distributing loads from a Point mesh to a Line2 mesh is the inverse of step 2. + +From Equation \ref{Lump} the equation that linearizes the lumping of loads on a destination mesh is +\begin{equation} +\label{LumpD} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{F}^{D} \\ \vec{M}^{D} \end{matrix} \right\} += + \begin{bmatrix} + I_{\mathit{N_D}} & 0 & 0 \\ + 0 & M_{li}^{DL} & 0 \\ + M_{uD}^{DL} & M_{f}^{DL} & M_{li}^{DL} \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{f}^{D} \\ \vec{m}^{D} \end{matrix} \right\} +\end{equation} +where $M_{li}^{DL}, M_{uD}^{DL}, M_{f}^{DL} \in \mathbb{R}^{ \mathit{N_{D}},\mathit{N_{D}}}$ are block matrices that indicate the mapping of the lumped values to distributed values. It follows that the inverse of this equation is +\begin{equation} +\label{InvLumpD} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{f}^{D} \\ \vec{m}^{D} \end{matrix} \right\} += + \begin{bmatrix} + I_{\mathit{N_D}} & 0 & 0 \\ + 0 & \left[ M_{li}^{DL} \right]^{-1} & 0 \\ + -\left[ M_{li}^{DL} \right]^{-1} M_{uD}^{DL} & + -\left[ M_{li}^{DL} \right]^{-1} M_{f}^{DL} \left[ M_{li}^{DL} \right]^{-1} & + \left[ M_{li}^{DL} \right]^{-1} \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{F}^{D} \\ \vec{M}^{D} \end{matrix} \right\} +\end{equation} +The only inverse we need is already formed (stored as an LU decomposition) from the loads transfer, so we need not form it again. + + +\subsubsection{Putting it together} +To form the matrices for loads transfers for the various mappings available, we now need to multiply a few matrices to return the linearization +matrix that converts loads from the source mesh to loads on the line mesh: +\begin{equation} +\label{LinearEqn} + \left\{ \begin{matrix} \vec{f}^{D} \\ \vec{m}^{D} \end{matrix} \right\} += + \begin{bmatrix} + 0 & 0 & M_{li} & 0 \\ + M_{uD} & M_{uS} & M_f & M_{li} + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^S \\ \vec{f}^{D} \\ \vec{m}^{D} \end{matrix} \right\} +\end{equation} + + + + +\begin{itemize} + \item Line2-to-Line2: Perform steps 1, 2, 3, and 4. + \begin{multline} + \left\{ \begin{matrix} \vec{f}^{D} \\ \vec{m}^{D} \end{matrix} \right\} + = + \begin{bmatrix} + 0 & \left[ M_{li}^{DL} \right]^{-1} & 0 \\ + -\left[ M_{li}^{DL} \right]^{-1} M_{uD}^{DL} & + -\left[ M_{li}^{DL} \right]^{-1} M_{f}^{DL} \left[ M_{li}^{DL} \right]^{-1} & + \left[ M_{li}^{DL} \right]^{-1} \\ + \end{bmatrix} + \\ + \begin{bmatrix} + I_{N_D} & 0 & 0 & 0 \\ + 0 & 0 & M_{li}^{D} & 0 \\ + M_{uD}^{D} & M_{uS}^{D} & M_{f}^{D} & M_{li}^{D} \\ + \end{bmatrix} + \begin{bmatrix} + I_{N_D} & 0 & 0 & 0 \\ + 0 & I_{\mathit{N_{SA}}} & 0 & 0 \\ + 0 & 0 & M_{li}^{SL} & 0 \\ + 0 & M_{uS}^{SL} & M_{f}^{SL} & M_{li}^{SL} \\ + \end{bmatrix} + \\ + \begin{bmatrix} + I_{\mathit{N_D}} & 0 & 0 & 0 \\ + 0 & M^A & 0 & 0 \\ + 0 & 0 & M^A & 0 \\ + 0 & 0 & 0 & M^A \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^{S} \\ \vec{f}^{S} \\ \vec{m}^{S} \end{matrix} \right\} + \end{multline} + \begin{align} + M_{li} &= \left(M_{li}^{DL}\right)^{-1}M_{li}^D M_{li}^{SL} M_A \\ + M_{uD} &= \left(M_{li}^{DL}\right)^{-1}\left[M_{uD}^D - M_{uD}^{DL}\right] \\ + M_{uS} &= \left(M_{li}^{DL}\right)^{-1} \left[ M_{uS}^D + M_{li}^D M_{uS}^{SL}\right] M_A \\ + M_{f} &= \left(M_{li}^{DL}\right)^{-1}\left( \left[M_{f}^D - M_{f}^{DL}\left(M_{li}^{DL}\right)^{-1}M_{li}^D\right] M_{li}^{SL} + + M_{li}^D M_{f}^{SL} \right)M_A \end{align} + + + \item Line2-to-Point: Perform steps 1, 2, and 3. + \begin{multline} + \left\{ \begin{matrix} \vec{F}^{D} \\ \vec{M}^{D} \end{matrix} \right\} + = + \begin{bmatrix} + 0 & 0 & M_{li}^{D} & 0 \\ + M_{uD}^{D} & M_{uS}^{D} & M_{f}^{D} & M_{li}^{D} \\ + \end{bmatrix} + \begin{bmatrix} + I_{N_D} & 0 & 0 & 0 \\ + 0 & I_{\mathit{N_{SA}}} & 0 & 0 \\ + 0 & 0 & M_{li}^{SL} & 0 \\ + 0 & M_{uS}^{SL} & M_{f}^{SL} & M_{li}^{SL} \\ + \end{bmatrix} + \\ + \begin{bmatrix} + I_{\mathit{N_D}} & 0 & 0 & 0 \\ + 0 & M^A & 0 & 0 \\ + 0 & 0 & M^A & 0 \\ + 0 & 0 & 0 & M^A \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^{S} \\ \vec{f}^{S} \\ \vec{m}^{S} \end{matrix} \right\} + \end{multline} + The linearization routine returns these four matrices: + \begin{align} + M_{li} &= M_{li}^D M_{li}^{SL} M_{A} \\ + M_{uD} &= M_{uD}^D \\ + M_{uS} &= \left[ M_{uS}^D + M_{li}^{D} M_{uS}^{SL}\right]M_{A} \\ + M_{f} &= \left[ M_{f}^D M_{li}^{SL} + M_{li}^{D} M_{f}^{SL} \right]M_{A} \end{align} + + + \item Point-to-Line2: Perform steps 3 and 4. + %\begin{equation} + \begin{multline} + \left\{ \begin{matrix} \vec{f}^{D} \\ \vec{m}^{D} \end{matrix} \right\} + = + \begin{bmatrix} + 0 & \left[ M_{li}^{DL} \right]^{-1} & 0 \\ + -\left[ M_{li}^{DL} \right]^{-1} M_{uD}^{DL} & + -\left[ M_{li}^{DL} \right]^{-1} M_{f}^{DL} \left[ M_{li}^{DL} \right]^{-1} & + \left[ M_{li}^{DL} \right]^{-1} \\ + \end{bmatrix} \\ + \begin{bmatrix} + I_{N_D} & 0 & 0 & 0 \\ + 0 & 0 & M_{li}^{D} & 0 \\ + M_{uD}^{D} & M_{uS}^{D} & M_{f}^{D} & M_{li}^{D} \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^{S} \\ \vec{F}^{S} \\ \vec{M}^{S} \end{matrix} \right\} + \end{multline} + %\end{equation} + The linearization routine returns these four matrices: + \begin{align} M_{li} &= \left(M_{li}^{DL}\right)^{-1}M_{li}^D \\ + M_{uD} &= \left(M_{li}^{DL}\right)^{-1}\left[M_{uD}^D - M_{uD}^{DL}\right] \\ + M_{uS} &= \left(M_{li}^{DL}\right)^{-1}M_{uS}^D \\ + M_{f} &= \left(M_{li}^{DL}\right)^{-1}\left[M_{f}^D - M_{f}^{DL} M_{li} \right] \end{align} + + + \item Point-to-Point: Perform step 3. + \begin{equation} + \left\{ \begin{matrix} \vec{F}^{D} \\ \vec{M}^{D} \end{matrix} \right\} + = + \begin{bmatrix} + 0 & 0 & M_{li}^{D} & 0 \\ + M_{uD}^{D} & M_{uS}^{D} & M_{f}^{D} & M_{li}^{D} \\ + \end{bmatrix} + \left\{ \begin{matrix} \vec{u}^D \\ \vec{u}^{S} \\ \vec{F}^{S} \\ \vec{M}^{S} \end{matrix} \right\} + \end{equation} + The linearization routine returns these four matrices: + \begin{align} M_{li} &= M_{li}^D \\ + M_{uD} &= M_{uD}^D \\ + M_{uS} &= M_{uS}^D \\ + M_{f} &= M_{f}^D \end{align} + +\end{itemize} + +\end{document} diff --git a/docs/OtherSupporting/OutListParameters.xlsx b/docs/OtherSupporting/OutListParameters.xlsx new file mode 100644 index 0000000000..a01573dc8c Binary files /dev/null and b/docs/OtherSupporting/OutListParameters.xlsx differ diff --git a/docs/source/dev/index.rst b/docs/source/dev/index.rst index 2725408ae7..81fa6aa01e 100644 --- a/docs/source/dev/index.rst +++ b/docs/source/dev/index.rst @@ -99,3 +99,14 @@ generally debugging and building out features. debugging.rst performance.rst versioning.rst + +Other Documentation +~~~~~~~~~~~~~~~~~~~ +Additional documentation exists that may be useful for developers seeking deeper +understanding of the solver and mathematics. This documentation is not generally +necessary for most development efforts. + +.. toctree:: + :maxdepth: 1 + + other_docs.rst diff --git a/docs/source/dev/other_docs.rst b/docs/source/dev/other_docs.rst new file mode 100644 index 0000000000..e6592f8dfa --- /dev/null +++ b/docs/source/dev/other_docs.rst @@ -0,0 +1,18 @@ +.. _other_docs: + +Other documentation +~~~~~~~~~~~~~~~~~~~ +Additional documentation exists that may be useful for developers seeking deeper +understanding of the solver and mathematics. This documentation is not generally +necessary for most development efforts. + +- :download:`DCM_Interpolation.pdf <../../OtherSupporting/DCM_Interpolation/DCM_Interpolation.pdf>` + This is a summary of the mathematics used in the interpolation of + DCM (direction cosine matrices) using logarithmic mapping and matrix exponentials. +- :download:`OpenFAST_Algorithms.pdf <../../OtherSupporting/OpenFAST_Algorithms/OpenFAST_Algorithms.pdf>` + This is a summary of the solve method used in the glue code. +- :download:`OutListParameters.xlsx <../../OtherSupporting/OutListParameters.xlsx>` + This Excel file contains the full list of outputs for each module. It is used to generate the + Fortran code for the output channel list handling for each module (this code is generally in + the _IO.f90 files). The MATLAB script available in the + `matlab-toolbox `__ repository at *Utilities/GetOutListParameters.m*. diff --git a/modules/aerodyn/src/OutListParameters.xlsx b/modules/aerodyn/src/OutListParameters.xlsx deleted file mode 100644 index 4ad9f419d9..0000000000 Binary files a/modules/aerodyn/src/OutListParameters.xlsx and /dev/null differ diff --git a/modules/beamdyn/src/OutListParameters.xlsx b/modules/beamdyn/src/OutListParameters.xlsx deleted file mode 100644 index 4a37cfa546..0000000000 Binary files a/modules/beamdyn/src/OutListParameters.xlsx and /dev/null differ diff --git a/modules/inflowwind/src/OutListParameters.xlsx b/modules/inflowwind/src/OutListParameters.xlsx deleted file mode 100644 index e82c023bad..0000000000 Binary files a/modules/inflowwind/src/OutListParameters.xlsx and /dev/null differ diff --git a/modules/openfast-library/src/OutListParameters.xlsx b/modules/openfast-library/src/OutListParameters.xlsx deleted file mode 100644 index 7272d92cc5..0000000000 Binary files a/modules/openfast-library/src/OutListParameters.xlsx and /dev/null differ diff --git a/modules/orcaflex-interface/src/OutListParameters.xlsx b/modules/orcaflex-interface/src/OutListParameters.xlsx deleted file mode 100644 index c163568a1c..0000000000 Binary files a/modules/orcaflex-interface/src/OutListParameters.xlsx and /dev/null differ