Skip to main content

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);

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);

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; }