Oasys GSA Documentation

# Data classes

Model is the main class that associates with GSA model files. Data and results can be extracted from an opened model.

# Model

Parameters: filename -- full path including folders

Model();

Model(string fileName);

Model Clone(Model source);

Parameters: exact name of concrete and steel Design code.

Model(string concreteDesignCode, string steelDesignCode);

ReturnValue Open(string fileName);

ReturnValue Close();

ReturnValue Save();

ReturnValue SaveAs(string fileName);

Parameters: analysisTaskID -- Analysis task number; analysisCaseID -- Analysis case number. Analysis case name is given as Analysis case 1 and description as L1 + L2.

Note: Add or delete analysis case functions are supported on analysis tasks with solution type static, static P-Delta, static NL.

ReadOnlyDictionary<int, AnalysisCaseResult> Results();

bool Analyse(int analysisTaskID);

bool DeleteResults (int analysisTaskID);

ReadOnlyDictionary<int, AnalysisTask> AnalysisTasks();

string AnalysisCaseDescription(int analysisCaseID);

string AnalysisCaseName(int analysisCaseID);

ReturnValue AddAnalysisCaseToTask(int analysisTaskID,string name,string description);

ReturnValue DeleteAnalysisCaseFromTask(int analysisTaskID,int analyisCaseID);

bool SetAnalysisCaseDescription(int analysisCaseID,string description);

int AddAnalysisTask(); //Note: Added task type is Linear Static

int AddCombinationCase(CombinationCase combinationCase);

void SetCombinationCases(ReadOnlyDictionary<int, CombinationCase> combinationCases);

ReadOnlyDictionary<int, CombinationCase> CombinationCases();

Parameters: axisID is Axis reference number

ReadOnlyDictionary<int, Axis> Axes();

int AddAxis(Axis axis);

void AddAxes(ReadOnlyCollection<Axis> axes);

void DeleteAxes(ReadOnlyCollection<int> axisIDs);

void DeleteAxes(int axisID, int numberOfAxes);

void DeleteAxis(int axisID);

string ConcreteDesignCode();

string SteelDesignCode();

Parameters: nodeID is node reference number; nodesList is a string to specify the list of nodes like "100 to 201" or it can a list name like "roof nodes".

ReadOnlyDictionary<int, Node> Nodes();

ReadOnlyDictionary<int, Node> Nodes(string nodesList);

int AddNode(Node node);

void AddNodes(ReadOnlyCollection<Node> nodes);

void DeleteNode(int nodeID);

void DeleteNodes(ReadOnlyCollection<int> nodeIDs);

void DeleteNodes(string nodesList);

void SetNode(int nodeID, Node node);

void SetNodes(ReadOnlyDictionary<int, Node> nodes);

Parameters: memberID is member reference number; memebersList is a string to specify the list of members like "1 to 10" or it can be a list name like "Roof members".

ReadOnlyDictionary<int, Member> Members();

ReadOnlyDictionary<int, Member> Members(string membersList);

int AddMember(Member member);

void AddMembers(ReadOnlyCollection<Member> members);

void DeleteMember(int memberID);

void DeleteMembers(ReadOnlyCollection<int> memberIDs);

void DeleteMembers(string membersList);

void SetMember(int memberID, Member member);

void SetMembers(ReadOnlyDictionary<int, Member> members);

double MemberArea(int memberID);

ReadOnlyCollection<double> MemberDirectionCosine(int memberID);

double MemberLength(int memberID);

Parameters: elementID is element reference number; elementsList is a string to specify the list of elements like "1 to 10", "PB1" or it can be a list name like "roof elements".

ReadOnlyDictionary<int, Element> Elements();

ReadOnlyDictionary<int, Element> Elements(string elementsList);

int AddElement(Element element);

void AddElements(ReadOnlyCollection<Element> elements);

void CreateElementsFromMembers();

void CollapseCoincidentNodes(double tolerance);

void DeleteElement(int elementID);

void DeleteElements(string elementsList);

void DeleteElements(ReadOnlyCollection<int> elementIDs);

void SetElement(int elementID, Element element);

void SetElements(ReadOnlyDictionary<int, Element> elements);

double ElementArea(int elementID);

ReadOnlyCollection<double> ElementDirectionCosine(int elementID);

double ElementLength(int elementID);

double ElementVolume(int elementID);

# Analysis material

Parameters: analysisMaterialID is analysis material reference number

