Awatif Data Structure

What sets Awatif apart is the significant challenge in our industry: the reliance on different apps for designing structures. Unfortunately, we still lack a unified data structure to interpolate between them. Awatif addresses this challenge by decomposing model complexity into its core primitives, which are geometry-based. Any structure geometry can be represented by a list of nodes and elements. All additional data required for analysis, design, or reporting is simply assigned to these nodes or elements.

Installation

The data structure is platform-agnostic; you can follow the same structure in Python or C#. Here, the types are defined in TypeScript, allowing you to import them into your algorithm. This enables smooth interpolation with other algorithms that adhere to the same data structure.

npm install awatif-data-structure

Usage

import { Element, Node, AnalysisInput } from "awatif-data-structure";

const nodes: Node[] = [
  [0, 0, 0],
  [0, 5, 0],
  [5, 5, 0],
  [5, 0, 0],
];
const elements: Element[] = [
  [0, 1],
  [1, 2],
  [2, 3],
];
const analysisInputs: AnalysisInput[] = [
  {
    node: 0,
    load: [0, -50, 0],
  },
  {
    element: 1,
    area: 10,
    elasticity: 200,
  },
];

Examples

Below are examples of a complete Finite Element Method (FEM) analysis using this data structure:

API Reference

For Geometry

type Node = [number, number, number];

Represent the position coordinates [x,y,z]

type Element = [number, number];

Represents the indices of the first and second node in the list of nodes.

For Analysis

Define material and section properties

type FrameAnalysisInput = {
  element: number;
  elasticity: number;
  area?: number;
};

`area`: Cross-sectional area.
`elasticity`: Modulus of elasticity.

type FrameAnalysisInput = {
  element: number;
  elasticity: number;
  shearModulus?: number;
  area?: number;
  momentOfInertiaZ?: number;
  momentOfInertiaY?: number;
  torsionalConstant?: number;
};

`area`: Cross-sectional area.
`elasticity`: Modulus of elasticity.
`shearModules`: Shear modulus or modulus of rigidity of the material.
`momentOfInertiaZ`: Moment of inertia (rotational inertia) of the section around the local z-axis.
`momentOfInertiaY`: Moment of inertia around the local y-axis.
`torsionalConstant`: Torsion constant or torsion coefficient of the section.

Defines which directions are supported (constrained from movement), true means supported, false means free to move.

type SupportAnalysisInput = {
  node: number;
  support: [boolean, boolean, boolean]
};

`support`: Supports in the global x, y, and z directions.

type SupportAnalysisInput = {
  node: number;
  support: [boolean, boolean, boolean, boolean, boolean, boolean]
};

`support`: Supports in the global x, y, and z directions and rotations around the global x, y, and z axes respectively.

Defines loads on nodes or elements

type LoadAnalysisInput = {
  node: number;
  load: [number, number, number]
}

`load`: The magnitude of the force for each direction in the global coordinates (x, y, z).

type LoadAnalysisInput = {
  node: number;
  load: [number, number, number, number, number, number];
}

`load`: The magnitude of the force for each direction in the global coordinates (x, y, z) and moments around the global x, y, and z axes respectively.

type DistributedLoadAnalysisInput = {
  element: number;
  distributedLoad: [number, number];
}

`distributedLoad`: A uniformly distributed force along a beam element in the global y and z directions consecutively. For example, an input of [3, 5] means 3 in the y direction and 5 in the z direction.

type AnalysisInput =
| PropertyAnalysisInput
| SupportAnalysisInput
| LoadAnalysisInput
| DistributedLoadAnalysisInput;

It is a union of all the existing analysis inputs.

Represents the deformations on nodes

type DeformationAnalysisOutput = {
  node: number;
  deformation: [number, number, number]
}

`deformation`: Deformations at the nodes measured in the global coordinate system (x, y, z).

type DeformationAnalysisOutput = {
  node: number;
  deformation: [number, number, number, number, number, number];
}

`deformation`: Deformations at the nodes measured in the global coordinate system (x, y, z) and rotations around the global x, y, and z axes respectively.

Represents the reactions on nodes

type ReactionAnalysisOutput = {
  node: number;
  reaction: [number, number, number]
}

`reaction`: Reactions at the nodes measured in the global coordinate system (x, y, z).

type ReactionAnalysisOutput = {
  node: number;
  reaction: [number, number, number, number, number, number];
}

`reaction`: Reactions at the nodes measured in the global coordinate system (x, y, z) and moments around the global x, y, and z axes respectively.

Represents the beam outputs on elements

type FrameAnalysisOutput = {
  element: number;
  normal?: [number, number];
}

`normal`: Normal force; positive values indicate tension, and negative values indicate compression. While the normal force is a single value, the data structure includes two numbers to accommodate beam elements, as they may yield different outputs at each element node. In the case of bar elements, this value is duplicated.

type FrameAnalysisOutput = {
  element: number;
  normal?: [number, number];
  shearY?: [number, number];
  shearZ?: [number, number];
  torsion?: [number, number];
  bendingY?: [number, number];
  bendingZ?: [number, number];
}

`normal`: Normal force; positive values indicate tension, and negative values indicate compression. While the normal force is a single value, the data structure includes two numbers to accommodate beam elements, as they may yield different outputs at each element node. In the case of bar elements, this value is duplicated.
`shearY`: Shear forces in the local y-direction.
`shearZ`: Shear force in the local z-direction.
`torsion`: Torsional moment about the local x-axis.
`bendingY`: Bending moment about the local y-axis.
`bendingZ`: Bending moment about the local z-axis.

type AnalysisOutputs = Record<
  string,
  (DeformationAnalysisOutput | ReactionAnalysisOutput | FrameAnalysisOutput)[]
>

It is a union of all the existing output objects, stored as a record to allow multiple load cases generation.

source code