Model

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

Constructors

Model(string concreteDesignCode, string steelDesignCode);
Model(string fileName);
Model();

Model and Analysis methods

bool Analyse(int taskID);
bool DeleteResults(int taskID);
void Open(string fileName);
ReturnValue Save();
ReturnValue SaveAs(string fileName);
ReturnValue Close();
Model Clone();

AluminiumMaterial related methods

AluminiumMaterial CreateAluminiumMaterial(string materialName);
void SetAluminiumMaterial(int materialID, AluminiumMaterial material);
int AddAluminiumMaterial(AluminiumMaterial material);
void DeleteAluminiumMaterial(int materialID);
ReadOnlyCollection<string> GetStandardAluminumMaterialNames();
ReadOnlyDictionary<int, AluminiumMaterial> AluminiumMaterials();

Analysis Case related methods

string AnalysisCaseDescription(int analysisCaseID);
string AnalysisCaseName(int analysisCaseID);
bool SetAnalysisCaseDescription(int analysisCaseID, string description);
ReturnValue AddAnalysisCaseToTask(int analysisTaskID, string name, string description);
ReturnValue DeleteAnalysisCaseFromTask(int analysisTaskID, int analyisCaseID);

AnalysisCaseResult related methods

ReadOnlyDictionary<int, AnalysisCaseResult> Results();

AnalysisMaterial related methods

int AddAnalysisMaterial(AnalysisMaterial material);
void DeleteAnalysisMaterial(int materialID);
void SetAnalysisMaterial(int materialID, AnalysisMaterial material);
ReadOnlyDictionary<int, AnalysisMaterial> AnalysisMaterials();

AnalysisTask related methods

bool Analyse(int taskID, TaskReport& analysisTaskReport);
string AnalysisTaskReport(int taskID);
int AddAnalysisTask(AnalysisTask task);
int AddAnalysisTask();
ReadOnlyDictionary<int, AnalysisTask> AnalysisTasks();

Assembly related methods

int AddAssembly(Assembly assembly);
void SetAssembly(int assemblyId, Assembly assembly);
void DeleteAssembly(int assemblyId);
ReadOnlyDictionary<int, Assembly> Assemblies();

Axis related methods

int AddAxis(Axis axis);
void AddAxes(ReadOnlyCollection<Axis> axes);
void DeleteAxis(int axisID);
void DeleteAxes(ReadOnlyCollection<int> axisIDs);
void DeleteAxes(int axisID, int numberOfAxes);
void SetAxis(int axisID, Axis axis);
void SetAxes(ReadOnlyDictionary<int, Axis> axes);
ReadOnlyDictionary<int, Axis> Axes();

BeamLoad related methods

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);
ReadOnlyCollection<BeamLoad> BeamLoads();

BeamThermalLoad related methods

int AddBeamThermalLoad(BeamThermalLoad beamThermalLoad);
void SetBeamThermalLoad(int beamThermalLoadId, BeamThermalLoad beamThermalLoad);
void AddBeamThermalLoads(ReadOnlyCollection<BeamThermalLoad> beamThermalLoads);
void DeleteBeamThermalLoad(int beamThermalLoadId);
void DeleteBeamThermalLoads(int beamThermalLoadId, int numberOfBeamThermalLoads);
ReadOnlyCollection<BeamThermalLoad> BeamThermalLoads();

CombinationCase related methods

int AddCombinationCase(CombinationCase combinationCase);
int AddCombinationCase(string name, string description);
void SetCombinationCases(ReadOnlyDictionary<int, CombinationCase> combinationCases);
ReadOnlyDictionary<int, CombinationCaseResult> CombinationCaseResults();
ReadOnlyDictionary<int, CombinationCase> CombinationCases();

ConcreteMaterial related methods

ConcreteMaterial CreateConcreteMaterial(string materialName);
void SetConcreteMaterial(int materialID, ConcreteMaterial material);
int AddConcreteMaterial(ConcreteMaterial material);
void DeleteConcreteMaterial(int materialID);
ReadOnlyCollection<string> GetStandardConcreteMaterialNames();
ReadOnlyDictionary<int, ConcreteMaterial> ConcreteMaterials();

DesignCode related methods

string ConcreteDesignCode();
string SteelDesignCode();

DesignTask related methods

