{ "cells": [ { "cell_type": "markdown", "source": [ "# Getting Started\n", "\n", "\n", "\n", "In this guide we introduce you to the basic functionality of this package in a step\n", "by step manner. This is a good starting point for learning about how to use this package." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "If you haven't yet, now would be a good time to install GXBeam. It can be\n", "installed from the Julia REPL by typing `]` (to enter the package manager) and then\n", "running `add GXBeam`." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Now, that the package is installed we need to load it so that we can use it. It's also\n", "often helpful to load the LinearAlgebra package." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "using GXBeam, LinearAlgebra\n", "nothing #hide" ], "metadata": {}, "execution_count": 1 }, { "cell_type": "markdown", "source": [ "The geometry we will be working with is a rotating beam with a swept tip as pictured.\n", "\n", "![](../assets/rotating-drawing.svg)\n", "\n", "This geometry has a fixed boundary condition on the left side of the beam and rotates\n", "around a point 2.5 inches to the left of the beam. We will investigate the steady\n", "behavior of this system for a variety of rotation rates when the sweep angle is 45°.\n", "\n", "## Creating an Assembly\n", "\n", "The first step for any analysis is to create an object of type `Assembly`. This\n", "object stores the properties of each of the points and beam elements in our model.\n", "\n", "To create an object of type Assembly we need the following:\n", " - An array of points\n", " - The starting point for each beam element\n", " - The ending point for each beam element\n", " - The frame of reference for each beam element, specified as a 3x3 direction cosine matrix\n", " - The stiffness or compliance matrix for each beam element\n", " - The mass or inverse mass matrix for each beam element, for dynamic simulations\n", " - The element length and midpoint, if the element is curved\n", "\n", "We will first focus on the geometry. We start by defining the straight section of the\n", "beam. This section extends from (2.5, 0, 0) to (34, 0, 0). The local coordinate frame\n", "for this section of the beam is the same as the global coordinate frame. We will\n", "discretize this section into 10 elements.\n", "\n", "To aid with constructing the geometry we can use the `discretize_beam` function.\n", "We pass in the length, starting point, and number of elements of the beam section to the\n", "`discretize_beam` function. The function returns the lengths, endpoints,\n", "midpoints, and reference frame of each beam element." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "# straight section of the beam\n", "L_b1 = 31.5 # length of straight section of the beam in inches\n", "r_b1 = [2.5, 0, 0] # starting point of straight section of the beam\n", "nelem_b1 = 10 # number of elements in the straight section of the beam\n", "lengths_b1, xp_b1, xm_b1, Cab_b1 = discretize_beam(L_b1, r_b1, nelem_b1)\n", "nothing #hide" ], "metadata": {}, "execution_count": 2 }, { "cell_type": "markdown", "source": [ "The length of each beam element is equal since we used the number of elements to define\n", "the discretization. For more control over the discretization we can pass in the\n", "discretization directly. The following is an equally valid method for obtaining\n", "uniformly spaced beam elements." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "# normalized element endpoints in the straight section of the beam\n", "disc_b1 = range(0, 1, length=nelem_b1+1)\n", "\n", "# discretize straight beam section\n", "lengths_b1, xp_b1, xm_b1, Cab_b1 = discretize_beam(L_b1, r_b1, disc_b1)\n", "\n", "nothing #hide" ], "metadata": {}, "execution_count": 3 }, { "cell_type": "markdown", "source": [ "We now create the geometry for the swept portion of the wing. To do so we use the same\n", "`discretize_beam` function, but use the additional keyword argument `frame` in\n", "order to define the undeformed local beam frame. The direction cosine matrix which\n", "describes the local beam frame is\n", "$$\n", "\\begin{bmatrix}\n", "e_{1,x} & e_{2,x} & e_{3,x} \\\\\n", "e_{1,y} & e_{2,y} & e_{3,y} \\\\\n", "e_{1,z} & e_{2,z} & e_{3,z} \\\\\n", "\\end{bmatrix}\n", "$$\n", "where $e_1$, $e_2$, and $e_3$ are unit vectors which define\n", "the axes of the local frame of reference in the body frame of reference. This matrix\n", "may be interpreted as a transformation matrix from the undeformed local beam frame to\n", "the body frame." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "sweep = 45 * pi/180\n", "\n", "# swept section of the beam\n", "L_b2 = 6 # length of swept section of the beam\n", "r_b2 = [34, 0, 0] # starting point of swept section of the beam\n", "nelem_b2 = 5 # number of elements in swept section of the beam\n", "e1 = [cos(sweep), -sin(sweep), 0] # axis 1\n", "e2 = [sin(sweep), cos(sweep), 0] # axis 2\n", "e3 = [0, 0, 1] # axis 3\n", "frame_b2 = hcat(e1, e2, e3) # transformation matrix from local to body frame\n", "lengths_b2, xp_b2, xm_b2, Cab_b2 = discretize_beam(L_b2, r_b2, nelem_b2;\n", " frame = frame_b2)\n", "nothing #hide" ], "metadata": {}, "execution_count": 4 }, { "cell_type": "markdown", "source": [ "We will now manually combine the results of our two calls to `discretize_beam`. Since\n", "the last endpoint from the straight section is the same as the first endpoint of the\n", "swept section we drop one of the endpoints when combining our results." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "# combine elements and points into one array\n", "nelem = nelem_b1 + nelem_b2 # total number of elements\n", "points = vcat(xp_b1, xp_b2[2:end]) # all points in our assembly\n", "start = 1:nelem_b1 + nelem_b2 # starting point of each beam element in our assembly\n", "stop = 2:nelem_b1 + nelem_b2 + 1 # ending point of each beam element in our assembly\n", "lengths = vcat(lengths_b1, lengths_b2) # length of each beam element in our assembly\n", "midpoints = vcat(xm_b1, xm_b2) # midpoint of each beam element in our assembly\n", "Cab = vcat(Cab_b1, Cab_b2) # transformation matrix from local to body frame\n", " # for each beam element in our assembly\n", "nothing #hide" ], "metadata": {}, "execution_count": 5 }, { "cell_type": "markdown", "source": [ "Next we need to define the stiffness (or compliance) and mass matrices for each\n", "beam element.\n", "\n", "The compliance matrix is defined by the following equation\n", "$$\n", "\\begin{bmatrix}\n", "\\gamma_{11} \\\\\n", "2\\gamma_{12} \\\\\n", "2\\gamma_{13} \\\\\n", "\\kappa_{1} \\\\\n", "\\kappa_{2} \\\\\n", "\\kappa_{3}\n", "\\end{bmatrix}\n", "=\n", "\\begin{bmatrix}\n", " S_{11} & S_{12} & S_{13} & S_{14} & S_{15} & S_{16} \\\\\n", " S_{12} & S_{22} & S_{23} & S_{24} & S_{25} & S_{26} \\\\\n", " S_{13} & S_{23} & S_{33} & S_{34} & S_{35} & S_{36} \\\\\n", " S_{14} & S_{24} & S_{43} & S_{44} & S_{45} & S_{46} \\\\\n", " S_{15} & S_{25} & S_{35} & S_{45} & S_{55} & S_{56} \\\\\n", " S_{16} & S_{26} & S_{36} & S_{46} & S_{56} & S_{66}\n", "\\end{bmatrix}\n", "\\begin{bmatrix}\n", " F_{1} \\\\\n", " F_{2} \\\\\n", " F_{3} \\\\\n", " M_{1} \\\\\n", " M_{2} \\\\\n", " M_{3}\n", "\\end{bmatrix}\n", "$$\n", "with the variables defined as follows:\n", " - $\\gamma_{11}$: beam axial strain\n", " - $2\\gamma_{12}$ engineering transverse strain along axis 2\n", " - $2\\gamma_{13}$ engineering transverse strain along axis 3\n", " - $\\kappa_1$: twist\n", " - $\\kappa_2$: curvature about axis 2\n", " - $\\kappa_3$: curvature about axis 3\n", " - $F_i$: resultant force about axis i\n", " - $M_i$: resultant moment about axis i\n", "\n", "The mass matrix is defined using the following equation\n", "$$\n", "\\begin{bmatrix}\n", " P_{1} \\\\\n", " P_{2} \\\\\n", " P_{3} \\\\\n", " H_{1} \\\\\n", " H_{2} \\\\\n", " H_{3}\n", "\\end{bmatrix}\n", "=\n", "\\begin{bmatrix}\n", " \\mu & 0 & 0 & 0 & \\mu x_{m3} & -\\mu x_{m2} \\\\\n", " 0 & \\mu & 0 & -\\mu x_{m3} & 0 & 0 \\\\\n", " 0 & 0 & \\mu & \\mu x_{m2} & 0 & 0 \\\\\n", " 0 & -\\mu x_{m3} & \\mu x_{m2} & i_{22} + i_{33} & 0 & 0 \\\\\n", " \\mu x_{m3} & 0 & 0 & 0 & i_{22} & -i_{23} \\\\\n", " -\\mu x_{m2} & 0 & 0 & 0 & -i_{23} & i_{33}\n", "\\end{bmatrix}\n", "\\begin{bmatrix}\n", " V_{1} \\\\\n", " V_{2} \\\\\n", " V_{3} \\\\\n", " \\Omega_{1} \\\\\n", " \\Omega_{2} \\\\\n", " \\Omega_{3}\n", "\\end{bmatrix}\n", "$$\n", "with the variables defined as follows:\n", " - $P$: linear momentum per unit length\n", " - $H$: angular momentum per unit length\n", " - $V$: linear velocity\n", " - $\\Omega$: angular velocity\n", " - $\\mu$: mass per unit length\n", " - $(x_{m2}, x_{m3})$: mass center location\n", " - $i_{22}$: mass moment of inertia about axis 2\n", " - $i_{33}$: mass moment of inertia about axis 3\n", " - $i_{23}$: product of inertia\n", "\n", "We assume that our beam has a constant cross section with the following properties:\n", " - 1 inch width\n", " - 0.063 inch height\n", " - 1.06 x 10^7 lb/in^2 elastic modulus\n", " - 0.325 Poisson's ratio\n", " - 2.51 x 10^-4 lb sec^2/in^4 density\n", "\n", "We also assume the following shear and torsion correction factors:\n", " - $k_y = 1.2000001839588001$\n", " - $k_z = 14.625127919304001$\n", " - $k_t = 65.85255016982444$" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "# cross section\n", "w = 1 # inch\n", "h = 0.063 # inch\n", "\n", "# material properties\n", "E = 1.06e7 # lb/in^2\n", "ν = 0.325\n", "ρ = 2.51e-4 # lb sec^2/in^4\n", "\n", "# shear and torsion correction factors\n", "ky = 1.2000001839588001\n", "kz = 14.625127919304001\n", "kt = 65.85255016982444\n", "\n", "A = h*w\n", "Iyy = w*h^3/12\n", "Izz = w^3*h/12\n", "J = Iyy + Izz\n", "\n", "# apply corrections\n", "Ay = A/ky\n", "Az = A/kz\n", "Jx = J/kt\n", "\n", "G = E/(2*(1+ν))\n", "\n", "compliance = fill(Diagonal([1/(E*A), 1/(G*Ay), 1/(G*Az), 1/(G*Jx), 1/(E*Iyy),\n", " 1/(E*Izz)]), nelem)\n", "\n", "mass = fill(Diagonal([ρ*A, ρ*A, ρ*A, ρ*J, ρ*Iyy, ρ*Izz]), nelem)\n", "nothing #hide" ], "metadata": {}, "execution_count": 6 }, { "cell_type": "markdown", "source": [ "Our case is simple enough that we can analytically calculate most values for the\n", "compliance and mass matrices, but this is not generally the case. For more complex\n", "geometries/structures see the section of the documentation titled `Computing Stiffness and Mass Matrices`\n", "Also note that any row/column of the stiffness and/or compliance matrix which is zero\n", "will be interpreted as infinitely stiff in that degree of freedom. This corresponds to a\n", "row/column of zeros in the compliance matrix.\n", "\n", "We are now ready to put together our assembly." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "assembly = Assembly(points, start, stop;\n", " compliance = compliance,\n", " mass = mass,\n", " frames = Cab,\n", " lengths = lengths,\n", " midpoints = midpoints)\n", "nothing #hide" ], "metadata": {}, "execution_count": 7 }, { "cell_type": "markdown", "source": [ "At this point this is probably a good time to check that the geometry of our assembly\n", "is correct. We can do this by visualizing the geometry in\n", "ParaView](https://www.paraview.org/). We can use the [`write_vtk` function to\n", "do this. Note that in order to visualize the generated file yourself you will need to\n", "[install ParaView](https://www.paraview.org/download/) separately." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "mkpath(\"rotating-geometry\")\n", "write_vtk(\"rotating-geometry/rotating-geometry\", assembly)" ], "metadata": {}, "execution_count": 8 }, { "cell_type": "markdown", "source": [ "![](../assets/rotating-geometry.png)" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Point Masses\n", "\n", "We won't be applying point masses to our model, but we will demonstrate how to do so.\n", "\n", "Point masses are defined by using the constructor `PointMass` and may be attached\n", "to any point. One instance of `PointMass` must be created for every point\n", "with attached point masses. These instances of `PointMass` are then stored\n", "in a dictionary with keys corresponding to each point index.\n", "\n", "Each `PointMass` contains a 6x6 mass matrix which describes the relationship\n", "between the linear/angular velocity of the point and the linear/angular momentum\n", "of the point mass. For a single point mass, this matrix is defined as\n", "$$\n", "\\begin{bmatrix}\n", " P_{x} \\\\\n", " P_{y} \\\\\n", " P_{z} \\\\\n", " H_{x} \\\\\n", " H_{y} \\\\\n", " H_{z}\n", "\\end{bmatrix}\n", "=\n", "\\begin{bmatrix}\n", " m & 0 & 0 & 0 & m p_{z} & -m p_{y} \\\\\n", " 0 & m & 0 & -m p_{z} & 0 & m p_{x} \\\\\n", " 0 & 0 & m & m p_{y} & -m p_{x} & 0 \\\\\n", " 0 & -m p_{z} & m p_{y} & I_{xx}^* & -I_{xy}^* & -I_{xz}^* \\\\\n", " m p_{z} & 0 & -m p_{x} & -I_{xy}^* & I_{yy}^* & -I_{yz}^* \\\\\n", " -m p_{y} & m p_{x} & 0 & -I_{xz}^* & -I_{yz}^* & I_{zz}^*\n", "\\end{bmatrix}\n", "\\begin{bmatrix}\n", " V_{x} \\\\\n", " V_{y} \\\\\n", " V_{z} \\\\\n", " \\Omega_{x} \\\\\n", " \\Omega_{y} \\\\\n", " \\Omega_{z}\n", "\\end{bmatrix}\n", "$$\n", "where $m$ is the mass of the point mass, $p$ is the position of the point mass\n", "relative to the point to which it is attached, and $I^*$ is the\n", "inertia matrix corresponding to the point mass, defined relative to the point.\n", "Multiple point masses may be modeled by adding their respective mass\n", "matrices together." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Objects of type `PointMass` may be constructed by providing the fully populated\n", "mass matrix as described above or by providing the mass, offset, and inertia matrix of\n", "the point mass, with the later being the inertia matrix of the point mass about its\n", "center of gravity rather than the beam center. To demonstrate, the following code places\n", "a 10 kg tip mass at the end of our swept beam." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "m = 10 # mass\n", "p = zeros(3) # relative location\n", "J = zeros(3,3) # inertia matrix (about the point mass center of gravity)\n", "\n", "# create dictionary of point masses\n", "point_masses = Dict(\n", " nelem+1 => PointMass(m, p, J)\n", " )\n", "\n", "nothing #hide" ], "metadata": {}, "execution_count": 9 }, { "cell_type": "markdown", "source": [ "## Defining Distributed Loads\n", "\n", "We won't be applying distributed loads to our model, but we will demonstrate how to do so.\n", "\n", "Distributed loads are defined by using the constructor `DistributedLoads`. One\n", "instance of `DistributedLoads` must be created for every beam element on which\n", "the distributed load is applied. These instances of `DistributedLoads` are then\n", "stored in a dictionary with keys corresponding to each beam element index.\n", "\n", "To define a `DistributedLoads` the assembly, element number, and distributed\n", "load functions must be passed to `DistributedLoads`. Possible distributed\n", "load functions are:\n", "- `fx`: Distributed x-direction force\n", "- `fy`: Distributed y-direction force\n", "- `fz`: Distributed z-direction force\n", "- `mx`: Distributed x-direction moment\n", "- `my`: Distributed y-direction moment\n", "- `mz`: Distributed z-direction moment\n", "- `fx_follower`: Distributed x-direction follower force\n", "- `fy_follower`: Distributed y-direction follower force\n", "- `fz_follower`: Distributed z-direction follower force\n", "- `mx_follower`: Distributed x-direction follower moment\n", "- `my_follower`: Distributed y-direction follower moment\n", "- `mz_follower`: Distributed z-direction follower moment\n", "\n", "Each of these forces/moments are specified as functions of the arbitrary coordinate ``s```.\n", "The $s$-coordinate at the start and end of the beam element can be specified\n", "using the keyword arguments $s1$ and $s2$." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "For example, the following code applies a uniform 10 pound distributed load in the\n", "z-direction on all beam elements:" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "distributed_loads = Dict{Int64, DistributedLoads{Float64}}()\n", "for ielem in 1:nelem\n", " distributed_loads[ielem] = DistributedLoads(assembly, ielem; fz = (s) -> 10)\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 10 }, { "cell_type": "markdown", "source": [ "To instead use a follower force (a force that rotates with the structure) we would use\n", "the following code:" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "distributed_loads = Dict{Int64, DistributedLoads{Float64}}()\n", "for ielem in 1:nelem\n", " distributed_loads[ielem] = DistributedLoads(assembly, ielem;\n", " fz_follower = (s) -> 10)\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 11 }, { "cell_type": "markdown", "source": [ "The units are arbitrary, but must be consistent with the units used when constructing\n", "the beam assembly. Also note that both non-follower and follower forces may exist\n", "simultaneously.\n", "\n", "Note that the distributed loads are integrated over each element when they\n", "are created using 4-point Gauss-Legendre quadrature. If more control over the\n", "integration is desired one may specify a custom integration method as described in the\n", "documentation for `DistributedLoads`." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Defining Prescribed Conditions\n", "\n", "Whereas distributed loads are applied to beam elements, prescribed conditions are\n", "external loads or displacement boundary conditions applied to points. One instance of\n", "`PrescribedConditions` must be created for every point on which prescribed\n", "conditions are applied. These instances of `PrescribedConditions` are then stored in a\n", "dictionary with keys corresponding to each point index.\n", "\n", "Possible prescribed conditions include:\n", "- `ux`: Prescribed x-displacement\n", "- `uy`: Prescribed y-displacement\n", "- `uz`: Prescribed z-displacement\n", "- `theta_x`: Prescribed first Wiener-Milenkovic parameter\n", "- `theta_y`: Prescribed second Wiener-Milenkovic parameter\n", "- `theta_z`: Prescribed third Wiener-Milenkovic parameter\n", "- `Fx`: Prescribed x-direction force\n", "- `Fy`: Prescribed y-direction force\n", "- `Fz`: Prescribed z-direction force\n", "- `Mx`: Prescribed x-axis moment\n", "- `My`: Prescribed y-axis moment\n", "- `Mz`: Prescribed z-axis moment\n", "- `Fx_follower`: Prescribed x-direction follower force\n", "- `Fy_follower`: Prescribed y-direction follower force\n", "- `Fz_follower`: Prescribed z-direction follower force\n", "- `Mx_follower`: Prescribed x-direction follower moment\n", "- `My_follower`: Prescribed y-direction follower moment\n", "- `Mz_follower`: Prescribed z-direction follower moment\n", "\n", "One can apply both force and displacement boundary conditions to the same point, but one\n", "cannot specify a force and displacement condition at the same point corresponding\n", "to the same degree of freedom.\n", "\n", "Here we create a fixed boundary condition on the left side of the beam." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "# create dictionary of prescribed conditions\n", "prescribed_conditions = Dict(\n", " # root section is fixed\n", " 1 => PrescribedConditions(ux=0, uy=0, uz=0, theta_x=0, theta_y=0, theta_z=0)\n", " )\n", "\n", "nothing #hide" ], "metadata": {}, "execution_count": 12 }, { "cell_type": "markdown", "source": [ "Note that most problems should have at least one point where deflections and/or\n", "rotations are constrained in order to be well-posed." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Pre-Allocating Memory for an Analysis\n", "\n", "At this point we have everything we need to perform an analysis. However, since we will\n", "be performing multiple analyses using the same assembly we can save computational time\n", "be pre-allocating memory for the analysis. This can be done by constructing an object of\n", "type `AbstractSystem`. There are two main options: `StaticSystem` for\n", "static systems and `DynamicSystem` for dynamic systems. The third option:\n", "`ExpandedSystem` is primarily useful when constructing a constant mass matrix\n", "system for use with [`DifferentialEquations`](https://github.com/SciML/DifferentialEquations.jl)\n", "Since our system is rotating, we construct an object of type `DynamicSystem`." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "system = DynamicSystem(assembly)\n", "nothing #hide" ], "metadata": {}, "execution_count": 13 }, { "cell_type": "markdown", "source": [ "## Performing a Steady State Analysis\n", "\n", "We're now ready to perform our steady state analyses. This can be done by calling\n", "`steady_state_analysis!` with the pre-allocated system storage, assembly,\n", "angular velocity, and the prescribed point conditions. A linear analysis may be\n", "performed instead of a nonlinear analysis by using the `linear` keyword argument.\n", "The outputs from our analysis are stored in an object of type `AssemblyState`." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "rpm = 0:25:750\n", "\n", "linear_states = Vector{AssemblyState{Float64}}(undef, length(rpm))\n", "for i = 1:length(rpm)\n", "\n", " # global frame rotation\n", " w0 = [0, 0, rpm[i]*(2*pi)/60]\n", "\n", " # perform linear steady state analysis\n", " _, state, converged = steady_state_analysis!(system, assembly,\n", " angular_velocity = w0,\n", " prescribed_conditions = prescribed_conditions,\n", " linear = true)\n", "\n", " # save result\n", " linear_states[i] = state\n", "\n", "end\n", "\n", "reset_state!(system)\n", "\n", "nonlinear_states = Vector{AssemblyState{Float64}}(undef, length(rpm))\n", "for i = 1:length(rpm)\n", "\n", " # global frame rotation\n", " w0 = [0, 0, rpm[i]*(2*pi)/60]\n", "\n", " # perform nonlinear steady state analysis\n", " _, state, converged = steady_state_analysis!(system, assembly,\n", " angular_velocity = w0,\n", " prescribed_conditions = prescribed_conditions)\n", "\n", " # save result\n", " nonlinear_states[i] = state\n", "\n", "end\n", "\n", "nothing #hide" ], "metadata": {}, "execution_count": 14 }, { "cell_type": "markdown", "source": [ "## Post Processing Results\n", "\n", "We can access the fields in each instance of `AssemblyState` in order to plot\n", "various quantities of interest. This object stores an array of objects of type\n", "`PointState` in the field `points` and an array of objects of type\n", "`ElementState` in the field `elements`.\n", "\n", "The fields of `PointState` are the following:\n", " - `u`: point linear displacement\n", " - `udot`: point linear displacement rate\n", " - `theta`: point angular displacement\n", " - `thetadot`: point angular displacement rate\n", " - `V`: linear velocity\n", " - `Vdot`: linear velocity rate\n", " - `Omega`: angular velocity\n", " - `Omegadot`: angular velocity rate\n", " - `F`: externally applied forces on the point\n", " - `M`: externally applied moments on the point\n", "\n", "The fields of `ElementState` are the following:\n", " - `u`: element linear displacement\n", " - `udot`: element linear displacement rate\n", " - `theta`: element angular displacement\n", " - `thetadot`: element angular displacement rate\n", " - `V`: element linear velocity\n", " - `Omega`: element angular velocity\n", " - `Fi`: internal forces (in the local element frame)\n", " - `Mi`: internal moments (in the local element frame)" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Unless otherwise noted, all fields are expressed in a body-fixed frame. Also note that\n", "angular displacements are expressed in terms of Wiener-Milenkovic parameters.\n", "\n", "To demonstrate how these fields can be accessed we will now plot the root moment and\n", "tip deflections." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "using Plots\n", "pyplot()\n", "nothing #hide" ], "metadata": {}, "execution_count": 15 }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.PyPlotBackend() n=2}", "image/png": "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", "text/html": [ "" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-06-12T19:48:40.338346\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.1, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ] }, "metadata": {}, "execution_count": 16 } ], "cell_type": "code", "source": [ "# root moment\n", "plot(\n", " xlim = (0, 760),\n", " xticks = 0:100:750,\n", " xlabel = \"Angular Speed (RPM)\",\n", " yticks = 0.0:2:12,\n", " ylabel = \"\\$M_z\\$ at the root (lb-in)\",\n", " grid = false,\n", " overwrite_figure=false\n", " )\n", "Mz_nl = [-nonlinear_states[i].points[1].M[3] for i = 1:length(rpm)]\n", "Mz_l = [-linear_states[i].points[1].M[3] for i = 1:length(rpm)]\n", "plot!(rpm, Mz_nl, label=\"Nonlinear\")\n", "plot!(rpm, Mz_l, label=\"Linear\")" ], "metadata": {}, "execution_count": 16 }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.PyPlotBackend() n=2}", "image/png": "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", "text/html": [ "" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-06-12T19:48:41.304746\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.1, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ] }, "metadata": {}, "execution_count": 17 } ], "cell_type": "code", "source": [ "# x tip deflection\n", "plot(\n", " xlim = (0, 760),\n", " xticks = 0:100:750,\n", " xlabel = \"Angular Speed (RPM)\",\n", " ylim = (-0.002, 0.074),\n", " yticks = 0.0:0.01:0.07,\n", " ylabel = \"\\$u_x\\$ at the tip (in)\",\n", " grid = false,\n", " overwrite_figure=false\n", " )\n", "ux_nl = [nonlinear_states[i].points[end].u[1] for i = 1:length(rpm)]\n", "ux_l = [linear_states[i].points[end].u[1] for i = 1:length(rpm)]\n", "plot!(rpm, ux_nl, label=\"Nonlinear\")\n", "plot!(rpm, ux_l, label=\"Linear\")" ], "metadata": {}, "execution_count": 17 }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.PyPlotBackend() n=2}", "image/png": "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", "text/html": [ "" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-06-12T19:48:42.046133\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.1, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ] }, "metadata": {}, "execution_count": 18 } ], "cell_type": "code", "source": [ "# y tip deflection\n", "plot(\n", " xlim = (0, 760),\n", " xticks = 0:100:750,\n", " xlabel = \"Angular Speed (RPM)\",\n", " ylim = (-0.01, 0.27),\n", " yticks = 0.0:0.05:0.25,\n", " ylabel = \"\\$u_y\\$ at the tip (in)\",\n", " grid = false,\n", " overwrite_figure=false\n", " )\n", "uy_nl = [nonlinear_states[i].points[end].u[2] for i = 1:length(rpm)]\n", "uy_l = [linear_states[i].points[end].u[2] for i = 1:length(rpm)]\n", "plot!(rpm, uy_nl, label=\"Nonlinear\")\n", "plot!(rpm, uy_l, label=\"Linear\")" ], "metadata": {}, "execution_count": 18 }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.PyPlotBackend() n=2}", "image/png": "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", "text/html": [ "" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", " \n", " 2023-06-12T19:48:42.938468\n", " image/svg+xml\n", " \n", " \n", " Matplotlib v3.7.1, https://matplotlib.org/\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n" ] }, "metadata": {}, "execution_count": 19 } ], "cell_type": "code", "source": [ "# rotation of the tip\n", "plot(\n", " xlim = (0, 760),\n", " xticks = 0:100:750,\n", " xlabel = \"Angular Speed (RPM)\",\n", " ylabel = \"\\$θ_z\\$ at the tip\",\n", " grid = false,\n", " overwrite_figure=false\n", " )\n", "theta_z_nl = [4*atan(nonlinear_states[i].points[end].theta[3]/4)\n", " for i = 1:length(rpm)]\n", "theta_z_l = [4*atan(linear_states[i].points[end].theta[3]/4)\n", " for i = 1:length(rpm)]\n", "\n", "plot!(rpm, theta_z_nl, label=\"Nonlinear\")\n", "plot!(rpm, theta_z_l, label=\"Linear\")" ], "metadata": {}, "execution_count": 19 }, { "cell_type": "markdown", "source": [ "## Other Capabilities\n", "\n", "Further information about how to use this package may be obtained by looking through the\n", "examples or browsing the Public API." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "---\n", "\n", "*This notebook was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).*" ], "metadata": {} } ], "nbformat_minor": 3, "metadata": { "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.9.1" }, "kernelspec": { "name": "julia-1.9", "display_name": "Julia 1.9.1", "language": "julia" } }, "nbformat": 4 }