AsapToolkit

Series of extension tools for Asap.jl including:

Internal displacement analysis across an element: ElementDisplacements
Internal force analysis across an element: InternalForces, ForceEnvelopes
Automatic frame generation: generateframe
Automatic 2D truss generation: generatewarren2d
Automatic 3D spaceframe generation: generatespaceframe

Element analysis

The internal forces for an element in an analyzed structure can be extracted via:

    InternalForces(element::Element, model::Model; resolution = 20)

Where resolution is the number of samples taken across the element. Results are stored in an InternalForces structure with the fields:

struct InternalForces
    element::Element
    resolution::Integer
    x::Vector{Float64}
    P::Vector{Float64}
    My::Vector{Float64}
    Vy::Vector{Float64}
    Mz::Vector{Float64}
    Vz::Vector{Float64}
end

Where y,z are with respect to the local coordinate system of the element.

Similar to force analysis, the transverse displacements can be extracted via ElementDisplacements(element::Element, model::Model; resolution = 20). Result is in the form:

struct ElementDisplacements
    element::Element
    resolution::Integer
    x::Vector{Float64}
    ulocal::Matrix{Float64}
    uglobal::Matrix{Float64}
    basepositions::Matrix{Float64}
end

Where ulocal and uglobal are $3 \times \text{resolution}$ matrices where each row represents X, Y, and Z.

Example:

section = toASAPframe(rand(allW()), Steel_Nmm.E, Steel_Nmm.G)

n1 = Node([0., 0., 0.], :fixed)
n2 = Node([6000., 0., 0.], :fixed)
nodes = [n1, n2]

element = Element(n1, n2, section)
elements = [element]

load1 = LineLoad(element, [0., 0., -30])
pointloads = [PointLoad(element, rand(), 25e3 .* [0., 0., -rand()]) for _ = 1:5]
loads = [load1; pointloads]

model = Model(nodes, elements, loads)
solve!(model)

fanalysis = InternalForces(element, model)
danalysis = ElementDisplacements(element, model)

force/displacement analysis for all elements in a structural model can be generated via:

forces(model::Model, increment::Real)
displacements(model::Mode, increment::Real)

Where increment is the absolute sampling distance along each element (not the number of samples taken in an element)

Load envelopes

If the internal forces of an element across multiple load cases is desire, one can use:

load_envelopes(model::Model, loads::Vector{Vector}, increment::Real)

This generates a vector of ForceEnvelopes for each element, which stores the lower/upper bounds of internal forces:

struct ForceEnvelopes
    element::Element
    resolution::Integer
    x::Vector{Float64}
    Plow::Vector{Float64}
    Phigh::Vector{Float64}
    Mylow::Vector{Float64}
    Myhigh::Vector{Float64}
    Vylow::Vector{Float64}
    Vyhigh::Vector{Float64}
    Mzlow::Vector{Float64}
    Mzhigh::Vector{Float64}
    Vzlow::Vector{Float64}
    Vzhigh::Vector{Float64}
end

Generation

3D Frame

generateframe can be used to create and analyze a 3D frame structure with joist -> girder -> column hierarchy, bi-directional X-bracing and optional braces at each XY bay to simulate a diaphragm.

generateframe(nx::Integer, 
    dx::Real, 
    ny::Integer, 
    dy::Real, 
    nz::Integer, 
    dz::Real, 
    joistSpacing::Real, 
    columnSection::Asap.Section, 
    primarySection::Asap.Section, 
    joistSection::Asap.Section, 
    braceSection::Asap.Section)

Where:

nx number of bays in primary span direction
dx bay spacing
ny number of bays in joist span direction
dy bay spacing
nz number of stories
dz floor height
joistSpacing spacing between joists
columnSection cross section properties for columns
primarySection cross section properties for primary beams
joistSection cross section properties for joists
braceSection cross section properties for braces

Optional inputs with default values:

diaphragm::Bool = false add a diaphragm to floor bays
diaphragmSection::Asap.section = nothing if diaphragm == true, by default will assign the same section as the braces unless defined here.
columnRelease::Symbol = :fixedfixed DOF releases for columns
primaryRelease::Symbol = :fixedfixed DOF releases for primary beams
joistRelease::Symbol = :joist DOF releases for joists
braceRelease::Symbol = :freefree DOF releases for braces
columnPsi::Real = 0. Angle of roll Ψ for column LCS
primaryPsi::Real = pi/2 Angle of roll Ψ for primary beam LCS
joistPsi::Real = pi/2 Angle of roll Ψ for joist LCS
base::Vector{<:Real} = [0., 0., 0.] starting position of frame grid generation

The output is a Frame object that stores all user parameters as fields, and the analyzed structural model in Frame.model.

Example

#choosing sections
begin
    W = allW()
    iStiffness = sortperm(getproperty.(W, :Ix))
    nsecs = length(W)

    mat = Steel_Nmm
    girder = toASAPframe((W[iStiffness])[Int(round(nsecs * 0.5))], mat.E, mat.G)
    joist = toASAPframe((W[iStiffness])[Int(round(nsecs * .2))], mat.E, mat.G)

    iArea = sortperm(getproperty.(W, :A))
    col = toASAPframe((W[iArea])[Int(round(nsecs * .75))], mat.E, mat.G)

    H = allHSSRound()
    iArea = sortperm(getproperty.(H, :A))
    nh = length(H)
    tube = toASAPframe((H[iArea])[Int(round(nh * 0.9))], mat.E, mat.G)

    girder.ρ = joist.ρ = tube.ρ = mat.ρ
