OWENS

Inputs pointing to the file paths of compiled binaries of external libraries

Internal, struct containing the CACTUS geometry file data for a blade

Internal, struct containing blade specific data and location within the mesh

Internal, struct containing the CACTUS geometry file data

component = Component(; name="nothing", nodeNumbers=nothing, elNumbers=nothing, ex=nothing, ey=nothing, ez=nothing, kx=nothing, ky=nothing, kz=nothing, lamU=nothing, lamL=nothing, lamW=nothing, inputlayup=nothing, inputmaterials=nothing, preCompInput=nothing, preCompOutput=nothing, plyProps=nothing, nuMadIn=nothing, stiffmatrix=nothing, massmatrix=nothing, sectionProps=nothing, stressU=nothing, stressL=nothing, strainU=nothing, strainL=nothing, ultsafetyfactorU=nothing, ultsafetyfactorL=nothing, bucksafetyfactorU=nothing, bucksafetyfactorL=nothing, damageU=nothing, damage_L=nothing, mass=nothing, cost=nothing)

This function stores the critical information associated with preprocessing and post processing to enable generalization. It is intended that an array of components will be generated by appending each subsequent component to the array at the mesh stage.

#Inputs

• name:::
• nodeNumbers:::
• elNumbers:::
• e_x:::
• e_y:::
• e_z:::
• k_x:::
• k_y:::
• k_z:::
• lam_U:::
• lam_L:::
• lam_W:::
• input_layup:::
• input_materials:::
• preCompInput:::
• preCompOutput:::
• plyProps:::
• nuMadIn:::
• stiff_matrix:::
• mass_matrix:::
• sectionProps:::
• stress_U:::
• stress_L:::
• strain_U:::
• strain_L:::
• ultsafetyfactor_U:::
• ultsafetyfactor_L:::
• bucksafetyfactor_U:::
• bucksafetyfactor_L:::
• damage_U:::
• damage_L:::
• mass:::
• cost:::

#Outputs

• component::OWENS.Component: Component struct with the same information as the input, some elements may be initialize as nothing and filled in later

DLCOptions(dictin::OrderedCollections.OrderedDict{Symbol,Any})

# Input
* `DLCs`: default ["none"], name of DLC
* `Vinf_range`: default inRange(5,20,16), inflow Cutin to cutout and discretization
* `IEC_std`: default ""1-ED3"", turbsim input file IEC standard
* `WindChar`: default ""A"", turbsim wind charasteric 
* `WindClass`: default , DLC turbsim wind class
* `turbsimsavepath`: default "./turbsimfiles", path where the turbsim files are saved
* `pathtoturbsim`: default othing, path to the turbsim executable
* `NumGrid_Z`: default 8, turbsim vertical discretizations 
* `NumGrid_Y`: default 6, turbsim horizontal discretizations
* `Vref`: default 0.0, reference/nominal wind speed m/s for turbsim or other inflow wind input file (depending on which DLC is selected)
* `Vdesign`: default 1.0, Design or rated speed of turbine, used for certain DLC cases
* `grid_oversize`: default .1, amount that the turbsim inflow is oversized compared to the turbine to allow for deflection
* `regenWindFiles`: default false, force regeneration of turbsim files even if they already exist
* `delta_t_turbsim`: default .05, turbsim timestep
* `simtime_turbsim`: default 00.0, turbsim total time, which loops if simtime exceeds turbsim time
* `RandSeed1`: default 0071, turbsim random seed number
* `DLCParams`: see ?OWENS.DLCParams, the current DLC parameters for the run, used as internal state information


# Output
* `DLC_Options`:

Internal, driveshaft stiffness k and damping c

DrivetrainOptions(dictin::OrderedCollections.OrderedDict{Symbol,Any})

# Input
* `turbineStartup`: default 0, TODO: clean up since it should be derived from control strategy
* `usingRotorSpeedFunction`: default false, TODO: clean up the speed function since the omegaocp RPM gets splined already
* `driveTrainOn`: default false, flag to turn on the drivetrain model TODO: clean this up to make it always use the drivetrain model, with default 100% efficiency and ratio of 1 so it outputs the values
* `JgearBox`: default 0.0, torsional stiffness of the gearbox TODO: resolve units
* `gearRatio`: default 1.0, ratio between the turbine driveshaft and generator shaft
* `gearBoxEfficiency`: default 1.0, efficiency of the gearbox, just decreases the torque that the generator model sees
* `generatorOn`: default false, TODO: clean up the generator options
* `useGeneratorFunction`: default false, TODO: clean up the generator options
* `generatorProps`: default 0.0, TODO: clean up the generator options
* `ratedTorque`: default 0.0, TODO: clean up the generator options
* `zeroTorqueGenSpeed`: default 0.0, TODO: clean up the generator options
* `pulloutRatio`: default 0.0, TODO: clean up the generator options
* `ratedGenSlipPerc`: default 0.0, TODO: clean up the generator options
* `OmegaGenStart`: default 0.0, TODO: clean up the generator options
* `driveShaftProps_K`: default 0.0, TODO: break this out, driveshaft stiffness and damping
* `driveShaftProps_C`: default 0.0, TODO: break this out, driveshaft stiffness and damping

# Output
* `Drivetrain_Options`:

Inputs(;verbosity=2, analysisType = "TNB", turbineStartup = 0, usingRotorSpeedFunction = false, tocp = [0.0,1.1], tocpVinf = [0.0,1.1], numTS = 50.0, deltat = 2e-3, Omegaocp = [7.2,7.2] ./ 60, Vinfocp = [12.0,12.0], aeroLoadsOn = 1, AD15On = false, driveTrainOn = false, generatorOn = false, platformActive = false, topsideOn = true, interpOrder = 2, hdinputfile = "none", mdinputfile = "none", JgearBox = 0.0, gearRatio = 1.0, gearBoxEfficiency = 1.0, useGeneratorFunction = false, generatorProps = 0.0, ratedTorque = 0.0, zeroTorqueGenSpeed = 0.0, pulloutRatio = 0.0, ratedGenSlipPerc = 0.0, OmegaGenStart = 0.0, omegaControl = false, OmegaInit = 7.2/60, #TODO: simplify this in the code since it is redundant rigid = false, #turn off structural dynamics aeroloadfile = "modulepath/../test/data/inputfilestest/DVAWT2BLCDTElementData.csv", owensfile = "modulepath/../test/data/inputfilestest/15mTowertransientdvawtc2_lcdt.owens", dataOutputFilename = "none", numDOFPerNode = 6, bladeData = [], driveShaftProps = DriveShaftProps(0.0,0.0) TOL = 1e-4, MAXITER = 300, )

Model inputs for OWENS coupled analysis, struct

Inputs

• verbosity::int: output verbosity where 0 is nothing, 1 is warnings, 2 is summary outputs, 3 is detailed outputs, and 4 is everything
• analysisType::string: Newmark Beta time stepping "TNB", Dean time stepping "TD", modal "M"
• turbineStartup::int: 1 forced start-up using generator as motor, 2 self-starting mode, 0 specified rotor speed mode")
• usingRotorSpeedFunction::bool: use user specified rotor speed profile function
• tocp::Array{<:float}: = time points for rotor speed profile (s)
• tocp_Vinf::Array{<:float}: = time points for specified Vinf profile (s)
• numTS::int: total number of timesteps to run
• delta_t::float: timestep interval (s)
• Omegaocp::Array{<:float}: = rotor speed points for rotor speed profile (Hz)
• Vinfocp::Array{<:float}: = rotor speed points for specified Vinf profile (Hz)
• aeroLoadsOn::bool: #0 off, 1 one way, 1.5 one way with deformation from last timestep, 2 two way
• AD15On::bool: flag to use AD15 for aero
• driveTrainOn::bool: flag to include drivetrain effects
• generatorOn::bool: flag to include generator effects
• platformActive::bool: flag to include platform coupling
• interpOrder::int: order used for extrapolating inputs and states, 0 flat, 1 linear, 2 quadratic
• hd_input_file::string: file path to the HydroDyn .dat input file
• ss_input_file::string: file path to the HydroDyn sea states input file
• md_input_file::string: file path to the MoorDyn .dat input file
• JgearBox::float: gearbox intertia, standard SI units
• gearRatio::float: gearbox gear ratio
• gearBoxEfficiency::float: gearbox efficiency (typically 0-1)
• useGeneratorFunction::bool: = flag to use user specified generator profile
• generatorProps::float: not used, should clean up
• ratedTorque::float: Generator rated max torque
• zeroTorqueGenSpeed::float: rated generator speed (minus slippage)
• pulloutRatio::float: Fraction of the min/max torque that the generator engages/disengages
• ratedGenSlipPerc::float: extra speed from slipping?
• OmegaGenStart::float: speed (Hz) at which generator would kick in
• omegaControl::bool: false for fixed speed, true for dynamic
• OmegaInit::float: initial rotor speed (Hz)
• aeroloadfile::string: string of the name and path for the cactus aeroloads if using the old serial owens call
• owensfile::string: string of the name and path for the owens input file if using the old serial owens call
• potflowfile::string: string of the prefix and path for the directory containing the potential flow files from WAMIT (required by HydroDyn)
• dataOutputFilename::string: path and name of output file, will be overwritten if already exists
• numDOFPerNode::int: number of degrees of freedom per node
• bladeData::BladeData: see ?BladeData, only used if calling the old serial owens function
• driveShaftProps::DriveShaftProps: see ?DriveShaftProps
• TOL::float: gauss-seidel iteration tolerance
• MAXITER::int: gauss-seidel maximum iterations

Outputs:

• OWENS.Inputs:

Internal, gauss-seidel iteration parameters

MeshOptions(dictin::OrderedCollections.OrderedDict{Symbol,Any})

# Input
* `ntelem`: default 20, number of tower elements in each blade, plus nodes wherever there is a component overlap
* `nbelem`: default 30, number of blade elements in each blade, plus nodes wherever there is a component overlap
* `ncelem`: default 30, number of cable elements in each cable if ARCUS
* `nselem`: default 10, number of elements in each strut
* `angularOffset`: default 0.0, moves the structure to align with the aero model
* `joint_type`: default 0, optionally can specify the strut to blade joints to be pinned about different axes, or 0 for welded
* `c_mount_ratio`: default 0.05, for ARCUS, where the cable mounts on the lower side of the blade
* `AD15hubR`: default 0.1, parameter, used in aerodyn coupling for the hub radius so that the vortex sheets don't go within the hub
* `cables_connected_to_blade_base`: default true, for ARCUS, for the two part simulation of the blade bending
* `turbineType`: default "Darrieus", mesh Darrieus, H-VAWT, controls if the tips of the blades are joined to the tower in the mesh or not. 
        
# Output
* `Mesh_Options`:

NuMad(nweb,nstack,nsegments,span,airfoil,tetype,twistd,chord,xoffset,aerocenter,stackmattypes,stacklayers,segments,DPtypes,skin,webstack,webdp)

Parameters defining the blade composite layup. See NuMad user guide SAND2012_7028 appendix B for more details

Arguments

• n_web::Int64: number of shear webs
• n_stack::Int64: number of predefined composite stacks
• n_segments::Int64: number of segments around the airfoil
• span::Vector{Float64}: span-wise position
• airfoil::Vector{String}: airfoil name
• te_type::Vector{String}: trailing edge type
• twist_d::Vector{Float64}: twist_d in degrees
• chord::Vector{Float64}: chord length
• xoffset::Vector{Float64}: The distance from the “nose” of a station to the blade reference axis.
• aerocenter::Vector{Float64}: This is an aerodynamic parameter that is an output from aerodynamic performance analysis of a two-dimensional airfoil section. The aerodynamic center is the point along the chord where the aerodynamic pitching moment does not vary with changes in angle of attack.
• stack_mat_types::Vector{Int64}: Material numbers used that correspond to each stack number
• stack_layers::Array{Int64,2}: number of layers at each span used corresponding to each material type (first index corresponds to spanwise position, second index corresponds to the stack number)
• segments::Array{Float64,2}: normalized starting and stopping points of each section (i.e. leading edge, sparcap, etc). First index corresponds to spanwise position, second index corresponds to the section, except there is an extra first column starting at -1 for the trailing edge. There must be a leading edge position at 0, and the last column must be 1 corresponding to the trailing edge again. Positions are fractions of the chord, lower (HP) is negative, upper (LP) is positive
• DPtypes::Array{Int64,2}: division point types (NOTE THAT THIS ISN'T IMPLEMENTED AND DOES NOTHING CURRENTLY, i.e. only SINGLE is being used). First index corresponds to spanwise position, second corresponds to section number
• skin_seq::Array{Seq,2}: stack sequence, is an array of structures, each containing a Vector{Int64} of the sequence (i.e. skin[2,5].seq). First index corresponds to spanwise positoin, second index the section
• web_seq::Array{Seq,2}: same format and meaning as skin sequence, but for the webs with the second index corresponding to the web number
• web_dp::Array{Seq,2}: same format as skin sequence, but this corresponds to the section numbers the web connects to at the top and bottom at both edges. There are always four entries in the CSV list and the order goes as follows: inboard LP, inboard HP, outboard HP, outboard LP.

OWENSAeroOptions(dictin::OrderedCollections.OrderedDict{Symbol,Any})

# Input
* `Nslices`: default 20, number of 3-D slices for the strip method to go from 2D to 3D considering curved deforming blades
* `ntheta`: default 30, number of azimuthal discretizations
* `ifw`: default false, use the inflow wind coupling to get inflow velocities TODO: change ifw to inflowwind inflowwind_active etc everywhere
* `DynamicStallModel`: defaultBV", dynamic stall model, should be under an OWENSAero options
* `RPI`: default true, rotating point iterative method (i.e. it just calculates at the blade positions and is much faster)
* `Aero_Buoyancy_Active`: default false, flag to turn buoyancy on for the blades.  This is likely to be replaced by a different model
* `Aero_AddedMass_Active`: default false, flag to turn added mass forces on, don't turn on if the added mass in the structures are on
* `Aero_RotAccel_Active`: default false, flag to turn added mass forces on, don't turn on if the added mass in the structures are on


# Output
* `OWENSAero_Options`:

OWENSFEAOptions(dictin::OrderedCollections.OrderedDict{Symbol,Any})

# Input
* `nlOn`: default true, nonlinear effects
* `RayleighAlpha`: default 0.05, damping coefficient scalar on the stiffness matrix
* `RayleighBeta`: default 0.05, damping coefficient scalar on the mass matrix
* `iterationType`: default "DI", internal iteration type DI direct iteration, NR newton rhapson (which is less stable than DI)
* `guessFreq`: default 0.0, for the built in flutter model frequency guessed for the flutter frequency 
* `numModes`: default 20, ROM model, number of modes used in the analysis type.  Less is faster but less accurate
* `adaptiveLoadSteppingFlag`: default true, for steady analysis if convergence fails, it will reduce the load and retry then increase the load
* `minLoadStepDelta`: default 0.0500, minimum change in load step
* `minLoadStep`: default 0.0500, minimum value of reduced load
* `prescribedLoadStep`: default 0.0, optional prescribed load fraction
* `maxNumLoadSteps`: default 20, used in static (steady state) analysis, max load steps for adaptive load stepping
* `tolerance`: default 1.0000e-06, total mesh unsteady analysis convergence tolerance for a timestep within the structural model
* `maxIterations`: default 50, total mesh unsteady analysis convergence max iterations for a timestep
* `elementOrder`: default 1, Element order, 1st order, 2nd order etc; determines the number of nodes per element (order +1).  Orders above 1 have not been tested in a long time  
* `alpha`: default 0.5, newmark time integration alpha parameter
* `gamma`: default 0.5, newmark time integration gamma parameter
* `AddedMass_Coeff_Ca`: default 0.0, added mass coefficient, scaling factor (typically 0-1) on the cones of water mass applied to each structural element in the 22 and 33 diagonal terms. 0 turns this off
* `platformTurbineConnectionNodeNumber`: default 1, TODO: reconnect this
* `aeroElasticOn`: default false, OWENSFEA for the built in flutter model
* `spinUpOn`: default true, TODO: remove this since it should always be true since that is how its used. To turn it off, just set RPM and gravity to 0.  OWENSFEA modal analysis, calculates steady centrifugal strain stiffening and then passes that model to the modal analysis
* `predef`: default false, Predeformation flag for two state analysis where a portion of the blade is deformed and the nonlinear strain stiffening terms are "update"-d, then "use"-d in two different analysis

# Output
* `OWENSFEA_Options`:

OWENSOpenFASTWrappersOptions(dictin::OrderedCollections.OrderedDict{Symbol,Any})

# Input
* `windINPfilename`: default nothing, If ifw or AeroDyn is being used, gets overwritten if using the DLC analysis type, the moordyn file location, like in the unit test
* `ifw_libfile`: default nothing, location of the respective OpenFAST library, if nothing it will use the internal OWENS installation
* `hd_lib`: default nothing, location of the respective OpenFAST library, if nothing it will use the internal OWENS installation
* `md_lib`: default nothing, location of the respective OpenFAST library, if nothing it will use the internal OWENS installation
* `adi_lib`: default nothing, location of the respective OpenFAST library, if nothing it will use the internal OWENS installation
* `adi_rootname`: default "/aerodyn", location of the respective OpenFAST library, if nothing it will use the internal OWENS installation
* `hd_input_file`: default "none", If platformActive, the hydrodyn file location, like in the unit test
* `ss_input_file`: default "none", If platformActive, the sea state file location, like in the unit test
* `md_input_file`: default "none", If platformActive, the moordyn file location, like in the unit test
* `potflowfile`: default nothing, If platformActive, the potential flow files location, like in the unit test
* `WindType`: default 3, Derived parameter, inflowwind wind file type when DLC generator is active, matches inflowwind WindType 
        
# Output
* `OWENSOpenFASTWrappers_Options`:

OWENSOptions(dictin::OrderedCollections.OrderedDict{Symbol,Any})

# Input
* `analysisType`: default "Unsteady",  Unsteady, DLC, Campbell, todo: steady, flutter may be re-activated in the future.
* `AeroModel`: default "DMS",  OWENSAero model "DMS" for double multiple streamtube or "AC" for actuator cylinder, or "AD" for aerodyn
* `structuralModel`: default "TNB",  Structural models available: TNB full timoshenko beam elements with time newmark beta time stepping, ROM reduced order modal model of the timoshenko elements, GX with GXBeam's methods for geometrically exact beam theory and more efficient methods and time stepping
* `controlStrategy`: default "normal",  should be in WindIO?- yes, 
* `numTS`: default 10,  number of time steps TODO: change to sim time and make this derived
* `delta_t`: default 0.05,  time step in seconds
* `platformActive`: default false,  flag to indicate if the floating platform model is active.  
* `topsideOn`: default true,  flat to be able to turn off the rotor and just run the floating portions
* `interpOrder`: default 2,  if platformActive, order used for extrapolating inputs and states, 0 flat, 1 linear, 2 quadratic
* `dataOutputFilename`: default nothing,  data output filename with path, set to nothing or don't specify to not output anything
* `rigid`: default false,  this bypasses the structural solve and just mapps the applied loads as the reaction loads, and the deflections remain 0
* `TOL`: default 1e-4,  gauss-seidel iteration tolerance - i.e. the two-way iteration tolerance
* `MAXITER`: default 300,  gauss-seidel max iterations - i.e. the two-way iterations
* `verbosity`: default 2,  verbosity where 0 is nothing, 1 is warnings, 2 is summary outputs, 3 is detailed outputs, and 4 is everything
* `VTKsaveName`: default "./vtk/windio",  Path and name of the VTK outputs, recommended to put it in its own folder (which it will automatically create if needed)
* `aeroLoadsOn`: default 2,  Level of aero coupling 0 structures only, 1 no deformation passed to the aero, 2 two-way coupling, 1.5 last time step's deformations passed to this timesteps aero and no internal iteration.
* `Prescribed_RPM_time_controlpoints`: default [0.0,100000.1],  If controlStrategy is "fixedRPM", array of time control points for the internal spline
* `Prescribed_RPM_RPM_controlpoints`: default [17.2,17.2],  If controlStrategy is "fixedRPM", array of RPM control points for the internal spline
* `Prescribed_Vinf_time_controlpoints`: default [0.0,100000.1],  If AeroModel is "DMS" or "AC, and ifw is false, array of time control points for the internal spline
* `Prescribed_Vinf_Vinf_controlpoints`: default [17.2,17.2],  If AeroModel is "DMS" or "AC, and ifw is false, array of Vinf control points for the internal spline 


# Output
* `OWENS_Options`:

Internal, struct containing the CACTUS geometry file data for a strut

Unified_Options

# Input
* `OWENS_Options::OWENS_Options`:
* `DLC_Options::DLC_Options`:
* `OWENSAero_Options::OWENSAero_Options`:
* `OWENSFEA_Options::OWENSFEA_Options`:
* `OWENSOpenFASTWrappers_Options::OWENSOpenFASTWrappers_Options`:
* `Mesh_Options::Mesh_Options`:
* `Drivetrain_Options::Drivetrain_Options`:

# Output
* `Unified_Options`:

Struct containing

material names

Composites.Material structs for each material name - see ?Composites.Material

ModelingOptions(yamlInputfile)

# Input
* `yamlInputfile::string`: yaml file containing ordered inputs matching the default keys


# Output
* `Unified_Options::Unified_Options`: Struct of structs containing all of the OWENS Options

OWENSVTK(savename,t,uHist,system,assembly,sections,aziHist,mymesh,myel,epsilon_x_hist,epsilon_y_hist,epsilon_z_hist,kappa_x_hist,kappa_y_hist,kappa_z_hist,FReactionHist)

Formats and outputs OWENS data into VTK format

#Intput

#Output

• none:

OWENSVTK(VTKsaveName,rundata,system,assembly,sections,mymesh,myel;tsave_idx=1:length(rundata.t,))

Formats and outputs OWENS data into VTK format

#Intput

#Output

• none:

Unsteady(model,topModel,mesh,el,aero;getLinearizedMatrices=false)

Executable function for transient analysis. Provides the interface of various external module with transient structural dynamics analysis capability.

# Input
* `inputs::Inputs`: see ?Inputs
* `topModel::FEAModel`: see ?OWENSFEA.FEAModel
* `mesh::Mesh`: see ?OWENSFEA.Mesh
* `el::El`: see ?OWENSFEA.El
* `bin::Bin`: see ?Bin
* `aero::function`: Fexternal, Fdof = aero(t) where Fexternal is the force on each affected mesh dof and Fdof is the corresponding DOFs affected
* `getLinearizedMatrices::Bool`: Flag to save the linearized matrices
* `elStorage::ElStorage.ElStorage`: Optional object containing stored element matrices
* `u_s::Array{<:float}`: Optional warm start of top deflections, of length Nnodes x Ndof


# Output
* `t`: time array (s)
* `aziHist`: azimuthal history array 
* `OmegaHist`: rotational speed array history (hz)
* `OmegaDotHist`: rotational acceleration array history
* `gbHist`: gearbox position history array
* `gbDotHist`: gearbox velocity history array
* `gbDotDotHist`: gearbox acceleration history array
* `FReactionHist`: Nodal reaction 6dof forces history
* `rigidDof`:
* `genTorque`: generator torque history
* `genPower`: generator power history
* `torqueDriveShaft`: driveshaft torque history
* `uHist`: mesh displacement history for each dof
* `epsilon_x_hist`: strain history for eps_xx_0 for each dof
* `epsilon_y_hist`: strain history for eps_xx_z for each dof
* `epsilon_z_hist`: strain history for eps_xx_y for each dof
* `kappa_x_hist`: strain history for gam_xz_0 for each dof
* `kappa_y_hist`: strain history for gam_xz_y for each dof
* `kappa_z_hist`: strain history for gam_xy_0 for each dof

Unsteady(model,topModel,mesh,el,aero;getLinearizedMatrices=false)

Executable function for transient analysis. Provides the interface of various external module with transient structural dynamics analysis capability.

# Input
* `inputs::Model`: see ?Model
* `topModel::FEAModel`: see ?OWENSFEA.FEAModel
* `mesh::Mesh`: see ?OWENSFEA.Mesh
* `el::El`: see ?OWENSFEA.El
* `bin::Bin`: see ?Bin
* `aero::function`: Fexternal, Fdof = aero(t) where Fexternal is the force on each affected mesh dof and Fdof is the corresponding DOFs affected
* `getLinearizedMatrices::Bool`: Flag to save the linearized matrices
* `elStorage::ElStorage.ElStorage`: Optional object containing stored element matrices
* `u_s::Array{<:float}`: Optional warm start of top deflections, of length Nnodes x Ndof


# Output
* `t`: time array
* `aziHist`: azimuthal history array
* `OmegaHist`: rotational speed array history
* `OmegaDotHist`: rotational acceleration array history
* `gbHist`: gearbox position history array
* `gbDotHist`: gearbox velocity history array
* `gbDotDotHist`: gearbox acceleration history array
* `FReactionHist`: Nodal reaction 6dof forces history
* `rigidDof`:
* `genTorque`: generator torque history
* `genPower`: generator power history
* `torqueDriveShaft`: driveshaft torque history
* `uHist`: mesh displacement history for each dof
* `epsilon_x_hist`: strain history for eps_xx_0 for each dof
* `epsilon_y_hist`: strain history for eps_xx_z for each dof
* `epsilon_z_hist`: strain history for eps_xx_y for each dof
* `kappa_x_hist`: strain history for gam_xz_0 for each dof
* `kappa_y_hist`: strain history for gam_xz_y for each dof
* `kappa_z_hist`: strain history for gam_xy_0 for each dof

calc_hydro_residual(new_accels, new_hydro_frcs, md_frc, u, FMultiplier)

Internal, finds the residual of the platform accelerations/forces when adding in new values from HydroDyn, MoorDyn, and OWENSFEA.

Input

• new_accels::Vector{<:float}: the new platform accelerations in the inertial reference frame from OWENSFEA (m/s/s)
• new_hydro_frcs::Vector{<:float}: the new platform hydro forces in the inertial reference frame from HydroDyn (N)
• md_frc::Vector{<:float}: the mooring forces at the platform in the inertial reference frame from MoorDyn (N)
• u::Vector{<:float}: input vector containing platform loads and accelerations prior to the new additions
• FMultiplier::Number: scaling factor used to make the loads/accelerations in the same magnitude for the Jacobians

Output

• u_resid: vector containing residual between the input u and the new load/accelerations

calculateDriveShaftReactionTorque(driveShaftProps,thetaRotor,thetaGB,thetaDotRotor,thetaDotGB)

Internal, calculates reaction torque of driveshaft

#Input

• driveShaftProps: object containing driveshaft properties
• thetaRotor: azimuth position of rotor/rotor shaft (rad)
• thetaGB: azimuth position of gearbox shaft (rad)
• thetaDotRotor: angular velocity of rotor/rotor shaft (rad/s)
• thetaDotGB: angular velocity of gearbox shaft (rad/s)

#Output

• torque: reaction torque of drive shaft

calculateElementOrientation(mesh)

Calculates the orientation of elements in a mesh.

#Input

• mesh::OWENSFEA.Mesh see ?OWENSFEA.Mesh object containing mesh data

#Output

• elOr::OWENSFEA.Ort see ?OWENSFEA.Ort object containing element orientation data

calculatePsiTheta(v)

Calculates the orientation of a single element. A local element frame is related to a hub frame through a transformation matrix CHtoE (transforming a vector from an element frame E to a global frame H) such that CHtoE = [M2(Theta)]*[M3(Psi)]. Here [M2( )] is a direction cosine matrix about a 2 axis and [M3( )] is a direction cosine matrix about a 3 axis.

#Input

• v: vector from node 1 to node 2 of an element

#Output

• Psi: "3" angle for element orientation (deg)
• Theta: "2" angle for element orientation (deg)

Count the cycles from the data

createGeneralTransformationMatrix(angleArray,axisArray)

Calculates the transformation matrix assocaited with a general Euler rotation sequence.

#Input

• angleArray: = array of angles for Euler rotation sequence
• axisArray: = array of axis of rotatoins for Euler rotation

#Output

• dcmTotal: = transformation matrix of specified euler rotation sequence

setInitConditions(initDisps, numNodes, numDOFPerNode)

Creates the formatted initial conditions array needed by OWENSFEA

#Input

• initDisps: an array of length numDOFPerNode specifying the initial displacement of each DOF
• numNodes: the number of nodes in the given mesh
• numDOFPerNode: the number of unconstrained degrees of freedom calculated in each node

#Output

• initCond: array containing initial conditions. initCond(i,1) node number for init cond i. initCond(i,2) local DOF number for init cond i. initCond(i,3) value for init cond i.

Creates a direction cosine matrix (dcm) associated with a rotation of angleDeg about axisNum.

createarcusmesh(;Htwrbase = 15.0, Hbld = 147.148-15.0, #blade height R = 54.014, # m bade radius nblade = 3, ntelem = 30, #tower elements nbelem = 30, #blade elements ncelem = 4, strutmountpoint = 0.01, # This puts struts at top and bottom bshapex = zeros(nbelem+1), #Blade shape, magnitude is irrelevant, scaled based on height and radius above bshapez = zeros(nbelem+1), jointtype = 0, cablesconnectedtoblade_base = true, angularOffset = 0.0)

ARCUS mesh configuration: no tower between blades, no struts, but cables from top center attaching to specified blade mount point at base

#Inputs

• Htwr_base::float: height of tower before blades attach (m)
• Hbld::float: blade height (m)
• R::float: bade radius (m)
• nblade::int: number of blades
• ntelem::int: number of tower elements
• nbelem::int: number of blade elements
• ncelem::int: number of strut elements
• c_mount_ratio::float: factor of blade height where the struts attach on both top and bottom
• bshapex::Array{<:float}: Blade shape, magnitude is irrelevant, scaled based on height and radius above
• bshapez::Array{<:float}: Blade shape, magnitude is irrelevant, scaled based on height and radius above
• joint_type::int: 0 is fixed, 1 is about x-axis, 2 is y-axis, etc
• cables_connected_to_blade_base::bool: = true,
• angularOffset::float: (rad) angular offset of mesh generation, typically used to match CACTUS input. Value of 0 puts blade 1 at the "north" position and the others populate counterclockwise when looking down

#Outputs

• mymesh::OWENSFEA.Mesh: see ?OWENSFEA.Mesh
• ort::OWENSFEA.Ort: see ?OWENSFEA.Ort
• myjoint:Array{<:float}: see ?OWENSFEA.FEAModel.joint

createhawtbiwingmesh(;Ht = 15.0, Hb = 147.148-15.0, #blade height R = 54.014, # m bade radius nblade = 3, ntelem = 30, #tower elements nbelem = 30, #blade elements ncelem = 4, strutmountpoint = 0.01, # This puts struts at top and bottom bshapex = zeros(nbelem+1), #Blade shape, magnitude is irrelevant, scaled based on height and radius above bshapez = zeros(nbelem+1), jointtype = 0, cablesconnectedtoblade_base = true, angularOffset = 0.0)

#Inputs

• Ht::float: height of tower before blades attach (m)
• Hb::float: blade height (m)
• R::float: bade radius (m)
• nblade::int: number of blades
• ntelem::int: number of tower elements
• nbelem::int: number of blade elements
• ncelem::int: number of strut elements
• c_mount_ratio::float: factor of blade height where the struts attach on both top and bottom
• bshapex::Array{<:float}: Blade shape, magnitude is irrelevant, scaled based on height and radius above
• bshapez::Array{<:float}: Blade shape, magnitude is irrelevant, scaled based on height and radius above
• joint_type::int: 0 is fixed, 1 is about x-axis, 2 is y-axis, etc
• cables_connected_to_blade_base::bool: = true,
• angularOffset::float: (rad) angular offset of mesh generation, typically used to match CACTUS input. Value of 0 puts blade 1 at the "north" position and the others populate counterclockwise when looking down

#Outputs

• mymesh::OWENSFEA.Mesh: see ?OWENSFEA.Mesh
• ort::OWENSFEA.Ort: see ?OWENSFEA.Ort
• myjoint:Array{<:float}: see ?OWENSFEA.FEAModel.joint

createhawtmesh(;Ht = 15.0, Hb = 147.148-15.0, #blade height R = 54.014, # m bade radius nblade = 3, ntelem = 30, #tower elements nbelem = 30, #blade elements ncelem = 4, strutmountpoint = 0.01, # This puts struts at top and bottom bshapex = zeros(nbelem+1), #Blade shape, magnitude is irrelevant, scaled based on height and radius above bshapez = zeros(nbelem+1), jointtype = 0, cablesconnectedtobladebase = true, angularOffset = 0.0)

ARCUS mesh configuration: no tower between blades, no struts, but cables from top center attaching to specified blade mount point at base

#Inputs

• Ht::float: height of tower before blades attach (m)
• Hb::float: blade height (m)
• R::float: bade radius (m)
• nblade::int: number of blades
• ntelem::int: number of tower elements
• nbelem::int: number of blade elements
• ncelem::int: number of strut elements
• c_mount_ratio::float: factor of blade height where the struts attach on both top and bottom
• bshapex::Array{<:float}: Blade shape, magnitude is irrelevant, scaled based on height and radius above
• bshapez::Array{<:float}: Blade shape, magnitude is irrelevant, scaled based on height and radius above
• joint_type::int: 0 is fixed, 1 is about x-axis, 2 is y-axis, etc
• cables_connected_to_blade_base::bool: = true,
• angularOffset::float: (rad) angular offset of mesh generation, typically used to match CACTUS input. Value of 0 puts blade 1 at the "north" position and the others populate counterclockwise when looking down

#Outputs

• mymesh::OWENSFEA.Mesh: see ?OWENSFEA.Mesh
• ort::OWENSFEA.Ort: see ?OWENSFEA.Ort
• myjoint:Array{<:float}: see ?OWENSFEA.FEAModel.joint

return mymesh, myort, myjoint, AD15bldNdIdxRng, AD15bldElIdxRng = createmeshcomponents(;Htwrbase = 15.0, Htwrblds = 147.148-15.0, Hbld = 147.148-15.0, #blade height R = 54.014, # m bade radius AD15hubR = 2.0, nblade = 3, ntelem = 30, #tower elements nbelem = 30, #blade elements nselem = 4, struttwrmountpoint = [0.01,0.5,0.9], strutbldmountpoint = [0.01,0.5,0.9], bshapex = zeros(nbelem+1), #Blade shape, magnitude is irrelevant, scaled based on height and radius above bshapez = zeros(nbelem+1), bshapey = zeros(nbelem+1), # but magnitude for this is relevant angularOffset = 0.0, #Blade shape, magnitude is irrelevant, scaled based on height and radius above AD15_ccw = false, verbosity=0, # 0 nothing, 1 basic, 2 lots: amount of printed information connectBldTips2Twr =true)

#Inputs

• Htwr_base::float: height of tower before blades attach (m)
• Htwr_blds::float: height of the tower once the blades attach (m)
• Hbld::float: blade height (m)
• R::float: bade radius (m)
• nblade::int: number of blades
• ntelem::int: number of tower elements
• nbelem::int: number of blade elements
• nselem::int: number of strut elements
• strut_twr_mountpoint::float = [0.01,0.5,0.9], # factor of blade height where the bottom strut attaches on the tower # This puts struts at top and bottom, as a fraction of the blade position
• strut_bld_mountpoint::float = [0.01,0.5,0.9], # factor of blade height where the bottom strut attaches on the blade # This puts struts at bottom 0, mid 0.5, and top 1.0 as a fraction of the blade position
• bshapex::Array{<:float}: Blade shape, magnitude is irrelevant, scaled based on height and radius above
• bshapez::Array{<:float}: Blade shape, magnitude is irrelevant, scaled based on height and radius above
• bshapey::Array{<:float}: Blade shape, magnitude IS relevant #TODO: resolve this
• angularOffset::float: (rad) angular offset of mesh generation, typically used to match CACTUS input. Value of 0 puts blade 1 at the "north" position and the others populate counterclockwise when looking down
• AD15_ccw::boolean: Use AD15 convention of VAWT counter-clockwise with blade root at top (blade points down)
• AD15hubR::float: AD15 has a hub radius, so the struts do not go all the way to the center of the axis of rotation, while the structural mesh does.

verbosity::int: 0 nothing, 1 basic, 2 lots: amount of printed information

• connectBldTips2Twr::book: True for Darrieus style, false for H-VAWT, but the blade shapes should be appropriate

#Outputs

• mymesh::OWENSFEA.Mesh: see ?OWENSFEA.Mesh
• myort::OWENSFEA.Ort: see ?OWENSFEA.Ort
• myjoint:Array{<:float}: see ?OWENSFEA.FEAModel.joint
• AD15bldNdIdxRng: indices for start and end of all blades for AD15 (includes struts). Note that strut start nodes may be inside the strut (strut connects to tower, AD15 blade connects to hub wich is a few nodes away from tower)
• AD15bldElIdxRng: range of elements for start and end of all AD15 blades (includes struts)

externalForcing(time,timeArray,ForceValHist,ForceDof)

Internal, linear time interpolation on the input forces (ForceValHist) for each specified ForceDof

This function specifies external forcing for a transient analysis. Fexternal is a vector of loads and Fdof is a corresponding vector of degrees of freedom the concentrated loads in Fexternal correspond to. The input time allows for arbitrary time varying loads The global degree of freedom number corresponding with the local degree of freedom of a node may be calculated by: globalDOFNumber = (nodeNumber-1)*6 + localDOFnumber The localDOFnumber may range from 1 to 6 such that 1 corresponds to a force in "x direction" of the co-rotating hub frame. 2 and 3 corresponds to a force in the "y" and "z directions" respectively. 4, 5, and 6 correspond to a moment about the "x", "y", and "z" directions respectively.

#Input

• time: Current time
• timeArray: time associated with ForceValHist
• ForceValHist: Forces for each time for each Dof
• ForceDof: Dofs within ForceValHist

#Output

• Fexternal: vector of external loads (forces/moments)
• Fdof: vector of corresponding DOF numbers to apply loads to

extrap_pred_vals(curr_vals, ts, t_out, interp_order)

Internal, calculates predicted values at t_out based on previous values at earlier times.

Input

• curr_vals::Vector{<:float}: input values
• ts::Vector{<:float}: time values corresponding to curr_vals. Left to right, times go from earliest to most recent.
• t_out::float: time for values to be extrapolated tocp
• interp_order::int: order of the spline fit for the extrapolation, 0 flat, 1 linear, 2 quadratic

Output

• pred_vals: extrapolated values at t_out

Find the minimum and maximum mean value and maximum range from a vector of cycles

Returns the range index where the value is found

frame_convert(init_frame_vals, trans_mat)

Internal, transfers 6 DOFs element-wise to a new reference frame

Input

• init_frame_vals::Vector{<:float}: Values in 6 degrees of freedom in the initial reference frame
• trans_mat::Array{<:float}: Transformation matrix to the output reference frame

Output

• out_frame_vals: Values in 6 degrees of freedom in the output reference frame

Internal, generates an output file name depending on the analysis type

• time::TF: in seconds
• nominalVinf::TF: Nominal velocity used to calculate the IEC gust size (m/s)
• R::TF: Turbine Radius (m)
• G_amp::TF: IEC gust amplitude (m/s)
• gustT::TF: IEC gust duration (s)
• gustDelayT::TF: IEC gust delay time

getOWENSPreCompOutput(numadIn;yscale=1.0,plyprops = plyproperties())

Takes numad formatted inputs for composite layup and material properties and runs them through OWENSPreComp

#Inputs

• numadIn::NuMad: see ?NuMad inputs
• yscale::float: airfoil thickness scaling
• plyprops::plyproperties(): see ?plyproperties for input material properties

#Outputs

• precompoutput::OWENSPreComp.Output: see ?OWENSPreComp.Input
• precompinput::OWENSPreComp.Input: see ?OWENSPreComp.properties
• lam_U::Composites.Laminate: laminate stacks used for post processing, size (nstations, nupper chorwise stations), upper surface, see ?Composites.Laminate
• lam_L::Composites.Laminate: laminate stacks used for post processing, size (nstations, nlower chorwise stations), lower surface, see ?Composites.Laminate
• lam_W::Composites.Laminate: laminate stacks used for post processing, size (nstations, nwebs), shear webs, see ?Composites.Laminate

getRotorPosSpeedAccelAtTime(t0,time,aziInit)

Uses the user defined function rotorSpeedProfile() to get the azimuth, speed, and acceleration of the rotor.

#Input

• t0 time at which azimuth integration is beginning
• time current time that position, velocity, and acceleration are being requested
• aziInit initial rotor azimuth angle integration will begin at

#Output

• rotorAzimuth azimuth position of rotor (rad) at time
• rotorSpeed rotor speed (Hz) at time
• rotorAcceleration rotor acceleration (Hz/s) at time

getSectPropsFromOWENSPreComp(usedUnitSpan,numadIn,precompoutput;GX=false,precompinputs=nothing,fluid_density=0.0,AddedMass_Coeff_Ca=1.0,N_airfoil_coord=100))

Arranges the precomp output into the sectional properties required by OWENSFEA

#Inputs

• usedUnitSpan::Array{<:float}: Array specifying the relative (0-1) mesh z locations where the sectional properties are actually called for (interpolation)
• numadIn::NuMAD: see ?NuMAD
• precompoutput::OWENSPreComp.properties: see ?OWENSPreComp.properties
• GX::bool: optional specifies if GX outputs should be output
• precompinputs: optional
• fluid_density::Float64: fluid density, used if added mass is on (AddedMassCoeffCa>0.0)
• AddedMass_Coeff_Ca::Float64: if >0.0, then added mass is calculated off of the airfoil geometry and included in the structures
• N_airfoil_coord::Int: Number of upper/lower common airfoil x points to spline to to enable VTK output of airfoil surface

#Outputs

• sectionPropsArray::SectionPropsArray: see ?OWENSFEA.SectionPropsArray, if !GX bool
• stiff: if GX bool
• mass: if GX bool

stiff, mass

mapACDMS(t,mesh,el)

map OWENSAero forces to OWENS mesh dofs

Inputs

• t::float: time at which to get the loads (can be called repeatedly at the same time or for large time gaps, will infill run as needed)
• mesh::OWENSFEA.Mesh: see ?OWENSFEA.Mesh
• mesh::OWENSFEA.El: see ?OWENSFEA.El

Outputs:

• ForceValHist::Array(<:float): Force or moment (N, N-m) at the time corresponding to the time specified
• ForceDof::Array(<:int): DOF numbers cooresponding to forces (i.e. mesh element 1 has dofs 1-6, 2 has dofs 7-12, etc)

mapAD15(t,mesh)

map AD15 forces to OWENS mesh dofs

Inputs

• t::float: time at which to get the loads (can be called repeatedly at the same time or for large time gaps, will infill run as needed)
• mesh::OWENSFEA.Mesh: see ?OWENSFEA.Mesh
• mesh::OWENSFEA.El: see ?OWENSFEA.El

Outputs:

• ForceValHist::Array(<:float): Force or moment (N, N-m) at the time corresponding to the time specified
• ForceDof::Array(<:int): DOF numbers cooresponding to forces (i.e. mesh element 1 has dofs 1-6, 2 has dofs 7-12, etc)

Internal, takes cactus loads and geometry and OWENS mesh and maps the loads to the blades' FEA dofs

my_getABD(matid::AbstractArray{<:Integer,1}, nply::AbstractArray{<:Integer,1}, tply::AbstractArray{<:Real,1}, theta::AbstractArray{<:Real,1}, q::AbstractArray{<:AbstractArray{<:Real,2},1}), offset::Real

my_getABD(lam::Laminate, q::AbstractArray{<:AbstractArray{<:Real,2},1}), offset::Real

Returns A, B, and D matrices

Arguments:

• matid::AbstractArray{<:Integer,1}: material id of each lamina
• nply::AbstractArray{<:Integer,1}: number of plies in each lamina
• tply::AbstractArray{<:Real,1}: thickness of a ply (m) in each lamina
• theta::AbstractArray{<:Real,1}: orientation (deg) of each lamina
• q::AbstractArray{<:AbstractArray{<:Real,2}}: Stiffness matrix of each lamina
• offset::Real: Optional, used if neutral axis is not centered on the ply. If used, specify distance from neutral axis to upper surface (m).

my_getplystrain(nply::AbstractArray{<:Integer,1}, tply::AbstractArray{<:Real,1}, theta::AbstractArray{<:Real,1}, resultantstrain::AbstractArray{<:Real,1}, offset::Real)

my_getplystrain(lam::Laminate, resultantstrain::AbstractArray{<:Real,1}, offset::Real)

Optional Argument

• offset::Real: Optional, used if neutral axis is not centered on the ply. If used, specify distance from neutral axis to upper surface (m).

Calculates strains in each ply aligned with principal material direction.

getz(tply::AbstractArray{<:Real,1}, nply::AbstractArray{<:Integer,1}, offset::Real)

getz(lam::Laminate, offset::Real)

Returns a laminate's z-coordinates (coordinates of top and bottom of laminas) given the thickness of plies in each lamina and the number of plies in each lamina. Offset is optional, defaults to 0.0, is the distance from the neutal axis to the upper ply if the laminate is not centered about the neutral axis of a beam.

mywrite_vtk(name, assembly::Assembly, [state::AssemblyState, ]λ::Number,
    eigenstate::AssemblyState; scaling=1.0, mode_scaling=1.0, cycles=1,
    steps=100)

Write a series of files corresponding to the elastic motion of the assembly about the deformed state encoded in state defined by the eigenvalue λ and the eigenvector encoded in eigenstate over the time period specified by time.

The steady-state deflections can be scaled with scaling and the eigenmode deflections can be scaled using mode_scaling.

The current time is encoded in the metadata tag "time"

mywrite_vtk(name, assembly::Assembly; kwargs...)
mywrite_vtk(name, assembly::Assembly, state::AssemblyState; kwargs...)
mywrite_vtk(name, assembly::Assembly, history::Vector{<:AssemblyState}], dt;
    kwargs...)

Write the deformed geometry (and associated data) to a VTK file for visualization using ParaView.

The state argument may be omitted to write the original geometry to a VTK file without any associated data.

If the solution time history is provided, the time step must also be provided

Keyword Arguments

• sections = nothing: Cross section geometry corresponding to each point, defined in a frame aligned with the body frame but centered around the corresponding point. Defined as an array with shape (3, ncross, np) where ncross is the number of points in each cross section and np is the number of points.
• scaling=1.0: Parameter to scale the deflections (only valid if state is provided)
• metadata=Dict(): Dictionary of metadata for the file(s)

Internal, gets specified rotor speed at time

owens(owensfile,analysisType;
    delta_t=2e-3,
    numTS=100,
    tocp=[0.0,1.1],
    Omegaocp=[0.0,1.0],
    OmegaInit=0.0,
    OmegaGenStart=0.0,
    usingRotorSpeedFunction=false,
    nlOn=true,
    Omega=0.0,
    turbineStartup=0,
    spinUpOn=false,
    numModesToExtract=20,
    displInitGuess=0.0,
    airDensity=1.2041,
    aeroElasticOn = false,
    guessFreq = 0,
    gravityOn = true,
    generatorOn = false,
    omegaControl = false,
    iterationType = "NR", # nlParams
    adaptiveLoadSteppingFlag = true,
    tolerance = 1.0000e-06,
    maxIterations = 50,
    maxNumLoadSteps = 20,
    minLoadStepDelta = 0.0500,
    minLoadStep = 0.0500,
    prescribedLoadStep = 0.0,
    elementOrder = 1,
    numDOFPerNode = 6,
    platformActive = false,
    platformTurbineConnectionNodeNumber = 1,
    JgearBox =0.0,
    gearRatio = 1.0,
    gearBoxEfficiency = 1.0,
    useGeneratorFunction = false,
    generatorProps = 0.0,
    driveTrainOn = false)

Original serial and file reading method of running an analysis.

#Inputs See ?OWENS.Model and ?OWENSFEA.FEAModel

#Outputs See ?OWENS.Unsteady, ?OWENSFEA.Modal

plotMesh plots a mesh with various orthographic and isometric views plotMesh(mesh,colorstring,meshSeg)

This function plots a mesh in a 3D with isometric view.

#Input

• mesh: object containing mesh data
• colorstring: string containing color for plotting
• meshSeg: array containing number of elements per mesh segment
• ax1: handle to the 1 plot
• ax2: handle to the 2 plot
• ax3: handle to the 3 plot
• ax4: handle to the 4 plot

#Output NONE

rainflow(signal;nbins_range=10,nbins_mean=10)

Convenience function that returns the binned cycles with the corresponding ranges and means

Inputs

• signal::Array{<:Real,1}: data input
• nbins_range::Array{<:Int,1}: Number of bins for range
• nbins_mean::Array{<:Int,1}: Number of bins for mean
• m` : Wohler exponent (default is 3)
• Teq` : The equivalent number of load cycles (default is 1, but normally the time duration in seconds is used)

Outputs:

• Ncycles::Array{<:Real,2}: Summed/binned cycles with columns corresponding to mean levels and rows corresponding to range levels
• meanIntervals::Array{<:Real,1}: Mean levels corresponging with bins columns
• rangeIntervals::Array{<:Real,1}: Range levels corresponging with bins rows
• equivalentLoad::Array{<:Real,1}: Design equivalent load for each mean level

readBCdata(bcfilename,numNodes,numDOFPerNode)

This function reads the boundray condition file and stores data in the boundary condition object.

#Input

• bcfilename::string: string containing boundary condition filename
• numNodes::int: number of nodes in structural model
• numDOFPerNode::int: number of degrees of freedom per node

#Output

• BC::OWENSFEA.BC_struct: see OWENSFEA.BC_struct, object containing boundary condition data

readBladeData(filename)

This function reads blade data from file

#Input

• filename::string: string containing /path/to/bladedata.bld

#Output

• bladeData::BladeData: see ?BladeData object containing blade data

Internal, reads cactus .geom file and stores each column in an array within the CactusGeom struct

readElementData(numElements,elfile,ortfile,bldfile

Reads element data and stores data in the element data object.

#Input

• numElements::int: number of elements in structural mesh
• elfile::string: element data path/to/filename
• ortfile::string: element orientation path/to/filename
• bldfile::string: blade data path/to/filename

#Output

• el::OWENSFEA.El: see OWENSFEA.El element data object

readGeneratorProps(generatorfilename)

This function reads generator properties from file.

#Input

• generatorfilenanme::string: = string containing path/to/generatorfile

#Output

• genprops: = model object containing generator properties

readMesh(filename)

Reads the mesh file and stores data in the mesh object.

input:

• filename::string string containing mesh path/to/filename.mesh

output:

• mesh::OWENSFEA.Mesh see OWENSFEA.Mesh

readNuMadGeomCSV(WindIO_Dict)

Parameters defining the rotor (apply to all sections).

Arguments

• WindIO_Dict::String: name of the numad excel CSV file being read (!!! THE NUMAD TAB MUST BE SAVED AS A CSV FOR THIS TO WORK !!!)
• WindIO_Dict::OrderedCollections.OrderedDict{Symbol, Any}: Alternatively, the already loaded in dictionary of windio inputs

Returns

• Output::NuMad: numad structure as defined in the NuMad structure docstrings.

readNuMadMaterialsCSV(NuMadmaterialsxlscsv_file)

Parameters defining the rotor materials.

Arguments

• NuMad_materials_xlscsv_file::String: name of the numad excel CSV file being read (!!! THE NUMAD TAB MUST BE SAVED AS A CSV FOR THIS TO WORK !!!)

Returns

• Output::plyproperties: plyproperties structure as defined in the plyproperties structure docstrings.

Internal, reads modal file and returns freq, damp, and modeshapes

rigidBodyRotation(B1,B2,B3,AngleArray,AxisArray)

Performs a coordinate transformation from a local body "B"(element) frame to a common hub frame "H" via a 3-2-3 euler rotation sequence

#Input

• B1: array containing body frame 1 coordinates of points to be mapped to the hub frame
• B2: array containing body frame 2 coordinates of points to be mapped to the hub frame
• B3: array containing body frame 3 coordinates of points to be mapped to the hub frame
• AngleArray: Array of angles for Euler rotation sequence
• AxisArray: Array of axes for Euler rotation sequence

#Output

• H1: array containg hub frame 1 coordinates of points mapped to the hub frame from body frame
• H2: array containg hub frame 2 coordinates of points mapped to the hub frame from body frame
• H3: array containg hub frame 3 coordinates of points mapped to the hub frame from body frame

That is CHtoB = [M3(SweepAngle)][M2(Theta)][M3(Psi)];

run34m(inputs,feamodel,mymesh,myel,aeroForces,deformAero;steady=true,system=nothing,assembly=nothing,VTKFilename="./outvtk")

helper function that rearranges the outputs into the expected 34m output # Input * inputs::Model: see ?Model * topModel::FEAModel: see ?OWENSFEA.FEAModel * mesh::Mesh: see ?OWENSFEA.Mesh * el::El: see ?OWENSFEA.El * aeroForces::function: Fexternal, Fdof = aero(t) where Fexternal is the force on each affected mesh dof and Fdof is the corresponding DOFs affected * deformAero::function: see deformTurb(azi;newOmega=-1,newVinf=-1,bldx=-1,bldz=-1,bld_twist=-1,steady=false) * steady::bool: run steadystate with no aero or not * system: see ?GXBeam.System * assembly: see ?GXBeam.Assembly * VTKFilename::string: Unused: path and name of VTK output

# Output
* `eps_x`: strain history for eps_xx_0 for (Nbld,N_ts,mymesh.meshSeg[2]+1)
* `eps_y`: strain history for eps_xx_z like above
* `eps_z`: strain history for eps_xx_y like above
* `kappa_x`: strain history for gam_xz_0 like above
* `kappa_y`: strain history for gam_xz_y like above
* `kappa_z`: strain history for gam_xy_0 like above
* `t`: time array
* `FReactionHist`: Nodal reaction 6dof forces history
* `OmegaHist`: rotational speed array history
* `genTorque`: generator torque history
* `torqueDriveShaft`: driveshaft torque history
* `aziHist`: azimuthal history array
* `uHist`: mesh displacement history for each dof
* `epsilon_x_hist`: strain history for eps_xx_0 for each dof
* `epsilon_y_hist`: strain history for eps_xx_z for each dof
* `epsilon_z_hist`: strain history for eps_xx_y for each dof
* `kappa_x_hist`: strain history for gam_xz_0 for each dof
* `kappa_y_hist`: strain history for gam_xz_y for each dof
* `kappa_z_hist`: strain history for gam_xy_0 for each dof

runDLC(modelopt,designparams,path;runScript = OWENS.runOWENSWINDIO)

# Input
* `modelopt::OWENS.ModelingOptions`: see ?OWENS.ModelingOption
* `designparams::OWENS.Design_Data`: see ?OWENS.Design_Data
* `path`: desired path to run everything
* `runScript`: function handle to run script, defaults to OWENS.runOWENSWINDIO


# Output
* `nothing`:

simpleGenerator(generatorProps,genSpeed)

Caclulates generator torque for simple induction generator

#Input

• generatorProps object containing generator properties, see ?inputs
• genSpeed::float generator speed (Hz)

#Output

• genTorque::float generator torque

This function sorts out points where the slope changes sign

Sums the cycle count given intervals of rangeintervals and meanintervals. The rangeintervals and meanintervals are given in fraction of range size

timeIntegrateSubSystem(M,K,C,F,delta_t,u,udot,uddot)

Internal, performs integration of a system using the Newmark-Beta method (constant-average acceleration sceheme).

#Input

• M: system mass matrix
• K: system sttiffness matrix
• C: system damping matrix
• F: system force vector
• delta_t: time step
• u: displacement at beginning of time step
• udot: velocity at beginning of time step
• uddot: acceleration at beginning of time step

#Output

• unp1: displacement at end of time step
• udotnp1: velocity at end of time step
• uddotnp1: acceleration at end of time step

transMat(theta1, theta2, theta3)

Internal, computes the 3x3 transformation matrix for given input rotations. The generated matrix is the closest orthonormal matrix to the Bernoulli-Euler transformation matrix from beam theory, which assumes small rotations. A full description of this matrix is found in the "FASTCoordinateSystems.doc" document by Jason Jonkman.

Internal, simple trapezoidal rule integration

updateRotorRotation updates rotor rotation

updateRotorRotation(Irotor,Crotor,Krotor,shaftTorque,genTorque,azi_s,Omega_s,OmegaDot_s,delta_t)

Internal, updates the rotor rotation given rotor properties and external torques

#Input

• Irotor: rotor inertia
• Crotor: arbitrary rotor damping
• Krotor: arbitrary rotor stiffness
• shaftTorque: torque from external forces on rotor
• genTorque: torque from generator
• azi_s: rotor azimuth (rad) at beginning of time step
• Omega_s: rotor speed (Hz) at beginning of time step
• OmegaDot_s: rotor acceleration (Hz/s) at beginning of time step
• delta_t: time step

#Output

• azi_sp1: rotor azimuth (rad) at end of time step
• Omega_sp1: rotor speed (Hz/s) at end of time step
• OmegaDot_sp1: rotor acceleration (Hz/s) at end of time step

Internal, unused, userDefinedRotorSpeedProfile

viz(;mesh=[],meshFile="none",resultsFile="none",selectedMode=10,sf=10)

Plots the mode shapes of a mode from a modal analysis performed using the OWENS toolkit. Either send the mesh struct or the mesh filename but not both

#Input

• mesh::OWENSFEA.Mesh: Mesh struct, See ?OWENSFEA.Mesh
• meshFile::String: optional string containing mesh file name
• resultsFile::String: optional string containing results file name
• selectedMode::Int: integer denoting selected mode to plot
• sf::Float: scale factor for mode shape displacements

#Output None

writeOwensNDL(fileRoot, nodes, cmkType, cmkValues)

writes a nodal input file

#Intput

• fileRoot::string: string path to desired location with name but no extension
• nodes::int: node numbers for C/M/K
• cmkType::string: "C" "M" or "K"
• cmkValues::float: C/M/K value

#Output

• none: