System definition

SystemDefinition

A structure document: its metadata, the rows of each table block, and the blocks the schema does not name.

• metadata::Metadata: the document's metadata
• materials::Rows{Material}: the rows of materials
• points::Rows{Point}: the rows of points
• segments::Rows{Segment}: the rows of segments
• spanwise_stations::Rows{SpanwiseStation}: the rows of spanwise_stations
• pulleys::Rows{Pulley}: the rows of pulleys
• tethers::Rows{Tether}: the rows of tethers
• winches::Rows{Winch}: the rows of winches
• wings::Rows{Wing}: the rows of wings
• canopy_faces::Rows{CanopyFace}: the rows of canopy_faces
• bodies::Rows{Body}: the rows of bodies
• tubes::Rows{Tube}: the rows of tubes
• extras::OrderedDict{String, Any}: blocks the schema does not name, in the order read

Rows{T} <: AbstractVector{T}

The rows of a block, indexed by position or by name: system.points[3], system.points[:kite] and system.points["kite"] are rows of points.

Metadata

The metadata block of a structure document.

• name::String
• description::String
• note::String
• awesIO_version::String: Version of this schema the file was written against.
• schema::String
• n_points::Int: Number of rows in the points block.
• connectivity_sha::String: Lowercase hex SHA-256 of the connectivity. State recorded against the structure can quote it, so that state is never replayed against a structure that indexes differently. The preimage is ASCII and built in document order, in three sections: the number of points, then each segment's two endpoints as ONE-BASED row numbers into the points block; then the number of bodies, then each tube's two bodies as one-based row numbers into the bodies block; then the number of canopy faces, then each face's corners as row numbers into the points block. The numbers of one element are comma-separated and every field ends in a semicolon, so a lone number always opens a section. Three points joined in a row and spanned by one face, on two bodies joined by one tube, read 3;1,2;2,3;2;1,2;1;1,2,3;. Row numbers are one-based so that implementations in zero-based languages agree with each other; a reader that gets this wrong sees every file as a mismatch.

load_structure(path; strict=true)

The SystemDefinition in the YAML structure document at path, read as from_yaml reads it.

structure_document(system::SystemDefinition)

The awesIO structure document of system, as SystemDefinition reads it: references by name, model columns after the schema's, extra blocks after the schema's, empty optional blocks and unset optional columns left out. Its awesIO_version is AWESIO_VERSION and its connectivity_sha that of system's own tables, whatever system.metadata holds.

pos_KA(wing::Wing, pos_ENU)

The position pos_ENU [m] in the world, in wing's KA frame: Rᵀ (pos_ENU − o), with o the wing's pos_ENU and R the rotation of its Q_KA2ENU.

from_yaml(text; strict=true)

The SystemDefinition in the YAML structure document text, read as SystemDefinition(document; strict) reads it.

to_yaml(system::SystemDefinition)

structure_document(system) as YAML text.

from_json(text; strict=true)

The SystemDefinition in the JSON structure document text, read as SystemDefinition(document; strict) reads it.

to_json(system::SystemDefinition)

structure_document(system) as JSON text.

connectivity_sha(sections...)

Lowercase hex SHA-256 of the structure schema's connectivity preimage of sections, each a count and its elements, each element the one-based row numbers it joins.

connectivity_sha(system::SystemDefinition)

The connectivity_sha of the points and segments, bodies and tubes, and canopy faces of system.

save_log(logger::Logger, system::SystemDefinition, name="sim_log", compress=true;
         metadata=Dict{String, String}(), kwargs...)

save_log(logger, name, compress; metadata, kwargs...) with system added to metadata as JSON under the key topology, which KiteGeometry.definition reads back.

definition(topology::AbstractString; strict=true)

The SystemDefinition in the JSON structure document a log carries under the key topology, read as from_json reads it.

definition(log::SysLog; strict=true)

The SystemDefinition a log loaded by load_log carries under its metadata key topology.

load_authoring(path; set::Settings, name, ignore_l0=false, place=true)
    -> (system, transforms)
load_authoring(authored::AbstractDict; set::Settings, name, ignore_l0=false,
               place=true)

The SystemDefinition SymbolicAWEModels' authoring YAML at path describes, or the parsed authoring document authored, and its Transforms, as Rows. The definition is placed: design positions moved by its tethers' stretched lengths and then by the transforms, each wing's KA frame the authored frame moved with its body. Each transform holds the points and bodies it moves: those naming it, a tether's inner points that of its ends, and a wing's body its wing's, else the first transform. set gives what a row leaves out: segment material, and every winch's gear ratio and drum radius. Each distinct line material is named after the multi-variable giving it, else after its first segment. name is the metadata name, the file's by default for a path; ignore_l0 makes every rest length the placed length. With place=false the definition is left in its design pose, for a tool that places it itself. Each non-empty block it does not read is kept as an extra block; one named after a block of the structure document, or holding a single value, is refused.

resolve_material(label, set; diameter, unit_stiffness, density, youngs_modulus)

(diameter, stiffness, density) of a segment from what its row gives, NaN for what it leaves out: stiffness is its Young's modulus [Pa], from youngs_modulus or from unit_stiffness [N] over its cross-section, or the nonlinear law unit_stiffness gives, the name of one or a callable force law. set's d_tether [mm], rho_tether and e_tether stand in for the rest.

unit_stiffness(material::Material, diameter)
unit_stiffness(segment, materials)

Axial stiffness times rest length [N] of a line of material and diameter [m], youngs_modulus * π (diameter/2)^2, or of segment of its material among materials; nothing where the material's law is not linear.

expand_tether!(points, segments, point_transforms, name, start_point, end_point, n,
               init, set, materials; model, segment_model, line...)

The tether name of n segments from start_point to end_point, its n - 1 inner points <name>_point_<i> added to points on the straight line between them, in the transform of whichever end has one per point_transforms, the transform of each of points or nothing, and its segments <name>_seg_<i> to segments; the tether carries model and each segment segment_model. Together the segments are init.stretched_length [m] long, else the distance between the ends. line is what resolve_material takes with set, the stiffness a number, a law's name or a callable force law; each segment's material goes among materials.

MaterialTable(rows::Vector{Material}, variables::Dict{String, Any})

The materials a load has named so far, and the variables of its YAML they may be named after.

Transform

The rigid motion that takes some of a system's points and bodies from the frame they are authored in to their pose in the world. It turns its object, the weighted rot_point else the position of body, to elevation and azimuth seen from its base, and about that radial until the frame of body has heading. The base is base_pos, where base_point is moved to, or the object base_transform turns. References are indices into the system's blocks and into the transforms.

Pose

Where the points and bodies of a system are: the position of each point [m], and a position [m] fixed in each body and the rotation of its frame into the world, indexed as the system's blocks. The transform functions move it in place.

place!(system::SystemDefinition, transforms)

Apply transforms (place_transforms!) to system where it stands, writing its points, its bodies and the wings sharing their names in place.

place_transforms!(pose::Pose, design::Pose, transforms)

Apply each of transforms, in order, to pose: shift its members so its base point is at its base_pos, or by how far what its base transform turns has moved from design; then turn! them about that base.

reposition!(pose::Pose, transforms)

turn! the members of each of transforms, in order, to its current elevation, azimuth and heading about its base where it stands in pose, without moving that base. A chained transform is not carried with its base, as place_transforms! carries it.

transform_velocities(pose::Pose, transforms) -> (point_vel, body_vel, body_spin)

The velocity [m/s] of each point and body position, and the angular velocity [rad/s] of each body in the world, of the rigid rotation about its base (spherical_spin) each of transforms gives its members in pose; zero for what none moves. The members of a chained transform get its own rotation alone, not its base's.

