tilde(x)

Construct the cross product operator matrix

transform_properties(K, T)

Applies the transformation T to the stiffness or mass matrix K

rotation_parameter_scaling(θ)

Extract a scaling parameter which may be multiplied by the angular parameters to yield the Wiener-Milenkovic rotation parameters. Use of this scaling parameter allows deflections greater than 360 degrees.

get_C(θ)

Returns the transformation matrix C given the three angular parameters in θ.

get_C_θ([C, ] θ)

Calculate the derivative of the Wiener-Milenkovic transformation matrix C with respect to each of the rotation parameters in θ.

get_Q(θ)

Calculate the matrix Q as defined in the paper "Geometrically nonlinear analysis of composite beams using Wiener-Milenković parameters" by Qi Wang and Wenbin Yu given the rotational parameters in θ.

get_Q_θ(θ)
get_Q_θ(Q, θ)

Calculate the derivative of the matrix Q with respect to each of the rotation parameters in θ.

get_Qinv(θ)

Calculate the matrix inverse Qinv as defined in the paper "Geometrically nonlinear analysis of composite beams using Wiener-Milenković parameters" by Qi Wang and Wenbin Yu given the rotational parameters in θ.

get_Qinv_θ(θ)

Calculate the derivative of the matrix inverse Qinv with respect to each of the rotation parameters in θ.

get_ΔQ(θ, Δθ [, Q])

Calculate the matrix ΔQ for structural damping calculations

get_ΔQ_θ(θ, Δθ, [Q, Q_θ1, Q_θ2, Q_θ3])

Calculate the derivative of the matrix ΔQ with respect to each of the rotation parameters in θ.

mul3(A_1, A_2, A_3, b)

Return the product of a 3x3x3 tensor represented by A_1, A_2, and A_3 with the vector b.

gauss_quadrature(f, a, b)

Default gauss-quadrature function used for integrating distributed loads.

update_body_acceleration_indices!(system, prescribed_conditions)
update_body_acceleration_indices!(indices, prescribed_conditions)

Updates the state variable indices corresponding to the body frame accelerations to correspond to the provided prescribed conditions.

body_accelerations(system, x=system.x; linear_acceleration=zeros(3), angular_acceleration=zeros(3))

Extract the linear and angular acceleration of the body frame from the state vector, if applicable. Otherwise return the provided linear and angular acceleration. This function is applicable only for steady state and initial condition analyses.

point_loads(x, ipoint, icol, force_scaling, prescribed_conditions)

Extract the loads F and M of point ipoint from the state variable vector or prescribed conditions.

point_load_jacobians(x, ipoint, icol, force_scaling, prescribed_conditions)

Calculate the load jacobians F_θ, F_F, M_θ, and M_M of point ipoint.

point_displacement(x, ipoint, icol_point, prescribed_conditions)

Extract the displacements u and θ of point ipoint from the state variable vector or prescribed conditions.

point_displacement_jacobians(ipoint, prescribed_conditions)

Calculate the displacement jacobians u_u and θ_θ of point ipoint.

point_displacement_rates(dx, ipoint, icol, prescribed_conditions)

Extract the displacement rates udot and θdot of point ipoint from the rate variable vector.

point_velocity_rates(dx, ipoint, icol_point)

Extract the velocity rates Vdot and Ωdot of point ipoint from the rate variable vector.

point_velocities(x, ipoint, icol_point)

Extract the velocities V and Ω of point ipoint from the state variable vector

initial_point_displacement(x, ipoint, icol_point, prescribed_conditions,
    rate_vars)

Extract the displacements u and θ of point ipoint from the state variable vector or prescribed conditions for an initial condition analysis.

initial_point_velocity_rates(x, ipoint, icol_point, prescribed_conditions,
    Vdot0, Ωdot0, rate_vars)

Extract the velocity rates Vdot and Ωdot of point ipoint from the state variable vector or provided initial conditions. Note that Vdot and Ωdot in this case do not include any contributions resulting from body frame motion.

initial_point_displacement_jacobian(ipoint, icol_point, prescribed_conditions,
    rate_vars)

Extract the displacement jacobians u_u and θ_θ of point ipoint from the state variable vector or prescribed conditions for an initial condition analysis.

initial_point_velocity_rate_jacobian(ipoint, icol_point, prescribed_conditions,
    rate_vars)

Return the velocity rate jacobians Vdot_Vdot and Ωdot_Ωdot of point ipoint. Note that Vdot and Ωdot in this case do not include any contributions resulting from body frame motion.

static_point_properties(x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity)

Calculate/extract the point properties needed to construct the residual for a static analysis

steady_point_properties(x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity,
    linear_acceleration=(@SVector zeros(3)), angular_acceleration=(@SVector zeros(3)))

Calculate/extract the point properties needed to construct the residual for a steady state analysis