int AddDesignTask(DesignTask designTask);
void SetDesignTask(int designTaskId, DesignTask designTask);
void DeleteDesignTask(int designTaskId);
bool Design(int designTaskId, TaskReport& designTaskReport);
bool Check(int designTaskId, TaskReport& designTaskReport);
ReadOnlyDictionary<int, SteelDesignTask> SteelDesignTasks();

DiagramSpecification related methods

GraphicDrawResult GetDiagrams(DiagramSpecification diagramSpecification);

Element related methods

void CreateElementsFromMembers();
string MemberElementSynchronisationReport();
ReadOnlyDictionary<int, Element> Elements(string elementsList);
ReadOnlyDictionary<int, Element> Elements();
ReadOnlyDictionary<int, LoadPanelElement> LoadPanelElements(string elementsList);
ReadOnlyDictionary<int, LoadPanelElement> LoadPanelElements();
int AddElement(Element element);
void AddElements(ReadOnlyCollection<Element> elements);
void DeleteElement(int elementID);
void DeleteElements(ReadOnlyCollection<int> elementIDs);
void DeleteElements(string elementsList);
void SetElement(int elementID, Element element);
void SetElements(ReadOnlyDictionary<int, Element> elements);
double ElementLength(int elementID);
double ElementArea(int elementID);
double ElementVolume(int elementID);
ReadOnlyCollection<double> ElementDirectionCosine(int elementID);
int AddLoadPanelElement(LoadPanelElement loadPanelElement);
void AddLoadPanelElements(ReadOnlyCollection<LoadPanelElement> loadPanelElements);
void DeleteLoadPanelElement(int loadPanelElementId);
void DeleteLoadPanelElements(ReadOnlyCollection<int> loadPanelElementIds);
void DeleteLoadPanelElements(string loadPanelElementList);
void SetLoadPanelElement(int loadPanelElementId, LoadPanelElement loadPanelElement);
void SetLoadPanelElements(ReadOnlyDictionary<int, LoadPanelElement> loadPanelElements);

FabricMaterial related methods

FabricMaterial CreateFabricMaterial(string materialName);
void SetFabricMaterial(int materialID, FabricMaterial material);
int AddFabricMaterial(FabricMaterial material);
void DeleteFabricMaterial(int materialID);
ReadOnlyCollection<string> GetStandardFabricMaterialNames();
ReadOnlyDictionary<int, FabricMaterial> FabricMaterials();

FaceLoad related methods

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);
ReadOnlyCollection<FaceLoad> FaceLoads();

FaceThermalLoad related methods

int AddFaceThermalLoad(FaceThermalLoad faceThermalLoad);
void SetFaceThermalLoad(int faceThermalLoadId, FaceThermalLoad faceThermalLoad);
void AddFaceThermalLoads(ReadOnlyCollection<FaceThermalLoad> faceThermalLoad);
void DeleteFaceThermalLoad(int faceThermalLoadId);
void DeleteFaceThermalLoads(int faceThermalLoadId, int numberOfFaceThermalLoads);
ReadOnlyCollection<FaceThermalLoad> FaceThermalLoads();

FrpMaterial related methods

FrpMaterial CreateFrpMaterial(string materialName);
void SetFrpMaterial(int materialID, FrpMaterial material);
int AddFrpMaterial(FrpMaterial material);
void DeleteFrpMaterial(int materialID);
ReadOnlyCollection<string> GetStandardFrpMaterialNames();
ReadOnlyDictionary<int, FrpMaterial> FrpMaterials();

GlassMaterial related methods

GlassMaterial CreateGlassMaterial(string materialName);
void SetGlassMaterial(int materialID, GlassMaterial material);
int AddGlassMaterial(GlassMaterial material);
void DeleteGlassMaterial(int materialID);
ReadOnlyCollection<string> GetStandardGlassMaterialNames();
ReadOnlyDictionary<int, GlassMaterial> GlassMaterials();

GraphicSpecification related methods

GraphicDrawResult Draw(GraphicSpecification graphicSpecification);

GravityLoad related methods

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);
ReadOnlyCollection<GravityLoad> GravityLoads();

GridAreaLoad related methods