ReadOnlyDictionary<int, AnalysisMaterial> AnalysisMaterials(); // Only elastic isotropic

int AddAnalysisMaterial(AnalysisMaterial material);

void DeleteAnalysisMaterial(int materialID);

void SetAnalysisMaterial(int materialID, AnalysisMaterial material);

# Aluminium material

ReadOnlyDictionary<int, AluminiumMaterial> AluminiumMaterials();

int AddAluminiumMaterial(AluminiumMaterial material);

void DeleteAluminiumMaterial(int materialID);

void SetAluminiumMaterial(int materialID, AluminiumMaterial material);

ReadOnlyCollection GetStandardAluminumMaterialNames();

AluminiumMaterial CreateAluminiumMaterial(string materialName);

# Concrete material

ReadOnlyDictionary<int, ConcreteMaterial> ConcreteMaterials();

int AddConcreteMaterial(ConcreteMaterial material);

void DeleteConcreteMaterial(int materialID);

void SetConcreteMaterial(int materialID, ConcreteMaterial material);

ReadOnlyCollection GetStandardConcreteMaterialNames();

ConcreteMaterial CreateConcreteMaterial(string materialName);

# Fabric material

ReadOnlyDictionary<int, FabricMaterial> FabricMaterials();

int AddFabricMaterial(FabricMaterial material);

void DeleteFabricMaterial(int materialID);

void SetFabricMaterial(int materialID, FabricMaterial material);

ReadOnlyCollection GetStandardFabricMaterialNames();

FabricMaterial CreateFabricMaterial(string materialName);

# FRP material

ReadOnlyDictionary<int, FrpMaterial> FrpMaterials();

int AddFrpMaterial(FrpMaterial material);

void DeleteFrpMaterial(int materialID);

void SetFrpMaterial(int materialID, FrpMaterial material);

ReadOnlyCollection GetStandardFrpMaterialNames();

FrpMaterial CreateFrpMaterial(string materialName);

# Glass material

ReadOnlyDictionary<int, GlassMaterial> GlassMaterials();

int AddGlassMaterial(GlassMaterial material);

void DeleteGlassMaterial(int materialID);

void SetGlassMaterial(int materialID, GlassMaterial material);

ReadOnlyCollection GetStandardGlassMaterialNames();

GlassMaterial CreateGlassMaterial(string materialName);

# Reinforcement material

ReadOnlyDictionary<int, ReinforcementMaterial> ReinforcementMaterials();

int AddReinforcementMaterial(ReinforcementMaterial material);

void DeleteReinforcementMaterial(int materialID);

void SetReinforcementMaterial(int materialID, ReinforcementMaterial material);

ReadOnlyCollection GetStandardReinforcementMaterialNames();

ReinforcementMaterial CreateReinforcementMaterial(string materialName);

# Steel material

ReadOnlyDictionary<int, SteelMaterial> SteelMaterials();

int AddSteelMaterial(SteelMaterial material);

void DeleteSteelMaterial(int materialID);

void SetSteelMaterial(int materialID, SteelMaterial material);

ReadOnlyCollection GetStandardSteelMaterialNames();

SteelMaterial CreateSteelMaterial(string materialName);

# Timber material

ReadOnlyDictionary<int, TimberMaterial> TimberMaterials();

int AddTimberMaterial(TimberMaterial material);

void DeleteTimberMaterial(int materialID);

void SetTimberMaterial(int materialID, TimberMaterial material);

ReadOnlyCollection GetStandardTimberMaterialNames();

TimberMaterial CreateTimberMaterial(string materialName);

ReadOnlyDictionary<int, LoadCase> LoadCases();

void DeleteLoadCase(int loadCaseID);

void SetLoadCases(ReadOnlyDictionary<int, LoadCase> loadCases);

GraphicDrawResult GetDiagrams(DiagramSpecification);

Parameters: beamLoadID is beam load reference number

ReadOnlyCollection<BeamLoad> BeamLoads();

int AddBeamLoad(BeamLoad beamLoad);

void AddBeamLoads(ReadOnlyCollection<BeamLoad> beamLoads);

void DeleteBeamLoad(int beamLoadID);

void DeleteBeamLoads(int beamLoadID, int numberOfBeamLoads);

void SetBeamLoad(int beamLoadID, BeamLoad beamLoad);

Parameters: beamThermalLoadId is beam thermal load reference number

