Skip to main content

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 CreateAluminiumMaterial(string materialName);
void SetAluminiumMaterial(int materialID, AluminiumMaterial material);
int AddAluminiumMaterial(AluminiumMaterial material);
void DeleteAluminiumMaterial(int materialID);
ReadOnlyCollection<string> GetStandardAluminumMaterialNames();
ReadOnlyDictionary<int, AluminiumMaterial> AluminiumMaterials();
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);
ReadOnlyDictionary<int, AnalysisCaseResult> Results();
int AddAnalysisMaterial(AnalysisMaterial material);
void DeleteAnalysisMaterial(int materialID);
void SetAnalysisMaterial(int materialID, AnalysisMaterial material);
ReadOnlyDictionary<int, AnalysisMaterial> AnalysisMaterials();
bool Analyse(int taskID, TaskReport& analysisTaskReport);
string AnalysisTaskReport(int taskID);
int AddAnalysisTask(AnalysisTask task);
int AddAnalysisTask();
ReadOnlyDictionary<int, AnalysisTask> AnalysisTasks();
int AddAssembly(Assembly assembly);
void SetAssembly(int assemblyId, Assembly assembly);
void DeleteAssembly(int assemblyId);
ReadOnlyDictionary<int, Assembly> Assemblies();
ReadOnlyDictionary<int, Axis> Axes();
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);
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();
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();
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 CreateConcreteMaterial(string materialName);
void SetConcreteMaterial(int materialID, ConcreteMaterial material);
int AddConcreteMaterial(ConcreteMaterial material);
void DeleteConcreteMaterial(int materialID);
ReadOnlyCollection<string> GetStandardConcreteMaterialNames();
ReadOnlyDictionary<int, ConcreteMaterial> ConcreteMaterials();
string ConcreteDesignCode();
string SteelDesignCode();
bool Design(int designTaskId, TaskReport& designTaskReport);
bool Check(int designTaskId, TaskReport& designTaskReport);
int AddDesignTask(DesignTask designTask);
void SetDesignTask(int designTaskId, DesignTask designTask);
void DeleteDesignTask(int designTaskId);
ReadOnlyDictionary<int, SteelDesignTask> SteelDesignTasks();
GraphicDrawResult GetDiagrams(DiagramSpecification diagramSpecification);
void CreateElementsFromMembers();
ReadOnlyDictionary<int, Element> Elements(string elementsList);
ReadOnlyDictionary<int, Element> Elements();
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);
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();
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();
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 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 CreateGlassMaterial(string materialName);
void SetGlassMaterial(int materialID, GlassMaterial material);
int AddGlassMaterial(GlassMaterial material);
void DeleteGlassMaterial(int materialID);
ReadOnlyCollection<string> GetStandardGlassMaterialNames();
ReadOnlyDictionary<int, GlassMaterial> GlassMaterials();
GraphicDrawResult Draw(GraphicSpecification graphicSpecification);
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();
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();
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();
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();
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();
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();
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();
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);
void DeleteLoadCase(int loadCaseID);
void SetLoadCases(ReadOnlyDictionary<int, LoadCase> loadCases);
ReadOnlyDictionary<int, LoadCase> LoadCases();
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);
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);
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();
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 CreateReinforcementMaterial(string materialName);
void SetReinforcementMaterial(int materialID, ReinforcementMaterial material);
int AddReinforcementMaterial(ReinforcementMaterial material);
void DeleteReinforcementMaterial(int materialID);
ReadOnlyCollection<string> GetStandardReinforcementMaterialNames();
ReadOnlyDictionary<int, ReinforcementMaterial> ReinforcementMaterials();
ReadOnlyDictionary<int, string> SteelSectionPools();
void SetSteelSectionPools(ReadOnlyDictionary<int, string> steelSectionPools);
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);
void SetSectionModifier(int sectionModifierID, SectionModifier sectionModifier);
void SetSectionModifiers(ReadOnlyDictionary<int, SectionModifier> sectionModifiers);
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 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 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 Titles();
UiUnits UiUnits();