int AddGridAreaLoad(GridAreaLoad gridAreaLoad);
void AddGridAreaLoads(ReadOnlyCollection<GridAreaLoad> gridAreaLoads);
void DeleteGridAreaLoad(int gridAreaLoadID);
void DeleteGridAreaLoads(int gridAreaLoadID, int numberOfGridAreaLoads);
void SetGridAreaLoad(int gridAreaLoadID, GridAreaLoad gridAreaLoad);
ReadOnlyCollection<GridAreaLoad> GridAreaLoads();

GridLine related methods

void SetGridLines(ReadOnlyDictionary<int, GridLine> gridLines);
int AddGridLineLoad(GridLineLoad gridLineLoad);
void AddGridLineLoads(ReadOnlyCollection<GridLineLoad> gridLineLoads);
void DeleteGridLineLoad(int gridLineLoadID);
void DeleteGridLineLoads(int gridLineLoadID, int numberOfGridLineLoads);
void SetGridLineLoad(int gridLineLoadID, GridLineLoad gridLineLoad);
ReadOnlyDictionary<int, GridLine> GridLines();
ReadOnlyCollection<GridLineLoad> GridLineLoads();

GridPlane related methods

int AddGridPlane(GridPlane gridPlane);
void AddGridPlanes(ReadOnlyCollection<GridPlane> gridPlanes);
void DeleteGridPlane(int gridPlaneID);
void DeleteGridPlanes(ReadOnlyCollection<int> gridPlaneIDs);
void DeleteGridPlanes(int gridPlaneID, int numberOfGridPlanes);
void SetGridPlane(int gridPlaneID, GridPlane gridPlane);
void SetGridPlanes(ReadOnlyDictionary<int, GridPlane> gridPlanes);
ReadOnlyDictionary<int, GridPlane> GridPlanes();

GridPointLoad related methods

int AddGridPointLoad(GridPointLoad gridPointLoad);
void AddGridPointLoads(ReadOnlyCollection<GridPointLoad> gridPointLoads);
void DeleteGridPointLoad(int gridPointLoadID);
void DeleteGridPointLoads(int gridPointLoadID, int numberOfGridPointLoads);
void SetGridPointLoad(int gridPointLoadID, GridPointLoad gridPointLoad);
ReadOnlyCollection<GridPointLoad> GridPointLoads();

GridSurface related methods

int AddGridSurface(GridSurface gridSurface);
void DeleteGridSurface(int gridSurfaceID);
void DeleteGridSurfaces(ReadOnlyCollection<int> gridSurfaceIDs);
void DeleteGridSurfaces(int gridSurfaceID, int numberOfGridSurfaces);
void SetGridSurface(int gridSurfaceID, GridSurface gridSurface);
int HighestGridSurface();
ReadOnlyDictionary<int, GridSurface> GridSurfaces();

Line related methods

int AddPolyline(Polyline polyline);
void SetPolyline(int polylineId, Polyline polyline);
void AddPolylines(ReadOnlyCollection<Polyline> polylines);
void DeletePolyline(int polylineId);
void DeletePolylines(int polylineId, int polylineCount);
ReadOnlyDictionary<int, Polyline> Polylines();

List related methods

Dictionary<int, EntityList> Lists(string listDefinition);
Dictionary<int, EntityList> Lists();
int AddList(EntityList list);
void AddLists(IEnumerable<EntityList> lists);
void DeleteList(int listId);
void DeleteLists(ReadOnlyCollection<int> listIds);
void DeleteLists(string listDefinition);
void SetList(int listId, EntityList list);
void SetLists(IDictionary<int, EntityList> lists);
ReadOnlyCollection<int> ExpandList(EntityList list, int highestEntityId);
ReadOnlyCollection<int> ExpandList(EntityList list);

LoadCase related methods

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

Member related methods

ReadOnlyDictionary<int, Member> Members(string membersList);
ReadOnlyDictionary<int, Member> Members();
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 MemberLength(int memberID);
double MemberArea(int memberID);
ReadOnlyCollection<double> MemberDirectionCosine(int memberID);

Node related methods

void CollapseCoincidentNodes(double tolerance);
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);
ReadOnlyDictionary<int, Node> Nodes(string nodesList);
ReadOnlyDictionary<int, Node> Nodes();
ReadOnlyCollection<NodeLoad> NodeLoads(NodeLoadType type);
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);

Prop2D related methods