ReadOnlyCollection<BeamThermalLoad> BeamThermalLoads();

int AddBeamThermalLoad(BeamThermalLoad beamThermalLoad);

void AddBeamThermalLoads(ReadOnlyCollection<BeamThermalLoad> beamThermalLoad);

void DeleteBeamThermalLoad(int beamThermalLoadId);

void DeleteBeamThermalLoads(int beamThermalLoadId, int numberOfBeamThermalLoads);

Parameters: faceLoadID is face load reference number

ReadOnlyCollection<FaceLoad> FaceLoads();

int AddFaceLoad(FaceLoad faceLoad);

void AddFaceLoads(ReadOnlyCollection<FaceLoad> faceLoads);

void DeleteFaceLoad(int faceLoadID);

void DeleteFaceLoads(int faceLoadID, int numberOfFaceLoads);

void SetFaceLoad(int faceLoadID, FaceLoad faceLoad);

Parameters: faceThermalLoadId is face thermal load reference number

ReadOnlyCollection<FaceThermalLoad> FaceThermalLoads();

int AddFaceThermalLoad(FaceThermalLoad faceThermalLoad);

void AddFaceThermalLoads(ReadOnlyCollection<FaceThermalLoad> faceThermalLoads);

void DeleteFaceThermalLoad(int faceThermalLoadId);

void DeleteFaceThermalLoads(int faceThermalLoadId, int numberOfFaceThermalLoads);

Parameters: gravityLoadID is gravity load reference number

ReadOnlyCollection<GravityLoad> GravityLoads();

int AddGravityLoad(GravityLoad gravityLoad);

void AddGravityLoads(ReadOnlyCollection<GravityLoad> gravityLoads);

void DeleteGravityLoad(int gravityLoadID);

void DeleteGravityLoads(int gravityLoadID, int numberOfGravityLoads);

void SetGravityLoad(int gravityLoadID, GravityLoad gravityLoad);

Parameters: nodeLoadID is node load reference number

ReadOnlyCollection<NodeLoad> NodeLoads(NodeLoadType type);

int AddNodeLoad(NodeLoadType type, NodeLoad nodeLoad);

void AddNodeLoads(NodeLoadType type, ReadOnlyCollection<NodeLoad> nodeLoads);

void DeleteNodeLoad(NodeLoadType type, int nodeLoadID);

void DeleteNodeLoads(NodeLoadType type, int nodeLoadID, int numberOfNodeLoads);

void SetNodeLoad(NodeLoadType type, int nodeLoadID, NodeLoad nodeLoad);

# 2D property related functions:

Parameters: prop2DID is 2D property reference number

ReadOnlyDictionary<int, Prop2D> Prop2Ds();

int AddProp2D(Prop2D prop2D);

void AddProp2Ds(ReadOnlyCollection<Prop2D> prop2Ds);

void DeleteProp2D(int prop2DID);

void DeleteProp2Ds(int prop2DID, int numberOfProp2Ds);

void DeleteProp2Ds(ReadOnlyCollection<int> prop2DIDs);

void SetProp2D(int prop2DID, Prop2D prop2D);

void SetProp2Ds(ReadOnlyDictionary<int, Prop2D> prop2Ds);

# 3D property related functions:

Parameters: prop3DID is 3D property reference number

ReadOnlyDictionary<int, Prop3D> Prop3Ds();

int AddProp3D(Prop3D prop3D);

void AddProp3Ds(ReadOnlyCollection<Prop3D> prop3Ds);

void DeleteProp3D(int prop3DID);

void DeleteProp3Ds(int prop3DID, int numberOfProp3Ds);

void DeleteProp3Ds(ReadOnlyCollection<int> prop3DIDs);

void SetProp3D(int prop3DID, Prop3D prop3D);

void SetProp3Ds(ReadOnlyDictionary<int, Prop3D> prop3Ds);

Parameters: sectionID is section reference number

ReadOnlyDictionary<int, Section> Sections();

int AddSection(Section section);

void AddSections(ReadOnlyCollection<Section> sections);

void DeleteSection(int sectionID);

void DeleteSections(int sectionID, int numberOfSections);

void DeleteSections(ReadOnlyCollection<int> sectionIDs);

void SetSection(int sectionID, Section section);

void SetSections(ReadOnlyDictionary<int, Section> sections);

Parameters: sectionModifierID is the reference number corresponding to the modified section