calc_heading(R_b_to_w, pos)

Heading [rad] of the frame R_b_to_w at pos [m] from the base: the angle of its x axis in the tangential plane, from the elevation direction towards the azimuthal one; zero with the nose towards the base.

Material{M}

A row of the materials block. What the elements are made of, which a solver needs to build them and a viewer does not. A material is a stiffness law and that law's parameters, which fix how it deforms and what it weighs. The laws tools share are defined below as <law>_parameters, which fix their parameters' names and units and the curve they describe. Any other law is free: it names a model its readers implement, and that model fixes its parameters. A reader that does not implement a material's law cannot build the elements naming it.

• name::Symbol: Unique name of the material.
• law::String: Name of the stiffness law: linear, membrane or breukels2011 as defined below, or any law its readers implement.
• parameters::OrderedDict{String, Any}: The law's parameters, by name, in the units the law gives them.
• model::M: the model the model column names, else NoModel

Point{M}

A row of the points block. Mass points.

• name::Symbol: Unique name of the point. A writer whose geometry is index-keyed writes the index as a string, "1" upwards.
• fixed::Bool: True where the point is held in the world, false where it is free or moves with its body.
• body::Union{Nothing, NameRef}: The rigid body the point is fixed in, moving with it and passing its force and moment on to it; null for a point of its own.
• pos_ENU::MVector{3, Float64} [m]: Position in the world.
• extra_mass::Union{Nothing, Float64} [kg]: Optional. Mass the point carries beyond its segments and canopy faces.
• model::M: the model the model column names, else NoModel

Segment{M}

A row of the segments block. Straight elastic elements between two points.

• name::Symbol: Unique name of the segment.
• points::NTuple{2, NameRef}: The two points the segment joins.
• rest_length::Union{Nothing, Float64} [m]: Optional. Unstretched length.
• diameter::Union{Nothing, Float64} [m]: Optional. Diameter of the line, for its mass, drag and cross-section.
• material::Union{Nothing, NameRef}: Optional. The material the line is made of.
• model::M: the model the model column names, else NoModel

SpanwiseStation{M}

A row of the spanwise_stations block. Chordwise sections of a wing. A station's points give the local chord, from which a reader derives the section's angle of attack and, where the points trace the profile, its airfoil shape. A station's local twist is the angle its chord has turned through about the wing's KA y axis from where the document places it, positive pitching the leading edge up. A station is not tied to the aerodynamic mesh. A wing's stations run from +y to -y of its KA frame.

• name::Symbol: Unique name of the station.
• wing::NameRef: The wing the station is a section of.
• points::Vector{NameRef}: The points the section is made of.
• model::M: the model the model column names, else NoModel

Pulley{M}

A row of the pulleys block.

• name::Symbol: Unique name of the pulley.
• segments::NTuple{2, NameRef}: The two segments the pulley trades length between.
• model::M: the model the model column names, else NoModel

Tether{M}

A row of the tethers block. Ordered runs of segments between two points. Material lives on the segments; a tether is the grouping a winch reels, and the length it is reeled from is its segments' rest_length.

• name::Symbol: Unique name of the tether.
• start_point::NameRef: The point the tether starts at.
• end_point::NameRef: The point the tether ends at.
• segments::Vector{NameRef}: The tether's segments, in order from start_point to end_point.
• model::M: the model the model column names, else NoModel

Winch{M}

A row of the winches block.

• name::Symbol: Unique name of the winch.
• tethers::Vector{NameRef}: The tethers the winch reels together.
• winch_point::NameRef: The point the drum sits at.
• gear_ratio::Union{Nothing, Float64} [-]: Optional. Gear ratio of the drive to the drum.
• drum_radius::Union{Nothing, Float64} [m]: Optional. Radius of the drum.
• model::M: the model the model column names, else NoModel

Wing{M}

A row of the wings block. Lifting surfaces, each with the stations that section it and at most one canopy, meshed by the canopy_faces that name the wing.