int AddProp2D(Prop2D prop2D);
void AddProp2Ds(ReadOnlyCollection<Prop2D> prop2Ds);
void DeleteProp2D(int prop2DID);
void DeleteProp2Ds(ReadOnlyCollection<int> prop2DIDs);
void DeleteProp2Ds(int prop2DID, int numberOfProp2Ds);
void SetProp2D(int prop2DID, Prop2D prop2D);
void SetProp2Ds(ReadOnlyDictionary<int, Prop2D> prop2Ds);
ReadOnlyDictionary<int, Prop2D> Prop2Ds();

Prop3D related methods

int AddProp3D(Prop3D prop3D);
void AddProp3Ds(ReadOnlyCollection<Prop3D> prop3Ds);
void DeleteProp3D(int prop3DID);
void DeleteProp3Ds(ReadOnlyCollection<int> prop3DIDs);
void DeleteProp3Ds(int prop3DID, int numberOfProp3Ds);
void SetProp3D(int prop3DID, Prop3D prop3D);
void SetProp3Ds(ReadOnlyDictionary<int, Prop3D> prop3Ds);
ReadOnlyDictionary<int, Prop3D> Prop3Ds();

ReinforcementMaterial related methods

ReinforcementMaterial CreateReinforcementMaterial(string materialName);
void SetReinforcementMaterial(int materialID, ReinforcementMaterial material);
int AddReinforcementMaterial(ReinforcementMaterial material);
void DeleteReinforcementMaterial(int materialID);
ReadOnlyCollection<string> GetStandardReinforcementMaterialNames();
ReadOnlyDictionary<int, ReinforcementMaterial> ReinforcementMaterials();

Section related methods

ReadOnlyDictionary<int, string> SteelSectionPools();
void SetSteelSectionPools(ReadOnlyDictionary<int, string> steelSectionPools);
void SetSectionModifier(int sectionModifierID, SectionModifier sectionModifier);
void SetSectionModifiers(ReadOnlyDictionary<int, SectionModifier> sectionModifiers);
ReadOnlyDictionary<int, Section> Sections();
ReadOnlyDictionary<int, SectionModifier> SectionModifiers();
int AddSection(Section section);
void AddSections(ReadOnlyCollection<Section> sections);
void DeleteSection(int sectionID);
void DeleteSections(ReadOnlyCollection<int> sectionIDs);
void DeleteSections(int sectionID, int numberOfSections);
void SetSection(int sectionID, Section section);
void SetSections(ReadOnlyDictionary<int, Section> sections);
int AddSectionModifier(SectionModifier sectionModifier);
void AddSectionModifiers(ReadOnlyCollection<SectionModifier> sectionModifiers);
void DeleteSectionModifier(int sectionModifierID);
void DeleteSectionModifiers(ReadOnlyCollection<int> sectionModifierIDs);
void DeleteSectionModifiers(int sectionModifierID, int numberOfSectionModifiers);

SpringProperty related methods

void AddSpringProperty(ReadOnlyCollection<SpringProperty> springProperties);
int AddSpringProperty(SpringProperty springProperty);
void SetSpringProperty(ReadOnlyDictionary<int, SpringProperty> springProperties);
void SetSpringProperty(int SpringPropertyId, SpringProperty springProperty);
void DeleteSpringProperty(int springPropertyId, int numberOfspringProperties);
void DeleteSpringProperty(int springPropertyId);
ReadOnlyDictionary<int, SpringProperty> SpringProperties();

SteelMaterial related methods

SteelMaterial CreateSteelMaterial(string materialName);
void SetSteelMaterial(int materialID, SteelMaterial material);
int AddSteelMaterial(SteelMaterial material);
void DeleteSteelMaterial(int materialID);
ReadOnlyCollection<string> GetStandardSteelMaterialNames();
ReadOnlyDictionary<int, SteelMaterial> SteelMaterials();

TimberMaterial related methods

TimberMaterial CreateTimberMaterial(string materialName);
void SetTimberMaterial(int materialID, TimberMaterial material);
int AddTimberMaterial(TimberMaterial material);
void DeleteTimberMaterial(int materialID);
ReadOnlyCollection<string> GetStandardTimberMaterialNames();
ReadOnlyDictionary<int, TimberMaterial> TimberMaterials();

Titles related methods

Titles Titles();

UiUnits related methods

UiUnits UiUnits();