input

package
v0.0.1-alpha Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 6, 2022 License: Apache-2.0 Imports: 9 Imported by: 0

Documentation

Overview

Code generated by go generate; DO NOT EDIT.

Index

Constants

View Source 
const (
	String = "string"
	Bool   = "bool"
	Int    = "int"
	Float  = "float64"
)

Variables

View Source 
var AD15AirfoilInfoSchema = NewSchema("AD15AirfoilInfo", []SchemaEntry{

	{Keyword: "InterpOrd", Type: Int, Desc: `Interpolation order to use for quasi-steady table lookup {1=linear; 3=cubic spline; "default"} [default=3]`, CanBeDefault: true},
	{Keyword: "NonDimArea", Type: Float, Desc: `The non-dimensional area of the airfoil (set to 1.0 if unsure or unneeded)`, Unit: "area/chord^2"},
	{Keyword: "NumCoords", Type: Int, Desc: `The number of coordinates in the airfoil shape file.  Set to zero if coordinates not included.`},
	{Keyword: "BL_file", Type: String, Desc: `The file name including the boundary layer characteristics of the profile. Ignored if the aeroacoustic module is not called.`},
	{Keyword: "NumTabs", Type: Int, Desc: `Number of airfoil tables in this file.  Each table must have lines for Re and Ctrl.`},

	{Keyword: "Re", Type: Float, Desc: `Reynolds numbers in millions`},
	{Keyword: "Ctrl", Type: Int, Desc: `Control setting (must be 0 for current AirfoilInfo)`},
	{Keyword: "InclUAdata", Type: Bool, Desc: `Is unsteady aerodynamics data included in this table? If TRUE, then include 30 UA coeffs below this line`},
	{Keyword: "alpha0", Type: Float, Desc: `0-lift angle of attack, depends on airfoil.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "alpha1", Type: Float, Desc: `Angle of attack at f=0.7, (approximately the stall angle) for AOA>alpha0.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "alpha2", Type: Float, Desc: `Angle of attack at f=0.7, (approximately the stall angle) for AOA<alpha0.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "eta_e", Type: Float, Desc: `Recovery factor in the range [0.85 - 0.95] used only for UAMOD=1, it is set to 1 in the code when flookup=True.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "C_nalpha", Type: Float, Desc: `Slope of the 2D normal force coefficient curve in the linear region of the polar.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "T_f0", Type: Float, Desc: `Intial value of the time constant associated with Df in the expression of Df and f'. Default value = 3.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "T_V0", Type: Float, Desc: `Intial value of the time constant associated with the vortex lift decay process; it is used in the expression of Cvn. It depends on Re,M, and airfoil class. Default value= 6.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "T_p", Type: Float, Desc: `Boundary-layer,leading edge pressure gradient time constant in the expression of Dp. It should be tuned based on airfoil experimental data. Default =1.7.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "T_VL", Type: Float, Desc: `Intial value of the time constant associated with the vortex advection process; it represents the non-dimensional time in semi-chords, needed for a vortex to travel from LE to trailing edge (TE); it is used in the expression of Cvn. It depends on Re, M (weakly), and airfoil. Value's range = [6; 13]; default value= 11.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "b1", Type: Float, Desc: `Constant in the expression of phi_alpha^c and phi_q^c;  from experimental results, it was set to 0.14. This value is relatively insensitive for thin airfoils, but may be different for turbine airfoils.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "b2", Type: Float, Desc: `Constant in the expression of phi_alpha^c and phi_q^c;  from experimental results, it was set to 0.53. This value is relatively insensitive for thin airfoils, but may be different for turbine airfoils.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "b5", Type: Float, Desc: `Constant in the expression of K'''_q,Cm_q^nc, and k_m,q; from  experimental results, it was set to 5.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "A1", Type: Float, Desc: `Constant in the expression of phi_alpha^c and phi_q^c;  from experimental results, it was set to 0.3. This value is relatively insensitive for thin airfoils, but may be different for turbine airfoils.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "A2", Type: Float, Desc: `Constant in the expression of phi_alpha^c and phi_q^c;  from experimental results, it was set to 0.7. This value is relatively insensitive for thin airfoils, but may be different for turbine airfoils.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "A5", Type: Float, Desc: `Constant in the expression of K'''_q,Cm_q^nc, and k_m,q; from  experimental results, it was set to 1.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "S1", Type: Float, Desc: `Constant in the f curve bestfit for alpha0<=AOA<=alpha1;by definition it depends on the airfoil. Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "S2", Type: Float, Desc: `Constant in the f curve bestfit for         AOA>alpha1;by definition it depends on the airfoil. Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "S3", Type: Float, Desc: `Constant in the f curve bestfit for alpha2<=AOA<alpha0;by definition it depends on the airfoil. Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "S4", Type: Float, Desc: `Constant in the f curve bestfit for         AOA<alpha2;by definition it depends on the airfoil. Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "Cn1", Type: Float, Desc: `Critical value of C0n at leading edge separation. It should be extracted from airfoil data at a given Mach and Reynolds number. It can be calculated from the static value of Cn at either the break in the pitching moment or the loss of chord force at the onset of stall. It is close to the condition of maximum lift of the airfoil at low Mach numbers.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "Cn2", Type: Float, Desc: `As Cn1 for negative AOAs.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "St_sh", Type: Float, Desc: `Strouhal's shedding frequency constant; default =0.19.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "Cd0", Type: Float, Desc: `2D drag coefficient value at 0-lift.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "Cm0", Type: Float, Desc: `2D pitching moment coeffcient about 1/4-chord location, at 0-lift, positive if nose up.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "k0", Type: Float, Desc: `Constant in the \hat(x)_cp curve best-fit; = (\hat(x)_AC-0.25). Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "k1", Type: Float, Desc: `Constant in the \hat(x)_cp curve best-fit. Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "k2", Type: Float, Desc: `Constant in the \hat(x)_cp curve best-fit. Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "k3", Type: Float, Desc: `Constant in the \hat(x)_cp curve best-fit. Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "k1_hat", Type: Float, Desc: `Constant in the expression of Cc due to leading edge vortex effects. Ignored if UAMod<>1.`, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "x_cp_bar", Type: Float, Desc: `Constant in the expression of \hat(x)_cp^v. Default value =0.2. Ignored if UAMod<>1.`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "UACutout", Type: Float, Desc: `Angle of attack above which unsteady aerodynamics are disabled (deg). [Specifying the string "Default" sets UACutout to 45 degrees]`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "filtCutOff", Type: Float, Desc: `Cut-off frequency (-3 dB corner frequency) for low-pass filtering the AoA input to UA, as well as the 1st and 2nd derivatives (Hz) [default = 20]`, CanBeDefault: true, SkipIf: []Condition{{"InclUAdata", "==", false}}},
	{Keyword: "NumAlf", Type: Int, Desc: `Number of data lines in the following CoeffData table`},
	{Keyword: "CoeffData", Dims: 1, Parse: parseAD15AirfoilCoeffs, Format: formatAD15AirfoilCoeffs,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "Alpha", Type: Float, Unit: "deg"},
				{Keyword: "Cl", Type: Float, Unit: "-"},
				{Keyword: "Cd", Type: Float, Unit: "-"},
				{Keyword: "Cm", Type: Float, Unit: "-"},
			},
		},
	},
})
View Source 
var AeroDyn14Schema = NewSchema("AeroDyn14", []SchemaEntry{
	{Heading: "AeroDyn 14 Input File"},
	{Keyword: "Title", Type: String, Parse: parseTitle, Format: formatTitle},
	{Keyword: "StallMod", Type: String, Desc: `Dynamic stall included`, Unit: "unquoted string", Options: []Option{{"BEDDOES", "BEDDOES"}, {"STEADY", "STEADY"}}},
	{Keyword: "UseCm", Type: String, Desc: `Use aerodynamic pitching moment model?`, Unit: "unquoted string", Options: []Option{{"USE_CM", "USE_CM"}, {"NO_CM", "NO_CM"}}},
	{Keyword: "InfModel", Type: String, Desc: `Inflow model [DYNIN or EQUIL]`, Unit: "unquoted string"},
	{Keyword: "IndModel", Type: String, Desc: `Induction-factor model [NONE or WAKE or SWIRL]`, Unit: "unquoted string"},
	{Keyword: "AToler", Type: Float, Desc: `Induction-factor tolerance (convergence criteria) (-)`},
	{Keyword: "TLModel", Type: String, Desc: `Tip-loss model (EQUIL only) [PRANDtl, GTECH, or NONE]`, Unit: "unquoted string"},
	{Keyword: "HLModel", Type: String, Desc: `Hub-loss model (EQUIL only) [PRANdtl or NONE]`, Unit: "unquoted string"},
	{Keyword: "TwrShad", Type: Float, Desc: `Tower-shadow velocity deficit (-)`},
	{Keyword: "ShadHWid", Type: Float, Desc: `Tower-shadow half width (m)`},
	{Keyword: "T_Shad_Refpt", Type: Float, Desc: `Tower-shadow reference point (m)`},
	{Keyword: "AirDens", Type: Float, Desc: `Air density (kg/m^3)`},
	{Keyword: "KinVisc", Type: Float, Desc: `Kinematic air viscosity [CURRENTLY IGNORED] (m^2/sec)`},
	{Keyword: "DTAero", Type: Float, Desc: `Time interval for aerodynamic calculations (sec)`},
	{Keyword: "NumFoil", Type: Int, Desc: `Number of airfoil files (-)`},
	{Keyword: "FoilNm", Type: String, Dims: 1, Parse: parseFoilNm, Format: formatFoilNm, Desc: `Names of the airfoil files [NumFoil lines] (quoted strings)`},
	{Keyword: "BldNodes", Type: Int, Desc: `Number of blade nodes used for analysis (-)`},
	{Keyword: "BlNd", Dims: 1, Parse: parseAeroDyn14BlNd, Format: formatAeroDyn14BlNd,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "RNodes", Type: Float},
				{Keyword: "AeroTwst", Type: Float},
				{Keyword: "DRNodes", Type: Float},
				{Keyword: "Chord", Type: Float},
				{Keyword: "NFoil", Type: Int},
				{Keyword: "PrnElm", Type: String},
			},
		},
	},
})
View Source 
var AeroDyn15Schema = NewSchema("AeroDyn15", []SchemaEntry{
	{Heading: "AeroDyn 15 Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "General Options"},
	{Keyword: "Echo", Type: Bool, Desc: `Echo the input to "<rootname>.AD.ech"?`, Unit: "flag"},
	{Keyword: "DTAero", Type: Float, CanBeDefault: true, Desc: `Time interval for aerodynamic calculations {or "default"}`, Unit: "sec"},
	{Keyword: "WakeMod", Type: Int, Desc: `Type of wake/induction model [WakeMod cannot be 2 or 3 when linearizing]`, Unit: "switch", Options: []Option{{0, "none"}, {1, "BEMT"}, {2, "DBEMT"}, {3, "OLAF"}}},
	{Keyword: "AFAeroMod", Type: Int, Desc: `Type of blade airfoil aerodynamics model[AFAeroMod must be 1 when linearizing]`, Unit: "switch", Options: []Option{{1, "steady model"}, {2, "Beddoes-Leishman unsteady model"}}},
	{Keyword: "TwrPotent", Type: Int, Desc: `Type tower influence on wind based on potential flow around the tower`, Unit: "switch", Options: []Option{{0, "none"}, {1, "baseline potential flow"}, {2, "potential flow with Bak correction"}}},
	{Keyword: "TwrShadow", Type: Int, Desc: `Calculate tower influence on wind based on downstream tower shadow`, Unit: "switch", Options: []Option{{0, "none"}, {1, "Powles model"}, {2, "Eames model"}}},
	{Keyword: "TwrAero", Type: Bool, Desc: `Calculate tower aerodynamic loads?`, Unit: "flag"},
	{Keyword: "FrozenWake", Type: Bool, Desc: `Assume frozen wake during linearization? [used only when WakeMod=1 and when linearizing]`, Unit: "flag"},
	{Keyword: "CavitCheck", Type: Bool, Desc: `Perform cavitation check? [AFAeroMod must be 1 when CavitCheck=true]`, Unit: "flag"},
	{Keyword: "CompAA", Type: Bool, Desc: `Flag to compute AeroAcoustics calculation [used only when WakeMod = 1 or 2]`},
	{Keyword: "AA_InputFile", Type: String, Desc: `AeroAcoustics input file [used only when CompAA=true]`},
	{Heading: "Environmental Conditions"},
	{Keyword: "AirDens", Type: Float, CanBeDefault: true, Desc: `Air density`, Unit: "kg/m^3"},
	{Keyword: "KinVisc", Type: Float, CanBeDefault: true, Desc: `Kinematic viscosity of working fluid`, Unit: "m^2/s"},
	{Keyword: "SpdSound", Type: Float, CanBeDefault: true, Desc: `Speed of sound in working fluid`, Unit: "m/s"},
	{Keyword: "Patm", Type: Float, CanBeDefault: true, Desc: `Atmospheric pressure [used only when CavitCheck=True]`, Unit: "Pa", Show: []Condition{{"CavitCheck", "==", true}}},
	{Keyword: "Pvap", Type: Float, CanBeDefault: true, Desc: `Vapour pressure of working fluid [used only when CavitCheck=True]`, Unit: "Pa", Show: []Condition{{"CavitCheck", "==", true}}},
	{Heading: "Blade-Element/Momentum Theory Options [unused when WakeMod=0 or 3]"},
	{Keyword: "SkewMod", Type: Int, Desc: `Type of skewed-wake correction model [unused when WakeMod=0 or 3]`, Unit: "switch", Options: []Option{{1, "uncoupled"}, {2, "Pitt/Peters"}, {3, "coupled"}}},
	{Keyword: "SkewModFactor", Type: Float, CanBeDefault: true, Desc: `Constant used in Pitt/Peters skewed wake model {or "default" is 15/32*pi} (-) [used only when SkewMod=2; unused when WakeMod=0 or 3]`},
	{Keyword: "TipLoss", Type: Bool, Desc: `Use the Prandtl tip-loss model? [unused when WakeMod=0 or 3]`, Unit: "flag"},
	{Keyword: "HubLoss", Type: Bool, Desc: `Use the Prandtl hub-loss model? [unused when WakeMod=0 or 3]`, Unit: "flag"},
	{Keyword: "TanInd", Type: Bool, Desc: `Include tangential induction in BEMT calculations? [unused when WakeMod=0 or 3]`, Unit: "flag"},
	{Keyword: "AIDrag", Type: Bool, Desc: `Include the drag term in the axial-induction calculation? [unused when WakeMod=0 or 3]`, Unit: "flag"},
	{Keyword: "TIDrag", Type: Bool, Desc: `Include the drag term in the tangential-induction calculation? [unused when WakeMod=0,3 or TanInd=FALSE]`, Unit: "flag"},
	{Keyword: "IndToler", Type: Float, CanBeDefault: true, Desc: `Convergence tolerance for BEMT nonlinear solve residual equation {or "default"} (-) [unused when WakeMod=0 or 3]`},
	{Keyword: "MaxIter", Type: Int, Desc: `Maximum number of iteration steps (-) [unused when WakeMod=0]`},
	{Heading: "Dynamic Blade-Element/Momentum Theory Options [used only when WakeMod=2]"},
	{Keyword: "DBEMT_Mod", Type: Int, Desc: `Type of dynamic BEMT (DBEMT) model [used only when WakeMod=2]`, Unit: "switch", Options: []Option{{1, "constant tau1"}, {2, "time-dependent tau1"}}},
	{Keyword: "tau1_const", Type: Float, Desc: `Time constant for DBEMT (s) [used only when WakeMod=2 and DBEMT_Mod=1]`},
	{Heading: "OLAF -- cOnvecting LAgrangian Filaments (Free Vortex Wake) Theory Options [used only when WakeMod=3]"},
	{Keyword: "OLAFInputFileName", Type: String, Desc: `Input file for OLAF [used only when WakeMod=3]`},
	{Heading: "Beddoes-Leishman Unsteady Airfoil Aerodynamics Options [used only when AFAeroMod=2]"},
	{Keyword: "UAMod", Type: Int, Desc: `Unsteady Aero Model Switch (switch) {1=Baseline model (Original), 2=Gonzalez's variant (changes in Cn,Cc,Cm), 3=Minnema/Pierce variant (changes in Cc and Cm)} [used only when AFAeroMod=2]`},
	{Keyword: "FLookup", Type: Bool, Desc: `Flag to indicate whether a lookup for f' will be calculated (TRUE) or whether best-fit exponential equations will be used (FALSE); if FALSE S1-S4 must be provided in airfoil input files (flag) [used only when AFAeroMod=2]`},
	{Heading: "Airfoil Information"},
	{Keyword: "AFTabMod", Type: Int, Desc: `Interpolation method for multiple airfoil tables {1=1D interpolation on AoA (first table only); 2=2D interpolation on AoA and Re; 3=2D interpolation on AoA and UserProp} (-)`},
	{Keyword: "InCol_Alfa", Type: Int, Desc: `The column in the airfoil tables that contains the angle of attack (-)`},
	{Keyword: "InCol_Cl", Type: Int, Desc: `The column in the airfoil tables that contains the lift coefficient (-)`},
	{Keyword: "InCol_Cd", Type: Int, Desc: `The column in the airfoil tables that contains the drag coefficient (-)`},
	{Keyword: "InCol_Cm", Type: Int, Desc: `The column in the airfoil tables that contains the pitching-moment coefficient; use zero if there is no Cm column (-)`},
	{Keyword: "InCol_Cpmin", Type: Int, Desc: `The column in the airfoil tables that contains the Cpmin coefficient; use zero if there is no Cpmin column (-)`},
	{Keyword: "NumAFfiles", Type: Int, Desc: `Number of airfoil files used (-)`},
	{Keyword: "AFNames", Type: String, Dims: 1, Parse: parseAFNames, Format: formatAFNames, Desc: `Airfoil file names (NumAFfiles lines) (quoted strings)`},
	{Heading: "Rotor/Blade Properties"},
	{Keyword: "UseBlCm", Type: Bool, Desc: `Include aerodynamic pitching moment in calculations?  (flag)`},
	{Keyword: "ADBlFile(1)", Type: String, Desc: `Name of file containing distributed aerodynamic properties for Blade #1 (-)`},
	{Keyword: "ADBlFile(2)", Type: String, Desc: `Name of file containing distributed aerodynamic properties for Blade #2 (-) [unused if NumBl < 2]`},
	{Keyword: "ADBlFile(3)", Type: String, Desc: `Name of file containing distributed aerodynamic properties for Blade #3 (-) [unused if NumBl < 3]`},
	{Heading: "Tower Influence and Aerodynamics [used only when TwrPotent/=0, TwrShadow/=0, or TwrAero=True]"},
	{Keyword: "NumTwrNds", Type: Int, Desc: `Number of tower nodes used in the analysis  (-) [used only when TwrPotent/=0, TwrShadow/=0, or TwrAero=True]`},
	{Keyword: "TwrNodes", Dims: 1,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "TwrElev", Type: Float, Desc: `(m)`},
				{Keyword: "TwrDiam", Type: Float, Desc: `(m)`},
				{Keyword: "TwrCd", Type: Float, Desc: `(-)`},
				{Keyword: "TwrTI", Type: Float, Desc: `(used only with TwrShadow=2) (-)`},
			},
		},
		Parse: parseTwrNodes, Format: formatTwrNodes,
	},
	{Heading: "Outputs"},
	{Keyword: "SumPrint", Type: Bool, Desc: `Generate a summary file listing input options and interpolated properties to "<rootname>.AD.sum"?  (flag)`},
	{Keyword: "NBlOuts", Type: Int, Desc: `Number of blade node outputs [0 - 9] (-)`},
	{Keyword: "BlOutNd", Dims: 1, Type: Int, Desc: `Blade nodes whose values will be output  (-)`},
	{Keyword: "NTwOuts", Type: Int, Desc: `Number of tower node outputs [0 - 9]  (-)`},
	{Keyword: "TwOutNd", Dims: 1, Type: Int, Desc: `Tower nodes whose values will be output  (-)`},
	{Keyword: "OutList", Type: String, Dims: 1, Parse: parseOutList, Format: formatOutList, Desc: `The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels, (-)`},
})
View Source 
var AeroDynBladeSchema = NewSchema("AeroDynBlade", []SchemaEntry{
	{Heading: "AeroDyn Blade Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "Blade Properties"},
	{Keyword: "NumBlNds", Type: Int, Desc: `Number of blade nodes used in the analysis (-)`},
	{Keyword: "BlNd", Dims: 1, Format: formatAeroDynBladeBlNd, Parse: parseAeroDynBladeBlNd,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "BlSpn", Type: Float, Desc: `(m)`},
				{Keyword: "BlCrvAC", Type: Float, Desc: `(m)`},
				{Keyword: "BlSwpAC", Type: Float, Desc: `(m)`},
				{Keyword: "BlCrvAng", Type: Float, Desc: `(deg)`},
				{Keyword: "BlTwist", Type: Float, Desc: `(deg)`},
				{Keyword: "BlChord", Type: Float, Desc: `(m)`},
				{Keyword: "BlAFID", Type: Int, Desc: `(-)`},
			},
		},
	},
})
View Source 
var BeamDynBladeSchema = NewSchema("BeamDynBlade", []SchemaEntry{
	{Heading: "BeamDyn Blade Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "Blade Parameters"},
	{Keyword: "station_total", Type: Int, Desc: `Number of blade input stations`},
	{Keyword: "damp_type", Type: Int, Desc: `Damping type: 0: no damping; 1: damped`},
	{Heading: "Damping Coefficient"},
	{Keyword: "mu", Type: Float, Dims: 1, Parse: parseBeamDynBladeMu, Format: formatBeamDynBladeMu},
	{Heading: "Distributed Properties"},
	{Keyword: "DistProps", Dims: 1,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "station_eta", Type: Float},
				{Keyword: "stiffness_matrix", Type: Float, Dims: 2},
				{Keyword: "mass_matrix", Type: Float, Dims: 2},
			},
		},
		Parse: parseBeamDynBladeDistProps, Format: formatBeamDynBladeDistProps,
	},
})
View Source 
var BeamDynSchema = NewSchema("BeamDyn", []SchemaEntry{
	{Heading: "Beamdyn Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "Simulation Control"},
	{Keyword: "Echo", Type: Bool, Desc: `Echo input data to "<RootName>.ech"? (flag)`},
	{Keyword: "QuasiStaticInit", Type: Bool, Desc: `Use quasi-static pre-conditioning with centripetal accelerations in initialization? (flag) [dynamic solve only]`},
	{Keyword: "rhoinf", Type: Float, Desc: `Numerical damping parameter for generalized-alpha integrator`},
	{Keyword: "quadrature", Type: Int, Desc: `Quadrature method: 1=Gaussian; 2=Trapezoidal (switch)`},
	{Keyword: "refine", Type: Int, CanBeDefault: true, Desc: `Refinement factor for trapezoidal quadrature (-) [DEFAULT = 1; used only when quadrature=2]`},
	{Keyword: "n_fact", Type: Int, CanBeDefault: true, Desc: `Factorization frequency for the Jacobian in N-R iteration(-) [DEFAULT = 5]`},
	{Keyword: "DTBeam", Type: Float, CanBeDefault: true, Desc: `Time step size (s)`},
	{Keyword: "load_retries", Type: Int, CanBeDefault: true, Desc: `Number of factored load retries before quitting the simulation [DEFAULT = 20]`},
	{Keyword: "NRMax", Type: Int, CanBeDefault: true, Desc: `Max number of iterations in Newton-Raphson algorithm (-) [DEFAULT = 10]`},
	{Keyword: "stop_tol", Type: Float, CanBeDefault: true, Desc: `Tolerance for stopping criterion (-) [DEFAULT = 1E-5]`},
	{Keyword: "tngt_stf_fd", Type: Bool, CanBeDefault: true, Desc: `Use finite differenced tangent stiffness matrix? (flag)`},
	{Keyword: "tngt_stf_comp", Type: Bool, CanBeDefault: true, Desc: `Compare analytical finite differenced tangent stiffness matrix? (flag)`},
	{Keyword: "tngt_stf_pert", Type: Float, CanBeDefault: true, Desc: `Perturbation size for finite differencing (-) [DEFAULT = 1E-6]`},
	{Keyword: "tngt_stf_difftol", Type: Float, CanBeDefault: true, Desc: `Maximum allowable relative difference between analytical and fd tangent stiffness (-); [DEFAULT = 0.1]`},
	{Keyword: "RotStates", Type: Bool, Desc: `Orient states in the rotating frame during linearization? (flag) [used only when linearizing] `},
	{Heading: "Geometry Parameter"},
	{Keyword: "member_total", Type: Int, Desc: `Total number of members (-)`},
	{Keyword: "kp_total", Type: Int, Desc: `Total number of key points (-) [must be at least 3]`},
	{Keyword: "Members", Dims: 2,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "kp_xr", Type: Float, Unit: "m", Desc: ``},
				{Keyword: "kp_yr", Type: Float, Unit: "m", Desc: ``},
				{Keyword: "kp_zr", Type: Float, Unit: "m", Desc: ``},
				{Keyword: "initial_twist", Type: Float, Unit: "deg", Desc: ``},
			},
		},
		Parse: parseBeamDynMembers, Format: formatBeamDynMembers,
	},
	{Heading: "Mesh Parameter"},
	{Keyword: "order_elem", Type: Int, Desc: `Order of interpolation (basis) function (-)`},
	{Heading: "Material Parameter"},
	{Keyword: "BldFile", Type: String, Desc: `Name of file containing properties for blade (quoted string)`},
	{Heading: "Pitch Actuator Parameters"},
	{Keyword: "UsePitchAct", Type: Bool, Desc: `Whether a pitch actuator should be used (flag)`},
	{Keyword: "PitchJ", Type: Float, Desc: `Pitch actuator inertia (kg-m^2) [used only when UsePitchAct is true]`},
	{Keyword: "PitchK", Type: Float, Desc: `Pitch actuator stiffness (kg-m^2/s^2) [used only when UsePitchAct is true]`},
	{Keyword: "PitchC", Type: Float, Desc: `Pitch actuator damping (kg-m^2/s) [used only when UsePitchAct is true]`},
	{Heading: "Outputs"},
	{Keyword: "SumPrint", Type: Bool, Desc: `Print summary data to "<RootName>.sum" (flag)`},
	{Keyword: "OutFmt", Type: String, Desc: `Format used for text tabular output, excluding the time channel.`},
	{Keyword: "NNodeOuts", Type: Int, Desc: `Number of nodes to output to file [0 - 9] (-)`},
	{Keyword: "OutNd", Dims: 1, Type: Int, Desc: `Nodes whose values will be output  (-)`},
	{Keyword: "OutList", Type: String, Dims: 1, Format: formatOutList, Parse: parseOutList, Desc: `The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels, (-)`},
})
View Source 
var ElastoDynBladeSchema = NewSchema("ElastoDynBlade", []SchemaEntry{
	{Heading: "ElastoDyn Blade Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "Blade Parameters"},
	{Keyword: "NBlInpSt", Type: Int, Desc: `Number of blade input stations`, Unit: "-"},
	{Keyword: "BldFlDmp(1)", Type: Float, Desc: `Blade flap mode #1 structural damping in percent of critical`, Unit: "%"},
	{Keyword: "BldFlDmp(2)", Type: Float, Desc: `Blade flap mode #2 structural damping in percent of critical`, Unit: "%"},
	{Keyword: "BldEdDmp(1)", Type: Float, Desc: `Blade edge mode #1 structural damping in percent of critical`, Unit: "%"},
	{Heading: "Blade Adjustment Factors"},
	{Keyword: "FlStTunr(1)", Type: Float, Desc: `Blade flapwise modal stiffness tuner, 1st mode`, Unit: "-"},
	{Keyword: "FlStTunr(2)", Type: Float, Desc: `Blade flapwise modal stiffness tuner, 2nd mode`, Unit: "-"},
	{Keyword: "AdjBlMs", Type: Float, Desc: `Factor to adjust blade mass density`, Unit: "-"},
	{Keyword: "AdjFlSt", Type: Float, Desc: `Factor to adjust blade flap stiffness`, Unit: "-"},
	{Keyword: "AdjEdSt", Type: Float, Desc: `Factor to adjust blade edge stiffness`, Unit: "-"},
	{Heading: "Distributed Blade Properties"},
	{Keyword: "BlInpSt", Dims: 1, Parse: parseBlInpSt, Format: formatBlInpSt,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "BlFract", Type: Float, Unit: "-"},
				{Keyword: "PitchAxis", Type: Float, Unit: "-"},
				{Keyword: "StrcTwst", Type: Float, Unit: "deg"},
				{Keyword: "BMassDen", Type: Float, Unit: "kg/m"},
				{Keyword: "FlpStff", Type: Float, Unit: "Nm^2"},
				{Keyword: "EdgStff", Type: Float, Unit: "Nm^2"},
			},
		},
	},
	{Heading: "Blade Mode Shapes"},
	{Keyword: "BldFl1Sh(2)", Type: Float, Desc: `Flap mode 1, coeff of x^2`},
	{Keyword: "BldFl1Sh(3)", Type: Float, Desc: `           , coeff of x^3`},
	{Keyword: "BldFl1Sh(4)", Type: Float, Desc: `           , coeff of x^4`},
	{Keyword: "BldFl1Sh(5)", Type: Float, Desc: `           , coeff of x^5`},
	{Keyword: "BldFl1Sh(6)", Type: Float, Desc: `           , coeff of x^6`},
	{Keyword: "BldFl2Sh(2)", Type: Float, Desc: `Flap mode 2, coeff of x^2`},
	{Keyword: "BldFl2Sh(3)", Type: Float, Desc: `           , coeff of x^3`},
	{Keyword: "BldFl2Sh(4)", Type: Float, Desc: `           , coeff of x^4`},
	{Keyword: "BldFl2Sh(5)", Type: Float, Desc: `           , coeff of x^5`},
	{Keyword: "BldFl2Sh(6)", Type: Float, Desc: `           , coeff of x^6`},
	{Keyword: "BldEdgSh(2)", Type: Float, Desc: `Edge mode 1, coeff of x^2`},
	{Keyword: "BldEdgSh(3)", Type: Float, Desc: `           , coeff of x^3`},
	{Keyword: "BldEdgSh(4)", Type: Float, Desc: `           , coeff of x^4`},
	{Keyword: "BldEdgSh(5)", Type: Float, Desc: `           , coeff of x^5`},
	{Keyword: "BldEdgSh(6)", Type: Float, Desc: `           , coeff of x^6`},
})
View Source 
var ElastoDynSchema = NewSchema("ElastoDyn", []SchemaEntry{
	{Heading: "ElastoDyn Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "Simulation Control"},
	{Keyword: "Echo", Type: Bool, Desc: `Echo input data to <RootName>.ech`, Unit: "flag"},
	{Keyword: "Method", Type: Int, Desc: `Integration method`, Options: []Option{{1, "RK4"}, {2, "AB4"}, {3, "ABM4"}}},
	{Keyword: "DT", Type: Float, Desc: `Integration time step`, Unit: "sec", CanBeDefault: true},
	{Heading: "Degrees Of Freedom"},
	{Keyword: "FlapDOF1", Type: Bool, Desc: `First flapwise blade mode DOF`, Unit: "flag"},
	{Keyword: "FlapDOF2", Type: Bool, Desc: `Second flapwise blade mode DOF`, Unit: "flag"},
	{Keyword: "EdgeDOF", Type: Bool, Desc: `First edgewise blade mode DOF`, Unit: "flag"},
	{Keyword: "TeetDOF", Type: Bool, Desc: `Rotor-teeter DOF [unused for 3 blades]`, Unit: "flag"},
	{Keyword: "DrTrDOF", Type: Bool, Desc: `Drivetrain rotational-flexibility DOF`, Unit: "flag"},
	{Keyword: "GenDOF", Type: Bool, Desc: `Generator DOF`, Unit: "flag"},
	{Keyword: "YawDOF", Type: Bool, Desc: `Yaw DOF`, Unit: "flag"},
	{Keyword: "TwFADOF1", Type: Bool, Desc: `First fore-aft tower bending-mode DOF`, Unit: "flag"},
	{Keyword: "TwFADOF2", Type: Bool, Desc: `Second fore-aft tower bending-mode DOF`, Unit: "flag"},
	{Keyword: "TwSSDOF1", Type: Bool, Desc: `First side-to-side tower bending-mode DOF`, Unit: "flag"},
	{Keyword: "TwSSDOF2", Type: Bool, Desc: `Second side-to-side tower bending-mode DOF`, Unit: "flag"},
	{Keyword: "PtfmSgDOF", Type: Bool, Desc: `Platform horizontal surge translation DOF`, Unit: "flag"},
	{Keyword: "PtfmSwDOF", Type: Bool, Desc: `Platform horizontal sway translation DOF`, Unit: "flag"},
	{Keyword: "PtfmHvDOF", Type: Bool, Desc: `Platform vertical heave translation DOF`, Unit: "flag"},
	{Keyword: "PtfmRDOF", Type: Bool, Desc: `Platform roll tilt rotation DOF`, Unit: "flag"},
	{Keyword: "PtfmPDOF", Type: Bool, Desc: `Platform pitch tilt rotation DOF`, Unit: "flag"},
	{Keyword: "PtfmYDOF", Type: Bool, Desc: `Platform yaw rotation DOF`, Unit: "flag"},
	{Heading: "Initial Conditions"},
	{Keyword: "OoPDefl", Type: Float, Desc: `Initial out-of-plane blade-tip displacement`, Unit: "meters"},
	{Keyword: "IPDefl", Type: Float, Desc: `Initial in-plane blade-tip deflection`, Unit: "meters"},
	{Keyword: "BlPitch(1)", Type: Float, Desc: `Blade 1 initial pitch`, Unit: "degrees"},
	{Keyword: "BlPitch(2)", Type: Float, Desc: `Blade 2 initial pitch`, Unit: "degrees"},
	{Keyword: "BlPitch(3)", Type: Float, Desc: `Blade 3 initial pitch [unused for 2 blades]`, Unit: "degrees"},
	{Keyword: "TeetDefl", Type: Float, Desc: `Initial or fixed teeter angle [unused for 3 blades]`, Unit: "degrees"},
	{Keyword: "Azimuth", Type: Float, Desc: `Initial azimuth angle for blade 1`, Unit: "degrees"},
	{Keyword: "RotSpeed", Type: Float, Desc: `Initial or fixed rotor speed`, Unit: "rpm"},
	{Keyword: "NacYaw", Type: Float, Desc: `Initial or fixed nacelle-yaw angle`, Unit: "degrees"},
	{Keyword: "TTDspFA", Type: Float, Desc: `Initial fore-aft tower-top displacement`, Unit: "meters"},
	{Keyword: "TTDspSS", Type: Float, Desc: `Initial side-to-side tower-top displacement`, Unit: "meters"},
	{Keyword: "PtfmSurge", Type: Float, Desc: `Initial or fixed horizontal surge translational displacement of platform`, Unit: "meters"},
	{Keyword: "PtfmSway", Type: Float, Desc: `Initial or fixed horizontal sway translational displacement of platform`, Unit: "meters"},
	{Keyword: "PtfmHeave", Type: Float, Desc: `Initial or fixed vertical heave translational displacement of platform`, Unit: "meters"},
	{Keyword: "PtfmRoll", Type: Float, Desc: `Initial or fixed roll tilt rotational displacement of platform`, Unit: "degrees"},
	{Keyword: "PtfmPitch", Type: Float, Desc: `Initial or fixed pitch tilt rotational displacement of platform`, Unit: "degrees"},
	{Keyword: "PtfmYaw", Type: Float, Desc: `Initial or fixed yaw rotational displacement of platform`, Unit: "degrees"},
	{Heading: "Turbine Configuration"},
	{Keyword: "NumBl", Type: Int, Desc: `Number of blades`, Unit: "-"},
	{Keyword: "TipRad", Type: Float, Desc: `The distance from the rotor apex to the blade tip`, Unit: "meters"},
	{Keyword: "HubRad", Type: Float, Desc: `The distance from the rotor apex to the blade root`, Unit: "meters"},
	{Keyword: "PreCone(1)", Type: Float, Desc: `Blade 1 cone angle`, Unit: "degrees"},
	{Keyword: "PreCone(2)", Type: Float, Desc: `Blade 2 cone angle`, Unit: "degrees"},
	{Keyword: "PreCone(3)", Type: Float, Desc: `Blade 3 cone angle [unused for 2 blades]`, Unit: "degrees"},
	{Keyword: "HubCM", Type: Float, Desc: `Distance from rotor apex to hub mass [positive downwind]`, Unit: "meters"},
	{Keyword: "UndSling", Type: Float, Desc: `Undersling length [distance from teeter pin to the rotor apex] , Unit:"meters"[unused for 3 blades]`},
	{Keyword: "Delta3", Type: Float, Desc: `Delta-3 angle for teetering rotors [unused for 3 blades]`, Unit: "degrees"},
	{Keyword: "AzimB1Up", Type: Float, Desc: `Azimuth value to use for I/O when blade 1 points up`, Unit: "degrees"},
	{Keyword: "OverHang", Type: Float, Desc: `Distance from yaw axis to rotor apex [3 blades] or teeter pin [2 blades]`, Unit: "meters"},
	{Keyword: "ShftGagL", Type: Float, Desc: `Distance from rotor apex [3 blades] or teeter pin [2 blades] to shaft strain gages [positive for upwind rotors]`, Unit: "meters"},
	{Keyword: "ShftTilt", Type: Float, Desc: `Rotor shaft tilt angle`, Unit: "degrees"},
	{Keyword: "NacCMxn", Type: Float, Desc: `Downwind distance from the tower-top to the nacelle CM`, Unit: "meters"},
	{Keyword: "NacCMyn", Type: Float, Desc: `Lateral  distance from the tower-top to the nacelle CM`, Unit: "meters"},
	{Keyword: "NacCMzn", Type: Float, Desc: `Vertical distance from the tower-top to the nacelle CM`, Unit: "meters"},
	{Keyword: "NcIMUxn", Type: Float, Desc: `Downwind distance from the tower-top to the nacelle IMU`, Unit: "meters"},
	{Keyword: "NcIMUyn", Type: Float, Desc: `Lateral  distance from the tower-top to the nacelle IMU`, Unit: "meters"},
	{Keyword: "NcIMUzn", Type: Float, Desc: `Vertical distance from the tower-top to the nacelle IMU`, Unit: "meters"},
	{Keyword: "Twr2Shft", Type: Float, Desc: `Vertical distance from the tower-top to the rotor shaft`, Unit: "meters"},
	{Keyword: "TowerHt", Type: Float, Desc: `Height of tower above ground level [onshore] or MSL [offshore]`, Unit: "meters"},
	{Keyword: "TowerBsHt", Type: Float, Desc: `Height of tower base above ground level [onshore] or MSL [offshore]`, Unit: "meters"},
	{Keyword: "PtfmCMxt", Type: Float, Desc: `Downwind distance from the ground level [onshore] or MSL [offshore] to the platform CM`, Unit: "meters"},
	{Keyword: "PtfmCMyt", Type: Float, Desc: `Lateral distance from the ground level [onshore] or MSL [offshore] to the platform CM`, Unit: "meters"},
	{Keyword: "PtfmCMzt", Type: Float, Desc: `Vertical distance from the ground level [onshore] or MSL [offshore] to the platform CM`, Unit: "meters"},
	{Keyword: "PtfmRefzt", Type: Float, Desc: `Vertical distance from the ground level [onshore] or MSL [offshore] to the platform reference point`, Unit: "meters"},
	{Heading: "Mass And Inertia"},
	{Keyword: "TipMass(1)", Type: Float, Desc: `Tip-brake mass, blade 1`, Unit: "kg"},
	{Keyword: "TipMass(2)", Type: Float, Desc: `Tip-brake mass, blade 2`, Unit: "kg"},
	{Keyword: "TipMass(3)", Type: Float, Desc: `Tip-brake mass, blade 3 [unused for 2 blades]`, Unit: "kg"},
	{Keyword: "HubMass", Type: Float, Desc: `Hub mass`, Unit: "kg"},
	{Keyword: "HubIner", Type: Float, Desc: `Hub inertia about rotor axis [3 blades] or teeter axis [2 blades]`, Unit: "kg m^2"},
	{Keyword: "GenIner", Type: Float, Desc: `Generator inertia about HSS`, Unit: "kg m^2"},
	{Keyword: "NacMass", Type: Float, Desc: `Nacelle mass`, Unit: "kg"},
	{Keyword: "NacYIner", Type: Float, Desc: `Nacelle inertia about yaw axis`, Unit: "kg m^2"},
	{Keyword: "YawBrMass", Type: Float, Desc: `Yaw bearing mass`, Unit: "kg"},
	{Keyword: "PtfmMass", Type: Float, Desc: `Platform mass`, Unit: "kg"},
	{Keyword: "PtfmRIner", Type: Float, Desc: `Platform inertia for roll tilt rotation about the platform CM`, Unit: "kg m^2"},
	{Keyword: "PtfmPIner", Type: Float, Desc: `Platform inertia for pitch tilt rotation about the platform CM`, Unit: "kg m^2"},
	{Keyword: "PtfmYIner", Type: Float, Desc: `Platform inertia for yaw rotation about the platform CM`, Unit: "kg m^2"},
	{Heading: "Blade"},
	{Keyword: "BldNodes", Type: Int, Desc: `Number of blade nodes (per blade) used for analysis`, Unit: "-"},
	{Keyword: "BldFile(1)", Type: String, Desc: `Name of file containing properties for blade 1 (quoted string)`},
	{Keyword: "BldFile(2)", Type: String, Desc: `Name of file containing properties for blade 2 (quoted string)`},
	{Keyword: "BldFile(3)", Type: String, Desc: `Name of file containing properties for blade 3 (quoted string) [unused for 2 blades]`},
	{Heading: "Rotor-Teeter"},
	{Keyword: "TeetMod", Type: Int, Desc: `Rotor-teeter spring/damper model (switch) [unused for 3 blades]`, Options: []Option{{0, "none"}, {1, "standard"}, {2, "user-defined from routine UserTeet"}}},
	{Keyword: "TeetDmpP", Type: Float, Desc: `Rotor-teeter damper position [used only for 2 blades and when TeetMod=1]`, Unit: "degrees"},
	{Keyword: "TeetDmp", Type: Float, Desc: `Rotor-teeter damping constant [used only for 2 blades and when TeetMod=1]`, Unit: "N-m/(rad/s)"},
	{Keyword: "TeetCDmp", Type: Float, Desc: `Rotor-teeter rate-independent Coulomb-damping moment (N-m) [used only for 2 blades and when TeetMod=1]`},
	{Keyword: "TeetSStP", Type: Float, Desc: `Rotor-teeter soft-stop position [used only for 2 blades and when TeetMod=1]`, Unit: "degrees"},
	{Keyword: "TeetHStP", Type: Float, Desc: `Rotor-teeter hard-stop position [used only for 2 blades and when TeetMod=1]`, Unit: "degrees"},
	{Keyword: "TeetSSSp", Type: Float, Desc: `Rotor-teeter soft-stop linear-spring constant [used only for 2 blades and when TeetMod=1]`, Unit: "N-m/rad"},
	{Keyword: "TeetHSSp", Type: Float, Desc: `Rotor-teeter hard-stop linear-spring constant [used only for 2 blades and when TeetMod=1]`, Unit: "N-m/rad"},
	{Heading: "Drivetrain"},
	{Keyword: "GBoxEff", Type: Float, Desc: `Gearbox efficiency`, Unit: "%"},
	{Keyword: "GBRatio", Type: Float, Desc: `Gearbox ratio`, Unit: "-"},
	{Keyword: "DTTorSpr", Type: Float, Desc: `Drivetrain torsional spring`, Unit: "N-m/rad"},
	{Keyword: "DTTorDmp", Type: Float, Desc: `Drivetrain torsional damper`, Unit: "N-m/(rad/s)"},
	{Heading: "Furling"},
	{Keyword: "Furling", Type: Bool, Desc: `Read in additional model properties for furling turbine [must currently be FALSE)`, Unit: "flag"},
	{Keyword: "FurlFile", Type: String, Desc: `Name of file containing furling properties (quoted string) [unused when Furling=False]`},
	{Heading: "Tower"},
	{Keyword: "TwrNodes", Type: Int, Desc: `Number of tower nodes used for analysis (-)`},
	{Keyword: "TwrFile", Type: String, Desc: `Name of file containing tower properties (quoted string)`},
	{Heading: "Output"},
	{Keyword: "SumPrint", Type: Bool, Desc: `Print summary data to '<RootName>.sum'`, Unit: "flag"},
	{Keyword: "OutFile", Type: Int, Desc: `Switch to determine where output will be placed: {1: in module output file only; 2: in glue code output file only; 3: both} (currently unused)`},
	{Keyword: "TabDelim", Type: Bool, Desc: `Use tab delimiters in text tabular output file? (currently unused)`, Unit: "flag"},
	{Keyword: "OutFmt", Type: String, Desc: `Format used for text tabular output (except time).  Resulting field should be 10 characters. (quoted string) (currently unused)`},
	{Keyword: "TStart", Type: Float, Desc: `Time to begin tabular output (s) (currently unused)`},
	{Keyword: "DecFact", Type: Int, Desc: `Decimation factor for tabular output {1: output every time step} (-) (currently unused)`},
	{Keyword: "NTwGages", Type: Int, Desc: `Number of tower nodes that have strain gages for output [0 to 9] (-)`},
	{Keyword: "TwrGagNd", Type: Int, Dims: 1, Desc: `List of tower nodes that have strain gages [1 to TwrNodes] (-) [unused if NTwGages=0]`},
	{Keyword: "NBlGages", Type: Int, Desc: `Number of blade nodes that have strain gages for output [0 to 9] (-)`},
	{Keyword: "BldGagNd", Type: Int, Dims: 1, Desc: `List of blade nodes that have strain gages [1 to BldNodes] (-) [unused if NBlGages=0]`},
	{Keyword: "OutList", Type: String, Dims: 1, Format: formatOutList, Parse: parseOutList, Desc: `The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels, (-)`},
})
View Source 
var ElastoDynTowerSchema = NewSchema("ElastoDynTower", []SchemaEntry{
	{Heading: "ElastoDyn Tower Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "Tower Parameters"},
	{Keyword: "NTwInpSt", Type: Int, Desc: `Number of input stations to specify tower geometry`},
	{Keyword: "TwrFADmp(1)", Type: Float, Desc: `Tower 1st fore-aft mode structural damping ratio`, Unit: "%"},
	{Keyword: "TwrFADmp(2)", Type: Float, Desc: `Tower 2nd fore-aft mode structural damping ratio`, Unit: "%"},
	{Keyword: "TwrSSDmp(1)", Type: Float, Desc: `Tower 1st side-to-side mode structural damping ratio`, Unit: "%"},
	{Keyword: "TwrSSDmp(2)", Type: Float, Desc: `Tower 2nd side-to-side mode structural damping ratio`, Unit: "%"},
	{Heading: "Tower Adjustment Factors"},
	{Keyword: "FAStTunr(1)", Type: Float, Desc: `Tower fore-aft modal stiffness tuner, 1st mode`, Unit: "-"},
	{Keyword: "FAStTunr(2)", Type: Float, Desc: `Tower fore-aft modal stiffness tuner, 2nd mode`, Unit: "-"},
	{Keyword: "SSStTunr(1)", Type: Float, Desc: `Tower side-to-side stiffness tuner, 1st mode`, Unit: "-"},
	{Keyword: "SSStTunr(2)", Type: Float, Desc: `Tower side-to-side stiffness tuner, 2nd mode`, Unit: "-"},
	{Keyword: "AdjTwMa", Type: Float, Desc: `Factor to adjust tower mass density`, Unit: "-"},
	{Keyword: "AdjFASt", Type: Float, Desc: `Factor to adjust tower fore-aft stiffness`, Unit: "-"},
	{Keyword: "AdjSSSt", Type: Float, Desc: `Factor to adjust tower side-to-side stiffness`, Unit: "-"},
	{Heading: "Distributed Tower Properties"},
	{Keyword: "TwInpSt", Dims: 1, Format: formatElastoDynTowerTwInpSt, Parse: parseElastoDynTowerTwInpSt,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "HtFract", Type: Float, Desc: `Fractional height of the flexible portion of tower for a given input station`, Unit: "-"},
				{Keyword: "TMassDen", Type: Float, Desc: `Tower mass density for a given input station`, Unit: "kg/m"},
				{Keyword: "TwFAStif", Type: Float, Desc: `Tower fore-aft stiffness for a given input station`, Unit: "Nm^2"},
				{Keyword: "TwSSStif", Type: Float, Desc: `Tower side-to-side stiffness for a given input station`, Unit: "Nm^2"},
			},
		},
	},
	{Heading: "Tower Fore-Aft Mode Shapes"},
	{Keyword: "TwFAM1Sh(2)", Type: Float, Desc: `Mode 1, coefficient of x^2 term`},
	{Keyword: "TwFAM1Sh(3)", Type: Float, Desc: `      , coefficient of x^3 term`},
	{Keyword: "TwFAM1Sh(4)", Type: Float, Desc: `      , coefficient of x^4 term`},
	{Keyword: "TwFAM1Sh(5)", Type: Float, Desc: `      , coefficient of x^5 term`},
	{Keyword: "TwFAM1Sh(6)", Type: Float, Desc: `      , coefficient of x^6 term`},
	{Keyword: "TwFAM2Sh(2)", Type: Float, Desc: `Mode 2, coefficient of x^2 term`},
	{Keyword: "TwFAM2Sh(3)", Type: Float, Desc: `      , coefficient of x^3 term`},
	{Keyword: "TwFAM2Sh(4)", Type: Float, Desc: `      , coefficient of x^4 term`},
	{Keyword: "TwFAM2Sh(5)", Type: Float, Desc: `      , coefficient of x^5 term`},
	{Keyword: "TwFAM2Sh(6)", Type: Float, Desc: `      , coefficient of x^6 term`},
	{Heading: "Tower Side-To-Side Mode Shapes"},
	{Keyword: "TwSSM1Sh(2)", Type: Float, Desc: `Mode 1, coefficient of x^2 term`},
	{Keyword: "TwSSM1Sh(3)", Type: Float, Desc: `      , coefficient of x^3 term`},
	{Keyword: "TwSSM1Sh(4)", Type: Float, Desc: `      , coefficient of x^4 term`},
	{Keyword: "TwSSM1Sh(5)", Type: Float, Desc: `      , coefficient of x^5 term`},
	{Keyword: "TwSSM1Sh(6)", Type: Float, Desc: `      , coefficient of x^6 term`},
	{Keyword: "TwSSM2Sh(2)", Type: Float, Desc: `Mode 2, coefficient of x^2 term`},
	{Keyword: "TwSSM2Sh(3)", Type: Float, Desc: `      , coefficient of x^3 term`},
	{Keyword: "TwSSM2Sh(4)", Type: Float, Desc: `      , coefficient of x^4 term`},
	{Keyword: "TwSSM2Sh(5)", Type: Float, Desc: `      , coefficient of x^5 term`},
	{Keyword: "TwSSM2Sh(6)", Type: Float, Desc: `      , coefficient of x^6 term`},
})
View Source 
var FASTSchema = NewSchema("FAST", []SchemaEntry{
	{Heading: "OpenFAST Input File"},
	{Keyword: "Title", Type: String, Desc: `File title`, Format: formatTitle, Parse: parseTitle},

	{Heading: "Simulation Control"},
	{Keyword: "Echo", Type: Bool, Desc: `Echo input data to <RootName>.ech`, Unit: "flag"},
	{Keyword: "AbortLevel", Type: String, Desc: `Error level when simulation should abort`, Unit: "string", Options: []Option{{"WARNING", "WARNING"}, {"SEVERE", "SEVERE"}, {"FATAL", "FATAL"}}},
	{Keyword: "TMax", Type: Float, Desc: `Total run time`, Unit: "sec"},
	{Keyword: "DT", Type: Float, Desc: `Recommended module time step`, Unit: "sec"},
	{Keyword: "InterpOrder", Type: Int, Desc: `Interpolation order for input/output time history`, Unit: "-", Options: []Option{{1, "Linear"}, {2, "Quadratic"}}},
	{Keyword: "NumCrctn", Type: Int, Desc: `Number of correction iterations {0=explicit calculation, i.e., no corrections}`, Unit: "-"},
	{Keyword: "DT_UJac", Type: Float, Desc: `Time between calls to get Jacobians`, Unit: "sec"},
	{Keyword: "UJacSclFact", Type: Float, Desc: `Scaling factor used in Jacobians`, Unit: "-"},

	{Heading: "Feature switches and flags"},
	{Keyword: "CompElast", Type: Int, Desc: `Compute structural dynamics`, Unit: "switch", Options: []Option{{1, "ElastoDyn"}, {2, "ElastoDyn + BeamDyn for blades"}}},
	{Keyword: "CompInflow", Type: Int, Desc: `Compute inflow wind velocities`, Unit: "switch", Options: []Option{{0, "Still Air"}, {1, "InflowWind"}, {2, "External (OpenFOAM)"}}},
	{Keyword: "CompAero", Type: Int, Desc: `Compute aerodynamic loads`, Unit: "switch", Options: []Option{{0, "None"}, {1, "AeroDyn v14"}, {2, "AeroDyn v15"}}},
	{Keyword: "CompServo", Type: Int, Desc: `Compute control and electrical-drive dynamics`, Unit: "switch", Options: []Option{{0, "None"}, {1, "ServoDyn"}}},
	{Keyword: "CompHydro", Type: Int, Desc: `Compute hydrodynamic loads`, Unit: "switch", Options: []Option{{0, "None"}, {1, "HydroDyn"}}},
	{Keyword: "CompSub", Type: Int, Desc: `Compute sub-structural dynamics`, Unit: "switch", Options: []Option{{0, "None"}, {1, "SubDyn"}, {2, "External Platform MCKF"}}},
	{Keyword: "CompMooring", Type: Int, Desc: `Compute mooring system`, Unit: "switch", Options: []Option{{0, "None"}, {1, "MAP++"}, {2, "FEAMooring"}, {3, "MoorDyn"}, {4, "OrcaFlex"}}},
	{Keyword: "CompIce", Type: Int, Desc: `Compute ice loads`, Unit: "switch", Options: []Option{{0, "None"}, {1, "IceFloe"}, {2, "IceDyn"}}},
	{Keyword: "MHK", Type: Int, Desc: `MHK turbine type`, Unit: "switch", Options: []Option{{0, "Not an MHK turbine"}, {1, "Fixed MHK turbine"}, {2, "Floating MHK turbine"}}},

	{Heading: "Environmental Conditions"},
	{Keyword: "Gravity", Type: Float, Desc: `Gravitational acceleration`, Unit: "m/s^2"},
	{Keyword: "AirDens", Type: Float, Desc: `Air density`, Unit: "kg/m^3"},
	{Keyword: "WtrDens", Type: Float, Desc: `Water density`, Unit: "kg/m^3"},
	{Keyword: "KinVisc", Type: Float, Desc: `Kinematic viscosity of working fluid`, Unit: "m^2/s"},
	{Keyword: "SpdSound", Type: Float, Desc: `Speed of sound in working fluid`, Unit: "m/s"},
	{Keyword: "Patm", Type: Float, Desc: `Atmospheric pressure [used only for an MHK turbine cavitation check]`, Unit: "Pa"},
	{Keyword: "Pvap", Type: Float, Desc: `Vapour pressure of working fluid [used only for an MHK turbine cavitation check]`, Unit: "Pa"},
	{Keyword: "WtrDpth", Type: Float, Desc: `Water depth`, Unit: "m"},
	{Keyword: "MSL2SWL", Type: Float, Desc: `Offset between still-water level and mean sea level [positive upward]`, Unit: "m"},

	{Heading: "Input Files"},
	{Keyword: "EDFile", Type: String, Desc: `Name of file containing ElastoDyn input parameters`, Unit: "quoted string"},
	{Keyword: "BDBldFile(1)", Type: String, Desc: `Name of file containing BeamDyn input parameters for blade 1`, Unit: "quoted string", Show: []Condition{{"CompElast", "==", 2}}},
	{Keyword: "BDBldFile(2)", Type: String, Desc: `Name of file containing BeamDyn input parameters for blade 2`, Unit: "quoted string", Show: []Condition{{"CompElast", "==", 2}}},
	{Keyword: "BDBldFile(3)", Type: String, Desc: `Name of file containing BeamDyn input parameters for blade 3`, Unit: "quoted string", Show: []Condition{{"CompElast", "==", 2}}},
	{Keyword: "InflowFile", Type: String, Desc: `Name of file containing inflow wind input parameters`, Unit: "quoted string", Show: []Condition{{"CompInflow", "==", 1}}},
	{Keyword: "AeroFile", Type: String, Desc: `Name of file containing aerodynamic input parameters`, Unit: "quoted string", Show: []Condition{{"CompAero", "==", 1}}},
	{Keyword: "ServoFile", Type: String, Desc: `Name of file containing control and electrical-drive input parameters`, Unit: "quoted string", Show: []Condition{{"CompServo", "==", 1}}},
	{Keyword: "HydroFile", Type: String, Desc: `Name of file containing hydrodynamic input parameters`, Unit: "quoted string", Show: []Condition{{"CompHydro", "==", 1}}},
	{Keyword: "SubFile", Type: String, Desc: `Name of file containing sub-structural input parameters`, Unit: "quoted string", Show: []Condition{{"CompSub", "==", 1}}},
	{Keyword: "MooringFile", Type: String, Desc: `Name of file containing mooring system input parameters`, Unit: "quoted string", Show: []Condition{{"CompMooring", ">", 0}}},
	{Keyword: "IceFile", Type: String, Desc: `Name of file containing ice input parameters`, Unit: "quoted string", Show: []Condition{{"CompIce", ">", 0}}},

	{Heading: "Output"},
	{Keyword: "SumPrint", Type: Bool, Desc: `Print summary data to '<RootName>.sum'`, Unit: "flag"},
	{Keyword: "SttsTime", Type: Float, Desc: `Amount of time between screen status messages`, Unit: "sec"},
	{Keyword: "ChkptTime", Type: Float, Desc: `Amount of time between creating checkpoint files for potential restart`, Unit: "sec"},
	{Keyword: "DT_Out", Type: Float, CanBeDefault: true, Desc: `Time step for tabular output (or "default")`, Unit: "sec"},
	{Keyword: "TStart", Type: Float, Desc: `Time to begin tabular output`, Unit: "sec"},
	{Keyword: "OutFileFmt", Type: Int, Desc: `Format for tabular (time-marching) output file`, Unit: "switch", Options: []Option{{0, "uncompressed binary [<RootName>.outb]"}, {1, "text file [<RootName>.out]"}, {2, "binary file [<RootName>.outb]"}, {3, "both 1 and 2"}}},
	{Keyword: "TabDelim", Type: Bool, Desc: `Use tab delimiters in text tabular output file?`, Unit: "flag", Options: []Option{{true, "Tabs"}, {false, "Spaces"}}},
	{Keyword: "OutFmt", Type: String, Desc: `Format used for text tabular output, excluding the time channel.  Resulting field should be 10 characters`, Unit: "quoted string"},

	{Heading: "Linearization"},
	{Keyword: "Linearize", Type: Bool, Desc: `Linearization analysis`},
	{Keyword: "CalcSteady", Type: Bool, Desc: `Calculate a steady-state periodic operating point before linearization?`, Unit: "flag", Show: []Condition{{"Linearize", "==", true}}},
	{Keyword: "TrimCase", Type: Int, Desc: `Controller parameter to be trimmed`, Unit: "-", Options: []Option{{1, "yaw"}, {2, "torque"}, {3, "pitch"}}, Show: []Condition{{"CalcSteady", "==", true}}},
	{Keyword: "TrimTol", Type: Float, Desc: `Tolerance for the rotational speed convergence`, Unit: "-", Show: []Condition{{"CalcSteady", "==", true}}},
	{Keyword: "TrimGain", Type: Float, Desc: `Proportional gain for the rotational speed error (>0) (rad/(rad/s) for yaw or pitch; Nm/(rad/s) for torque)`, Show: []Condition{{"CalcSteady", "==", true}}},
	{Keyword: "Twr_Kdmp", Type: Float, Desc: `Damping factor for the tower`, Unit: "N/(m/s)", Show: []Condition{{"CalcSteady", "==", true}}},
	{Keyword: "Bld_Kdmp", Type: Float, Desc: `Damping factor for the blades`, Unit: "N/(m/s)", Show: []Condition{{"CalcSteady", "==", true}}},
	{Keyword: "NLinTimes", Type: Int, Desc: `Number of times to linearize [>=1]`, Show: []Condition{{"Linearize", "==", true}}},
	{Keyword: "LinTimes", Type: Float, Dims: 1, Desc: `List of times at which to linearize [1 to NLinTimes] [used only when Linearize=True and CalcSteady=False]`, Unit: "sec", Show: []Condition{{"Linearize", "==", true}, {"CalcSteady", "==", false}}},
	{Keyword: "LinInputs", Type: Int, Desc: `Inputs included in linearization`, Unit: "switch", Options: []Option{{0, "none"}, {1, "standard"}, {2, "all module inputs (debug)"}}, Show: []Condition{{"Linearize", "==", true}}},
	{Keyword: "LinOutputs", Type: Int, Desc: `Outputs included in linearization`, Unit: "switch", Options: []Option{{0, "none"}, {1, "from OutList(s)"}, {2, "all module outputs (debug)"}}, Show: []Condition{{"Linearize", "==", true}}},
	{Keyword: "LinOutJac", Type: Bool, Desc: `Include full Jacobians in linearization output (for debug)`, Unit: "flag", Show: []Condition{{"Linearize", "==", true}, {"LinInputs", "==", 2}, {"LinOutputs", "==", 2}}},
	{Keyword: "LinOutMod", Type: Bool, Desc: `Write module-level linearization output files in addition to output for full system?`, Unit: "flag", Show: []Condition{{"Linearize", "==", true}}},

	{Heading: "Visualization"},
	{Keyword: "WrVTK", Type: Int, Desc: `VTK visualization data output`, Unit: "switch", Options: []Option{{0, "none"}, {1, "initialization data only"}, {2, "animation"}, {3, "mode shapes"}}},
	{Keyword: "VTK_type", Type: Int, Desc: `Type of VTK visualization data`, Unit: "switch", Options: []Option{{1, "surfaces"}, {2, "basic meshes (lines/points)"}, {3, "all meshes (debug)"}}, Show: []Condition{{"WrVTK", ">", 0}}},
	{Keyword: "VTK_fields", Type: Bool, Desc: `Write mesh fields to VTK data files?`, Unit: "flag", Show: []Condition{{"WrVTK", ">", 0}}},
	{Keyword: "VTK_fps", Type: Float, Desc: `Frame rate for VTK output (frames per second) {will use closest integer multiple of DT}`, Show: []Condition{{"WrVTK", "in", []int{2, 3}}}},
})
View Source 
var InflowWindSchema = NewSchema("InflowWind", []SchemaEntry{
	{Heading: "InflowWind Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "General"},
	{Keyword: "Echo", Type: Bool, Desc: `Echo input data to <RootName>.ech (flag)`},
	{Keyword: "WindType", Type: Int, Desc: `switch for wind file type`, Options: []Option{{1, "steady"}, {2, "uniform"}, {3, "binary TurbSim FF"}, {4, "binary Bladed-style FF"}, {5, "HAWC format"}, {6, "User defined"}, {7, "native Bladed FF"}}},
	{Keyword: "PropagationDir", Type: Float, Desc: `Direction of wind propagation (meteorological rotation from aligned with X (positive rotates towards -Y) -- degrees) (not used for native Bladed format WindType=7)`},
	{Keyword: "VFlowAng", Type: Float, Desc: `Upflow angle (degrees) (not used for native Bladed format WindType=7)`},
	{Keyword: "NWindVel", Type: Int, Desc: `Number of points to output the wind velocity`, Options: []Option{{0, "0"}, {1, "1"}, {2, "2"}, {3, "3"}, {4, "4"}, {5, "5"}, {6, "6"}, {7, "7"}, {8, "8"}, {9, "9"}}},
	{Keyword: "WindVxiList", Type: Float, Dims: 1, Desc: `List of coordinates in the inertial X direction`, Unit: "m"},
	{Keyword: "WindVyiList", Type: Float, Dims: 1, Desc: `List of coordinates in the inertial Y direction`, Unit: "m"},
	{Keyword: "WindVziList", Type: Float, Dims: 1, Desc: `List of coordinates in the inertial Z direction`, Unit: "m"},
	{Heading: "Parameters for Steady Wind Conditions [used only for WindType = 1]"},
	{Keyword: "HWindSpeed", Type: Float, Desc: `Horizontal wind speed`, Unit: "m/s"},
	{Keyword: "RefHt", Type: Float, Desc: `Reference height for horizontal wind speed`, Unit: "m"},
	{Keyword: "PLExp", Type: Float, Desc: `Power law exponent`, Unit: "-"},
	{Heading: "Parameters for Uniform wind file [used only for WindType = 2]"},
	{Keyword: "FileName_Uni", Type: String, Desc: `Filename of time series data for uniform wind field`, Unit: "-"},
	{Keyword: "RefHt_Uni", Type: Float, Desc: `Reference height for horizontal wind speed`, Unit: "m"},
	{Keyword: "RefLength", Type: Float, Desc: `Reference length for linear horizontal and vertical sheer`, Unit: "-"},
	{Heading: "Parameters for Binary TurbSim Full-Field files [used only for WindType = 3]"},
	{Keyword: "FileName_BTS", Type: String, Desc: `Name of the Full field wind file to use (.bts)`},
	{Heading: "Parameters for Binary Bladed-style Full-Field files [used only for WindType = 4 or WindType = 7]"},
	{Keyword: "FileNameRoot", Type: String, Desc: `WindType=4: Rootname of the full-field wind file to use (.wnd, .sum); WindType=7: name of the intermediate file with wind scaling values`},
	{Keyword: "TowerFile", Type: Bool, Desc: `Have tower file (.twr) (flag) ignored when WindType = 7`},
	{Heading: "Parameters for HAWC-format binary files  [Only used with WindType = 5] //==="},
	{Keyword: "FileName_u", Type: String, Desc: `name of the file containing the u-component fluctuating wind (.bin)`},
	{Keyword: "FileName_v", Type: String, Desc: `name of the file containing the v-component fluctuating wind (.bin)`},
	{Keyword: "FileName_w", Type: String, Desc: `name of the file containing the w-component fluctuating wind (.bin)`},
	{Keyword: "NX", Type: Int, Desc: `number of grids in the x direction (in the 3 files above)`, Unit: "-"},
	{Keyword: "NY", Type: Int, Desc: `number of grids in the y direction (in the 3 files above)`, Unit: "-"},
	{Keyword: "NZ", Type: Int, Desc: `number of grids in the z direction (in the 3 files above)`, Unit: "-"},
	{Keyword: "DX", Type: Float, Desc: `distance (in meters) between points in the x direction`, Unit: "m"},
	{Keyword: "DY", Type: Float, Desc: `distance (in meters) between points in the y direction`, Unit: "m"},
	{Keyword: "DZ", Type: Float, Desc: `distance (in meters) between points in the z direction`, Unit: "m"},
	{Keyword: "RefHt_Hawc", Type: Float, Desc: `reference height; the height (in meters) of the vertical center of the grid`, Unit: "m"},
	{Heading: "Scaling parameters for turbulence"},
	{Keyword: "ScaleMethod", Type: Int, Desc: `Turbulence scaling method`, Options: []Option{{0, "none"}, {1, "direct scaling"}, {2, "calculate scaling factor based on a desired standard deviation"}}},
	{Keyword: "SFx", Type: Float, Desc: `Turbulence scaling factor for the x direction [ScaleMethod=1]`, Unit: "-"},
	{Keyword: "SFy", Type: Float, Desc: `Turbulence scaling factor for the y direction [ScaleMethod=1]`, Unit: "-"},
	{Keyword: "SFz", Type: Float, Desc: `Turbulence scaling factor for the z direction [ScaleMethod=1]`, Unit: "-"},
	{Keyword: "SigmaFx", Type: Float, Desc: `Turbulence standard deviation to calculate scaling from in x direction [ScaleMethod=2]`, Unit: "m/s"},
	{Keyword: "SigmaFy", Type: Float, Desc: `Turbulence standard deviation to calculate scaling from in y direction [ScaleMethod=2]`, Unit: "m/s"},
	{Keyword: "SigmaFz", Type: Float, Desc: `Turbulence standard deviation to calculate scaling from in z direction [ScaleMethod=2]`, Unit: "m/s"},
	{Heading: "Mean wind profile parameters (added to HAWC-format files)"},
	{Keyword: "URef", Type: Float, Desc: `Mean u-component wind speed at the reference height`, Unit: "m/s"},
	{Keyword: "WindProfile", Type: Int, Desc: `Wind profile type`, Options: []Option{{0, "constant"}, {1, "logarithmic"}, {2, "power law"}}},
	{Keyword: "PLExp_Hawc", Type: Float, Desc: `Power law exponent (used for PL wind profile type only)`, Unit: "-"},
	{Keyword: "Z0", Type: Float, Desc: `Surface roughness length (used for LG wind profile type only)`, Unit: "m"},
	{Keyword: "XOffset", Type: Float, Desc: `Initial offset in +x direction (shift of wind box)`},
	{Heading: "Output"},
	{Keyword: "SumPrint", Type: Bool, Desc: `Print summary data to <RootName>.IfW.sum (flag)`},
	{Keyword: "OutList", Type: String, Dims: 1, Format: formatOutList, Parse: parseOutList, Desc: `The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels`, Unit: "-"},
})
View Source 
var Schemas = map[string]Schema{
	"AD15AirfoilInfo": AD15AirfoilInfoSchema,
	"AeroDyn14":       AeroDyn14Schema,
	"AeroDyn15":       AeroDyn15Schema,
	"AeroDynBlade":    AeroDynBladeSchema,
	"BeamDyn":         BeamDynSchema,
	"BeamDynBlade":    BeamDynBladeSchema,
	"ElastoDyn":       ElastoDynSchema,
	"ElastoDynBlade":  ElastoDynBladeSchema,
	"ElastoDynTower":  ElastoDynTowerSchema,
	"FAST":            FASTSchema,
	"InflowWind":      InflowWindSchema,
	"ServoDyn":        ServoDynSchema,
	"TurbSim":         TurbSimSchema,
}
View Source 
var ServoDynSchema = NewSchema("ServoDyn", []SchemaEntry{
	{Heading: "ServoDyn Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "Simulation Control"},
	{Keyword: "Echo", Type: Bool, Desc: `Echo input data to <RootName>.ech (flag)`},
	{Keyword: "DT", Type: Float, CanBeDefault: true, Desc: `Communication interval for controllers (s) (or "default")`},
	{Heading: "Pitch Control"},
	{Keyword: "PCMode", Type: Int, Desc: `Pitch control mode {0: none, 3: user-defined from routine PitchCntrl, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)`},
	{Keyword: "TPCOn", Type: Float, Desc: `Time to enable active pitch control (s) [unused when PCMode=0]`},
	{Keyword: "TPitManS(1)", Type: Float, Desc: `Time to start override pitch maneuver for blade 1 and end standard pitch control (s)`},
	{Keyword: "TPitManS(2)", Type: Float, Desc: `Time to start override pitch maneuver for blade 2 and end standard pitch control (s)`},
	{Keyword: "TPitManS(3)", Type: Float, Desc: `Time to start override pitch maneuver for blade 3 and end standard pitch control (s) [unused for 2 blades]`},
	{Keyword: "PitManRat(1)", Type: Float, Desc: `Pitch rate at which override pitch maneuver heads toward final pitch angle for blade 1 (deg/s)`},
	{Keyword: "PitManRat(2)", Type: Float, Desc: `Pitch rate at which override pitch maneuver heads toward final pitch angle for blade 2 (deg/s)`},
	{Keyword: "PitManRat(3)", Type: Float, Desc: `Pitch rate at which override pitch maneuver heads toward final pitch angle for blade 3 (deg/s) [unused for 2 blades]`},
	{Keyword: "BlPitchF(1)", Type: Float, Desc: `Blade 1 final pitch for pitch maneuvers (degrees)`},
	{Keyword: "BlPitchF(2)", Type: Float, Desc: `Blade 2 final pitch for pitch maneuvers (degrees)`},
	{Keyword: "BlPitchF(3)", Type: Float, Desc: `Blade 3 final pitch for pitch maneuvers (degrees) [unused for 2 blades]`},
	{Heading: "Generator And Torque Control"},
	{Keyword: "VSContrl", Type: Int, Desc: `Variable-speed control mode {0: none, 1: simple VS, 3: user-defined from routine UserVSCont, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)`},
	{Keyword: "GenModel", Type: Int, Desc: `Generator model {1: simple, 2: Thevenin, 3: user-defined from routine UserGen} (switch) [used only when VSContrl=0]`},
	{Keyword: "GenEff", Type: Float, Desc: `Generator efficiency [ignored by the Thevenin and user-defined generator models] (%)`},
	{Keyword: "GenTiStr", Type: Bool, Desc: `Method to start the generator {T: timed using TimGenOn, F: generator speed using SpdGenOn} (flag)`},
	{Keyword: "GenTiStp", Type: Bool, Desc: `Method to stop the generator {T: timed using TimGenOf, F: when generator power = 0} (flag)`},
	{Keyword: "SpdGenOn", Type: Float, Desc: `Generator speed to turn on the generator for a startup (HSS speed) (rpm) [used only when GenTiStr=False]`},
	{Keyword: "TimGenOn", Type: Float, Desc: `Time to turn on the generator for a startup (s) [used only when GenTiStr=True]`},
	{Keyword: "TimGenOf", Type: Float, Desc: `Time to turn off the generator (s) [used only when GenTiStp=True]`},
	{Heading: "Simple Variable-Speed Torque Control"},
	{Keyword: "VS_RtGnSp", Type: Float, Desc: `Rated generator speed for simple variable-speed generator control (HSS side) (rpm) [used only when VSContrl=1]`},
	{Keyword: "VS_RtTq", Type: Float, Desc: `Rated generator torque/constant generator torque in Region 3 for simple variable-speed generator control (HSS side) (N-m) [used only when VSContrl=1]`},
	{Keyword: "VS_Rgn2K", Type: Float, Desc: `Generator torque constant in Region 2 for simple variable-speed generator control (HSS side) (N-m/rpm^2) [used only when VSContrl=1]`},
	{Keyword: "VS_SlPc", Type: Float, Desc: `Rated generator slip percentage in Region 2 1/2 for simple variable-speed generator control (%) [used only when VSContrl=1]`},
	{Heading: "Simple Induction Generator"},
	{Keyword: "SIG_SlPc", Type: Float, Desc: `Rated generator slip percentage (%) [used only when VSContrl=0 and GenModel=1]`},
	{Keyword: "SIG_SySp", Type: Float, Desc: `Synchronous (zero-torque) generator speed (rpm) [used only when VSContrl=0 and GenModel=1]`},
	{Keyword: "SIG_RtTq", Type: Float, Desc: `Rated torque (N-m) [used only when VSContrl=0 and GenModel=1]`},
	{Keyword: "SIG_PORt", Type: Float, Desc: `Pull-out ratio (Tpullout/Trated) (-) [used only when VSContrl=0 and GenModel=1]`},
	{Heading: "Thevenin-Equivalent Induction Generator"},
	{Keyword: "TEC_Freq", Type: Float, Desc: `Line frequency [50 or 60] (Hz) [used only when VSContrl=0 and GenModel=2]`},
	{Keyword: "TEC_NPol", Type: Int, Desc: `Number of poles [even integer > 0] (-) [used only when VSContrl=0 and GenModel=2]`},
	{Keyword: "TEC_SRes", Type: Float, Desc: `Stator resistance (ohms) [used only when VSContrl=0 and GenModel=2]`},
	{Keyword: "TEC_RRes", Type: Float, Desc: `Rotor resistance (ohms) [used only when VSContrl=0 and GenModel=2]`},
	{Keyword: "TEC_VLL", Type: Float, Desc: `Line-to-line RMS voltage (volts) [used only when VSContrl=0 and GenModel=2]`},
	{Keyword: "TEC_SLR", Type: Float, Desc: `Stator leakage reactance (ohms) [used only when VSContrl=0 and GenModel=2]`},
	{Keyword: "TEC_RLR", Type: Float, Desc: `Rotor leakage reactance (ohms) [used only when VSContrl=0 and GenModel=2]`},
	{Keyword: "TEC_MR", Type: Float, Desc: `Magnetizing reactance (ohms) [used only when VSContrl=0 and GenModel=2]`},
	{Heading: "High-Speed Shaft Brake"},
	{Keyword: "HSSBrMode", Type: Int, Desc: `HSS brake model {0: none, 1: simple, 3: user-defined from routine UserHSSBr, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)`},
	{Keyword: "THSSBrDp", Type: Float, Desc: `Time to initiate deployment of the HSS brake (s)`},
	{Keyword: "HSSBrDT", Type: Float, Desc: `Time for HSS-brake to reach full deployment once initiated (sec) [used only when HSSBrMode=1]`},
	{Keyword: "HSSBrTqF", Type: Float, Desc: `Fully deployed HSS-brake torque (N-m)`},
	{Heading: "Nacelle-Yaw Control"},
	{Keyword: "YCMode", Type: Int, Desc: `Yaw control mode {0: none, 3: user-defined from routine UserYawCont, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)`},
	{Keyword: "TYCOn", Type: Float, Desc: `Time to enable active yaw control (s) [unused when YCMode=0]`},
	{Keyword: "YawNeut", Type: Float, Desc: `Neutral yaw position--yaw spring force is zero at this yaw (degrees)`},
	{Keyword: "YawSpr", Type: Float, Desc: `Nacelle-yaw spring constant (N-m/rad)`},
	{Keyword: "YawDamp", Type: Float, Desc: `Nacelle-yaw damping constant (N-m/(rad/s))`},
	{Keyword: "TYawManS", Type: Float, Desc: `Time to start override yaw maneuver and end standard yaw control (s)`},
	{Keyword: "YawManRat", Type: Float, Desc: `Yaw maneuver rate (in absolute value) (deg/s)`},
	{Keyword: "NacYawF", Type: Float, Desc: `Final yaw angle for override yaw maneuvers (degrees)`},
	{Heading: "Aerodynamic Flow Control"},
	{Keyword: "AfCmode", Type: Int, Desc: `Airfoil control mode {0: none, 1: cosine wave cycle, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)`},
	{Keyword: "AfC_Mean", Type: Float, Desc: `Mean level for cosine cycling or steady value (-) [used only with AfCmode==1]`},
	{Keyword: "AfC_Amp", Type: Float, Desc: `Amplitude for for cosine cycling of flap signal (-) [used only with AfCmode==1]`},
	{Keyword: "AfC_Phase", Type: Float, Desc: `Phase relative to the blade azimuth (0 is vertical) for for cosine cycling of flap signal (deg) [used only with AfCmode==1]`},
	{Heading: "Structural Control"},
	{Keyword: "NumBStC", Type: Int, Desc: `Number of blade structural controllers (integer)`},
	{Keyword: "BStCfiles", Type: String, Desc: `Name of the files for blade structural controllers (quoted strings) [unused when NumBStC==0]`},
	{Keyword: "NumNStC", Type: Int, Desc: `Number of nacelle structural controllers (integer)`},
	{Keyword: "NStCfiles", Type: String, Desc: `Name of the files for nacelle structural controllers (quoted strings) [unused when NumNStC==0]`},
	{Keyword: "NumTStC", Type: Int, Desc: `Number of tower structural controllers (integer)`},
	{Keyword: "TStCfiles", Type: String, Desc: `Name of the files for tower structural controllers (quoted strings) [unused when NumTStC==0]`},
	{Keyword: "NumSStC", Type: Int, Desc: `Number of substructure structural controllers (integer)`},
	{Keyword: "SStCfiles", Type: String, Desc: `Name of the files for substructure structural controllers (quoted strings) [unused when NumSStC==0]`},
	{Heading: "Cable Control"},
	{Keyword: "CCmode", Type: Int, Desc: `Cable control mode {0: none, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)`},
	{Heading: "BLADED Interface"},
	{Keyword: "DLL_FileName", Type: String, Desc: `Name/location of the dynamic library {.dll [Windows] or .so [Linux]} in the Bladed-DLL format (-) [used only with Bladed Interface]`},
	{Keyword: "DLL_InFile", Type: String, Desc: `Name of input file sent to the DLL (-) [used only with Bladed Interface]`},
	{Keyword: "DLL_ProcName", Type: String, Desc: `Name of procedure in DLL to be called (-) [case sensitive; used only with DLL Interface]`},
	{Keyword: "DLL_DT", Type: Float, CanBeDefault: true, Desc: `Communication interval for dynamic library (s) (or "default") [used only with Bladed Interface]`},
	{Keyword: "DLL_Ramp", Type: Bool, Desc: `Whether a linear ramp should be used between DLL_DT time steps [introduces time shift when true] (flag) [used only with Bladed Interface]`},
	{Keyword: "BPCutoff", Type: Float, Desc: `Cutoff frequency for low-pass filter on blade pitch from DLL (Hz) [used only with Bladed Interface]`},
	{Keyword: "NacYaw_North", Type: Float, Desc: `Reference yaw angle of the nacelle when the upwind end points due North (deg) [used only with Bladed Interface]`},
	{Keyword: "Ptch_Cntrl", Type: Int, Desc: `Record 28: Use individual pitch control {0: collective pitch; 1: individual pitch control} (switch) [used only with Bladed Interface]`},
	{Keyword: "Ptch_SetPnt", Type: Float, Desc: `Record  5: Below-rated pitch angle set-point (deg) [used only with Bladed Interface]`},
	{Keyword: "Ptch_Min", Type: Float, Desc: `Record  6: Minimum pitch angle (deg) [used only with Bladed Interface]`},
	{Keyword: "Ptch_Max", Type: Float, Desc: `Record  7: Maximum pitch angle (deg) [used only with Bladed Interface]`},
	{Keyword: "PtchRate_Min", Type: Float, Desc: `Record  8: Minimum pitch rate (most negative value allowed) (deg/s) [used only with Bladed Interface]`},
	{Keyword: "PtchRate_Max", Type: Float, Desc: `Record  9: Maximum pitch rate  (deg/s) [used only with Bladed Interface]`},
	{Keyword: "Gain_OM", Type: Float, Desc: `Record 16: Optimal mode gain (Nm/(rad/s)^2) [used only with Bladed Interface]`},
	{Keyword: "GenSpd_MinOM", Type: Float, Desc: `Record 17: Minimum generator speed (rpm) [used only with Bladed Interface]`},
	{Keyword: "GenSpd_MaxOM", Type: Float, Desc: `Record 18: Optimal mode maximum speed (rpm) [used only with Bladed Interface]`},
	{Keyword: "GenSpd_Dem", Type: Float, Desc: `Record 19: Demanded generator speed above rated (rpm) [used only with Bladed Interface]`},
	{Keyword: "GenTrq_Dem", Type: Float, Desc: `Record 22: Demanded generator torque above rated (Nm) [used only with Bladed Interface]`},
	{Keyword: "GenPwr_Dem", Type: Float, Desc: `Record 13: Demanded power (W) [used only with Bladed Interface]`},
	{Heading: "BLADED Interface Torque-Speed Look-Up Table"},
	{Keyword: "DLL_NumTrq", Type: Int, Desc: `Record 26: No. of points in torque-speed look-up table {0 = none and use the optimal mode parameters; nonzero = ignore the optimal mode PARAMETERs by setting Record 16 to 0.0} (-) [used only with Bladed Interface]`},
	{Keyword: "GenSpdTrq", Dims: 1,
		Table: &Table{
			Columns: []TableColumn{
				{Keyword: "GenSpd_TLU", Type: Float, Dims: 1, Desc: `GenSpd_TLU`},
				{Keyword: "GenTrq_TLU", Type: Float, Dims: 1, Desc: `GenTrq_TLU`},
			},
		},
		Parse: parseGenSpdTrq, Format: formatGenSpdTrq,
	},
	{Heading: "Output"},
	{Keyword: "SumPrint", Type: Bool, Desc: `Print summary data to <RootName>.sum (flag) (currently unused)`},
	{Keyword: "OutFile", Type: Int, Desc: `Switch to determine where output will be placed: {1: in module output file only; 2: in glue code output file only; 3: both} (currently unused)`},
	{Keyword: "TabDelim", Type: Bool, Desc: `Use tab delimiters in text tabular output file? (flag) (currently unused)`},
	{Keyword: "OutFmt", Type: String, Desc: `Format used for text tabular output (except time).  Resulting field should be 10 characters. (quoted string) (currently unused)`},
	{Keyword: "TStart", Type: Float, Desc: `Time to begin tabular output (s) (currently unused)`},
	{Keyword: "OutList", Type: String, Dims: 1, Format: formatOutList, Parse: parseOutList, Desc: `The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels, (-)`},
})
View Source 
var TurbSimSchema = NewSchema("TurbSim", []SchemaEntry{
	{Heading: "TurbSim Input File"},
	{Keyword: "Title", Type: String, Format: formatTitle, Parse: parseTitle},
	{Heading: "Runtime Options"},
	{Keyword: "Echo", Type: Bool, Desc: `Echo input data to <RootName>.ech (flag)`},
	{Keyword: "RandSeed1", Type: Int, Desc: `First random seed  (-2147483648 to 2147483647)`},
	{Keyword: "RandSeed2", Type: String, Desc: `Second random seed (-2147483648 to 2147483647) for intrinsic pRNG, or an alternative pRNG: "RanLux" or "RNSNLW"`},
	{Keyword: "WrBHHTP", Type: Bool, Desc: `Output hub-height turbulence parameters in binary form?  (Generates RootName.bin)`},
	{Keyword: "WrFHHTP", Type: Bool, Desc: `Output hub-height turbulence parameters in formatted form?  (Generates RootName.dat)`},
	{Keyword: "WrADHH", Type: Bool, Desc: `Output hub-height time-series data in AeroDyn form?  (Generates RootName.hh)`},
	{Keyword: "WrADFF", Type: Bool, Desc: `Output full-field time-series data in TurbSim/AeroDyn form? (Generates RootName.bts)`},
	{Keyword: "WrBLFF", Type: Bool, Desc: `Output full-field time-series data in BLADED/AeroDyn form?  (Generates RootName.wnd)`},
	{Keyword: "WrADTWR", Type: Bool, Desc: `Output tower time-series data? (Generates RootName.twr)`},
	{Keyword: "WrFMTFF", Type: Bool, Desc: `Output full-field time-series data in formatted (readable) form?  (Generates RootName.u, RootName.v, RootName.w)`},
	{Keyword: "WrACT", Type: Bool, Desc: `Output coherent turbulence time steps in AeroDyn form? (Generates RootName.cts)`},
	{Keyword: "Clockwise", Type: Bool, Desc: `Clockwise rotation looking downwind? (used only for full-field binary files - not necessary for AeroDyn)`},
	{Keyword: "ScaleIEC", Type: Int, Desc: `Scale IEC turbulence models to exact target standard deviation? [0=no additional scaling; 1=use hub scale uniformly; 2=use individual scales]`},
	{Heading: "-"},
	{Heading: "Turbine/Model Specifications"},
	{Keyword: "NumGrid_Z", Type: Int, Desc: `Vertical grid-point matrix dimension`},
	{Keyword: "NumGrid_Y", Type: Int, Desc: `Horizontal grid-point matrix dimension`},
	{Keyword: "TimeStep", Type: Float, Desc: `Time step [seconds]`},
	{Keyword: "AnalysisTime", Type: Float, Desc: `Length of analysis time series [seconds] (program will add time if necessary: AnalysisTime = MAX(AnalysisTime, UsableTime+GridWidth/MeanHHWS) )`},
	{Keyword: "UsableTime", Type: Float, Format: formatUsableTime, Parse: parseUsableTime, Desc: `Usable length of output time series [seconds] (program will add GridWidth/MeanHHWS seconds unless UsableTime is "ALL")`},
	{Keyword: "HubHt", Type: Float, Desc: `Hub height [m] (should be > 0.5*GridHeight)`},
	{Keyword: "GridHeight", Type: Float, Desc: `Grid height [m]`},
	{Keyword: "GridWidth", Type: Float, Desc: `Grid width [m] (should be >= 2*(RotorRadius+ShaftLength))`},
	{Keyword: "VFlowAng", Type: Float, Desc: `Vertical mean flow (uptilt) angle [degrees]`},
	{Keyword: "HFlowAng", Type: Float, Desc: `Horizontal mean flow (skew) angle [degrees]`},
	{Heading: "-"},
	{Heading: "Meteorological Boundary Conditions"},
	{Keyword: "TurbModel", Type: String, Desc: `Turbulence model ("IECKAI","IECVKM","GP_LLJ","NWTCUP","SMOOTH","WF_UPW","WF_07D","WF_14D","TIDAL","API","USRINP","TIMESR", or "NONE")`},
	{Keyword: "UserFile", Type: String, Desc: `Name of the file that contains inputs for user-defined spectra or time series inputs (used only for "USRINP" and "TIMESR" models)`},
	{Keyword: "IECstandard", Type: String, Desc: `Number of IEC 61400-x standard (x=1,2, or 3 with optional 61400-1 edition number (i.e. "1-Ed2") )`},
	{Keyword: "IECturbc", Type: String, Desc: `IEC turbulence characteristic ("A", "B", "C" or the turbulence intensity in percent) ("KHTEST" option with NWTCUP model, not used for other models)`},
	{Keyword: "IEC_WindType", Type: String, Desc: `IEC turbulence type ("NTM"=normal, "xETM"=extreme turbulence, "xEWM1"=extreme 1-year wind, "xEWM50"=extreme 50-year wind, where x=wind turbine class 1, 2, or 3)`},
	{Keyword: "ETMc", Type: Float, CanBeDefault: true, Desc: `IEC Extreme Turbulence Model "c" parameter [m/s]`},
	{Keyword: "WindProfileType", Type: String, CanBeDefault: true, Desc: `Velocity profile type ("LOG";"PL"=power law;"JET";"H2L"=Log law for TIDAL model;"API";"USR";"TS";"IEC"=PL on rotor disk, LOG elsewhere; or "default")`},
	{Keyword: "ProfileFile", Type: String, Desc: `Name of the file that contains input profiles for WindProfileType="USR" and/or TurbModel="USRVKM" [-]`},
	{Keyword: "RefHt", Type: Float, Desc: `Height of the reference velocity (URef) [m]`},
	{Keyword: "URef", Type: Float, CanBeDefault: true, Desc: `Mean (total) velocity at the reference height [m/s] (or "default" for JET velocity profile) [must be 1-hr mean for API model; otherwise is the mean over AnalysisTime seconds]`},
	{Keyword: "ZJetMax", Type: Float, CanBeDefault: true, Desc: `Jet height [m] (used only for JET velocity profile, valid 70-490 m)`},
	{Keyword: "PLExp", Type: Float, CanBeDefault: true, Desc: `Power law exponent [-] (or "default")`},
	{Keyword: "Z0", Type: Float, CanBeDefault: true, Desc: `Surface roughness length [m] (or "default")`},
	{Heading: "-"},
	{Heading: "Non-IEC Meteorological Boundary Conditions"},
	{Keyword: "Latitude", Type: Float, CanBeDefault: true, Desc: `Site latitude [degrees] (or "default")`},
	{Keyword: "RICH_NO", Type: Float, Desc: `Gradient Richardson number [-]`},
	{Keyword: "UStar", Type: Float, CanBeDefault: true, Desc: `Friction or shear velocity [m/s] (or "default")`},
	{Keyword: "ZI", Type: Float, CanBeDefault: true, Desc: `Mixing layer depth [m] (or "default")`},
	{Keyword: "PC_UW", Type: Float, CanBeDefault: true, Desc: `Hub mean uw Reynolds stress [m^2/s^2] (or "default" or "none")`},
	{Keyword: "PC_UV", Type: Float, CanBeDefault: true, Desc: `Hub mean uv Reynolds stress [m^2/s^2] (or "default" or "none")`},
	{Keyword: "PC_VW", Type: Float, CanBeDefault: true, Desc: `Hub mean vw Reynolds stress [m^2/s^2] (or "default" or "none")`},
	{Heading: "-"},
	{Heading: "Spatial Coherence Parameters"},
	{Keyword: "SCMod1", Type: String, CanBeDefault: true, Desc: `u-component coherence model ("GENERAL", "IEC", "API", "NONE", or "default")`},
	{Keyword: "SCMod2", Type: String, CanBeDefault: true, Desc: `v-component coherence model ("GENERAL", "IEC", "NONE", or "default")`},
	{Keyword: "SCMod3", Type: String, CanBeDefault: true, Desc: `w-component coherence model ("GENERAL", "IEC", "NONE", or "default")`},
	{Keyword: "InCDec1", Type: Float, CanBeDefault: true, Desc: `u-component coherence parameters for general or IEC models [-, m^-1] (e.g. "10.0  0.3e-3" in quotes) (or "default")`},
	{Keyword: "InCDec2", Type: Float, CanBeDefault: true, Desc: `v-component coherence parameters for general or IEC models [-, m^-1] (e.g. "10.0  0.3e-3" in quotes) (or "default")`},
	{Keyword: "InCDec3", Type: Float, CanBeDefault: true, Desc: `w-component coherence parameters for general or IEC models [-, m^-1] (e.g. "10.0  0.3e-3" in quotes) (or "default")`},
	{Keyword: "CohExp", Type: Float, CanBeDefault: true, Desc: `Coherence exponent for general model [-] (or "default")`},
	{Heading: "-"},
	{Heading: "Coherent Turbulence Scaling Parameters"},
	{Keyword: "CTEventPath", Type: String, Desc: `Name of the path where event data files are located`},
	{Keyword: "CTEventFile", Type: String, Desc: `Type of event files ("LES", "DNS", or "RANDOM")`},
	{Keyword: "Randomize", Type: Bool, Desc: `Randomize the disturbance scale and locations? (true/false)`},
	{Keyword: "DistScl", Type: Float, Desc: `Disturbance scale [-] (ratio of event dataset height to rotor disk). (Ignored when Randomize = true.)`},
	{Keyword: "CTLy", Type: Float, Desc: `Fractional location of tower centerline from right [-] (looking downwind) to left side of the dataset. (Ignored when Randomize = true.)`},
	{Keyword: "CTLz", Type: Float, Desc: `Fractional location of hub height from the bottom of the dataset. [-] (Ignored when Randomize = true.)`},
	{Keyword: "CTStartTime", Type: Float, Desc: `Minimum start time for coherent structures in RootName.cts [seconds]`},
})

Functions

This section is empty.

Types

type AD15AirfoilInfo 

type AD15AirfoilInfo struct {
	InterpOrd  int                        // Interpolation order to use for quasi-steady table lookup {1=linear; 3=cubic spline; "default"} [default=3]
	NonDimArea float64                    // The non-dimensional area of the airfoil (set to 1.0 if unsure or unneeded)
	NumCoords  int                        // The number of coordinates in the airfoil shape file.  Set to zero if coordinates not included.
	BL_file    string                     // The file name including the boundary layer characteristics of the profile. Ignored if the aeroacoustic module is not called.
	NumTabs    int                        // Number of airfoil tables in this file.  Each table must have lines for Re and Ctrl.
	Re         float64                    // Reynolds numbers in millions
	Ctrl       int                        // Control setting (must be 0 for current AirfoilInfo)
	InclUAdata bool                       // Is unsteady aerodynamics data included in this table? If TRUE, then include 30 UA coeffs below this line
	Alpha0     float64                    // 0-lift angle of attack, depends on airfoil.
	Alpha1     float64                    // Angle of attack at f=0.7, (approximately the stall angle) for AOA>alpha0.
	Alpha2     float64                    // Angle of attack at f=0.7, (approximately the stall angle) for AOA<alpha0.
	Eta_e      float64                    // Recovery factor in the range [0.85 - 0.95] used only for UAMOD=1, it is set to 1 in the code when flookup=True.
	C_nalpha   float64                    // Slope of the 2D normal force coefficient curve in the linear region of the polar.
	T_f0       float64                    // Intial value of the time constant associated with Df in the expression of Df and f'. Default value = 3.
	T_V0       float64                    // Intial value of the time constant associated with the vortex lift decay process; it is used in the expression of Cvn. It depends on Re,M, and airfoil class. Default value= 6.
	T_p        float64                    // Boundary-layer,leading edge pressure gradient time constant in the expression of Dp. It should be tuned based on airfoil experimental data. Default =1.7.
	T_VL       float64                    // Intial value of the time constant associated with the vortex advection process; it represents the non-dimensional time in semi-chords, needed for a vortex to travel from LE to trailing edge (TE); it is used in the expression of Cvn. It depends on Re, M (weakly), and airfoil. Value's range = [6; 13]; default value= 11.
	B1         float64                    // Constant in the expression of phi_alpha^c and phi_q^c;  from experimental results, it was set to 0.14. This value is relatively insensitive for thin airfoils, but may be different for turbine airfoils.
	B2         float64                    // Constant in the expression of phi_alpha^c and phi_q^c;  from experimental results, it was set to 0.53. This value is relatively insensitive for thin airfoils, but may be different for turbine airfoils.
	B5         float64                    // Constant in the expression of K”'_q,Cm_q^nc, and k_m,q; from  experimental results, it was set to 5.
	A1         float64                    // Constant in the expression of phi_alpha^c and phi_q^c;  from experimental results, it was set to 0.3. This value is relatively insensitive for thin airfoils, but may be different for turbine airfoils.
	A2         float64                    // Constant in the expression of phi_alpha^c and phi_q^c;  from experimental results, it was set to 0.7. This value is relatively insensitive for thin airfoils, but may be different for turbine airfoils.
	A5         float64                    // Constant in the expression of K”'_q,Cm_q^nc, and k_m,q; from  experimental results, it was set to 1.
	S1         float64                    // Constant in the f curve bestfit for alpha0<=AOA<=alpha1;by definition it depends on the airfoil. Ignored if UAMod<>1.
	S2         float64                    // Constant in the f curve bestfit for         AOA>alpha1;by definition it depends on the airfoil. Ignored if UAMod<>1.
	S3         float64                    // Constant in the f curve bestfit for alpha2<=AOA<alpha0;by definition it depends on the airfoil. Ignored if UAMod<>1.
	S4         float64                    // Constant in the f curve bestfit for         AOA<alpha2;by definition it depends on the airfoil. Ignored if UAMod<>1.
	Cn1        float64                    // Critical value of C0n at leading edge separation. It should be extracted from airfoil data at a given Mach and Reynolds number. It can be calculated from the static value of Cn at either the break in the pitching moment or the loss of chord force at the onset of stall. It is close to the condition of maximum lift of the airfoil at low Mach numbers.
	Cn2        float64                    // As Cn1 for negative AOAs.
	St_sh      float64                    // Strouhal's shedding frequency constant; default =0.19.
	Cd0        float64                    // 2D drag coefficient value at 0-lift.
	Cm0        float64                    // 2D pitching moment coeffcient about 1/4-chord location, at 0-lift, positive if nose up.
	K0         float64                    // Constant in the \hat(x)_cp curve best-fit; = (\hat(x)_AC-0.25). Ignored if UAMod<>1.
	K1         float64                    // Constant in the \hat(x)_cp curve best-fit. Ignored if UAMod<>1.
	K2         float64                    // Constant in the \hat(x)_cp curve best-fit. Ignored if UAMod<>1.
	K3         float64                    // Constant in the \hat(x)_cp curve best-fit. Ignored if UAMod<>1.
	K1_hat     float64                    // Constant in the expression of Cc due to leading edge vortex effects. Ignored if UAMod<>1.
	X_cp_bar   float64                    // Constant in the expression of \hat(x)_cp^v. Default value =0.2. Ignored if UAMod<>1.
	UACutout   float64                    // Angle of attack above which unsteady aerodynamics are disabled (deg). [Specifying the string "Default" sets UACutout to 45 degrees]
	FiltCutOff float64                    // Cut-off frequency (-3 dB corner frequency) for low-pass filtering the AoA input to UA, as well as the 1st and 2nd derivatives (Hz) [default = 20]
	NumAlf     int                        // Number of data lines in the following CoeffData table
	CoeffData  []AD15AirfoilInfoCoeffData //
	Defaults   map[string]struct{}
}

AD15AirfoilInfo

func NewAD15AirfoilInfo 

func NewAD15AirfoilInfo() *AD15AirfoilInfo

func ReadAD15AirfoilInfo 

func ReadAD15AirfoilInfo(path string) (*AD15AirfoilInfo, error)

func (*AD15AirfoilInfo) Format 

func (s *AD15AirfoilInfo) Format() (text []byte, err error)

func (*AD15AirfoilInfo) Parse 

func (s *AD15AirfoilInfo) Parse(text []byte) error

func (*AD15AirfoilInfo) Write 

func (s *AD15AirfoilInfo) Write(path string) error

type AD15AirfoilInfoCoeffData 

type AD15AirfoilInfoCoeffData struct {
	Alpha float64 //
	Cl    float64 //
	Cd    float64 //
	Cm    float64 //
}

AD15AirfoilInfoCoeffData

type AeroDyn14 

type AeroDyn14 struct {

	// AeroDyn 14 Input File
	Title        string          //
	StallMod     string          // Dynamic stall included
	UseCm        string          // Use aerodynamic pitching moment model?
	InfModel     string          // Inflow model [DYNIN or EQUIL]
	IndModel     string          // Induction-factor model [NONE or WAKE or SWIRL]
	AToler       float64         // Induction-factor tolerance (convergence criteria) (-)
	TLModel      string          // Tip-loss model (EQUIL only) [PRANDtl, GTECH, or NONE]
	HLModel      string          // Hub-loss model (EQUIL only) [PRANdtl or NONE]
	TwrShad      float64         // Tower-shadow velocity deficit (-)
	ShadHWid     float64         // Tower-shadow half width (m)
	T_Shad_Refpt float64         // Tower-shadow reference point (m)
	AirDens      float64         // Air density (kg/m^3)
	KinVisc      float64         // Kinematic air viscosity [CURRENTLY IGNORED] (m^2/sec)
	DTAero       float64         // Time interval for aerodynamic calculations (sec)
	NumFoil      int             // Number of airfoil files (-)
	FoilNm       []string        // Names of the airfoil files [NumFoil lines] (quoted strings)
	BldNodes     int             // Number of blade nodes used for analysis (-)
	BlNd         []AeroDyn14BlNd //
	Defaults     map[string]struct{}
}

AeroDyn14

func NewAeroDyn14 

func NewAeroDyn14() *AeroDyn14

func ReadAeroDyn14 

func ReadAeroDyn14(path string) (*AeroDyn14, error)

func (*AeroDyn14) Format 

func (s *AeroDyn14) Format() (text []byte, err error)

func (*AeroDyn14) Parse 

func (s *AeroDyn14) Parse(text []byte) error

func (*AeroDyn14) Write 

func (s *AeroDyn14) Write(path string) error

type AeroDyn14BlNd 

type AeroDyn14BlNd struct {
	RNodes   float64 //
	AeroTwst float64 //
	DRNodes  float64 //
	Chord    float64 //
	NFoil    int     //
	PrnElm   string  //
}

AeroDyn14BlNd

type AeroDyn15 

type AeroDyn15 struct {

	// AeroDyn 15 Input File
	Title string //

	// General Options
	Echo         bool    // Echo the input to "<rootname>.AD.ech"?
	DTAero       float64 // Time interval for aerodynamic calculations {or "default"}
	WakeMod      int     // Type of wake/induction model [WakeMod cannot be 2 or 3 when linearizing]
	AFAeroMod    int     // Type of blade airfoil aerodynamics model[AFAeroMod must be 1 when linearizing]
	TwrPotent    int     // Type tower influence on wind based on potential flow around the tower
	TwrShadow    int     // Calculate tower influence on wind based on downstream tower shadow
	TwrAero      bool    // Calculate tower aerodynamic loads?
	FrozenWake   bool    // Assume frozen wake during linearization? [used only when WakeMod=1 and when linearizing]
	CavitCheck   bool    // Perform cavitation check? [AFAeroMod must be 1 when CavitCheck=true]
	CompAA       bool    // Flag to compute AeroAcoustics calculation [used only when WakeMod = 1 or 2]
	AA_InputFile string  // AeroAcoustics input file [used only when CompAA=true]

	// Environmental Conditions
	AirDens  float64 // Air density
	KinVisc  float64 // Kinematic viscosity of working fluid
	SpdSound float64 // Speed of sound in working fluid
	Patm     float64 // Atmospheric pressure [used only when CavitCheck=True]
	Pvap     float64 // Vapour pressure of working fluid [used only when CavitCheck=True]

	// Blade-Element/Momentum Theory Options [unused when WakeMod=0 or 3]
	SkewMod       int     // Type of skewed-wake correction model [unused when WakeMod=0 or 3]
	SkewModFactor float64 // Constant used in Pitt/Peters skewed wake model {or "default" is 15/32*pi} (-) [used only when SkewMod=2; unused when WakeMod=0 or 3]
	TipLoss       bool    // Use the Prandtl tip-loss model? [unused when WakeMod=0 or 3]
	HubLoss       bool    // Use the Prandtl hub-loss model? [unused when WakeMod=0 or 3]
	TanInd        bool    // Include tangential induction in BEMT calculations? [unused when WakeMod=0 or 3]
	AIDrag        bool    // Include the drag term in the axial-induction calculation? [unused when WakeMod=0 or 3]
	TIDrag        bool    // Include the drag term in the tangential-induction calculation? [unused when WakeMod=0,3 or TanInd=FALSE]
	IndToler      float64 // Convergence tolerance for BEMT nonlinear solve residual equation {or "default"} (-) [unused when WakeMod=0 or 3]
	MaxIter       int     // Maximum number of iteration steps (-) [unused when WakeMod=0]

	// Dynamic Blade-Element/Momentum Theory Options [used only when WakeMod=2]
	DBEMT_Mod  int     // Type of dynamic BEMT (DBEMT) model [used only when WakeMod=2]
	Tau1_const float64 // Time constant for DBEMT (s) [used only when WakeMod=2 and DBEMT_Mod=1]

	// OLAF -- cOnvecting LAgrangian Filaments (Free Vortex Wake) Theory Options [used only when WakeMod=3]
	OLAFInputFileName string // Input file for OLAF [used only when WakeMod=3]

	// Beddoes-Leishman Unsteady Airfoil Aerodynamics Options [used only when AFAeroMod=2]
	UAMod   int  // Unsteady Aero Model Switch (switch) {1=Baseline model (Original), 2=Gonzalez's variant (changes in Cn,Cc,Cm), 3=Minnema/Pierce variant (changes in Cc and Cm)} [used only when AFAeroMod=2]
	FLookup bool // Flag to indicate whether a lookup for f' will be calculated (TRUE) or whether best-fit exponential equations will be used (FALSE); if FALSE S1-S4 must be provided in airfoil input files (flag) [used only when AFAeroMod=2]

	// Airfoil Information
	AFTabMod    int      // Interpolation method for multiple airfoil tables {1=1D interpolation on AoA (first table only); 2=2D interpolation on AoA and Re; 3=2D interpolation on AoA and UserProp} (-)
	InCol_Alfa  int      // The column in the airfoil tables that contains the angle of attack (-)
	InCol_Cl    int      // The column in the airfoil tables that contains the lift coefficient (-)
	InCol_Cd    int      // The column in the airfoil tables that contains the drag coefficient (-)
	InCol_Cm    int      // The column in the airfoil tables that contains the pitching-moment coefficient; use zero if there is no Cm column (-)
	InCol_Cpmin int      // The column in the airfoil tables that contains the Cpmin coefficient; use zero if there is no Cpmin column (-)
	NumAFfiles  int      // Number of airfoil files used (-)
	AFNames     []string // Airfoil file names (NumAFfiles lines) (quoted strings)

	// Rotor/Blade Properties
	UseBlCm   bool   // Include aerodynamic pitching moment in calculations?  (flag)
	ADBlFile1 string // Name of file containing distributed aerodynamic properties for Blade #1 (-)
	ADBlFile2 string // Name of file containing distributed aerodynamic properties for Blade #2 (-) [unused if NumBl < 2]
	ADBlFile3 string // Name of file containing distributed aerodynamic properties for Blade #3 (-) [unused if NumBl < 3]

	// Tower Influence and Aerodynamics [used only when TwrPotent/=0, TwrShadow/=0, or TwrAero=True]
	NumTwrNds int                 // Number of tower nodes used in the analysis  (-) [used only when TwrPotent/=0, TwrShadow/=0, or TwrAero=True]
	TwrNodes  []AeroDyn15TwrNodes //

	// Outputs
	SumPrint bool     // Generate a summary file listing input options and interpolated properties to "<rootname>.AD.sum"?  (flag)
	NBlOuts  int      // Number of blade node outputs [0 - 9] (-)
	BlOutNd  []int    // Blade nodes whose values will be output  (-)
	NTwOuts  int      // Number of tower node outputs [0 - 9]  (-)
	TwOutNd  []int    // Tower nodes whose values will be output  (-)
	OutList  []string // The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels, (-)
	Defaults map[string]struct{}
}

AeroDyn15

func NewAeroDyn15 

func NewAeroDyn15() *AeroDyn15

func ReadAeroDyn15 

func ReadAeroDyn15(path string) (*AeroDyn15, error)

func (*AeroDyn15) Format 

func (s *AeroDyn15) Format() (text []byte, err error)

func (*AeroDyn15) Parse 

func (s *AeroDyn15) Parse(text []byte) error

func (*AeroDyn15) Write 

func (s *AeroDyn15) Write(path string) error

type AeroDyn15TwrNodes 

type AeroDyn15TwrNodes struct {
	TwrElev float64 // (m)
	TwrDiam float64 // (m)
	TwrCd   float64 // (-)
	TwrTI   float64 // (used only with TwrShadow=2) (-)
}

AeroDyn15TwrNodes

type AeroDynBlade 

type AeroDynBlade struct {

	// AeroDyn Blade Input File
	Title string //

	// Blade Properties
	NumBlNds int                // Number of blade nodes used in the analysis (-)
	BlNd     []AeroDynBladeBlNd //
	Defaults map[string]struct{}
}

AeroDynBlade

func NewAeroDynBlade 

func NewAeroDynBlade() *AeroDynBlade

func ReadAeroDynBlade 

func ReadAeroDynBlade(path string) (*AeroDynBlade, error)

func (*AeroDynBlade) Format 

func (s *AeroDynBlade) Format() (text []byte, err error)

func (*AeroDynBlade) Parse 

func (s *AeroDynBlade) Parse(text []byte) error

func (*AeroDynBlade) Write 

func (s *AeroDynBlade) Write(path string) error

type AeroDynBladeBlNd 

type AeroDynBladeBlNd struct {
	BlSpn    float64 // (m)
	BlCrvAC  float64 // (m)
	BlSwpAC  float64 // (m)
	BlCrvAng float64 // (deg)
	BlTwist  float64 // (deg)
	BlChord  float64 // (m)
	BlAFID   int     // (-)
}

AeroDynBladeBlNd

type BeamDyn 

type BeamDyn struct {

	// Beamdyn Input File
	Title string //

	// Simulation Control
	Echo             bool    // Echo input data to "<RootName>.ech"? (flag)
	QuasiStaticInit  bool    // Use quasi-static pre-conditioning with centripetal accelerations in initialization? (flag) [dynamic solve only]
	Rhoinf           float64 // Numerical damping parameter for generalized-alpha integrator
	Quadrature       int     // Quadrature method: 1=Gaussian; 2=Trapezoidal (switch)
	Refine           int     // Refinement factor for trapezoidal quadrature (-) [DEFAULT = 1; used only when quadrature=2]
	N_fact           int     // Factorization frequency for the Jacobian in N-R iteration(-) [DEFAULT = 5]
	DTBeam           float64 // Time step size (s)
	Load_retries     int     // Number of factored load retries before quitting the simulation [DEFAULT = 20]
	NRMax            int     // Max number of iterations in Newton-Raphson algorithm (-) [DEFAULT = 10]
	Stop_tol         float64 // Tolerance for stopping criterion (-) [DEFAULT = 1E-5]
	Tngt_stf_fd      bool    // Use finite differenced tangent stiffness matrix? (flag)
	Tngt_stf_comp    bool    // Compare analytical finite differenced tangent stiffness matrix? (flag)
	Tngt_stf_pert    float64 // Perturbation size for finite differencing (-) [DEFAULT = 1E-6]
	Tngt_stf_difftol float64 // Maximum allowable relative difference between analytical and fd tangent stiffness (-); [DEFAULT = 0.1]
	RotStates        bool    // Orient states in the rotating frame during linearization? (flag) [used only when linearizing]

	// Geometry Parameter
	Member_total int                // Total number of members (-)
	Kp_total     int                // Total number of key points (-) [must be at least 3]
	Members      [][]BeamDynMembers //

	// Mesh Parameter
	Order_elem int // Order of interpolation (basis) function (-)

	// Material Parameter
	BldFile string // Name of file containing properties for blade (quoted string)

	// Pitch Actuator Parameters
	UsePitchAct bool    // Whether a pitch actuator should be used (flag)
	PitchJ      float64 // Pitch actuator inertia (kg-m^2) [used only when UsePitchAct is true]
	PitchK      float64 // Pitch actuator stiffness (kg-m^2/s^2) [used only when UsePitchAct is true]
	PitchC      float64 // Pitch actuator damping (kg-m^2/s) [used only when UsePitchAct is true]

	// Outputs
	SumPrint  bool     // Print summary data to "<RootName>.sum" (flag)
	OutFmt    string   // Format used for text tabular output, excluding the time channel.
	NNodeOuts int      // Number of nodes to output to file [0 - 9] (-)
	OutNd     []int    // Nodes whose values will be output  (-)
	OutList   []string // The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels, (-)
	Defaults  map[string]struct{}
}

BeamDyn

func NewBeamDyn 

func NewBeamDyn() *BeamDyn

func ReadBeamDyn 

func ReadBeamDyn(path string) (*BeamDyn, error)

func (*BeamDyn) Format 

func (s *BeamDyn) Format() (text []byte, err error)

func (*BeamDyn) Parse 

func (s *BeamDyn) Parse(text []byte) error

func (*BeamDyn) Write 

func (s *BeamDyn) Write(path string) error

type BeamDynBlade 

type BeamDynBlade struct {

	// BeamDyn Blade Input File
	Title string //

	// Blade Parameters
	Station_total int // Number of blade input stations
	Damp_type     int // Damping type: 0: no damping; 1: damped

	// Damping Coefficient
	Mu []float64 //

	// Distributed Properties
	DistProps []BeamDynBladeDistProps //
	Defaults  map[string]struct{}
}

BeamDynBlade

func NewBeamDynBlade 

func NewBeamDynBlade() *BeamDynBlade

func ReadBeamDynBlade 

func ReadBeamDynBlade(path string) (*BeamDynBlade, error)

func (*BeamDynBlade) Format 

func (s *BeamDynBlade) Format() (text []byte, err error)

func (*BeamDynBlade) Parse 

func (s *BeamDynBlade) Parse(text []byte) error

func (*BeamDynBlade) Write 

func (s *BeamDynBlade) Write(path string) error

type BeamDynBladeDistProps 

type BeamDynBladeDistProps struct {
	Station_eta      float64     //
	Stiffness_matrix [][]float64 //
	Mass_matrix      [][]float64 //
}

BeamDynBladeDistProps

type BeamDynMembers 

type BeamDynMembers struct {
	Kp_xr         float64 //
	Kp_yr         float64 //
	Kp_zr         float64 //
	Initial_twist float64 //
}

BeamDynMembers

type Condition 

type Condition struct {
	Field    string `json:"field"`
	Relation string `json:"relation"`
	Value    any    `json:"value"`
}

type ElastoDyn 

type ElastoDyn struct {

	// ElastoDyn Input File
	Title string //

	// Simulation Control
	Echo   bool    // Echo input data to <RootName>.ech
	Method int     // Integration method
	DT     float64 // Integration time step

	// Degrees Of Freedom
	FlapDOF1  bool // First flapwise blade mode DOF
	FlapDOF2  bool // Second flapwise blade mode DOF
	EdgeDOF   bool // First edgewise blade mode DOF
	TeetDOF   bool // Rotor-teeter DOF [unused for 3 blades]
	DrTrDOF   bool // Drivetrain rotational-flexibility DOF
	GenDOF    bool // Generator DOF
	YawDOF    bool // Yaw DOF
	TwFADOF1  bool // First fore-aft tower bending-mode DOF
	TwFADOF2  bool // Second fore-aft tower bending-mode DOF
	TwSSDOF1  bool // First side-to-side tower bending-mode DOF
	TwSSDOF2  bool // Second side-to-side tower bending-mode DOF
	PtfmSgDOF bool // Platform horizontal surge translation DOF
	PtfmSwDOF bool // Platform horizontal sway translation DOF
	PtfmHvDOF bool // Platform vertical heave translation DOF
	PtfmRDOF  bool // Platform roll tilt rotation DOF
	PtfmPDOF  bool // Platform pitch tilt rotation DOF
	PtfmYDOF  bool // Platform yaw rotation DOF

	// Initial Conditions
	OoPDefl   float64 // Initial out-of-plane blade-tip displacement
	IPDefl    float64 // Initial in-plane blade-tip deflection
	BlPitch1  float64 // Blade 1 initial pitch
	BlPitch2  float64 // Blade 2 initial pitch
	BlPitch3  float64 // Blade 3 initial pitch [unused for 2 blades]
	TeetDefl  float64 // Initial or fixed teeter angle [unused for 3 blades]
	Azimuth   float64 // Initial azimuth angle for blade 1
	RotSpeed  float64 // Initial or fixed rotor speed
	NacYaw    float64 // Initial or fixed nacelle-yaw angle
	TTDspFA   float64 // Initial fore-aft tower-top displacement
	TTDspSS   float64 // Initial side-to-side tower-top displacement
	PtfmSurge float64 // Initial or fixed horizontal surge translational displacement of platform
	PtfmSway  float64 // Initial or fixed horizontal sway translational displacement of platform
	PtfmHeave float64 // Initial or fixed vertical heave translational displacement of platform
	PtfmRoll  float64 // Initial or fixed roll tilt rotational displacement of platform
	PtfmPitch float64 // Initial or fixed pitch tilt rotational displacement of platform
	PtfmYaw   float64 // Initial or fixed yaw rotational displacement of platform

	// Turbine Configuration
	NumBl     int     // Number of blades
	TipRad    float64 // The distance from the rotor apex to the blade tip
	HubRad    float64 // The distance from the rotor apex to the blade root
	PreCone1  float64 // Blade 1 cone angle
	PreCone2  float64 // Blade 2 cone angle
	PreCone3  float64 // Blade 3 cone angle [unused for 2 blades]
	HubCM     float64 // Distance from rotor apex to hub mass [positive downwind]
	UndSling  float64 // Undersling length [distance from teeter pin to the rotor apex] , Unit:"meters"[unused for 3 blades]
	Delta3    float64 // Delta-3 angle for teetering rotors [unused for 3 blades]
	AzimB1Up  float64 // Azimuth value to use for I/O when blade 1 points up
	OverHang  float64 // Distance from yaw axis to rotor apex [3 blades] or teeter pin [2 blades]
	ShftGagL  float64 // Distance from rotor apex [3 blades] or teeter pin [2 blades] to shaft strain gages [positive for upwind rotors]
	ShftTilt  float64 // Rotor shaft tilt angle
	NacCMxn   float64 // Downwind distance from the tower-top to the nacelle CM
	NacCMyn   float64 // Lateral  distance from the tower-top to the nacelle CM
	NacCMzn   float64 // Vertical distance from the tower-top to the nacelle CM
	NcIMUxn   float64 // Downwind distance from the tower-top to the nacelle IMU
	NcIMUyn   float64 // Lateral  distance from the tower-top to the nacelle IMU
	NcIMUzn   float64 // Vertical distance from the tower-top to the nacelle IMU
	Twr2Shft  float64 // Vertical distance from the tower-top to the rotor shaft
	TowerHt   float64 // Height of tower above ground level [onshore] or MSL [offshore]
	TowerBsHt float64 // Height of tower base above ground level [onshore] or MSL [offshore]
	PtfmCMxt  float64 // Downwind distance from the ground level [onshore] or MSL [offshore] to the platform CM
	PtfmCMyt  float64 // Lateral distance from the ground level [onshore] or MSL [offshore] to the platform CM
	PtfmCMzt  float64 // Vertical distance from the ground level [onshore] or MSL [offshore] to the platform CM
	PtfmRefzt float64 // Vertical distance from the ground level [onshore] or MSL [offshore] to the platform reference point

	// Mass And Inertia
	TipMass1  float64 // Tip-brake mass, blade 1
	TipMass2  float64 // Tip-brake mass, blade 2
	TipMass3  float64 // Tip-brake mass, blade 3 [unused for 2 blades]
	HubMass   float64 // Hub mass
	HubIner   float64 // Hub inertia about rotor axis [3 blades] or teeter axis [2 blades]
	GenIner   float64 // Generator inertia about HSS
	NacMass   float64 // Nacelle mass
	NacYIner  float64 // Nacelle inertia about yaw axis
	YawBrMass float64 // Yaw bearing mass
	PtfmMass  float64 // Platform mass
	PtfmRIner float64 // Platform inertia for roll tilt rotation about the platform CM
	PtfmPIner float64 // Platform inertia for pitch tilt rotation about the platform CM
	PtfmYIner float64 // Platform inertia for yaw rotation about the platform CM

	// Blade
	BldNodes int    // Number of blade nodes (per blade) used for analysis
	BldFile1 string // Name of file containing properties for blade 1 (quoted string)
	BldFile2 string // Name of file containing properties for blade 2 (quoted string)
	BldFile3 string // Name of file containing properties for blade 3 (quoted string) [unused for 2 blades]

	// Rotor-Teeter
	TeetMod  int     // Rotor-teeter spring/damper model (switch) [unused for 3 blades]
	TeetDmpP float64 // Rotor-teeter damper position [used only for 2 blades and when TeetMod=1]
	TeetDmp  float64 // Rotor-teeter damping constant [used only for 2 blades and when TeetMod=1]
	TeetCDmp float64 // Rotor-teeter rate-independent Coulomb-damping moment (N-m) [used only for 2 blades and when TeetMod=1]
	TeetSStP float64 // Rotor-teeter soft-stop position [used only for 2 blades and when TeetMod=1]
	TeetHStP float64 // Rotor-teeter hard-stop position [used only for 2 blades and when TeetMod=1]
	TeetSSSp float64 // Rotor-teeter soft-stop linear-spring constant [used only for 2 blades and when TeetMod=1]
	TeetHSSp float64 // Rotor-teeter hard-stop linear-spring constant [used only for 2 blades and when TeetMod=1]

	// Drivetrain
	GBoxEff  float64 // Gearbox efficiency
	GBRatio  float64 // Gearbox ratio
	DTTorSpr float64 // Drivetrain torsional spring
	DTTorDmp float64 // Drivetrain torsional damper

	// Furling
	Furling  bool   // Read in additional model properties for furling turbine [must currently be FALSE)
	FurlFile string // Name of file containing furling properties (quoted string) [unused when Furling=False]

	// Tower
	TwrNodes int    // Number of tower nodes used for analysis (-)
	TwrFile  string // Name of file containing tower properties (quoted string)

	// Output
	SumPrint bool     // Print summary data to '<RootName>.sum'
	OutFile  int      // Switch to determine where output will be placed: {1: in module output file only; 2: in glue code output file only; 3: both} (currently unused)
	TabDelim bool     // Use tab delimiters in text tabular output file? (currently unused)
	OutFmt   string   // Format used for text tabular output (except time).  Resulting field should be 10 characters. (quoted string) (currently unused)
	TStart   float64  // Time to begin tabular output (s) (currently unused)
	DecFact  int      // Decimation factor for tabular output {1: output every time step} (-) (currently unused)
	NTwGages int      // Number of tower nodes that have strain gages for output [0 to 9] (-)
	TwrGagNd []int    // List of tower nodes that have strain gages [1 to TwrNodes] (-) [unused if NTwGages=0]
	NBlGages int      // Number of blade nodes that have strain gages for output [0 to 9] (-)
	BldGagNd []int    // List of blade nodes that have strain gages [1 to BldNodes] (-) [unused if NBlGages=0]
	OutList  []string // The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels, (-)
	Defaults map[string]struct{}
}

ElastoDyn

func NewElastoDyn 

func NewElastoDyn() *ElastoDyn

func ReadElastoDyn 

func ReadElastoDyn(path string) (*ElastoDyn, error)

func (*ElastoDyn) Format 

func (s *ElastoDyn) Format() (text []byte, err error)

func (*ElastoDyn) Parse 

func (s *ElastoDyn) Parse(text []byte) error

func (*ElastoDyn) Write 

func (s *ElastoDyn) Write(path string) error

type ElastoDynBlade 

type ElastoDynBlade struct {

	// ElastoDyn Blade Input File
	Title string //

	// Blade Parameters
	NBlInpSt  int     // Number of blade input stations
	BldFlDmp1 float64 // Blade flap mode #1 structural damping in percent of critical
	BldFlDmp2 float64 // Blade flap mode #2 structural damping in percent of critical
	BldEdDmp1 float64 // Blade edge mode #1 structural damping in percent of critical

	// Blade Adjustment Factors
	FlStTunr1 float64 // Blade flapwise modal stiffness tuner, 1st mode
	FlStTunr2 float64 // Blade flapwise modal stiffness tuner, 2nd mode
	AdjBlMs   float64 // Factor to adjust blade mass density
	AdjFlSt   float64 // Factor to adjust blade flap stiffness
	AdjEdSt   float64 // Factor to adjust blade edge stiffness

	// Distributed Blade Properties
	BlInpSt []ElastoDynBladeBlInpSt //

	// Blade Mode Shapes
	BldFl1Sh2 float64 // Flap mode 1, coeff of x^2
	BldFl1Sh3 float64 //            , coeff of x^3
	BldFl1Sh4 float64 //            , coeff of x^4
	BldFl1Sh5 float64 //            , coeff of x^5
	BldFl1Sh6 float64 //            , coeff of x^6
	BldFl2Sh2 float64 // Flap mode 2, coeff of x^2
	BldFl2Sh3 float64 //            , coeff of x^3
	BldFl2Sh4 float64 //            , coeff of x^4
	BldFl2Sh5 float64 //            , coeff of x^5
	BldFl2Sh6 float64 //            , coeff of x^6
	BldEdgSh2 float64 // Edge mode 1, coeff of x^2
	BldEdgSh3 float64 //            , coeff of x^3
	BldEdgSh4 float64 //            , coeff of x^4
	BldEdgSh5 float64 //            , coeff of x^5
	BldEdgSh6 float64 //            , coeff of x^6
	Defaults  map[string]struct{}
}

ElastoDynBlade

func NewElastoDynBlade 

func NewElastoDynBlade() *ElastoDynBlade

func ReadElastoDynBlade 

func ReadElastoDynBlade(path string) (*ElastoDynBlade, error)

func (*ElastoDynBlade) Format 

func (s *ElastoDynBlade) Format() (text []byte, err error)

func (*ElastoDynBlade) Parse 

func (s *ElastoDynBlade) Parse(text []byte) error

func (*ElastoDynBlade) Write 

func (s *ElastoDynBlade) Write(path string) error

type ElastoDynBladeBlInpSt 

type ElastoDynBladeBlInpSt struct {
	BlFract   float64 //
	PitchAxis float64 //
	StrcTwst  float64 //
	BMassDen  float64 //
	FlpStff   float64 //
	EdgStff   float64 //
}

ElastoDynBladeBlInpSt

type ElastoDynTower 

type ElastoDynTower struct {

	// ElastoDyn Tower Input File
	Title string //

	// Tower Parameters
	NTwInpSt  int     // Number of input stations to specify tower geometry
	TwrFADmp1 float64 // Tower 1st fore-aft mode structural damping ratio
	TwrFADmp2 float64 // Tower 2nd fore-aft mode structural damping ratio
	TwrSSDmp1 float64 // Tower 1st side-to-side mode structural damping ratio
	TwrSSDmp2 float64 // Tower 2nd side-to-side mode structural damping ratio

	// Tower Adjustment Factors
	FAStTunr1 float64 // Tower fore-aft modal stiffness tuner, 1st mode
	FAStTunr2 float64 // Tower fore-aft modal stiffness tuner, 2nd mode
	SSStTunr1 float64 // Tower side-to-side stiffness tuner, 1st mode
	SSStTunr2 float64 // Tower side-to-side stiffness tuner, 2nd mode
	AdjTwMa   float64 // Factor to adjust tower mass density
	AdjFASt   float64 // Factor to adjust tower fore-aft stiffness
	AdjSSSt   float64 // Factor to adjust tower side-to-side stiffness

	// Distributed Tower Properties
	TwInpSt []ElastoDynTowerTwInpSt //

	// Tower Fore-Aft Mode Shapes
	TwFAM1Sh2 float64 // Mode 1, coefficient of x^2 term
	TwFAM1Sh3 float64 //       , coefficient of x^3 term
	TwFAM1Sh4 float64 //       , coefficient of x^4 term
	TwFAM1Sh5 float64 //       , coefficient of x^5 term
	TwFAM1Sh6 float64 //       , coefficient of x^6 term
	TwFAM2Sh2 float64 // Mode 2, coefficient of x^2 term
	TwFAM2Sh3 float64 //       , coefficient of x^3 term
	TwFAM2Sh4 float64 //       , coefficient of x^4 term
	TwFAM2Sh5 float64 //       , coefficient of x^5 term
	TwFAM2Sh6 float64 //       , coefficient of x^6 term

	// Tower Side-To-Side Mode Shapes
	TwSSM1Sh2 float64 // Mode 1, coefficient of x^2 term
	TwSSM1Sh3 float64 //       , coefficient of x^3 term
	TwSSM1Sh4 float64 //       , coefficient of x^4 term
	TwSSM1Sh5 float64 //       , coefficient of x^5 term
	TwSSM1Sh6 float64 //       , coefficient of x^6 term
	TwSSM2Sh2 float64 // Mode 2, coefficient of x^2 term
	TwSSM2Sh3 float64 //       , coefficient of x^3 term
	TwSSM2Sh4 float64 //       , coefficient of x^4 term
	TwSSM2Sh5 float64 //       , coefficient of x^5 term
	TwSSM2Sh6 float64 //       , coefficient of x^6 term
	Defaults  map[string]struct{}
}

ElastoDynTower

func NewElastoDynTower 

func NewElastoDynTower() *ElastoDynTower

func ReadElastoDynTower 

func ReadElastoDynTower(path string) (*ElastoDynTower, error)

func (*ElastoDynTower) Format 

func (s *ElastoDynTower) Format() (text []byte, err error)

func (*ElastoDynTower) Parse 

func (s *ElastoDynTower) Parse(text []byte) error

func (*ElastoDynTower) Write 

func (s *ElastoDynTower) Write(path string) error

type ElastoDynTowerTwInpSt 

type ElastoDynTowerTwInpSt struct {
	HtFract  float64 // Fractional height of the flexible portion of tower for a given input station
	TMassDen float64 // Tower mass density for a given input station
	TwFAStif float64 // Tower fore-aft stiffness for a given input station
	TwSSStif float64 // Tower side-to-side stiffness for a given input station
}

ElastoDynTowerTwInpSt

type FAST 

type FAST struct {

	// OpenFAST Input File
	Title string // File title

	// Simulation Control
	Echo        bool    // Echo input data to <RootName>.ech
	AbortLevel  string  // Error level when simulation should abort
	TMax        float64 // Total run time
	DT          float64 // Recommended module time step
	InterpOrder int     // Interpolation order for input/output time history
	NumCrctn    int     // Number of correction iterations {0=explicit calculation, i.e., no corrections}
	DT_UJac     float64 // Time between calls to get Jacobians
	UJacSclFact float64 // Scaling factor used in Jacobians

	// Feature switches and flags
	CompElast   int // Compute structural dynamics
	CompInflow  int // Compute inflow wind velocities
	CompAero    int // Compute aerodynamic loads
	CompServo   int // Compute control and electrical-drive dynamics
	CompHydro   int // Compute hydrodynamic loads
	CompSub     int // Compute sub-structural dynamics
	CompMooring int // Compute mooring system
	CompIce     int // Compute ice loads
	MHK         int // MHK turbine type

	// Environmental Conditions
	Gravity  float64 // Gravitational acceleration
	AirDens  float64 // Air density
	WtrDens  float64 // Water density
	KinVisc  float64 // Kinematic viscosity of working fluid
	SpdSound float64 // Speed of sound in working fluid
	Patm     float64 // Atmospheric pressure [used only for an MHK turbine cavitation check]
	Pvap     float64 // Vapour pressure of working fluid [used only for an MHK turbine cavitation check]
	WtrDpth  float64 // Water depth
	MSL2SWL  float64 // Offset between still-water level and mean sea level [positive upward]

	// Input Files
	EDFile      string // Name of file containing ElastoDyn input parameters
	BDBldFile1  string // Name of file containing BeamDyn input parameters for blade 1
	BDBldFile2  string // Name of file containing BeamDyn input parameters for blade 2
	BDBldFile3  string // Name of file containing BeamDyn input parameters for blade 3
	InflowFile  string // Name of file containing inflow wind input parameters
	AeroFile    string // Name of file containing aerodynamic input parameters
	ServoFile   string // Name of file containing control and electrical-drive input parameters
	HydroFile   string // Name of file containing hydrodynamic input parameters
	SubFile     string // Name of file containing sub-structural input parameters
	MooringFile string // Name of file containing mooring system input parameters
	IceFile     string // Name of file containing ice input parameters

	// Output
	SumPrint   bool    // Print summary data to '<RootName>.sum'
	SttsTime   float64 // Amount of time between screen status messages
	ChkptTime  float64 // Amount of time between creating checkpoint files for potential restart
	DT_Out     float64 // Time step for tabular output (or "default")
	TStart     float64 // Time to begin tabular output
	OutFileFmt int     // Format for tabular (time-marching) output file
	TabDelim   bool    // Use tab delimiters in text tabular output file?
	OutFmt     string  // Format used for text tabular output, excluding the time channel.  Resulting field should be 10 characters

	// Linearization
	Linearize  bool      // Linearization analysis
	CalcSteady bool      // Calculate a steady-state periodic operating point before linearization?
	TrimCase   int       // Controller parameter to be trimmed
	TrimTol    float64   // Tolerance for the rotational speed convergence
	TrimGain   float64   // Proportional gain for the rotational speed error (>0) (rad/(rad/s) for yaw or pitch; Nm/(rad/s) for torque)
	Twr_Kdmp   float64   // Damping factor for the tower
	Bld_Kdmp   float64   // Damping factor for the blades
	NLinTimes  int       // Number of times to linearize [>=1]
	LinTimes   []float64 // List of times at which to linearize [1 to NLinTimes] [used only when Linearize=True and CalcSteady=False]
	LinInputs  int       // Inputs included in linearization
	LinOutputs int       // Outputs included in linearization
	LinOutJac  bool      // Include full Jacobians in linearization output (for debug)
	LinOutMod  bool      // Write module-level linearization output files in addition to output for full system?

	// Visualization
	WrVTK      int     // VTK visualization data output
	VTK_type   int     // Type of VTK visualization data
	VTK_fields bool    // Write mesh fields to VTK data files?
	VTK_fps    float64 // Frame rate for VTK output (frames per second) {will use closest integer multiple of DT}
	Defaults   map[string]struct{}
}

FAST

func NewFAST 

func NewFAST() *FAST

func ReadFAST 

func ReadFAST(path string) (*FAST, error)

func (*FAST) Format 

func (s *FAST) Format() (text []byte, err error)

func (*FAST) Parse 

func (s *FAST) Parse(text []byte) error

func (*FAST) Write 

func (s *FAST) Write(path string) error

type FormatFunc 

type FormatFunc func(w io.Writer, s any, field any, entry SchemaEntry) error

type InflowWind 

type InflowWind struct {

	// InflowWind Input File
	Title string //

	// General
	Echo           bool      // Echo input data to <RootName>.ech (flag)
	WindType       int       // switch for wind file type
	PropagationDir float64   // Direction of wind propagation (meteorological rotation from aligned with X (positive rotates towards -Y) -- degrees) (not used for native Bladed format WindType=7)
	VFlowAng       float64   // Upflow angle (degrees) (not used for native Bladed format WindType=7)
	NWindVel       int       // Number of points to output the wind velocity
	WindVxiList    []float64 // List of coordinates in the inertial X direction
	WindVyiList    []float64 // List of coordinates in the inertial Y direction
	WindVziList    []float64 // List of coordinates in the inertial Z direction

	// Parameters for Steady Wind Conditions [used only for WindType = 1]
	HWindSpeed float64 // Horizontal wind speed
	RefHt      float64 // Reference height for horizontal wind speed
	PLExp      float64 // Power law exponent

	// Parameters for Uniform wind file [used only for WindType = 2]
	FileName_Uni string  // Filename of time series data for uniform wind field
	RefHt_Uni    float64 // Reference height for horizontal wind speed
	RefLength    float64 // Reference length for linear horizontal and vertical sheer

	// Parameters for Binary TurbSim Full-Field files [used only for WindType = 3]
	FileName_BTS string // Name of the Full field wind file to use (.bts)

	// Parameters for Binary Bladed-style Full-Field files [used only for WindType = 4 or WindType = 7]
	FileNameRoot string // WindType=4: Rootname of the full-field wind file to use (.wnd, .sum); WindType=7: name of the intermediate file with wind scaling values
	TowerFile    bool   // Have tower file (.twr) (flag) ignored when WindType = 7

	// Parameters for HAWC-format binary files  [Only used with WindType = 5] //===
	FileName_u string  // name of the file containing the u-component fluctuating wind (.bin)
	FileName_v string  // name of the file containing the v-component fluctuating wind (.bin)
	FileName_w string  // name of the file containing the w-component fluctuating wind (.bin)
	NX         int     // number of grids in the x direction (in the 3 files above)
	NY         int     // number of grids in the y direction (in the 3 files above)
	NZ         int     // number of grids in the z direction (in the 3 files above)
	DX         float64 // distance (in meters) between points in the x direction
	DY         float64 // distance (in meters) between points in the y direction
	DZ         float64 // distance (in meters) between points in the z direction
	RefHt_Hawc float64 // reference height; the height (in meters) of the vertical center of the grid

	// Scaling parameters for turbulence
	ScaleMethod int     // Turbulence scaling method
	SFx         float64 // Turbulence scaling factor for the x direction [ScaleMethod=1]
	SFy         float64 // Turbulence scaling factor for the y direction [ScaleMethod=1]
	SFz         float64 // Turbulence scaling factor for the z direction [ScaleMethod=1]
	SigmaFx     float64 // Turbulence standard deviation to calculate scaling from in x direction [ScaleMethod=2]
	SigmaFy     float64 // Turbulence standard deviation to calculate scaling from in y direction [ScaleMethod=2]
	SigmaFz     float64 // Turbulence standard deviation to calculate scaling from in z direction [ScaleMethod=2]

	// Mean wind profile parameters (added to HAWC-format files)
	URef        float64 // Mean u-component wind speed at the reference height
	WindProfile int     // Wind profile type
	PLExp_Hawc  float64 // Power law exponent (used for PL wind profile type only)
	Z0          float64 // Surface roughness length (used for LG wind profile type only)
	XOffset     float64 // Initial offset in +x direction (shift of wind box)

	// Output
	SumPrint bool     // Print summary data to <RootName>.IfW.sum (flag)
	OutList  []string // The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels
	Defaults map[string]struct{}
}

InflowWind

func NewInflowWind 

func NewInflowWind() *InflowWind

func ReadInflowWind 

func ReadInflowWind(path string) (*InflowWind, error)

func (*InflowWind) Format 

func (s *InflowWind) Format() (text []byte, err error)

func (*InflowWind) Parse 

func (s *InflowWind) Parse(text []byte) error

func (*InflowWind) Write 

func (s *InflowWind) Write(path string) error

type Model 

type Model struct {
	AeroDyn14       *AeroDyn14
	AeroDyn15       *AeroDyn15
	AD15AirfoilInfo []*AD15AirfoilInfo
	AeroDynBlade    []*AeroDynBlade
	BeamDyn         []*BeamDyn
	BeamDynBlade    []*BeamDynBlade
	ElastoDyn       *ElastoDyn
	ElastoDynBlade  []*ElastoDynBlade
	ElastoDynTower  *ElastoDynTower
	FAST            *FAST
	InflowWind      *InflowWind
	ServoDyn        *ServoDyn
}

func ReadFiles 

func ReadFiles(fastFilePath string) (*Model, error)

func (*Model) WriteFiles 

func (inp *Model) WriteFiles(fastFilePath string) error

type Option 

type Option struct {
	Value any    `json:"value"`
	Text  string `json:"text"`
}

type ParseFunc 

type ParseFunc func(s any, v reflect.Value, lines []string) ([]string, error)

type Schema 

type Schema []SchemaEntry

func NewSchema 

func NewSchema(name string, entries []SchemaEntry) Schema

type SchemaEntry 

type SchemaEntry struct {
	Keyword      string
	Field        string
	Type         string
	Dims         int
	Desc         string
	Heading      string `json:",omitempty"`
	Default      any    `json:",omitempty"`
	CanBeDefault bool
	Unit         string
	Options      []Option    `json:",omitempty"`
	SkipIf       []Condition `json:",omitempty"`
	Show         []Condition `json:",omitempty"`
	Table        *Table      `json:",omitempty"`
	Parse        ParseFunc   `json:"-"`
	Format       FormatFunc  `json:"-"`
}

type ServoDyn 

type ServoDyn struct {

	// ServoDyn Input File
	Title string //

	// Simulation Control
	Echo bool    // Echo input data to <RootName>.ech (flag)
	DT   float64 // Communication interval for controllers (s) (or "default")

	// Pitch Control
	PCMode     int     // Pitch control mode {0: none, 3: user-defined from routine PitchCntrl, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)
	TPCOn      float64 // Time to enable active pitch control (s) [unused when PCMode=0]
	TPitManS1  float64 // Time to start override pitch maneuver for blade 1 and end standard pitch control (s)
	TPitManS2  float64 // Time to start override pitch maneuver for blade 2 and end standard pitch control (s)
	TPitManS3  float64 // Time to start override pitch maneuver for blade 3 and end standard pitch control (s) [unused for 2 blades]
	PitManRat1 float64 // Pitch rate at which override pitch maneuver heads toward final pitch angle for blade 1 (deg/s)
	PitManRat2 float64 // Pitch rate at which override pitch maneuver heads toward final pitch angle for blade 2 (deg/s)
	PitManRat3 float64 // Pitch rate at which override pitch maneuver heads toward final pitch angle for blade 3 (deg/s) [unused for 2 blades]
	BlPitchF1  float64 // Blade 1 final pitch for pitch maneuvers (degrees)
	BlPitchF2  float64 // Blade 2 final pitch for pitch maneuvers (degrees)
	BlPitchF3  float64 // Blade 3 final pitch for pitch maneuvers (degrees) [unused for 2 blades]

	// Generator And Torque Control
	VSContrl int     // Variable-speed control mode {0: none, 1: simple VS, 3: user-defined from routine UserVSCont, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)
	GenModel int     // Generator model {1: simple, 2: Thevenin, 3: user-defined from routine UserGen} (switch) [used only when VSContrl=0]
	GenEff   float64 // Generator efficiency [ignored by the Thevenin and user-defined generator models] (%)
	GenTiStr bool    // Method to start the generator {T: timed using TimGenOn, F: generator speed using SpdGenOn} (flag)
	GenTiStp bool    // Method to stop the generator {T: timed using TimGenOf, F: when generator power = 0} (flag)
	SpdGenOn float64 // Generator speed to turn on the generator for a startup (HSS speed) (rpm) [used only when GenTiStr=False]
	TimGenOn float64 // Time to turn on the generator for a startup (s) [used only when GenTiStr=True]
	TimGenOf float64 // Time to turn off the generator (s) [used only when GenTiStp=True]

	// Simple Variable-Speed Torque Control
	VS_RtGnSp float64 // Rated generator speed for simple variable-speed generator control (HSS side) (rpm) [used only when VSContrl=1]
	VS_RtTq   float64 // Rated generator torque/constant generator torque in Region 3 for simple variable-speed generator control (HSS side) (N-m) [used only when VSContrl=1]
	VS_Rgn2K  float64 // Generator torque constant in Region 2 for simple variable-speed generator control (HSS side) (N-m/rpm^2) [used only when VSContrl=1]
	VS_SlPc   float64 // Rated generator slip percentage in Region 2 1/2 for simple variable-speed generator control (%) [used only when VSContrl=1]

	// Simple Induction Generator
	SIG_SlPc float64 // Rated generator slip percentage (%) [used only when VSContrl=0 and GenModel=1]
	SIG_SySp float64 // Synchronous (zero-torque) generator speed (rpm) [used only when VSContrl=0 and GenModel=1]
	SIG_RtTq float64 // Rated torque (N-m) [used only when VSContrl=0 and GenModel=1]
	SIG_PORt float64 // Pull-out ratio (Tpullout/Trated) (-) [used only when VSContrl=0 and GenModel=1]

	// Thevenin-Equivalent Induction Generator
	TEC_Freq float64 // Line frequency [50 or 60] (Hz) [used only when VSContrl=0 and GenModel=2]
	TEC_NPol int     // Number of poles [even integer > 0] (-) [used only when VSContrl=0 and GenModel=2]
	TEC_SRes float64 // Stator resistance (ohms) [used only when VSContrl=0 and GenModel=2]
	TEC_RRes float64 // Rotor resistance (ohms) [used only when VSContrl=0 and GenModel=2]
	TEC_VLL  float64 // Line-to-line RMS voltage (volts) [used only when VSContrl=0 and GenModel=2]
	TEC_SLR  float64 // Stator leakage reactance (ohms) [used only when VSContrl=0 and GenModel=2]
	TEC_RLR  float64 // Rotor leakage reactance (ohms) [used only when VSContrl=0 and GenModel=2]
	TEC_MR   float64 // Magnetizing reactance (ohms) [used only when VSContrl=0 and GenModel=2]

	// High-Speed Shaft Brake
	HSSBrMode int     // HSS brake model {0: none, 1: simple, 3: user-defined from routine UserHSSBr, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)
	THSSBrDp  float64 // Time to initiate deployment of the HSS brake (s)
	HSSBrDT   float64 // Time for HSS-brake to reach full deployment once initiated (sec) [used only when HSSBrMode=1]
	HSSBrTqF  float64 // Fully deployed HSS-brake torque (N-m)

	// Nacelle-Yaw Control
	YCMode    int     // Yaw control mode {0: none, 3: user-defined from routine UserYawCont, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)
	TYCOn     float64 // Time to enable active yaw control (s) [unused when YCMode=0]
	YawNeut   float64 // Neutral yaw position--yaw spring force is zero at this yaw (degrees)
	YawSpr    float64 // Nacelle-yaw spring constant (N-m/rad)
	YawDamp   float64 // Nacelle-yaw damping constant (N-m/(rad/s))
	TYawManS  float64 // Time to start override yaw maneuver and end standard yaw control (s)
	YawManRat float64 // Yaw maneuver rate (in absolute value) (deg/s)
	NacYawF   float64 // Final yaw angle for override yaw maneuvers (degrees)

	// Aerodynamic Flow Control
	AfCmode   int     // Airfoil control mode {0: none, 1: cosine wave cycle, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)
	AfC_Mean  float64 // Mean level for cosine cycling or steady value (-) [used only with AfCmode==1]
	AfC_Amp   float64 // Amplitude for for cosine cycling of flap signal (-) [used only with AfCmode==1]
	AfC_Phase float64 // Phase relative to the blade azimuth (0 is vertical) for for cosine cycling of flap signal (deg) [used only with AfCmode==1]

	// Structural Control
	NumBStC   int    // Number of blade structural controllers (integer)
	BStCfiles string // Name of the files for blade structural controllers (quoted strings) [unused when NumBStC==0]
	NumNStC   int    // Number of nacelle structural controllers (integer)
	NStCfiles string // Name of the files for nacelle structural controllers (quoted strings) [unused when NumNStC==0]
	NumTStC   int    // Number of tower structural controllers (integer)
	TStCfiles string // Name of the files for tower structural controllers (quoted strings) [unused when NumTStC==0]
	NumSStC   int    // Number of substructure structural controllers (integer)
	SStCfiles string // Name of the files for substructure structural controllers (quoted strings) [unused when NumSStC==0]

	// Cable Control
	CCmode int // Cable control mode {0: none, 4: user-defined from Simulink/Labview, 5: user-defined from Bladed-style DLL} (switch)

	// BLADED Interface
	DLL_FileName string  // Name/location of the dynamic library {.dll [Windows] or .so [Linux]} in the Bladed-DLL format (-) [used only with Bladed Interface]
	DLL_InFile   string  // Name of input file sent to the DLL (-) [used only with Bladed Interface]
	DLL_ProcName string  // Name of procedure in DLL to be called (-) [case sensitive; used only with DLL Interface]
	DLL_DT       float64 // Communication interval for dynamic library (s) (or "default") [used only with Bladed Interface]
	DLL_Ramp     bool    // Whether a linear ramp should be used between DLL_DT time steps [introduces time shift when true] (flag) [used only with Bladed Interface]
	BPCutoff     float64 // Cutoff frequency for low-pass filter on blade pitch from DLL (Hz) [used only with Bladed Interface]
	NacYaw_North float64 // Reference yaw angle of the nacelle when the upwind end points due North (deg) [used only with Bladed Interface]
	Ptch_Cntrl   int     // Record 28: Use individual pitch control {0: collective pitch; 1: individual pitch control} (switch) [used only with Bladed Interface]
	Ptch_SetPnt  float64 // Record  5: Below-rated pitch angle set-point (deg) [used only with Bladed Interface]
	Ptch_Min     float64 // Record  6: Minimum pitch angle (deg) [used only with Bladed Interface]
	Ptch_Max     float64 // Record  7: Maximum pitch angle (deg) [used only with Bladed Interface]
	PtchRate_Min float64 // Record  8: Minimum pitch rate (most negative value allowed) (deg/s) [used only with Bladed Interface]
	PtchRate_Max float64 // Record  9: Maximum pitch rate  (deg/s) [used only with Bladed Interface]
	Gain_OM      float64 // Record 16: Optimal mode gain (Nm/(rad/s)^2) [used only with Bladed Interface]
	GenSpd_MinOM float64 // Record 17: Minimum generator speed (rpm) [used only with Bladed Interface]
	GenSpd_MaxOM float64 // Record 18: Optimal mode maximum speed (rpm) [used only with Bladed Interface]
	GenSpd_Dem   float64 // Record 19: Demanded generator speed above rated (rpm) [used only with Bladed Interface]
	GenTrq_Dem   float64 // Record 22: Demanded generator torque above rated (Nm) [used only with Bladed Interface]
	GenPwr_Dem   float64 // Record 13: Demanded power (W) [used only with Bladed Interface]

	// BLADED Interface Torque-Speed Look-Up Table
	DLL_NumTrq int                 // Record 26: No. of points in torque-speed look-up table {0 = none and use the optimal mode parameters; nonzero = ignore the optimal mode PARAMETERs by setting Record 16 to 0.0} (-) [used only with Bladed Interface]
	GenSpdTrq  []ServoDynGenSpdTrq //

	// Output
	SumPrint bool     // Print summary data to <RootName>.sum (flag) (currently unused)
	OutFile  int      // Switch to determine where output will be placed: {1: in module output file only; 2: in glue code output file only; 3: both} (currently unused)
	TabDelim bool     // Use tab delimiters in text tabular output file? (flag) (currently unused)
	OutFmt   string   // Format used for text tabular output (except time).  Resulting field should be 10 characters. (quoted string) (currently unused)
	TStart   float64  // Time to begin tabular output (s) (currently unused)
	OutList  []string // The next line(s) contains a list of output parameters.  See OutListParameters.xlsx for a listing of available output channels, (-)
	Defaults map[string]struct{}
}

ServoDyn

func NewServoDyn 

func NewServoDyn() *ServoDyn

func ReadServoDyn 

func ReadServoDyn(path string) (*ServoDyn, error)

func (*ServoDyn) Format 

func (s *ServoDyn) Format() (text []byte, err error)

func (*ServoDyn) Parse 

func (s *ServoDyn) Parse(text []byte) error

func (*ServoDyn) Write 

func (s *ServoDyn) Write(path string) error

type ServoDynGenSpdTrq 

type ServoDynGenSpdTrq struct {
	GenSpd_TLU []float64 // GenSpd_TLU
	GenTrq_TLU []float64 // GenTrq_TLU
}

ServoDynGenSpdTrq

type Table 

type Table struct {
	Columns []TableColumn
}

type TableColumn 

type TableColumn struct {
	Keyword  string
	Field    string
	Type     string
	Dims     int
	Unit     string
	Desc     string
	Optional bool
}

type TurbSim 

type TurbSim struct {

	// TurbSim Input File
	Title string //

	// Runtime Options
	Echo      bool   // Echo input data to <RootName>.ech (flag)
	RandSeed1 int    // First random seed  (-2147483648 to 2147483647)
	RandSeed2 string // Second random seed (-2147483648 to 2147483647) for intrinsic pRNG, or an alternative pRNG: "RanLux" or "RNSNLW"
	WrBHHTP   bool   // Output hub-height turbulence parameters in binary form?  (Generates RootName.bin)
	WrFHHTP   bool   // Output hub-height turbulence parameters in formatted form?  (Generates RootName.dat)
	WrADHH    bool   // Output hub-height time-series data in AeroDyn form?  (Generates RootName.hh)
	WrADFF    bool   // Output full-field time-series data in TurbSim/AeroDyn form? (Generates RootName.bts)
	WrBLFF    bool   // Output full-field time-series data in BLADED/AeroDyn form?  (Generates RootName.wnd)
	WrADTWR   bool   // Output tower time-series data? (Generates RootName.twr)
	WrFMTFF   bool   // Output full-field time-series data in formatted (readable) form?  (Generates RootName.u, RootName.v, RootName.w)
	WrACT     bool   // Output coherent turbulence time steps in AeroDyn form? (Generates RootName.cts)
	Clockwise bool   // Clockwise rotation looking downwind? (used only for full-field binary files - not necessary for AeroDyn)
	ScaleIEC  int    // Scale IEC turbulence models to exact target standard deviation? [0=no additional scaling; 1=use hub scale uniformly; 2=use individual scales]

	// Turbine/Model Specifications
	NumGrid_Z    int     // Vertical grid-point matrix dimension
	NumGrid_Y    int     // Horizontal grid-point matrix dimension
	TimeStep     float64 // Time step [seconds]
	AnalysisTime float64 // Length of analysis time series [seconds] (program will add time if necessary: AnalysisTime = MAX(AnalysisTime, UsableTime+GridWidth/MeanHHWS) )
	UsableTime   float64 // Usable length of output time series [seconds] (program will add GridWidth/MeanHHWS seconds unless UsableTime is "ALL")
	HubHt        float64 // Hub height [m] (should be > 0.5*GridHeight)
	GridHeight   float64 // Grid height [m]
	GridWidth    float64 // Grid width [m] (should be >= 2*(RotorRadius+ShaftLength))
	VFlowAng     float64 // Vertical mean flow (uptilt) angle [degrees]
	HFlowAng     float64 // Horizontal mean flow (skew) angle [degrees]

	// Meteorological Boundary Conditions
	TurbModel       string  // Turbulence model ("IECKAI","IECVKM","GP_LLJ","NWTCUP","SMOOTH","WF_UPW","WF_07D","WF_14D","TIDAL","API","USRINP","TIMESR", or "NONE")
	UserFile        string  // Name of the file that contains inputs for user-defined spectra or time series inputs (used only for "USRINP" and "TIMESR" models)
	IECstandard     string  // Number of IEC 61400-x standard (x=1,2, or 3 with optional 61400-1 edition number (i.e. "1-Ed2") )
	IECturbc        string  // IEC turbulence characteristic ("A", "B", "C" or the turbulence intensity in percent) ("KHTEST" option with NWTCUP model, not used for other models)
	IEC_WindType    string  // IEC turbulence type ("NTM"=normal, "xETM"=extreme turbulence, "xEWM1"=extreme 1-year wind, "xEWM50"=extreme 50-year wind, where x=wind turbine class 1, 2, or 3)
	ETMc            float64 // IEC Extreme Turbulence Model "c" parameter [m/s]
	WindProfileType string  // Velocity profile type ("LOG";"PL"=power law;"JET";"H2L"=Log law for TIDAL model;"API";"USR";"TS";"IEC"=PL on rotor disk, LOG elsewhere; or "default")
	ProfileFile     string  // Name of the file that contains input profiles for WindProfileType="USR" and/or TurbModel="USRVKM" [-]
	RefHt           float64 // Height of the reference velocity (URef) [m]
	URef            float64 // Mean (total) velocity at the reference height [m/s] (or "default" for JET velocity profile) [must be 1-hr mean for API model; otherwise is the mean over AnalysisTime seconds]
	ZJetMax         float64 // Jet height [m] (used only for JET velocity profile, valid 70-490 m)
	PLExp           float64 // Power law exponent [-] (or "default")
	Z0              float64 // Surface roughness length [m] (or "default")

	// Non-IEC Meteorological Boundary Conditions
	Latitude float64 // Site latitude [degrees] (or "default")
	RICH_NO  float64 // Gradient Richardson number [-]
	UStar    float64 // Friction or shear velocity [m/s] (or "default")
	ZI       float64 // Mixing layer depth [m] (or "default")
	PC_UW    float64 // Hub mean uw Reynolds stress [m^2/s^2] (or "default" or "none")
	PC_UV    float64 // Hub mean uv Reynolds stress [m^2/s^2] (or "default" or "none")
	PC_VW    float64 // Hub mean vw Reynolds stress [m^2/s^2] (or "default" or "none")

	// Spatial Coherence Parameters
	SCMod1  string  // u-component coherence model ("GENERAL", "IEC", "API", "NONE", or "default")
	SCMod2  string  // v-component coherence model ("GENERAL", "IEC", "NONE", or "default")
	SCMod3  string  // w-component coherence model ("GENERAL", "IEC", "NONE", or "default")
	InCDec1 float64 // u-component coherence parameters for general or IEC models [-, m^-1] (e.g. "10.0  0.3e-3" in quotes) (or "default")
	InCDec2 float64 // v-component coherence parameters for general or IEC models [-, m^-1] (e.g. "10.0  0.3e-3" in quotes) (or "default")
	InCDec3 float64 // w-component coherence parameters for general or IEC models [-, m^-1] (e.g. "10.0  0.3e-3" in quotes) (or "default")
	CohExp  float64 // Coherence exponent for general model [-] (or "default")

	// Coherent Turbulence Scaling Parameters
	CTEventPath string  // Name of the path where event data files are located
	CTEventFile string  // Type of event files ("LES", "DNS", or "RANDOM")
	Randomize   bool    // Randomize the disturbance scale and locations? (true/false)
	DistScl     float64 // Disturbance scale [-] (ratio of event dataset height to rotor disk). (Ignored when Randomize = true.)
	CTLy        float64 // Fractional location of tower centerline from right [-] (looking downwind) to left side of the dataset. (Ignored when Randomize = true.)
	CTLz        float64 // Fractional location of hub height from the bottom of the dataset. [-] (Ignored when Randomize = true.)
	CTStartTime float64 // Minimum start time for coherent structures in RootName.cts [seconds]
	Defaults    map[string]struct{}
}

TurbSim

func NewTurbSim 

func NewTurbSim() *TurbSim

func ReadTurbSim 

func ReadTurbSim(path string) (*TurbSim, error)

func (*TurbSim) Format 

func (s *TurbSim) Format() (text []byte, err error)

func (*TurbSim) Parse 

func (s *TurbSim) Parse(text []byte) error

func (*TurbSim) Write 

func (s *TurbSim) Write(path string) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.