• name::Symbol: Unique name of the wing.
• pos_ENU::MVector{3, Float64} [m]: The origin of the wing's KA frame, the frame its aerodynamic mesh is drawn in, in the world. A position, not necessarily a point.
• Q_KA2ENU::MVector{4, Float64} [-]: Rotation from the wing's KA frame into the world.
• canopy_material::Union{Nothing, NameRef}: Optional. The material every face of the wing's canopy is made of, or null where the wing has no canopy.
• model::M: the model the model column names, else NoModel

CanopyFace{M}

A row of the canopy_faces block. Triangles and quadrilaterals of fabric spanned between points, whose mass a reader shares among the corners. How the fabric carries load, as a membrane or as springs along its edges, is the reader's model.

• name::Symbol: Unique name of the face.
• wing::NameRef: The wing whose canopy the face belongs to.
• points::Vector{NameRef}: The face's three or four corners, in order around it.
• model::M: the model the model column names, else NoModel

Body{M}

A row of the bodies block. Rigid bodies. A body's KA frame is oriented as docs/source/conventions.rst defines _KA where the body has wing geometry, and as its writer likes where it has no leading edge.

• name::Symbol: Unique name of the body.
• pos_ENU::MVector{3, Float64} [m]: The body's origin, the centre of its own mass, in the world.
• Q_KA2ENU::MVector{4, Float64} [-]: Rotation from the body's KA frame into the world.
• extra_mass::Union{Nothing, Float64} [kg]: Optional. Mass the body carries beyond the points fixed to it.
• extra_inertia_KA::Union{Nothing, MMatrix{3, 3, Float64, 9}} [kg*m^2]: Optional. Inertia tensor of extra_mass about the body's origin, in its KA axes. Principal moments are the case where the KA axes are the principal axes and the tensor is diagonal.
• model::M: the model the model column names, else NoModel

Tube{M}

A row of the tubes block. Inflated beam elements between two bodies, whose positions fix the element's ends and so its rest length. How it curves between those ends belongs to the element: only a shape its material's law cannot hold, or a taper, is a chain of tubes.

• name::Symbol: Unique name of the tube.
• bodies::NTuple{2, NameRef}: The two bodies whose positions fix the tube's ends.
• diameter::Union{Nothing, Float64} [m]: Optional. Diameter, one for the whole element.
• pressure::Union{Nothing, Float64} [Pa]: Optional. Inflation pressure.
• material::Union{Nothing, NameRef}: Optional. The material the element's rigidities are derived from, at its diameter and pressure.
• model::M: the model the model column names, else NoModel

NameRef

A reference to another component: its name, as a Symbol, or its index into its block once a SystemDefinition has resolved it.

AbstractModel

Supertype of the models M of a component T{M}: the parameters a tool attaches to a row through the model its model column names, one field per extra column.

NoModel <: AbstractModel

The model of a component whose model column is absent or names no registered model.

register_model!(block, name, M, units; default=false)

Make a row of block whose model column reads name carry an M, built from the columns named after the model_columns of M, whose units are given in that order. With default, the rows of a block table without a model column carry an M too. Refuses an M with a field the component already has, and a second default for block. A package registering its models calls this from its __init__.

model_columns(M)

The fields of the model type M that are columns of a document, in order: all of them unless M adds a method naming fewer. An M with fields that are no column is built from its columns alone, M(columns...).

model_type(block, name)

The model registered for block under name, or NoModel for nothing or an unregistered name.

The blocks load_authoring reads.

The awesIO version of the vendored schema.

The component type of each table block, in schema order.

The constants of SymbolicAWEModels' Breukels (2011) inflated tube.

Rows, and models, of one type are equal where every field is.

The name of the model each block's rows read where its table has no model column.

The dynamics types of SymbolicAWEModels.

The columns material reads.

A registered model: its type and the unit of each of its columns, in field order.

The unit of each optional column of each table block, by name.

The block each reference column of a table block refers into.

The blocks a structure document must carry.

The unit of each required column of each table block, in order.

T(; kwargs...) where {T <: Component}

A component of type T from one keyword argument per field, with defaults(T) filling those not given; T{M} takes M from model. References may be names or indices.

Reference points as a row writes them: a weight per point reference.

AuthoringWing

What a row of the wings block says of its wing besides its name: whether it is a particle wing, its stations and transform, and what places and weighs its body.

Component

Supertype of the row types of the table blocks.

Placement

The pose of a system while it is placed: where each point and body origin is, how each body is turned, and what of the authoring YAML moves them. system holds the components, every reference an index; the vectors are indexed as its blocks.

Reference points as a weight per point index, the weights summing to one.

Stretched length [m], force [N] and stretch fraction a tether starts at, each optional.

WingFrame

The points that fix a wing body's frame: its origin, and the two pairs giving its z and its y axis.

The model of a row the loader adds to block: the block's default with every column unset, NoModel where that default needs a column filled.

Body indices whose placement carries point index: the body it rides, or the wing body of the station it is a member of. Empty for a point that stands free.

Move one cluster of tethers to their mean stretched length: the free ends, what is downstream of them and the bodies those ride translate along the mean tether, and each tether's inner points are spread along it in proportion to their segment lengths.

Share each tether's rest length (init_unstretched_len) equally over its segments.

apply_tether_init_stretched_lens!(placement::Placement)

Move every tether given a stretched length to it, from the endpoint on the boundary — a fixed or winch point, or one carried only by STATIC bodies. Tethers whose reach overlaps are placed together at their mean length. Refuses a tether with neither endpoint on the boundary, and skips one with both, warning.

The frame authored gives its wing body in point indices, or nothing where its row leaves out its origin or either pair of reference points.

authoring_model(block, row, name=<its model cell>)

The model of row of block: the one name names, by default its model cell, else, where name is missing as for a row with no model column, the block's default, built from the columns named after its fields; NoModel where that names no registered model. An absent column is an unset cell, refused for a field that cannot hold nothing.

Position [m] in pose of the base of transform, one of transforms: its base point, or what its base transform turns.

Each body index mapped to the bodies it shares a tube with.

The block a row of type T belongs to.

calc_R_t_to_w(pos)

Rotation from the tangential frame at pos [m] into the world: z radial along pos, y azimuthal and level, x towards elevation, y × z.

Put every body-carried point at its anchor on its body, where the body now is.

Move the KA frame of each wing of system as the body sharing its name moved from before to after.

check_variable_names(data, variables)

Error when a variable name is also used as a component name, since references to that component would resolve to the variable instead.

Applies the awesIO_version rule of SystemDefinition(document) to version.

Translation along the direction of the mean of the anchor-to-free vectors spans that brings their mean length to mean_len, by Newton's method.

Root of each body's group of bodies joined by tubes, by union-find.

The name of the model the rows of a block table without a model column read, or nothing.

The required columns of T its constructor fills in: a free point of its own, and the identity rotation of a wing's or a body's frame.

defaults(T)

The keyword arguments a T(; kwargs...) constructor fills in when they are not given: every optional column unset, default_values(T), and no model.

design_pose(draft, set, point_wings, authored_wings, authored_bodies, inits)

The Placement of draft in its design pose: each wing body given its mass (wing_mass!) and posed by wing_body_pose, each carried point anchored in its body's frame, and every unset rest length the design length.

value as a structure document writes it, a reference into target by name.

The error for two rows of block named name.

expand_multi_variable_row(row, headers, multi_variables) -> row

Replace every cell of row naming a multi-variable by that variable's fields. In a headers/data row the fields fill the columns starting at the cell, written in header order, so the row carries one entry for the whole group. In a dict row they are merged in without overwriting fields the row states itself.

expand_multi_variables(table, multi_variables) -> table

Expand the multi-variables used in the rows of one YAML block. Blocks that hold no data rows are returned unchanged.

The component ref names among the rows of block for owner: by name, or by its one-based index.

Whether the block table holds anything: any value but a table without rows.

Index of each component of block of system by name.

Share each pulley's summed rest length between its two segments in proportion to their lengths.

init_unstretched_len(placement, index)

Rest length [m] of tether index from its placed length: that length times its stretch_frac, or the length its force [N] stretches to at the segments' common unit_stiffness; the placed length where neither is given.

The name among materials (material!) of a line of density [kg/m^3] and stiffness: a linear material of that Young's modulus [Pa], named after the multi-variable giving both else label; the nonlinear law of that name; or the law unit_stiffness holding that callable force law, named label.

A segment carrying model, its material resolved from line (resolve_material) and set and named among materials; a zero rest_length is set from the design pose before placement.

material!(materials::MaterialTable, name, law, parameters)

The name of the material of law and parameters among materials, added where none has them as name, or as name_2, name_3, … where another material holds that name.

The material columns of a segment or tether row, NaN where a column is unset.

min_rotation(curr_dir, target_dir) -> (axis, angle)

Axis and angle [rad] of the smallest rotation taking the unit vector curr_dir onto target_dir, which adds no roll about either; about some perpendicular axis where the two are opposite.

The cell of model, registered as registration, in the model column header: the registered name for model, else the field of that name, nothing where it has none.

The field of the model M in row, from the column of that name, unset where the column is absent. Refuses a column not in the registered unit.

model_registration(block, M)

The registration for block whose type M is a subtype of, such as a parametric model's UnionAll: its name, that type and its column units. nothing for NoModel.

value as field of model M, refusing nothing where the field cannot hold it.

The index of each component of rows by its name, refusing a name used twice.

The index of each optional column of block among headers, refusing one whose unit is not the schema's.

ref resolved into the indices names, nothing for nothing.

The point ref as reference points of weight one, nothing for nothing.

The dynamics type a cell names, upper case, refusing the removed WING.

parse_table(table) -> Vector{NamedTuple}

The rows of a headers/data table, or of a data list of mappings, as named tuples. Rows starting with a # string are skipped, short rows padded with nothing, and long rows skipped with a warning.

particle_wing_parts(draft, wing, members) -> (point_idxs, body_idxs)

The points of particle wing — its stations' points, else its frame points members — and the other bodies sharing a tube-connected group with the bodies those points ride.

place_authored!(placement::Placement, design::Pose, transforms; ignore_l0=false)

Place the system by its tethers' lengths and transforms, from the pose design placement stands in: tethers to their stretched lengths, every unset rest length to the length it then has, tether and pulley rest lengths shared out, the transforms applied (place_transforms!), and each body's points carried with it. ignore_l0 makes every rest length the placed length.

placed_definition(placement::Placement, design::Pose)

The SystemDefinition of placement where it stands: each point and body at its placed position, a body at the centre of its own mass, each wing's KA frame the authored frame moved as its body moved from design, and the metadata's connectivity_sha that of its tables.

The index of the wing ref names for point, 0 for none, refusing one that does not exist.

point_wing_indices(draft, point_wings, wing_names) -> Vector{Int}

The index of the wing each point of draft names in point_wings, none for a point a tether adds (point_wing_index). Refuses a station's point that names another wing than the station's, or none.

Rotation matrix of the scalar-first quaternion q.

radial_direction(transform)

Unit vector in the world from a transform's base towards where its elevation and azimuth put the turned object: (cos el cos az, cos el sin az, sin el).

The plain bodies of the bodies block at their origins, each with its transform, the centre of its own mass in its frame [m], and whether it is STATIC.

The canopy faces of the canopy_faces block, their wing and corners by name or index.

The points of the points block, each with the wing and transform it names.

The pulleys of the pulleys block.

read_rows(data, block, columns; modelled=true, key=String(block)) -> [(row, model)]

The rows of the table key of data, none where it is absent or empty, each with the model of block it reads (authoring_model) where modelled, else NoModel. Refuses a filled cell in a column that neither the loader, which reads columns and idx, nor that model reads.

The segments of the segments block, their materials resolved against set and named among materials.

The spanwise stations of the stations block, each on the wing it names or the wing listing it among its stations.

The components in the headers/units/data table of block: the required columns leading, then optional and model columns by header. Refuses a filled column they do not read unless strict is false, which warns.

read_tethers!(points, segments, point_transforms, data, set, materials)

The tethers of the tethers block and the length each starts at. A tether row naming its segment_idxs runs over those segments, between the points they chain unless it names them; one naming n_segments adds that many segments and the points between them, on the straight line between its ends, to points and segments, its material resolved against set and named among materials, each carrying the segments' default model read from the row's columns.

The rows of the transforms block, their angles read in degrees, references by name.

The tubes of the tubes block, each made of the material of its law among materials: SymbolicAWEModels' constants for breukels2011, no parameters for another.

The winches of the winches block, with set's gear ratio and drum radius.

The wings of the wings block, each with what it says of its body.

Whether a row registered as registration reads the default model of block.

Weighted position of the reference points refs among the positions pos.

Make every rest length the segment's length, so no segment is stretched.

The names of the columns of block that the schema requires, in order.

component of block with every reference in it an index into indices' blocks.

ref resolved into the indices names, 0 for nothing.

refs resolved into point indices.

resolve_transforms(authored, draft, authored_wings, point_transforms, body_transforms)

The Transform of each authored transform row on draft, its references indices. Its members are the points and bodies whose transform in point_transforms and body_transforms names it. A transform naming a wing turns that wing's origin and heads its body; one naming a rot_point turns that point and heads its first member body.

resolve_variable!(resolved, raw, name, pending) -> value

Value of variable name, substituting any variables it refers to first. Strings that are not variable names are returned unchanged; pending tracks the chain being resolved to report cycles.

resolve_yaml_variables(data, variables=yaml_variables(data)) -> data

Apply an optional top-level variables block to the rest of the YAML tree and drop the block. A variable holding a number, string or list replaces any cell written as its name; a variable holding a mapping is a multi-variable and fills the columns it names at once. Variables may refer to other variables.

Each point riding a rigid structure mapped to all the points sharing it: the members of a rigid wing, and the points riding any body of one tube-connected group (root).

R with each column rotated about the axis k by θ [rad].

Rotate the members of transform in pose, bodies' frames included, about the axis k through base_pos [m] by θ [rad].

v rotated about the axis k by θ [rad], by Rodrigues' formula.

Scalar-first quaternion of the rotation matrix R, from its numerically stable branch: the trace where it is positive, else the largest diagonal element.

The index of the row of rows named name, refusing a name no row or two rows have.

row_model(field_value, block, name)

The model of a row of block: the one registered under name, under the block's default where name is missing for a table without a model column, and NoModel where that names no registered model. Each field of its type M is field_value(M, field, unit).

The one-based row numbers each component of block refers to in column.

Length of segment between the positions pos [m].

Move the members of transform in pose by shift [m].

spherical_spin(transform)

Angular velocity [rad/s] in the world of the rigid rotation about a transform's base its elevation_vel, azimuth_vel and turn_rate describe, about the tangential -y, the world's z and radial_direction.

substitute_variables(value, lookup)

Replace every string inside value (scalars, list entries and mapping values, recursively) by lookup(string). The headers entry of a table is left alone, so a column may share its name with a variable.

(anchor, free) endpoints of tether: the one in boundary and the other, or (nothing, nothing) where neither or both are.

The tether indices placed grouped into clusters whose reach (points each touches) overlap, by union-find.

The points reached from from through segments outside tether and through rigid_siblings, stopping at boundary: what moves with the tether's free end. Refuses a structure that reaches back to anchor.

What a tether row gives of the length it starts at, refusing the removed init_unstretched_length.

Point indices along tether, from its start through each segment's far end.

The axial stiffness times rest length [N] all segments of tether share, from their linear materials and diameters, refusing another law or segments that differ.

to_field(T, value)

value, as a keyword argument or a structure document gives it, as a field of type T.

The indices whose transform in refs, resolved into the indices names, is i.

The bodies that translate with seeds: the seeds and every body reached from them over tubes, stopping at the bodies static_body clamps.

turn!(pose, transform, base_pos)

Rotate the members of transform about base_pos [m]: by the smallest rotation that puts what it turns on its radial_direction, then about that radial until its body has its heading. Refuses a turned object at the base, and warns at the zenith or nadir, where azimuth and heading are undefined.

Position [m] in pose of what transform turns.

The headers of the filled cells that model does not read.

Set every unset (zero) rest length to the segment's length.

The name of the first multi-variable among variables whose fields hold parameters, else label.

wing_body_pose(draft, authored, members, point_names)
    -> (origin, R, com_offset, inertia)

The design pose of a wing's body: its origin [m], its rotation into the world, the centre of its own mass in its frame [m], and its own inertia about that centre in its axes [kg*m²], nothing for none. A particle wing's body sits at its origin, framed by its reference points where it has them; a rigid wing's is framed by its reference points, else at the centre of its own mass (wing_inertia) in the world's axes.

Rotation into the world and origin of the wing frame frame on the positions pos: z from the first z reference to the second, x across the y references and z, y completing the right-handed frame.

wing_inertia(points, members, authored) -> (com, inertia)

Centre [m] and per-unit-mass inertia [m²] about it, in world axes, of a rigid wing's own mass: the com and unit_inertia its row gives, else those of its frame points members as point masses, inertia nothing where they carry no mass and com their centroid.

wing_mass!(draft, wing, authored, members, set)

Spread set.mass equally over the frame points members of wing where the wing carries no mass of its own: for a rigid wing, neither its extra_mass nor its members'; for a particle wing, neither its members nor the bodies they and its stations ride (particle_wing_parts). A particle wing's own extra_mass is ignored, warning.

The reference points of the origin of the body of the wing authored, nothing where that origin is the centre of its mass.

component with the fields changes names replaced.

The headers/units/data table of the components rows of block: the required columns and the optional columns a row fills, then each column of a row's model that a row fills, after the model column unless every row reads the block's default model.

Optional row field, nothing when the column is absent or yaml_unset.

Optional numeric field as a Float64.

The angle a transform row name gives in degrees in field, in radians: default where it is unset, refusing an unset one without.

Optional reference field: an index or a name, nothing where unset or 0.

The pair of reference points in field of the row of wing name, or nothing.

Reference points as a row writes them — one reference, a list averaged equally, or [reference, weight] pairs — as weights per reference.

Name of a row: its name field, else its one-based index i, which an idx field must repeat.

A reference cell as a NameRef, nothing where it is unset.

The 3×3 per-unit-mass inertia [m²] a wing row gives as a matrix or as [Ixx, Iyy, Izz, Ixy, Ixz, Iyz], or nothing.

yaml_unset(value) -> Bool

Whether a cell is unset: nothing, or the nothing placeholder a written table uses to leave one row's cell empty in a column the other rows fill.

yaml_variables(data) -> Dict

The variables of the variables block of data, each with the variables it refers to substituted; none where it has no such block.

Optional 3-vector field.

save_log(logger::Logger, system::SystemDefinition, name="sim_log", compress=true;
         metadata=Dict{String, String}(), kwargs...)

save_log(logger, name, compress; metadata, kwargs...) with system added to metadata as JSON under the key topology, which KiteGeometry.definition reads back.