initial_point_properties(x, indices, rate_vars, force_scaling,
    assembly, ipoint, prescribed_conditions, point_masses, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration,
    u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Calculate/extract the point properties needed to construct the residual for a time domain analysis initialization.

newmark_point_properties(x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity,
    udot_init, θdot_init, Vdot_init, Ωdot_init, dt)

Calculate/extract the point properties needed to construct the residual for a newmark-scheme time stepping analysis

dynamic_point_properties(dx, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity)

Calculate/extract the point properties needed to construct the residual for a dynamic analysis

expanded_steady_point_properties(x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity,
    linear_acceleration=(@SVector zeros(3)), angular_acceleration=(@SVector zeros(3)))

Calculate/extract the point properties needed to construct the residual for a constant mass matrix system.

expanded_dynamic_point_properties(dx, x, indices, force_scaling, assembly,
    ipoint, prescribed_conditions, point_masses, gravity, linear_velocity,
    angular_velocity)

Calculate/extract the point properties needed to construct the residual for a constant mass matrix system.

point_velocity_residuals(properties)

Calculate the velocity residuals rV and rΩ for a point for a steady state analysis.

expanded_point_velocity_residuals(properties)

Calculate the velocity residuals rV and rΩ for a point for a constant mass matrix system.

static_point_resultants(properties)

Calculate the net loads F and M applied at a point for a static analysis.

dynamic_point_resultants(properties)

Calculate the net loads F and M applied at a point for a steady analysis.

expanded_point_resultants(properties)

Calculate the net loads F and M applied at a point for a constant mass matrix system.

static_point_residual!(resid, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity)

Calculate and insert the residual entries corresponding to a point for a static analysis into the system residual vector.

steady_point_residual!(resid, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity,
    linear_acceleration, angular_acceleration)

Calculate and insert the residual entries corresponding to a point for a steady state analysis into the system residual vector.

initial_point_residual!(resid, x, indices, rate_vars,
    force_scaling, assembly, ipoint, prescribed_conditions, point_masses, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration,
    u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Calculate and insert the residual entries corresponding to a point for the initialization of a time domain analysis into the system residual vector.

newmark_point_residual!(resid, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity,
    udot_init, θdot_init, Vdot_init, Ωdot_init, dt)

Calculate and insert the residual entries corresponding to a point for a newmark-scheme time marching analysis into the system residual vector.

dynamic_point_residual!(resid, dx, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity)

Calculate and insert the residual entries corresponding to a point for a dynamic analysis into the system residual vector.

expanded_steady_point_residual!(resid, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity,
    linear_acceleration, angular_acceleration)

Calculate and insert the residual entries corresponding to a point into the system residual vector for a constant mass matrix system.

expanded_dynamic_point_residual!(resid, dx, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity)

Calculate and insert the residual entries corresponding to a point into the system residual vector for a constant mass matrix system.

static_point_jacobian_properties(properties, x, indices, force_scaling, assembly,
    ipoint, prescribed_conditions, point_masses, gravity)

Calculate/extract the point properties needed to calculate the jacobian entries corresponding to a point for a static analysis

steady_point_jacobian_properties(properties, x, indices, force_scaling,
    assembly, ipoint, prescribed_conditions, point_masses, gravity,
    ub_ub, θb_θb, vb_vb, ωb_ωb, ab_ab, αb_αb)

Calculate/extract the point properties needed to calculate the jacobian entries corresponding to a point for a steady state analysis

initial_point_jacobian_properties(properties, x, indices, rate_vars,
    force_scaling, assembly, ipoint, prescribed_conditions, point_masses, gravity,
    u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Calculate/extract the point properties needed to calculate the jacobian entries corresponding to a point for a Newmark scheme time marching analysis

newmark_point_jacobian_properties(properties, x, indices, force_scaling,
    assembly, ipoint, prescribed_conditions, point_masses, gravity,
    udot_init, θdot_init, Vdot_init, Ωdot_init, dt)

Calculate/extract the point properties needed to calculate the jacobian entries corresponding to a point for a Newmark scheme time marching analysis

dynamic_point_jacobian_properties(properties, dx, x, indices, force_scaling,
    assembly, ipoint, prescribed_conditions, point_masses, gravity)

Calculate/extract the point properties needed to calculate the jacobian entries corresponding to a point for a dynamic analysis

expanded_steady_point_jacobian_properties(properties, x, indices, force_scaling,
    assembly, ipoint, prescribed_conditions, point_masses, gravity)

Calculate/extract the point properties needed to calculate the jacobian entries corresponding to a point for a constant mass matrix system

expanded_dynamic_point_jacobian_properties(properties, dx, x, indices, force_scaling,
    assembly, ipoint, prescribed_conditions, point_masses, gravity)

Calculate/extract the point properties needed to calculate the jacobian entries corresponding to a point for a constant mass matrix system

mass_matrix_point_jacobian_properties(x, indices, force_scaling,
    assembly, ipoint, prescribed_conditions, point_masses)

Calculate/extract the point properties needed to calculate the mass matrix jacobian entries corresponding to a point

expanded_mass_matrix_point_jacobian_properties(assembly, ipoint, prescribed_conditions, point_masses)

Calculate/extract the point properties needed to calculate the mass matrix jacobian entries corresponding to a point for a constant mass matrix system

static_point_resultant_jacobians(properties)

Calculate the jacobians for the net loads F and M applied at a point for a static analysis.

steady_point_resultant_jacobians(properties)

Calculate the jacobians for the net loads F and M applied at a point for a steady state analysis.

initial_point_resultant_jacobians(properties)

Calculate the jacobians for the net loads F and M applied at a point for the initialization of a time domain analysis.

dynamic_point_resultant_jacobians(properties)

Calculate the jacobians for the net loads F and M applied at a point for a dynamic analysis.

expanded_steady_point_resultant_jacobians(properties)

Calculate the jacobians for the net loads F and M applied at a point for a constant mass matrix system

expanded_dynamic_point_resultant_jacobians(properties)

Calculate the jacobians for the net loads F and M applied at a point for a constant mass matrix system

mass_matrix_point_resultant_jacobians(properties)

Calculate the mass matrix jacobians for the net loads F and M applied at a point

point_velocity_jacobians(ipoint)

Calculate the velocity jacobians V_V and Ω_Ω of point ipoint.

initial_point_velocity_jacobians(properties)

Calculate the jacobians of the velocity residuals rV and rΩ of a point for the initialization of a time domain analysis.

newmark_point_velocity_jacobians(properties)

Calculate the jacobians of the velocity residuals rV and rΩ of a point for a Newmark scheme time-marching analysis.

dynamic_point_velocity_jacobians(properties)

Calculate the jacobians of the velocity residuals rV and rΩ of a point for a dynamic state analysis.

expanded_point_velocity_jacobians(properties)

Calculate the jacobians of the velocity residuals rV and rΩ of a point for a constant mass matrix system

mass_matrix_point_velocity_jacobians(properties)

Calculate the mass matrix jacobians of the velocity residuals rV and rΩ of a point

insert_static_point_jacobians!(jacob, indices, force_scaling, ipoint, properties,
    resultants)

Insert the jacobian entries corresponding to a point for a static analysis into the system jacobian matrix.

insert_steady_point_jacobians!(jacob, indices, force_scaling, ipoint,
    properties, resultants, velocities)

Insert the jacobian entries corresponding to a point for a steady state analysis into the system jacobian matrix.

insert_initial_point_jacobians!(jacob, indices, force_scaling, ipoint, properties,
    resultants, velocities)

Insert the jacobian entries corresponding to a point for the initialization of a time domain analysis into the system jacobian matrix.

insert_dynamic_point_jacobians!(jacob, indices, force_scaling, ipoint,
    properties, resultants, velocities)

Insert the jacobian entries corresponding to a point for a steady state analysis into the system jacobian matrix.

insert_expanded_steady_point_jacobians!(jacob, indices, force_scaling, ipoint, properties,
    resultants, velocities)

Insert the jacobian entries corresponding to a point for a constant mass matrix system into the system jacobian matrix for a constant mass matrix system.

insert_expanded_dynamic_point_jacobians!(jacob, indices, force_scaling, ipoint, properties,
    resultants, velocities)

Insert the jacobian entries corresponding to a point for a constant mass matrix system into the system jacobian matrix for a constant mass matrix system.

insert_mass_matrix_point_jacobians!(jacob, gamma, indices, two_dimensional, force_scaling, ipoint,
    properties, resultants, velocities)

Insert the mass matrix jacobian entries corresponding to a point into the system jacobian matrix.

insert_expanded_mass_matrix_point_jacobians!(jacob, gamma, indices, two_dimensional, force_scaling, ipoint,
    properties, resultants, velocities)

Insert the mass matrix jacobian entries corresponding to a point into the system jacobian matrix.

static_point_jacobian!(jacob, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity)

Calculate and insert the jacobian entries corresponding to a point for a static analysis into the system jacobian matrix.

steady_point_jacobian!(jacob, x, indices, force_scaling, assembly,
    ipoint, prescribed_conditions, point_masses, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration)

Calculate and insert the jacobian entries corresponding to a point for a steady state analysis into the system jacobian matrix.

initial_point_jacobian!(jacob, x, indices, rate_vars,
    force_scaling, assembly, ipoint, prescribed_conditions, point_masses, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration,
    u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Calculate and insert the jacobian entries corresponding to a point for the initialization of a time domain analysis into the system jacobian matrix.

newmark_point_jacobian!(jacob, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity,
    udot_init, θdot_init, Vdot_init, Ωdot_init, dt))

Calculate and insert the jacobian entries corresponding to a point for a Newmark scheme time marching analysis into the system jacobian matrix.

dynamic_point_jacobian!(jacob, dx, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity)

Calculate and insert the jacobian entries corresponding to a point for a dynamic analysis into the system jacobian matrix.

expanded_steady_point_jacobian!(jacob, x, indices, force_scaling,
    assembly, ipoint, prescribed_conditions, point_masses, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration)

Calculate and insert the jacobian entries corresponding to a point for a constant mass matrix system into the system jacobian matrix.

expanded_dynamic_point_jacobian!(jacob, dx, x, indices, force_scaling, assembly, ipoint,
    prescribed_conditions, point_masses, gravity, linear_velocity, angular_velocity)

Calculate and insert the jacobian entries corresponding to a point for a constant mass matrix system into the system jacobian matrix.

mass_matrix_point_jacobian!(jacob, gamma, x, indices, two_dimensional, force_scaling, assembly,
    ipoint, prescribed_conditions)

Calculate and insert the mass_matrix jacobian entries corresponding to a point into the system jacobian matrix.

expanded_mass_matrix_point_jacobian!(jacob, gamma, indices, two_dimensional, force_scaling, assembly,
    ipoint, prescribed_conditions, point_masses)

Calculate and insert the mass_matrix jacobian entries corresponding to a point into the system jacobian matrix for a constant mass matrix system

Element{TF}

Composite type that defines a beam element's properties

Fields

• L: Beam element length
• x: Beam element location
• compliance: Beam element compliance matrix
• mass: Beam element mass matrix
• Cab: Transformation matrix from the undeformed beam element frame to the body frame
• mu: Beam element damping coefficients

element_loads(x, ielem, icol_elem, force_scaling)

Extract the internal loads (F, M) for a beam element from the state variable vector. These loads are expressed in the deformed element frame.

expanded_element_loads(x, ielem, icol_elem, force_scaling)

Extract the internal loads of a beam element at its endpoints (F1, M1, F2, M2) from the state variable vector for a constant mass matrix system.

expanded_element_velocities(x, ielem, icol_elem)

Extract the velocities of a beam element from the state variable vector for a constant mass matrix system.

static_element_properties(x, indices, force_scaling, assembly, ielem,
    prescribed_conditions, gravity)

Calculate/extract the element properties needed to construct the residual for a static analysis

steady_element_properties(x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, gravity, linear_velocity, angular_velocity,
    linear_acceleration=(@SVector zeros(3)), angular_acceleration=(@SVector zeros(3)))

Calculate/extract the element properties needed to construct the residual for a steady state analysis

initial_element_properties(x, indices, rate_vars, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration, u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Calculate/extract the element properties needed to construct the residual for a time-domain analysis initialization

newmark_element_properties(x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, gravity, linear_velocity, angular_velocity,
    Vdot_init, Ωdot_init, dt)

Calculate/extract the element properties needed to construct the residual for a newmark- scheme time stepping analysis

dynamic_element_properties(dx, x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, gravity, linear_velocity, angular_velocity)

Calculate/extract the element properties needed to construct the residual for a dynamic analysis

expanded_steady_element_properties(x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, gravity, linear_velocity, angular_velocity,
    linear_acceleration=(@SVector zeros(3)), angular_acceleration=(@SVector zeros(3)))

Calculate/extract the element properties needed to construct the residual for a constant mass matrix system

expanded_dynamic_element_properties(dx, x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, gravity, linear_velocity, angular_velocity)

Calculate/extract the element properties needed to construct the residual for a constant mass matrix system

compatibility_residuals(properties)

Calculate the compatibility residuals for the beam element

expanded_element_velocity_residuals(properties)

Calculate the velocity residuals rV and rΩ of a beam element for a constant mass matrix system.

expanded_element_equilibrium_residuals(properties, distributed_loads, ielem)

Calculate the equilibrium residuals of a beam element for a constant mass matrix system.

static_element_resultants(properties, distributed_loads, ielem)

Calculate the resultant loads applied at each end of a beam element for a static analysis.

dynamic_element_resultants(properties, distributed_loads, ielem)

Calculate the resultant loads applied at each end of a beam element for a steady state analysis.

expanded_element_resultants(properties)

Calculate the resultant loads applied at each end of a beam element for a constant mass matrix system.

insert_element_residuals!(resid, indices, force_scaling, assembly, ielem,
    compatibility, resultants)

Insert the residual entries corresponding to a beam element into the system residual vector.

insert_expanded_element_residuals!(resid, indices, force_scaling, assembly, ielem,
    compatibility, velocities, equilibrium, resultants)

Insert the residual entries corresponding to a beam element into the system residual vector for a constant mass matrix system.

static_element_residual!(resid, x, indices, force_scaling, assembly, ielem,
    prescribed_conditions, distributed_loads, gravity)

Calculate and insert the residual entries corresponding to a beam element for a static analysis into the system residual vector.

steady_element_residual!(resid, x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, distributed_loads, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration)

Calculate and insert the residual entries corresponding to a beam element for a steady state analysis into the system residual vector.

initial_element_residual!(resid, x, indices, rate_vars,
    force_scaling, structural_damping, assembly, ielem, prescribed_conditions,
    distributed_loads, gravity, linear_velocity, angular_velocity,
    linear_acceleration, angular_acceleration, u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Calculate and insert the residual entries corresponding to a beam element for the initialization of a time domain simulation into the system residual vector.

newmark_element_residual!(resid, x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, distributed_loads, gravity,
    linear_velocity, angular_velocity, Vdot_init, Ωdot_init, dt)

Calculate and insert the residual entries corresponding to a beam element for a newmark-scheme time marching analysis into the system residual vector.

dynamic_element_residual!(resid, dx, x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, distributed_loads, gravity,
    linear_velocity, angular_velocity)

Calculate and insert the residual entries corresponding to a beam element for a dynamic analysis into the system residual vector.

expanded_steady_element_residual!(resid, x, indices, force_scaling, structural_damping,
    assembly, ielem, prescribed_conditions, distributed_loads, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration)

Calculate and insert the residual entries corresponding to a beam element for a constant mass matrix system into the system residual vector.

expanded_dynamic_element_residual!(resid, dx, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, distributed_loads,
    gravity, linear_velocity, angular_velocity)

Calculate and insert the residual entries corresponding to a beam element for a constant mass matrix system into the system residual vector.

static_element_jacobian_properties(properties, x, indices, force_scaling,
    assembly, ielem, prescribed_conditions, gravity)

Calculate/extract the element properties needed to calculate the jacobian entries corresponding to a beam element for a static analysis

steady_element_jacobian_properties(properties, x, indices,
    force_scaling, structural_damping, assembly, ielem, prescribed_conditions,
    gravity)

Calculate/extract the element properties needed to calculate the jacobian entries corresponding to a element for a steady state analysis

initial_element_jacobian_properties(properties, x, indices, rate_vars,
    force_scaling, structural_damping, assembly, ielem, prescribed_conditions, gravity,
    u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Calculate/extract the element properties needed to calculate the jacobian entries corresponding to a element for a Newmark scheme time marching analysis

newmark_element_jacobian_properties(properties, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, gravity,
    Vdot_init, Ωdot_init, dt)

Calculate/extract the element properties needed to calculate the jacobian entries corresponding to a element for a Newmark scheme time marching analysis

dynamic_element_jacobian_properties(properties, dx, x, indices,
    force_scaling, assembly, ielem, prescribed_conditions, gravity)

Calculate/extract the element properties needed to calculate the jacobian entries corresponding to a element for a dynamic analysis

expanded_element_jacobian_properties(properties, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, gravity)

Calculate/extract the element properties needed to calculate the jacobian entries corresponding to a element for a steady state analysis

expanded_dynamic_element_jacobian_properties(properties, dx, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, gravity)

Calculate/extract the element properties needed to calculate the jacobian entries corresponding to a element for a dynamic analysis

mass_matrix_element_jacobian_properties(x, indices, force_scaling,
assembly, ielem, prescribed_conditions)

Calculate/extract the element properties needed to calculate the mass matrix jacobian entries corresponding to a beam element

expanded_mass_matrix_element_jacobian_properties(assembly, ielem, prescribed_conditions)

Calculate/extract the element properties needed to calculate the mass matrix jacobian entries corresponding to a beam element for a constant mass matrix system

expanded_element_velocity_jacobians(properties)

Calculate the jacobians of the element velocity residuals for a constant mass matrix system.

expanded_steady_element_equilibrium_jacobians(properties)

Calculate the jacobians of the element equilibrium residuals for a constant mass matrix system.

expanded_dynamic_element_equilibrium_jacobians(properties)

Calculate the jacobians of the element equilibrium residuals for a constant mass matrix system.

expanded_mass_matrix_element_equilibrium_jacobians(properties)

Calculate the mass matrix jacobians for the resultant loads applied at each end of a beam element for a constant mass matrix system

static_element_resultant_jacobians(properties, distributed_loads, ielem)

Calculate the jacobians for the resultant loads applied at each end of a beam element for a static analysis.

steady_element_resultant_jacobians(properties, distributed_loads, ielem)

Calculate the jacobians for the resultant loads applied at each end of a beam element for a steady state analysis.

initial_element_resultant_jacobians(properties, distributed_loads, ielem)

Calculate the jacobians for the resultant loads applied at each end of V beam element for the initialization of a time domain analysis.

dynamic_element_resultant_jacobians(properties, distributed_loads, ielem)

Calculate the jacobians for the resultant loads applied at each end of a beam element for a dynamic analysis.

expanded_element_resultant_jacobians(properties)

Calculate the jacobians for the resultant loads applied at each end of a beam element for a constant mass matrix system.

mass_matrix_element_resultant_jacobians(properties)

Calculate the mass matrix jacobians for the resultant loads applied at each end of a beam element

static_element_jacobian!(jacob, x, indices, force_scaling,
    assembly, ielem, prescribed_conditions, distributed_loads, gravity)

Calculate and insert the jacobian entries corresponding to a beam element for a static analysis into the system jacobian matrix.

steady_element_jacobian!(jacob, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, distributed_loads,
    gravity, linear_velocity, angular_velocity, linear_acceleration, angular_acceleration)

Calculate and insert the jacobian entries corresponding to a beam element for a steady state analysis into the system jacobian matrix.

initial_element_jacobian!(jacob, x, indices, rate_vars, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, distributed_loads,
    gravity, ub, θb, vb, ωb, ab, αb, u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Calculate and insert the jacobian entries corresponding to a beam element for the initialization of a time domain analysis into the system jacobian matrix.

newmark_element_jacobian!(jacob, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, distributed_loads,
    gravity, linear_velocity, angular_velocity, Vdot_init, Ωdot_init, dt)

Calculate and insert the jacobian entries corresponding to a beam element for a Newmark-scheme time marching analysis into the system jacobian matrix.

dynamic_element_jacobian!(jacob, dx, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, distributed_loads,
    gravity, linear_velocity, angular_velocity)

Calculate and insert the jacobian entries corresponding to a beam element for a dynamic analysis into the system jacobian matrix.

expanded_steady_element_jacobian!(jacob, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, distributed_loads,
    gravity, linear_velocity, angular_velocity, linear_acceleration,
    angular_acceleration)

Calculate and insert the jacobian entries corresponding to a beam element for a dynamic analysis into the system jacobian matrix.

expanded_dynamic_element_jacobian!(jacob, dx, x, indices, force_scaling,
    structural_damping, assembly, ielem, prescribed_conditions, distributed_loads,
    gravity, linear_velocity, angular_velocity)

Calculate and insert the jacobian entries corresponding to a beam element for a dynamic analysis into the system jacobian matrix.

mass_matrix_element_jacobian!(jacob, gamma, x, indices, two_dimensional, force_scaling, assembly,
    ielem, prescribed_conditions)

Calculate and insert the mass_matrix jacobian entries corresponding to a beam element into the system jacobian matrix.

expanded_mass_matrix_element_jacobian!(jacob, gamma, indices, two_dimensional, force_scaling, assembly,
    ielem, prescribed_conditions)

Calculate and insert the mass_matrix jacobian entries corresponding to a beam element into the system jacobian matrix for a constant mass matrix system

SystemIndices

Structure for holding indices for accessing the state variables and equations associated with each point and beam element in a system.

default_force_scaling(assembly)

Defines a suitable default force scaling factor based on the nonzero elements of the compliance matrices in assembly.

curve_triad(Cab, k, s)
curve_triad(Cab, kkt, ktilde, kn, s)

Return the transformation matrix at s along the length of the beam given the curvature vector k and the initial transformation matrix Cab.

curve_coordiantes(r, Cab, k, s)
curve_coordinates(r, Cab, kkt, ktilde, kn, s)

Return the coordinates at s along the length of the beam given the starting point r, initial transformation matrix Cab, and curvature vector k.

set_initial_state!([x=system.x,] system, rate_vars, assembly, state; kwargs...)

Set the state variables in x for an initial condition analysis to the values in state

two_dimensional_residual!(resid, x)

Modify the residual to constrain the results of an analysis to the x-y plane.

static_system_residual!(resid, x, indices, two_dimensional, force_scaling,
    assembly, prescribed_conditions, distributed_loads, point_masses, gravity)

Populate the system residual vector resid for a static analysis

initial_system_residual!(resid, x, indices, rate_vars1, rate_vars2,
    two_dimensional, force_scaling, structural_damping, assembly, prescribed_conditions,
    distributed_loads, point_masses, gravity, linear_velocity, angular_velocity,
    linear_acceleration, angular_acceleration, u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Populate the system residual vector resid for the initialization of a time domain simulation.

steady_system_residual!(resid, x, indices, two_dimensional, force_scaling,
    structural_damping, assembly, prescribed_conditions, distributed_loads,
    point_masses, gravity, vb, ωb, ab, αb)

Populate the system residual vector resid for a steady state analysis

newmark_system_residual!(resid, x, indices, two_dimensional, force_scaling, structural_damping,
    assembly, prescribed_conditions, distributed_loads, point_masses, gravity,
    linear_velocity, angular_velocity, udot_init, θdot_init, Vdot_init, Ωdot_init, dt)

Populate the system residual vector resid for a Newmark scheme time marching analysis.

dynamic_system_residual!(resid, dx, x, indices, two_dimensional, force_scaling,
    structural_damping, assembly, prescribed_conditions, distributed_loads,
    point_masses, gravity, linear_velocity, angular_velocity)

Populate the system residual vector resid for a general dynamic analysis.

expanded_steady_system_residual!(resid, x, indices, two_dimensional, force_scaling, structural_damping,
    assembly, prescribed_conditions, distributed_loads, point_masses, gravity,
    linear_velocity, angular_velocity, linear_acceleration, angular_acceleration)

Populate the system residual vector resid for a constant mass matrix system.

expanded_dynamic_system_residual!(resid, dx, x, indices, two_dimensional, force_scaling,
    structural_damping, assembly, prescribed_conditions, distributed_loads,
    point_masses, gravity, linear_velocity, angular_velocity)

Populate the system residual vector resid for a constant mass matrix system.

two_dimensional_jacobian!(jacob, x)

Modify the jacobian to constrain the results of an analysis to the x-y plane.

static_system_jacobian!(jacob, x, indices, two_dimensional, force_scaling,
    assembly, prescribed_conditions, distributed_loads, point_masses, gravity)

Populate the system jacobian matrix jacob for a static analysis

steady_system_jacobian!(jacob, x, indices, two_dimensional, force_scaling,
    structural_damping, assembly, prescribed_conditions, distributed_loads,
    point_masses, gravity, linear_velocity, angular_velocity, linear_acceleration,
    angular_acceleration)

Populate the system jacobian matrix jacob for a steady-state analysis

initial_system_jacobian!(jacob, x, indices, rate_vars1, rate_vars2, two_dimensional, force_scaling,
    structural_damping, assembly, prescribed_conditions, distributed_loads,
    point_masses, gravity, linear_velocity, angular_velocity, linear_acceleration,
    angular_acceleration, u0, θ0, V0, Ω0, Vdot0, Ωdot0)

Populate the system jacobian matrix jacob for the initialization of a time domain simulation.

newmark_system_jacobian!(jacob, x, indices, two_dimensional, force_scaling, structural_damping,
    assembly, prescribed_conditions, distributed_loads, point_masses, gravity,
    linear_velocity, angular_velocity, udot_init, θdot_init, Vdot_init, Ωdot_init, dt)

Populate the system jacobian matrix jacob for a Newmark scheme time marching analysis.

dynamic_system_jacobian!(jacob, dx, x, indices, two_dimensional, force_scaling,
    structural_damping, assembly, prescribed_conditions, distributed_loads,
    point_masses, gravity, linear_velocity, angular_velocity)

Populate the system jacobian matrix jacob for a general dynamic analysis.

expanded_steady_system_jacobian!(jacob, x, indices, two_dimensional, force_scaling, structural_damping,
    assembly, prescribed_conditions, distributed_loads, point_masses, gravity,
    ub_p, θb_p, vb_p, ωb_p, ab_p, αb_p)

Populate the system jacobian matrix jacob for a general dynamic analysis with a constant mass matrix system.

expanded_dynamic_system_jacobian!(jacob, dx, x, indices, two_dimensional, force_scaling, structural_damping,
    assembly, prescribed_conditions, distributed_loads, point_masses, gravity,
    linear_velocity, angular_velocity)

Populate the system jacobian matrix jacob for a general dynamic analysis with a constant mass matrix system.

system_mass_matrix!(jacob, x, indices, two_dimensional, force_scaling,  assembly,
    prescribed_conditions, point_masses)

Calculate the jacobian of the residual expressions with respect to the state rates.

system_mass_matrix!(jacob, gamma, x, indices, two_dimensional, force_scaling, assembly,
    prescribed_conditions, point_masses)

Calculate the jacobian of the residual expressions with respect to the state rates and add the result multiplied by gamma to jacob.

expanded_system_mass_matrix(system, assembly;
    two_dimensional = false,
    prescribed_conditions=Dict{Int, PrescribedConditions}(),
    point_masses=Dict{Int, PointMass}())

Calculate the jacobian of the residual expressions with respect to the state rates for a constant mass matrix system.

expanded_system_mass_matrix!(jacob, indices, two_dimensional, force_scaling,  assembly, prescribed_conditions,
    point_masses)

Calculate the jacobian of the residual expressions with respect to the state rates.

expanded_system_mass_matrix!(jacob, gamma, indices, two_dimensional, force_scaling, assembly,
    prescribed_conditions, point_masses)

Calculate the jacobian of the residual expressions with respect to the state rates and add the result multiplied by gamma to jacob.

initialize_system!(system, assembly, tvec; kwargs...)

Pre-allocate the history for a stepped time-domain analysis and conduct the initial condition analysis.

step_system!(history, system, assembly, tvec; kwargs...)

A similar function to timedomainanalysis, but instead history is already allocated and it only takes one step with the system.

Inputs

• system::DynamicSystem : The dynamic system to be stepped.
• paug: The augmented parameter vector.
• x: The current state vector.
• constants: The constants tuple.
• initial_state: The initial state of the system.
• assembly: The assembly of the system.
• tvec: The time vector.
• i: The current time step index.
• prescribed_conditions: A dictionary of prescribed conditions.
• distributed_loads: A dictionary of distributed loads.
• point_masses: A dictionary of point masses.
• linear_velocity: The linear velocity of the body frame.
• angular_velocity: The angular velocity of the body frame.
• linear_acceleration: The linear acceleration of the body frame.
• angular_acceleration: The angular acceleration of the body frame.
• gravity: The gravity vector in the body frame.
• structural_damping: A flag indicating whether to enable structural damping.
• linear: A flag indicating whether a linear analysis should be performed.
• show_trace: A flag indicating whether to display the solution progress.
• update_linearization: A flag indicating whether to update the linearization state variables for a linear analysis with the instantaneous state variables.
• xpfunc: A function that returns parameters as a function of the state variables.
• pfunc: A function that returns parameters as a function of time.
• p: Sensitivity parameters.
• converged: A reference to a boolean indicating whether the solution converged.

take_step(x, dx, system, assembly, t, tprev, 
prescribed_conditions, distributed_loads, point_masses,
gravity, linear_velocity, angular_velocity,
xpfunc, pfunc, p,
structural_damping, two_dimensional)

Take a single implicit Euler time step for the given system.

simulate(assembly, tvec; prescribed_conditions, distributed_loads, point_masses, gravity, linear_velocity, angular_velocity,
xpfunc, pfunc, p, structural_damping, two_dimensional, verbose)

Use the takestep function to run a timedomain_analysis.

WARNING: The implicit Euler method is not as stable as the Newmark-beta method. You may experience instability for stiff systems or large time steps.

SectionCache{TM, TSM, TMF, TSMF, TAF, TSAF}

Internal cache for section properties

area_and_centroid_of_element(node)

Compute area and centroid of an element specified by its four nodes

Modify number of layers based on a given maximum thickness

given nodes/elements for upper surface and lower surface separately, combine into one set making sure to reuse the common nodes that occur at the LE/TE

create nodes and elements for half (upper or lower) portion of airfoil

rotate_ply_to_element(Q, theta)

Rotate constitutive matrix Q by ply angle theta

add new point xn into existing airfoil coordinates x, y. Used to ensure breakpoints are in airfoil mesh. assumes x is already sorted (and thus represents either upper or lower half)

determine tangential direction for each point on airfoil (as a normal vector with magnitudes tx and ty). keyword signifies whether this is the upper or lower surface

element_orientation(nodes)

Calculate the orientation beta of a single element using its nodes. Return cos(beta) and sin(beta)

element_submatrix(element, nodes)

Performs 2-point Gauss quadrature of one element

add the nodes and elements for the webs. given the x locations (by idx) where the webs start and the number of grid points in the webs.

determine where web intersects the inner surface curves. creates a new discretization where points are added to line up with the vertical mesh in the web. also returns the x vector index where the web mesh should start

airfoil coordinates xaf, yaf are assumed to start at trailing edge and traverse counterclockwise back to trailing edge. (thus upper surface first) coordinates are also assumed to be chord-normalized so that xaf is between 0 and 1. xbreak is a vector defining locations that need to be inserted into airfoil coordinates (for upper and lower surfaces) ds is a desired spacing for resampling (set ds=nothing to not resample) Alternatively can use vector nseg to define number of points in each interval between xbreak (see resample())

Method separates airfoil into upper and lower surfaces, adds in break points, and optionally resamples.

node2idx(nodenums)

Convenience function to map node numbers to locations in global matrix.

node2idx!(idx, nodenums)

In-place version of node2idx.

reorder(K)

Reorder stiffness or compliance matrix from internal order to GXBeam order

determine curve for inner surface to find intersections at trailing edge and with webs

elementQ(material, theta, cbeta, sbeta)

Calculate element constitutive matrix Q accounting for fiber orientation theta and element orientation beta (where cbeta = cos(beta) and sbeta=sin(beta))

resample airfoil coordinates x, y with linear interpolation, making sure to exactly hit the points in vector xbreak (e.g., [0, 0.2, 0.4, 0.7, 1.0]). ds defines the target size between coordinates (rounded to nearnest number of grid points). assumes x is already sorted (and thus represents either upper or lower half or airfoil coordinates) points in xbreak do not have to exist in the original x vector alternatively you can define nseg, a vector of size: length(xbreak) - 1, defining how many points to use in each interval (e.g., [15, 20, 40, 30]) If nseg is provided then ds is ignored. During optimization either keep mesh fixed, or if changes are needed, then nseg should be used rather than ds to avoid discrete changes.

stiffness(material)

Construct constitutive matrix Q for the specified material (with the internal ordering).

convert segments to all have the same number of layers for ease in meshing. Overall definition remains consistent, just break up some thicker layers into multiple thinner layers (with same material and orientation properties)

linearsolve(A, B; kwargs...)

Linear solve which is overloaded with analytic derivatives. Returns the factorized matrix Afact and the result of the linear solve X.

rotate_element_to_beam(Q, c, s)

Rotate constitutive matrix Q by element orientation beta where c = cos(beta) and s = sin(beta)

element_integrand(ksi, eta, element, nodes)

Compute the integrand for a single element with a given ksi, eta.

given curves for inner surfaces, find where they intersect (if they intersect), for handling trailing-edge mesh returns index of upper and lower surface where the trailing-edge-mesh should start (before intersection). also returns the x, y location of intersection.

mesh_area(nodes, elements)

Compute total area of the mesh.

Inputs

• nodes::Vector{Node{TF}}: all the nodes in the mesh
• elements::Vector{MeshElement{TF}}: all the elements in the mesh

Returns

• A::TF: total area of the mesh

mesh_cylinder(R, thickness, material)

A simple function to mesh a circular cross-section.

Inputs

• r::Vector{Float} - A vector of all the radial location of nodes. Assumed from least to greatest.
• materials::Vector{Material} - All of the materials used in the cross section.
• material_idx::Vector{Int} - The index of the material in the materials vector for each layer.

Assumed in order of outermost layer to inner most layer. Note: This is opposite to the order of r.

• plyangles::Vector{Float} - The ply angle of a given radial element (same order as material_idx).
• nt::Int - Number of tangential points (How many elements around the circle).