ReadOnlyDictionary<int, SectionModifier> SectionModifiers();

int AddSectionModifier(SectionModifier sectionModifier);

void AddSectionModifiers(ReadOnlyCollection<SectionModifier> sectionModifiers);

void DeleteSectionModifier(int sectionModifierID);

void DeleteSectionModifiers(int sectionModifierID, int numberOfSectionModifiers);

void DeleteSectionModifiers(ReadOnlyCollection<int> sectionModifierIDs);

void SetSectionModifier(int sectionModifierID, SectionModifier sectionModifier);

void SetSectionModifiers(

ReadOnlyDictionary<int, SectionModifier> sectionModifiers);

ReadOnlyDictionary<int, EntityList> Lists();

ReadOnlyDictionary<int, EntityList> Lists(string listDescription);

int AddList(EntityList list);

void AddLists(ReadOnlyCollection<EntityList> lists);

void DeleteList(int listId);

void DeleteLists(ReadOnlyCollection<string> list);

void DeleteLists(ReadOnlyCollection<int> listIds);

void SetList(listId, EntityList list);

void SetLists(ReadOnlyDictionary<int, EntityList> lists);

ReadOnlyCollection<int> ExpandList(EntityList list);

ReadOnlyCollection<int> ExpandList(EntityList list, int highestEntityId);

ReadOnlyDictionary<int, GridLine> GridLines();

void SetGridLines(ReadOnlyDictionary<int, GridLine> gridLines);

Titles Titles();

ReadOnlyDictionary<int, GridSurface> GridSurfaces()

int AddGridSurface(GridSurface gridSurface);

void AddGridSurfaces(ReadOnlyCollection<GridSurface> gridSurfaces);

void DeleteGridSurface(int gridSurfaceID);

void DeleteGridSurfaces(int gridSurfaceID, int numberOfGridSurfaces);

void DeleteGridSurfaces(ReadOnlyCollection<int> gridSurfaceIDs);

void SetGridSurface(int gridSurfaceID, GridSurface gridSurface);

void SetGridSurfaces(ReadOnlyDictionary<int, GridSurface> gridSurfaces);

int HighestGridSurface();

void ValidateGridSurfaceName(string gridSurfaceName, int gridSurfaceId);

UiUnits UiUnits();

# AnalysisTask

# Properties

int Type { get; set; }

ReadOnlyCollection<int> Cases { get; }

ReadOnlyCollection<int> TaskDependencies { get; }

string Name { get; set; }

# Axis

# Properties

AxisType Type { get; set;}

string Name { get; set;}

Vector3 Origin { get; set;}

Vector3 XVector { get; set;}

Vector3 XYPlane { get; set;}

# Functions

string TypeAsString();

# Design code

# Methods

ReadOnlyCollection GetConcreteDesignCodeNames();

ReadOnlyCollection GetSteelDesignCodeNames()

# DiagramSpecification

# Properties

string ListDefinition { get; set; }

string Cases { get; set; }

DiagramType Type { get; set; }

double ScaleFactor { get; set; }

bool IsNormalised { get; set; }

# EntityList

# Properties

string Name { get; set; }

string Definition { get; set; }

EntityType Type { get; set; }

# BeamLoad

# Properties

BeamLoadType Type { get; set; }

bool IsProjected { get; set; }

Direction Direction { get; set; }

int AxisProperty { get; set; }

int Case { get; set; }

EntityType EntityType { get; set; }

string EntityList { get; set; }

string Name { get; set; }

# Functions

Parameter: position is 0 based index.

position = O represents Position 1

position = 1 represents Position 2

double Position(int position);

double Value(int position);

void SetPosition(int position, double value);

void SetValue(int position, double value);

string DirectionAsString();

string TypeAsString();

# Positions and values

Position 1

This is only relevant for point loads and patch loads. For a point load this is the location of the load measured from end 1 of the beam; for a patch load it is the start of the patch load measured from end 1 of the beam Position 1 can be specified as a length or as a percentage of the length of the element, e.g. either 1.2 or 15%. As the variable is double, %values to be entered as negative values i.e. equivalent to 15% is -0.15

Value 1

Load magnitude. For a point load this is the load value; for a uniform load this is the load intensity; for a linear load this is the load intensity at end 1; for a patch load this is the load intensity at Position 1.

Position 2

