Common fixity types

Inactive DOF w/r/t plane

Define loads applied to structure/elements

BridgeElement(elementStart::Element, posStart::Float64, elementEnd::Element, posEnd::Float64, section::Section, id = :element; release = :fixedfixed)

Create a bridge element between two frame elements. Connects from elementStart at a position elementStart.length * posStart away from elementStart.nodeStart.position to elementEnd at elementEnd.length * posEnd away from elementEnd.nodeStart.position. IE posStart, posEnd ∈ ]0, 1[

Element(nodes::Vector{Node}, nodeIndex::Vector{Int64}, section::Section, id::Symbol = nothing; release = :fixedfixed)
Element(nodeStart::Node, nodeEnd::Node, section::Section, id = :element; release = :fixedfixed)

Create a frame element with an optional id tag.

Example

julia> Element(nodes, [1,2], sec)
julia> Element(node1, node2, sec, :groundfloor_element)

Optional argument release

This property enables decoupling of nodal DOFs with respect to the end of the element.

Available releases:

• :fixedfixed (default) - all DOFs are tied to nodes
• :fixedfree - rotational DOFs are released at end node
• :freefixed - rotational DOFs are released at start node
• :freefree - all rotational DOFs are released (truss element)
• :joist - all rotational DOFs except torsion are released

Example

julia> Element(nodes, [1,2], sec; release = :fixedfree)

FDMelement(points::Vector{FDMnode}, iStart::Int64, iEnd::Int64, q::Real, id = :element)
FDMelement(points::Vector{FDMnode}, indices::Vector{Int64}, q::Real, id = :element)
FDMelement(pointStart::FDMnode, pointEnd::FDMnode, q::Real, id = :element)

An element in a Force Density Method network that connects two nodes with force density q and an optional identifier id::Symbol

FDMload(points::Vector{FDMnode}, i::Int64, force::Vector{<:Real})
FDMload(point::FDMnode, force::Vector{<:Real})

An external force applied to a FDM node: load = [Px, Py, Pz]

FDMnode(x::Real, y::Real, z::Real, dof::Bool, id = :node)
FDMnode(pos::Vector{<:Real}, dof::Bool, id = :node)

A node in an FDM network defined by its spatial position [x, y, z] and degree of freedom (free = true, fixed = false)

Fields

• position::Vector{Float64}: the [x,y,z] position of the node
• dof::Bool: true = free; false = fixed
• id::Symbol: identifier (optional)
• nodeID::Integer: global indentifier (internal)
• reaction::Vector{Float64}: the [x,y,z] reaction forces if node is fixed

GravityLoad(element::Element, factor::Float64)

A gravity load (negative global Z) applied along a member.

Generates distributed load w = element.section.A * element.section.ρ * factor, where factor should be the appropriate acceleration due to gravity.

LineLoad(element::Element, value::Vector{Float64})

A distributed line load [wx, wy, wz] in (force/length) applied along an element in the global coordinate system.

Material(E::Float64, G::Float64, ρ::Float64, ν::Float64)

Define a structural material.

Fields

• E Modulus of Elasticity [Force/distance²]
• G Shear Modulus [Force/distance²]
• ρ Density [Mass/distance³]
• ν Poisson's Ratio [unitless]

Model(nodes::Vector{Node}, elements::Vector{Element}, loads::Vector{AbstractLoad})

Create a complete structural model ready for analysis.

Network(nodes::Vector{FDMnode}, elements::Vector{FDMelement}, loads::Vector{FDMload})

A FDM network defined by a collection of nodes, elements, and loads.

Fields

• nodes::Vector{FDMnode} collection of nodes in network
• elements::Vector{FDMelement} collection of elements in network
• loads::Vector{FDMload} collection of external loads in network
• q::Vector{<:Real} vector of elemental force densities [n_e × 1]
• Q::SparseMatrixCSC{Float64, Int64} diagonalized sparse matrix of q [ne × ne]
• C::SparseMatrixCSC{Int64, Int64} element/node connectivity matrix [ne × nn]
• N::Vector{Int64} vector of free node indices
• F::Vector{Int64} vector of fixed node indices
• Cn::SparseMatrixCSC{Int64, Int64} connectivity matrix of free nodes = C[:, N]
• Cf::SparseMatrixCSC{Int64, Int64} connectivity matrix of fixed nofes = C[:. F]
• P::Matrix{<:Real} external load matrix [n_n × 3]
• Pn::Matrix{<:Real} loads applied to free nodes = P[N, :]
• xyz::Matrix{<:Real} positions of all nodes [n_n × 3]

Node(position::Vector{Float64}, dofs::Vector{Bool}, id::Symbol = nothing)

Instantiate a 6 DOF node with given position and fixities. Optional symbol identifier, id.

Example

julia> Node([4.3, 2.2, 10.4], [true, true, false, true, false, false])
Node([4.3, 2.2, 10.4], Bool[1, 1, 0, 1, 0, 0], #undef, #undef, #undef, nothing)

Node(position::Vector{Float64}, fixity::Symbol, id::Symbol = nothing)

Instantiate a 6 DOF node with given position and common boundary type. Optional symbol identifier, id.

Available boundary conditions:

• :free
• :fixed
• :pinned
• :(x/y/z)free
• :(x/y/z)fixed

Example

julia> Node([4.3, 2.2, 10.4], :zfixed)
Node([4.3, 2.2, 10.4], Bool[1, 1, 0, 1, 1, 1], #undef, #undef, #undef, nothing)

NodeForce(node::AbstractNode, value::Vector{Float64})
NodeForce(nodes::Vector{<:AbstractNode}, index::Integer, value::Vector{Float64})

A force vector [Fx, Fy, Fz] in the global coordinate system applied to a node.

NodeMoment(node::Node, value::Vector{Float64})

A moment vector [Mx, My, Mz] in the global coordinate system applied to a node with rotational DOFs.

PointLoad(element::Element, position::Float64, value::Vector{Float64})

A point load [Px, Py, Pz] applied in the global coordinate system at a distance position × element.length from the starting node.

Section(A::Float64, E::Float64, G::Float64, Ix::Float64, Iy::Float64, J::Float64, ρ::Float64 = 1.)
Section(mat::Material, A::Float64, Ix::Float64, Iy::Float64, J::Float64)

A cross section assigned to an element.

Fields

• A Area [Distance²]
• E Modulus of Elasticity [Force/Distance²]
• Ix Nominal strong moment of inertia [Distance⁴]
• Iy Nominal weak moment of inertia [Distance⁴]
• J Torsional constant [Distance⁴]
• ρ=1 Density [Mass/Distance³]

TrussElement(nodes::Vector{TrussNode}, nodeIndex::Vector{Int64}, section::AbstractSection, id = :element)
TrussElement(nodeStart::TrussNode, nodeEnd::TrussNode, section::AbstractSection, id = :element)

Create a truss element.

Example

julia> TrussElement(nt, [1,2], sec)
TrussElement(Section(794.0, 200000.0, 77000.0, 737000.0, 737000.0, 1.47e6, 1.0), [1, 2], TrussNode([0.8879630592102802, 0.6713937498337156, 0.617463764682365], Bool[0, 0, 0], #undef, [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], nothing), TrussNode([0.16046742214916832, 0.15869760269854827, 0.6247762072043447], Bool[1, 1, 1], #undef, [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], nothing), #undef, 0.8900341077991537, #undef, #undef, #undef, 1.5707963267948966, #undef, nothing)

TrussModel(nodes::Vector{TrussNode}, elements::Vector{TrussElement}, loads::Vector{NodeForce})

Create a complete structural model ready for analysis.

TrussNode(position::Vector{Float64}, dofs::Vector{Bool}, id::Symbol = nothing)

Instantiate a 3 DOF node with given position and fixities. Optional symbol identifier, id.

Example

julia> TrussNode([1., 1., 56.], [false, true, true])
TrussNode([1.0, 1.0, 56.0], Bool[0, 1, 1], #undef, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], nothing)

TrussNode(position::Vector{Float64}, fixity::Symbol, id::Symbol = nothing)

Instantiate a 3 DOF node with given position and common boundary type. Optional symbol identifier, id.

Available boundary conditions:

• :free
• :pinned
• :(x/y/z)free
• :(x/y/z)fixed

Example

julia> TrussNode([1., 1., 56.], :pinned)
TrussNode([1.0, 1.0, 56.0], Bool[0, 0, 0], #undef, [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], nothing)

TrussSection(A::Float64, E::Float64)
TrussSection(mat::Material, A::Float64)

A cross section assigned to a truss element.

Fields

• A Area [Distance²]
• E Modulus of Elasticity [Force/Distance²]
• ρ Density [Mass/Distance³]

NF!(network::Network)

Extract fixed/free DOF indices from a vector of nodes.

Extracts the indices of free (N) and fixed (F) nodes

NF(points::Vector{FDMnode})

Return fixed/free DOF indices from a vector of nodes.

R(element::Element; tol = 1e-4)

Get the [12 × 12] transformation matrix for a given element.

tol defines the threshold criteria for triggering special R computation for elements aligned with the global Y axis

R(element::TrussElement)

Get the [2 × 6] transformation matrix for a truss element.

R(xvec::Vector{Float64}, Ψ; tol = 1e-4)

Return the [12 × 12] transformation matrix given a local x vector xvec

tol defines the threshold criteria for triggering special R computation for elements aligned with the global Y axis

R(xvec::Vector{Float64})

Get the [2 × 6] transformation matrix given a local x vector xvec

axial_force(element::Element)

Extract the axial force of an element

axial_force(element::TrussElement)

Extract the axial force of an element

branch_matrix!(network::Network)

Populate the [nelements × nnodes] sparse connectivity matrix, network.C

branch_matrix(elements::Vector{FDMelement}, points::Vector{FDMnode})

Return the [nelements × nnodes] sparse connectivity matrix, network.C

connectivity(model::AbstractModel)

Get the [nₑ × nₙ] sparse matrix where C[i, j] = -1 if element i starts at node j, and C[i,j] = 1 if element i ends at node j, and 0 otherwise.

create_F(model::TrussModel, loads::Vector{NodeForce})

create load vector F = P

create_F(model::TrussModel, loads::Vector{NodeForce})

create load vector F = P - Pf

create_S!(model::Model)

Assemble the global stiffness matrix S.

create_S!(model::TrussModel)

Assemble the global stiffness matrix S.

deconstruct_nodes!(network::Network)

Populate the [n_nodes × 3] matrix of nodal positions, network.xyz

deconstruct_nodes(points::Vector{FDMnode})

return the [n_nodes × 3] matrix of nodal positions, network.xyz

dofs(points::Vector{FDMnode})

Return the fixed/free DOF information from a vector of nodes.

endpoints(element::AbstractElement)

Extract the start and end points as two vectors.

fixnode!(node::AbstractNode, fixity::Symbol)

Fix the DOFs of a node to a common boundary condition.

Arguments

• node::AbstractNodenode to modify
• fixity::Symbol boundary condition to apply. Available boundary conditions:
  • :free
  • :fixed
  • :pinned
  • :(x/y/z)free
  • :(x/y/z)fixed

force_densities!(network::Network)

Extract the force densities of elements in a network and assemble the global Q matrix, network.Q

force_densities(elements::Vector{FDMelement})

Extract the force densities of a vector of elements.

forces(network::Network)

Return the axial forces in a network.

global_K!(element::Element)

Populate the element stiffness matrix element.K in GCS.

global_K(element::Element)

Return the element stiffness matrix in GCS.

initial_lengths(network::Network, E::Real, A::Real)

Get the required unstressed length of elements given a material stiffness E and cross sectional area A.

initial_lengths(network::Network, E::Vector{<:Real}, A::Vector{<:Real})

Get the required unstressed length of elements given an element-wise material stiffness vector E and cross sectional area vector A.

k_fixedfixed(element::Element)

[12 × 12] stiffness matrix for a beam element fully coupled at both ends.

k_fixedfree(element::Element)

[12 × 12] stiffness matrix for a beam element with rotational DOFs decoupled at the end node.

k_freefixed(element::Element)

[12 × 12] stiffness matrix for a beam element with rotational DOFs decoupled at the start node.

k_freefree(element::Element)

[12 × 12] stiffness matrix for a beam element with full decoupled rotational DOFs.

k_joist(element::Element)

[12 × 12] stiffness matrix for a beam element with only torsional DOFs coupled to nodes.

lcs(element::AbstractElement, Ψ::Float64; tol = 1e-6)

Populate local coordinate system unit vectors of a given element and pitch angle Ψ: [localx, localy, local_z]

lcs(xin::Vector{Float64}, Ψ::Float64; tol = 1e-4)

Get the local coordinate system unit vectors of a given local x axis and pitch angle Ψ: [localx, localy, local_z]

lcs(element::AbstractElement, Ψ::Float64; tol = 1e-6)

Get the local coordinate system unit vectors of a given element and pitch angle Ψ: [localx, localy, local_z]

load_matrix!(network::Network)

Generate the [n_nodes × 3] matrix of nodal forces, P

local_K(element::Element)

Return the element stiffness matrix in LCS.

local_x(element::AbstractElement; unit = true)

Get the local x vector of an element: element.nodeEnd.position - element.nodeStart.position. unit = true gives the normalized vector.

midpoint(element::AbstractElement)

Extract the centerpoint of an element as a vector.

node_positions(model::AbstractModel)

Generate the [nₙ × 3] node position matrix

planarize!(model::AbstractModel, plane = :XY)

Fix all nodal DOFs to remain on plane = plane

planarize!(nodes, plane = :XY)

Restrict the DOFs of a set of nodes to a given global plane. E.g., when analyzing a 2D structure.

Arguments

• nodes::Vector{<:AbstractNode} vector of nodes to restrict
• plane::Symbol = :XY plane to restrict DOFs. Defaults to the XY plane, can be:
  • :XY
  • :XZ
  • :YZ

populate_DOF_indices!(model::Model)

Populate all indices, references, and other information in a model.

populate_DOF_indices!(model::TrussModel)

Populate all indices, references, and other information in a truss model.

populate_indices!(network::Network)

Populate the node/element global IDs in a network.

populate_load!(model::AbstractModel, load::NodeForce)

Populate the global load vector model.P with a nodal force.

populate_load!(model::Model, load::ElementLoad)

Generate the fixed-end force vector Q for a given load, and populate the global fixed-end force vector Pf.

populate_load!(model::Model, load::NodeMoment)

Populate the global load vector model.P with a nodal moment.

populate_load!(P::Vector{Float64}, load::ElementLoad)

Populate an external fixed-end force vector Pf with respect the an elemental load load

populate_load!(P::Vector{Float64}, load::NodeForce)

Populate the global load vector P` with a nodal force.

populate_load!(model::Model, load::NodeMoment)

Populate the global load vector model.P with a nodal moment.

populate_loads!(model::Model)

Generate the nodal force vectors model.P (external) and model.Pf (fixed-end)

populate_loads!(model::TrussModel)

Generate the nodal force vectors model.P

post_process!(model::AbstractModel)

Post process a model after solving for displacements using solve!(model)

post_process_elements!(model::AbstractModel)

Populate elemental LCS force vectors in element.forces

post_process_nodes!(model::AbstractModel)

Populate nodal reaction and displacement fields

process!(model::Model)

Process a structural model: add linkages between nodes and elements, determine DOF orders, generate the load vectors P, Pf, and assemble the global stiffness matrix, S.

process!(network::Network)

Preprocess a network. Assign indices and references, and generate global collectors of position, force density, etc.

process!(model::TrussModel)

Process a structural truss model: add linkages between nodes and elements, determine DOF orders, generate the load vector P, and assemble the global stiffness matrix, S.

Test function for solving models with bridge elements

process_elements!(model::Model)

Populate the transformation matrix and global elemental stiffness matrix of the elements in a model.

process_elements!(model::TrussModel)

Populate the transformation matrix and global elemental stiffness matrix of the elements in a truss model.

process_elements!(elements::Vector{<:FrameElement})

Populate the transformation matrix and global elemental stiffness matrix of the elements in a vector of elements.

q_local(load::LineLoad)

Equivalent fixed end forces for a gravity (line) load

q_local(load::LineLoad)

Equivalent fixed end forces for a line load

q_local(load::PointLoad)

Equivalent fixed end forces for a point load.

reactions!(model::AbstractModel)

Populate external reaction forces in model.reactions

reactions!(network::Network)

Get the reaction force vectors of fixed nodes.

solve!(model::Model, L::Vector{AbstractLoad})

Replace the assigned model loads with a new load vector and solve.

solve!(model::Model; reprocess = false)

Solve for the nodal displacements of a structural model. reprocess = true reevaluates all node/element properties and reassembles the global stiffness matrix.

solve!(network::Network; reprocess = false)

Solve an FDM network for equilibrium positions.

solve!(model::TrussModel, L::Vector{NodeForce})

Replace the assigned model loads with a new load vector and solve.

solve!(model::TrussModel; reprocess = false)

Solve for the nodal displacements of a structural truss model. reprocess = true reevaluates all node/element properties and reassembles the global stiffness matrix.

solve(model::Model, L::Vector{AbstractLoad})

Return the displacement vector under a given load set L.

solve(network::Network, q::Union{Vector{Int64}, Vector{Float64}})

Solve an FDM problem w/r/t a new vector of force densities

solve(model::TrussModel, L::Vector{NodeForce})

Return the displacement vector to a new set of loads.

update_DOF!(model::AbstractModel)

Update the free/fixed degrees of freedom for a model

update_q!(network::Network, q::Float64)

Set all force density values to q and re-solve.

update_q!(network::Network, q::Vector{Float64}, indices::Vector{Int64}))

Update all force densities of elements at indices with values in q and resolve.

update_q!(network::Network, q::Vector{Float64})

Update all force densities with q and re-solve.

update_xyz!(network::Network)

Update network.xyz to reflect new equilibrium positions of nodes.

volume(model::AbstractModel)

Get the material volume of a structural model

Extract all elements with a given ID elements = Vector{Element}() elements[:outerEdges]

Custom indexing based on IDs of structs