end

# geometry hyperparameters for frame
begin
    nx = 3
    ny = 6
    nz = 30
    dx = 6000
    dy = 5000
    dz = 4200
end

# generate and extract
frame = generateframe(nx,
    dx,
    ny,
    dy,
    nz,
    dz,
    500,
    col,
    girder,
    joist,
    tube;
    columnPsi = pi/2,
    diaphragm = true,
    );

model = frame.model;

2D trusses

Regularly spaced

generatewarren2d(n::Integer,
    dx::Real,
    dy::Real,
    section::Asap.AbstractSection;
    type = :arch,
    base = [0., 0., 0.])

Where:

n number of bays (must be odd)
dx bay spacing in X direction
dy depth of truss
section element section

With optional parameters:

type::Symbol = :arch: can be :arch or :catenary which chooses with the longer chord is the tensile or compressive chord
base::Vector{<:Real} = [0,0,0]: base point for truss generation

Example

#parameters
n = 11
dx = 1500
dy = 1400
section = toASAPtruss(rand(allHSSRound()), Steel_Nmm.E)

#generate
warrentruss = generatewarren2d(n,
    dx,
    dy,
    section)

#extract
truss = warrentruss.model

Irregularly spaced

generatewarren2d(xpositions::Vector{<:Real},
    ypositions::Vector{<:Real},
    ypositions2::Vector{<:Real},
    section::Asap.AbstractSection;
    type = :arch,
    base = [0., 0., 0.])

Where:

xpositions x-positions of long chord nodes (should generally be in increasing order)
ypositions y-positions of long chord nodes. length(xpositions) == length(ypositions).
ypositions2 y-positions of short chord nodes. The x-positions are always centered between two long chord nodes. length(ypositions) == length(ypositions2) + 1

Example

#irregular
xpos = cumsum(rand(7) .* 2000) .+ 500
ypos = - sort(rand(7) .* 1000); ypos[1] = ypos[end] = 0.
ypos2 = sort(rand(6) .* 1500) .+ 1500

truss = generatewarren2d(xpos,
    ypos,
    ypos2,
    section)

3D spaceframes

Regular spaceframe

generatespaceframe(nx::Integer,
        dx::Real,
        ny::Integer,
        dy::Real,
        dz::Real,
        section::Asap.AbstractSection;
        support = :corner,
        load = [0., 0., -10.],
        base = [0., 0., 0.])

Where:

nx number of bays in x-direction
dx bay spacing
ny number of bays in y-direction
dy bay spacing
dz spaceframe depth
section element properties

With optional parameters:

support::Symbol = :corner support condition types. Choose from:
- :corner support all nodes in each corner bay of the spaceframe (16 nodes total)
- :x support all the extremity nodes aligned with x-axis (1-way span)
- :y support all extremity nodes aligned with y-axis (1-way span)
- :xy support all perimeter nodes (2-way span)
- :center support the nodes that form the center bay of the structure
load::Vector{<:Real} = [0, 0, -10] load applied to all bottom nodes (excluding supports)
base::Vector{<:Real} = [0,0,0] starting point for generation

Example

nx = 20
dx = 1000.
ny = 31
dy = 1300.
dz = 1250.

sec = rand(allHSSRound())
tube = toASAPtruss(sec, Steel_Nmm.E)
σ = 350.

sf = generatespaceframe(nx, dx, ny, dy, dz, tube; load = [0., 0., -30e3]);

truss = sf.truss;

Irregular spaceframe

generatespaceframe(nx::Integer,
    dx::Real,
    ny::Integer,
    dy::Real,
    z0::Real,
    interpolator::Interpolations.AbstractExtrapolation,
    section::Asap.AbstractSection,
    offset = false;
    support = :corner,
    load = [0., 0., -10.],
    base = [0., 0., 0.])

The major differences are:

dz is replaced with z0, the initial offset between the top surface and bottom surface of the spaceframe
interpolator defines the z-height function of the spaceframe nodes
offset determines whether the bottom plane remains in place or follows the top plane

interpolator must define a function that takes in two inputs (x,y coordinates) and returns a scalar value (z coordinate):

$$ \text{interpolator}: (x,y) ; \in ; \mathbb{R}^2 \rightarrow \mathbb{R} $$

Where: $$ x \in [0,1]\ y \in [0,1] $$

This can be generated using the cubic_spline_interpolation function in Interpolations.jl. See example below:

Example

n = 4
x = range(0,1,n)
y = range(0,1,n)
z = rand(n,n) .* 4500

itp = cubic_spline_interpolation((x,y), z)

@time sf = generatespaceframe(nx, dx, ny, dy, dz, itp, tube, true; load = [0., 0., -30e3]);
truss = sf.truss;

keithjlee/AsapToolkit

AsapToolkit

Element analysis

Example:

Load envelopes

Generation

3D Frame

Example

2D trusses

Regularly spaced

Example

Irregularly spaced

Example

3D spaceframes

Regular spaceframe

Example

Irregular spaceframe

Example