This is only relevant for patch loads and is the end of the patch load measured from end 1 of the beam. Position 2 can be specified as a length or as a percentage of the length of the element, e.g. either 2.4 or 85%. As the variable is double, %values to be entered as negative values i.e. equivalent to 85% is -0.85

Value 2

Load magnitude. For a linear load this is the load intensity at end 2 and for a patch load this is the load intensity at Position 2.

# BeamThermalLoad

# Properties

string Name { get; set; }

EntityType EntityType { get; set; }

string EntityList { get; set; }

int Case { get; set; }

double UniformTemperature { get; set; }

# FaceLoad

# Properties

bool IsProjected { get; set; }

Direction Direction { get; set; }

FaceLoadType Type { get; set; }

int AxisProperty { get; set; }

int Case { get; set; }

EntityType EntityType { get; set; }

string EntityList { get; set; }

string Name { get; set; }

Vector2 Position { get; set; }

# Functions

double Value(int position);

void SetValue(int position, double value);

string TypeAsString();

# Variable -- position

Position (int) - varies from 1 to 4, value is the pressure corresponding to the position.

Position (vector2) - Position of load is applicable for point load type. The position of the point load to be specified in ( r , s ) coordinates based on two-dimensional shape function. Coordinates vary from −1 to 1 for Quad4 and Quad8 and vary from 0 to 1 for Triangle3 and Triangle6.

dotnet-api-1

# FaceThermalLoad

# Properties

string Name { get; set; }

EntityType EntityType { get; set; }

string EntityList { get; set; }

int Case { get; set; }

double UniformTemperature { get; set; }

# GravityLoad

# Properties

int Case { get; set; }

EntityType EntityType { get; set; }

string EntityList { get; set; }

string Name { get; set; }

Vector3 Factor { get; set; }

# NodeLoad

# Properties

Direction Direction { get; set; }

double Value { get; set; }

int AxisProperty { get; set; }

int Case { get; set; }

string Name { get; set; }

string Nodes { get; set; }

# GraphicDrawResult

# Properties

ReadOnlyCollection<Line> Lines { get; }

ReadOnlyCollection<Annotation> Annotations { get; }

# Node

# Properties

Bool6 Restraint { get; set; }

int AxisProperty { get; set; }

int DamperProperty { get; set; }

int MassProperty { get; set; }

int SpringProperty { get; set; }

string Name { get; set; }

ValueType Colour { get; set; }

Vector3 Position { get; set; }

# Member

# Properties

AnalysisOrder Type2D { get; set; }

bool IsDummy { get; set; }

double MeshSize { get; set; }

MeshMode2d MeshMode2d { get; set; }

double OrientationAngle { get; set; }

ElementType Type1D { get; set; }

int Group { get; set; }

int MemberEnd1 { get; set; }

int MemberEnd2 { get; set; }

int OrientationNode { get; set; }

int Property { get; set; }

MemberType Type { get; set; }

Offset Offset { get; set; }

AutomaticOffset AutomaticOffset { get; set; }

string Name { get; set; }

string Topology { get; set; }

ValueType Colour { get; set; }

bool IsIntersector { get; set; }

Nullable<double> EquivalentUniformMomentFactor { get; set; }

Nullable<double> MomentAmplificationFactorStrongAxis { get; set; }

Nullable<double> MomentAmplificationFactorWeakAxis { get; set; }

# Functions

EndRelease GetEndRelease(int iTopology);

void SetEndRelease(int iTopology, EndRelease endRelease);

string Type1DAsString();

string Type2DAsString();

string TypeAsString();

# Element

# Properties

bool IsDummy { get; set; }

double OrientationAngle { get; set; }

ElementType Type { get; set; }

int Group { get; set; }

int OrientationNode { get; set; }

int Property { get; set; }

Offset Offset { get; set; }

ReadOnlyCollection<int> Topology { get; set; }

string Name { get; set; }

ValueType Colour { get; set; }

# Functions

EndRelease GetEndRelease(int iTopology);

Bool6 Release(int iTopology);

void SetEndRelease(int iTopology, EndRelease endRelease);

void SetRelease(int iTopology, Bool6 release);

string TypeAsString();

# Prop2D

# Properties

double Thickness { get; set; }

int AxisProperty { get; set; }

int MaterialAnalysisProperty { get; set; }

int MaterialGradeProperty { get; set; }

MaterialType MaterialType { get; set; }

Property2D_Type Type { get; set; }

SupportType SupportType { get; set; }

ReferenceSurface ReferenceSurface { get; set; }

double AdditionalOffsetZ { get; set; }

int ReferenceEdge { get; set; }

Prop2DModifier PropertyModifier { get; }

string Name { get; set; }

ValueType Colour { get; set; }

# Functions

string MaterialTypeAsString();

string TypeAsString();

# Prop2DModifier

# Properties

double AdditionalMass { get; set; }

Prop2DModifierAttribute InPlane{ get; set; }

Prop2DModifierAttribute Bending { get; set; }

Prop2DModifierAttribute Shear { get; set; }

Prop2DModifierAttribute Volume { get; set; }

# Prop3D

# Properties

int AxisProperty { get; set; }

int MaterialAnalysisProperty { get; set; }

int MaterialGradeProperty { get; set; }

MaterialType MaterialType { get; set; }

string Name { get; set; }

ValueType Colour { get; set; }

# Functions

string MaterialTypeAsString();

# Section

# Properties

int MaterialAnalysisProperty { get; set; }

int MaterialGradeProperty { get; set; }

int Pool { get; set; }

MaterialType MaterialType { get; set; }

BasicOffset BasicOffset { get; set; }

double AdditionalOffsetY { get; set; }

double AdditionalOffsetZ { get; set; }

string Name { get; set; }

string Profile { get; set; }

ValueType Colour { get; set; }

# Functions

string MaterialTypeAsString();

SectionProperties Properties();

# SectionProperties

# Properties

double Angle { get; }

double Area { get; }

double Iyy { get; }

double Iyz { get; }

double Izz { get; }

double Iuu { get; }

double Ivv { get; }

double J { get; }

double C { get; }

double Kyy { get; }

double Kzz { get; }

double Kuu { get; }

double Kvv { get; }

double Ry { get; }

double Rz { get; }

double SurfaceAreaPerLength { get; }

double VolumePerLength { get; }

double Zpy { get; }

double Zpz { get; }

double Zy { get; }

double Zz { get; }

double Cy { get; }

double Cz { get; }

# SectionModifier

# Properties

double AdditionalMass { get; set; }

SectionModifierAttribute AreaModifier { get; set; }

SectionModifierAttribute I11Modifier { get; set; }

SectionModifierAttribute I22Modifier { get; set; }

bool IsBendingAxesPrincipal { get; set; }

bool IsReferencePointCentroid { get; set; }

SectionModifierAttribute JModifier { get; set; }

SectionModifierAttribute K11Modifier { get; set; }

SectionModifierAttribute K22Modifier { get; set; }

SectionModifierStressType StressOption { get; set; }

SectionModifierAttribute VolumeModifier { get; set; }

# Titles

# Properties

string Calculation { get; set; }

string Initials { get; set; }

string JobNumber { get; set; }

string Notes { get; set; }

string SubTitle { get; set; }

string Title { get; set; }

# UiUnits

# Properties

ForceUnit Force { get; set; }

LengthUnit LengthLarge { get; set; }

LengthUnit LengthSmall { get; set; }

LengthUnit LengthSections { get; set; }

MassUnit Mass { get; set; }

TemperatureUnit Temperature { get; set; }

TimeUnit TimeShort { get; set; }

TimeUnit TimeMedium { get; set; }

TimeUnit TimeLong { get; set; }

StrainUnit Strain { get; set; }

StressUnit Stress { get; set; }

VelocityUnit Velocity { get; set; }

AccelerationUnit Acceleration { get; set; }

EnergyUnit Energy { get; set; }

AngleUnit Angle { get; set; }

# CombinationCase

# Properties

string Name { get; }

string Definition { get; }

# GridSurface

# Properties

int GridPlane { get; set; }

double Direction { get; set; }

double Tolerance { get; set; }

Element_Type ElementType { get; set; }

Span_Type SpanType { get; set; }

GridSurfaceExpansionType ExpansionType { get; set; }

string Elements { get; set; }

# Functions

string ElementTypeAsString();

string SpanTypeAsString();

string Definition { get; }

# LoadCase

# Properties

string Name { get; set; }

LoadCaseType CaseType { get; set; }

# GridLine

# Properties

string Label { get; }

GridLineShape Shape { get; set; }

double X { get; set; }

double Y { get; set; }

double Length { get; set; }

double Theta1 { get; set; }

double Theta2 { get; set; }

← Material Classes →