# OpenStaad Python — full documentation > Open-source (MIT), unofficial Python library to automate Bentley STAAD.Pro through the > OpenSTAAD COM API. Install with `pip install openstaad`. Runs on Windows only, with > STAAD.Pro installed and a .STD model open. ## Rules for writing openstaad code - Use the session API: `from openstaad import ops` then `s = ops.connect()` (the active STAAD.Pro instance) or `s = ops.connect(path)` (a .STD already open, by path). Every function below is a method on `s`, e.g. `s.GetBeamList()`. - Do NOT use the legacy classes `Root()`, `Geometry()`, `Load()`, `Output()`, `Properties()`, `View()`, `Design()`, `Command()` or `Support()`: they are deprecated in 0.0.x and removed in 0.1.0. See the migration guide if you meet them in existing code. - Two unit systems apply. Every value that comes back arrives in the model's base unit, which the script cannot choose and which is an STAAD.Pro application setting, not a file property. Call `s.GetBaseUnit()` first. `"Metric"` means meters and kilonewtons (not mm); `"English"` means inches and kips (not feet, not pounds). Convert explicitly before comparing or reporting. - Every value the script sends is read in the model's input units (`GetInputUnitForLength()` / `GetInputUnitForForce()`, set with `SetInputUnits()`), which are independent of the base unit. Read them before writing and align them with the base unit. - Function names mirror the OpenSTAAD API names (e.g. `GetMemberIncidence`, `AddNodalLoad`), so OpenSTAAD knowledge transfers directly; check the reference below for the Python signature and return type. - Results (forces, displacements, reactions) are only available after the model has been analyzed. --- # What is OpenStaad Python? > **⚠️ Important Note:** OpenStaad Python requires an active and valid Staad.PRO file to function properly. OpenStaad Python (OPS) is a library designed to simplify interaction with the OpenStaad API. It provides an intuitive and user-friendly interface that allows structural engineers and developers to automate common tasks in Staad.PRO efficiently. --- ## Why Use OpenStaad Python? - **Easy to Use:** Provides a simplified API that reduces the complexity of working directly with OpenStaad. - **Automation:** Enables automation of repetitive tasks such as model creation, analysis, and result extraction. - **Integration:** Compatible with Python, making it easy to integrate with other libraries and tools. - **Clear Documentation:** Designed to be easy to learn and use, with practical examples. --- ## Installation You can easily install OpenStaad Python using `pip`: ```bash pip install openstaad ``` --- ## Getting Started Make sure you have [Staad.PRO](https://www.bentley.com/software/staad/) installed and a valid file open before using OpenStaad Python. ### Basic Example ```python from openstaad import ops s = ops.connect() beam_list = s.GetBeamList() beam_nodes = s.GetMemberIncidence(10) print("Beam list:", beam_list) print("Beam nodes:", beam_nodes) ``` --- ## Key Features - **Access Geometry:** Get detailed information about structural elements such as beams, nodes, and plates. - **Model Control:** Create, save, and analyze models directly from Python. - **Customizable Units:** Work with different unit systems as per your needs — see the [Unit Systems guide](/guides/unit_systems) for what OpenStaad returns and why. - **Analysis Results:** Extract results like displacements, forces, and moments programmatically. --- ## Using OpenStaad with AI Assistants This documentation is published in a form that AI assistants can read directly: - [`/llms.txt`](https://www.openstaad.com/llms.txt): an index of every page, with the rules an assistant needs to write correct openstaad code (session API, base units). - [`/llms-full.txt`](https://www.openstaad.com/llms-full.txt): the whole reference in a single file. - Every doc page has a plain-markdown twin at the same URL plus `.md`, e.g. [`/docs/node.md`](https://www.openstaad.com/docs/node.md). If you work with a coding agent such as Claude Code, Gemini CLI, Codex or Cursor, add this to your project's `CLAUDE.md` or `AGENTS.md`: ```markdown This project automates STAAD.Pro with the `openstaad` Python library. Before writing openstaad code, read https://www.openstaad.com/llms.txt and follow its rules. Use `from openstaad import ops; s = ops.connect()` and call every function on `s`. Always check `s.GetBaseUnit()` before interpreting any number. ``` --- ## Additional Resources - [Official OpenStaad Documentation](https://docs.bentley.com/LiveContent/web/STAAD.Pro%20Help-v14/en/GUID-93E26CB6-E60E-4175-920A-72D504639722.html) - [Staad.PRO Page](https://www.bentley.com/software/staad/) --- Start exploring the possibilities with OpenStaad Python and take your structural projects to the next level! Source: https://www.openstaad.com/guides/what_is_openstaad --- # Start from Scratch This guide will walk you through the process of setting up your environment to use OpenStaad Python, starting from scratch. By the end, you'll have everything you need to write and execute your first OpenStaad Python script. --- ## Prerequisites Before starting, ensure you have the following: 1. A computer running Windows (required for Staad.PRO). 2. An active license for [Staad.PRO](https://www.bentley.com/software/staad/). --- ## Step 1: Install Staad.PRO 1. Download Staad.PRO from the [Bentley Systems website](https://www.bentley.com/software/staad/). 2. Follow the installation instructions provided by Bentley. 3. Ensure that Staad.PRO is installed and activated with a valid license. --- ## Step 2: Install Visual Studio Code 1. Download Visual Studio Code (VS Code) from the [official website](https://code.visualstudio.com/). 2. Run the installer and follow the setup instructions. 3. Once installed, open VS Code and install the following extensions: - **Python** (by Microsoft): Provides Python support in VS Code. - **Markdown All in One** (optional): For better Markdown editing. --- ## Step 3: Install Python 1. Download Python from the [official Python website](https://www.python.org/downloads/). 2. During installation, ensure you check the box **"Add Python to PATH"**. 3. Verify the installation by opening a terminal (Command Prompt or PowerShell) and running: ```bash python --version ``` You should see the installed Python version. --- ## Step 4: Install OpenStaad Python 1. Open a terminal (Command Prompt or PowerShell). 2. Install OpenStaad Python using pip: ```bash pip install openstaad ``` 3. Verify the installation by running: ```bash pip show openstaad ``` You should see details about the OpenStaad package. --- ## Step 5: Create Your First OpenStaad Python Script 1. Open Visual Studio Code. 2. Create a new file and save it with a `.py` extension (e.g., `first_openstaad_script.py`). 3. Write the following code to test your OpenStaad installation: ```python from openstaad import ops # Connect to the running STAAD.Pro instance s = ops.connect() # Get a list of beams in the model beam_list = s.GetBeamList() # Print the beam list print("Beam List:", beam_list) ``` 4. Save the file. 5. Open Staad.PRO and load a model file. 6. In the terminal, navigate to the directory where your script is saved and run: ```bash python first_openstaad_script.py ``` 7. You should see the output of the beam list in the terminal. --- ## Step 6: Explore OpenStaad Python Now that you have your first script running, you can explore the OpenStaad Python library further. Source: https://www.openstaad.com/guides/start_from_scratch --- # OpenStaad Unit Systems: one to get, one to set OpenSTAAD works with **two unit systems**, and each one governs a different direction: - **To get values, base units.** Everything OpenSTAAD hands back to your script arrives in the base units: meters and kN, or inches and kips. - **To set values, input units.** Everything your script sends is read in the model's input units, the model's current `UNIT` command. They are independent. A session can have English base units and metric input units at the same time, and that is working as designed. ![Diagram of the two unit systems. STAAD.Pro holds the base unit, an application setting the script can only read, and the model's UNIT command, the input units, which the script can read and change. Values the script gets come back in base units; values it sets are read in input units.](/images/unit-systems-diagram.svg) --- ## The difference at a glance | | **Base units** | **Input units** | |---|---|---| | Direction | Values you **get** (STAAD → script) | Values you **set** (script → STAAD) | | What they are | `English` (in, kip) or `Metric` (m, kN) | The model's `UNIT` command, such as `UNIT METER KN` | | Who controls them | The STAAD.Pro **application** (Application Configuration → Base Unit) | The **model**, through its `UNIT` command | | Can your script change them? | **No** | **Yes**, with `SetInputUnits()` | | How to read them | `GetBaseUnit()` | `GetInputUnitForLength()`, `GetInputUnitForForce()` | | Details | [Base Units](/guides/base_units) | [Input Units](/guides/input_units) | --- ## What it means for your scripts Getting this wrong is silent. Nothing raises, nothing warns, and the design check just comes out wrong. ```python print(s.GetBaseUnit()) # -> "English" x, y, z = s.GetNodeCoordinates(1) # (236.22, 0, 0): inches (base) s.CreateNode(4, 3.048, 0, 0) # 3.048 read as meters (input) ``` - **A returned `236.22` is not 236 m.** It is 236.22 in, or 6 m, in a model whose base unit is English. You never choose the unit of a returned value, so read `GetBaseUnit()` and convert. - **The base unit is not in the file.** It belongs to the STAAD.Pro installation that opens the model, so the same `.std` can return different numbers on two machines. Never assume it from how the model was built. - **Changing the input units changes every later write.** `SetInputUnits()` does not alter what you read back, but from then on every value you send is taken in the new unit. --- ## Three habits that keep you safe 1. **Read `GetBaseUnit()` at the start of every script**, and convert returned values at the boundary. Label every number you print with its unit. 2. **Read the input units before you send anything**, and set them to match the base units so sent and returned values share one system. 3. **Never assume a value's unit from how the model looks in STAAD.Pro.** The interface can show meters while OpenSTAAD returns inches. --- ## Where to go next - [Base Units](/guides/base_units) — the units of returned values, why they are an application setting, every derived quantity and a conversion pattern. - [Input Units](/guides/input_units) — the units of sent values, the integer unit codes and how to set them safely. Source: https://www.openstaad.com/guides/unit_systems --- # Base Units: the units OpenStaad returns to you Every number OpenSTAAD **returns** to your script — a node coordinate, a member end force, a displacement, a section area — comes back in the model's **base units**, a unit your script did not choose and cannot change. Getting this wrong is silent. A beam reported as `236.22` is not a 236 m span; it is 236.22 in, or 6 m, in a model whose base unit happens to be English. Nothing raises, nothing warns — the design check just comes out wrong. This page is only about base units, the **get** side. For the units of values you **send**, see [Input Units](/guides/input_units); for how the two fit together, see [Unit Systems](/guides/unit_systems). --- ## The short answer | Base unit | Length-derived values | Force-derived values | |---|---|---| | **Metric** | meters (`m`) | kilonewtons (`kN`) | | **English** | inches (`in`) | kilopounds (`kip`) | That is the whole rule for reads. Everything else in this page is a consequence of it. Note the two easy mistakes: the English force unit is the **kip**, not the pound — and the metric length unit is the **meter**, not the millimeter. A displacement of `0.012` in a metric model is 12 mm, not 0.012 mm. --- ## Base unit is not stored in the file ![STAAD.Pro Application Configuration dialog showing the Base Unit setting under General, with Metric selected](/images/base-units-app-config.png) Base unit is not a `.std` file property. It's set in STAAD.Pro's own **Application Configuration → General → Base Unit** dialog (pictured above), and it applies to whatever file is opened next — it is read once, when the file is opened, not stored inside it. A model built and tested entirely with STAAD.Pro configured for **English** can have a `.std` file that contains no mention of Metric anywhere — only `UNIT` lines from `SetInputUnits()` calls, which are a separate, per-command setting (see [Input Units](/guides/input_units)): ``` UNIT INCHES KIP JOINT COORDINATES 1 0 0 0; 2 120 0 0; 3 240 0 0; ... UNIT METER KN ... UNIT INCHES KIP ``` Close that file, switch **Application Configuration → General → Base Unit** to **Metric**, and reopen the same, unmodified `.std` file: `GetBaseUnit()` immediately starts returning `"Metric"`, and every previously-in-inches value — node coordinates, load magnitudes — comes back converted to meters and kN, with no edit to the file at all. Two people can open the identical file with different STAAD installs configured differently and get different values back from every `Get*` call — same file, same geometry, different numbers. This makes `GetBaseUnit()` **not safely cacheable across sessions or machines**, and not something a script can infer from the file itself without calling the API. Any pipeline that assumes "this model is an English-unit model" because that's how it was built is wrong; it depends on whoever's STAAD instance opens it next. **Always call `GetBaseUnit()` at the start of a script; never assume it from how the model was authored.** --- ## Reading the base unit `GetBaseUnit()` returns the string `"Metric"` or `"English"` for the currently open `.STD`: ```python from openstaad import ops s = ops.connect() print(s.GetBaseUnit()) # -> "Metric" or "English" ``` Underneath, STAAD returns the integer `1` for English and `2` for Metric; the library maps it to the string so you never have to remember which is which. Any script that will run on somebody else's model — or on your own model from a machine configured differently — should read this on the first line and branch on it. A script that assumes metric is a script that works until the day it doesn't. --- ## Can I get returned values in a different unit than the base unit? No. OpenSTAAD has no setting that changes the units of returned values: `SetInputUnits()` only affects what you send, and the base unit is set by the STAAD.Pro application, not by your script. If you need a value in another unit, convert it yourself as soon as it arrives — see *A conversion pattern that holds up* below. --- ## Derived quantities Only length and force are primitive. Everything else is built from them, which means every derived unit changes with the base unit too: | Quantity | Metric | English | |---|---|---| | Length, displacement, section dimension | `m` | `in` | | Force, reaction, axial force | `kN` | `kip` | | Moment | `kN·m` | `kip·in` | | Stress | `kN/m²` | `kip/in²` (ksi) | | Section area | `m²` | `in²` | | Section modulus | `m³` | `in³` | | Moment of inertia | `m⁴` | `in⁴` | | Distributed force | `kN/m` | `kip/in` | | Density | `kN/m³` | `kip/in³` | The practical consequence: a conversion factor of `0.0254` is not enough. An area needs `0.0254²`, an inertia needs `0.0254⁴`, and a stress needs `force / length²`. Converting each quantity with the same length factor is a common and expensive bug. These factors were checked by reading the same unmodified model with English and then Metric base units (STAAD.Pro 2025 25.0.1.424, openstaad 0.0.15). The ratio `English / Metric` matched the table: | Quantity read | Ratio `English / Metric` | |---|---| | Coordinates, displacements | 39.370 | | Reactions, member end forces | 0.22481 | | Moments | 8.8507 | | Section area (`Ax`, `Ay`, `Az`) | 1550.003 | | `Iy`, `Iz` | 2 402 510 | | Modulus of elasticity | 1.4504e-4 | | Material density | 3.684e-6 | | UDL magnitude | 5.710e-3 | Not everything follows the base unit. Rotations, Poisson's ratio and the thermal expansion coefficient came back identical under both. Section modulus was not verified, because no function returns it directly. The torsional constant returned by `GetBeamProperty` was the one exception we could not explain: it did not follow the `39.37⁴` factor (`0.3` in⁴ against `1.181e-7` m⁴, a ratio of about 2 539 564 instead of 2 402 510), so do not convert it with the inertia factor without checking it against your own model. --- ## A conversion pattern that holds up Read the base unit once, derive every factor from the two primitives, and never hand-write a conversion at the call site: ```python from openstaad import ops IN_TO_M = 0.0254 # exact KIP_TO_KN = 4.4482216152605 # exact class BaseUnits: """Factors converting OpenStaad's base-unit values into m / kN.""" def __init__(self, base_unit: str): if base_unit == "Metric": self.length, self.force = 1.0, 1.0 elif base_unit == "English": self.length, self.force = IN_TO_M, KIP_TO_KN else: raise ValueError(f"unknown base unit: {base_unit!r}") # Everything below is derived, so it can never drift out of sync. @property def area(self): return self.length ** 2 @property def inertia(self): return self.length ** 4 @property def moment(self): return self.force * self.length @property def stress(self): return self.force / self.length ** 2 @property def dist_force(self): return self.force / self.length s = ops.connect() u = BaseUnits(s.GetBaseUnit()) x, y, z = s.GetNodeCoordinates(1) print(f"node 1: ({x * u.length:.3f}, {y * u.length:.3f}, {z * u.length:.3f}) m") # end = 0 (start) or 1 (end); last argument is 0 global / 1 local fx, fy, fz, mx, my, mz = s.GetMemberEndForces(1, 0, 1, 1) print(f"axial = {fx * u.force:.2f} kN") print(f"moment = {mz * u.moment:.2f} kN·m") ``` Two habits make this robust: - **Convert at the boundary.** Turn base-unit values into your working units the moment they arrive, and keep everything downstream in one system. Mixed-unit values flowing through a calculation are nearly impossible to debug after the fact. - **Label your output.** Print the unit next to the number. A report that says `236.22` invites the reader to guess; one that says `236.22 in` does not. --- ## Checklist - Read `GetBaseUnit()` once at startup, every run — never assume it from how the model was authored or from a previous run. It's an application setting, not a file property. - Convert returned values at the boundary and label every printed number with its unit. - Derive area, inertia, moment and stress factors from the length and force factors; never reuse the length factor alone. - If a script runs on shared models or teammates' machines, don't assume `GetBaseUnit()` will be the same on every machine — check STAAD's Application Configuration if results look suspiciously off by a unit factor. --- ## Further reading - [Unit Systems](/guides/unit_systems) — how base units and input units work together. - [Input Units](/guides/input_units) — the units of every value you send. - [Get Base Unit](/docs/session-file-root#GetBaseUnit) — the function reference. - [Units in STAAD.Pro](https://docs.bentley.com/LiveContent/web/STAAD.Pro%20Help-v19/en/GUID-C03F5D61-17FE-4FE3-8CB8-042D71C2F6AB.html) — Bentley's own description of the base unit setting. Source: https://www.openstaad.com/guides/base_units --- # Input Units: the units OpenStaad reads from you Every number your script **sends** to OpenSTAAD — a node coordinate in `CreateNode`, a load in `AddNodalLoad`, a distributed force in `AddMemberUniformForce` — is interpreted in the model's **input units**: whatever the model's current `UNIT` command says, such as `UNIT MMS KN` or `UNIT FEET KIP`. Unlike base units, your script can read them and change them. Getting this wrong is silent. Send `3.048` while the input length unit is meters and you have a 3.048 m node; send the same number while it is millimeters and you have a 3 mm one. Nothing raises, nothing warns. This page is only about input units, the **set** side. For the units of values you get **back**, see [Base Units](/guides/base_units); for how the two fit together, see [Unit Systems](/guides/unit_systems). --- ## Reading the input units ```python from openstaad import ops s = ops.connect() print(s.GetInputUnitForLength()) # e.g. "Meter" print(s.GetInputUnitForForce()) # e.g. "KiloNewton" ``` Read them before sending anything. They are a property of the open model's current `UNIT` command, so they can differ from what you expect if the model was authored, or last changed, by someone else. Input units are **independent of base units**. A session can have English base units and metric input units at the same time: reads come back in inches while writes are taken as meters. A model can be authored in `UNIT METER KN`, show meters everywhere in the STAAD.Pro interface, and still return inches through OpenSTAAD, because its base unit is English. This is working as designed. --- ## Setting the input units `SetInputUnits()` sets length and force together; `SetInputUnitForLength()` and `SetInputUnitForForce()` set one at a time. All three take integer codes: | Code | Length | Force | |---|---|---| | 0 | Inch | Kilopound | | 1 | Feet | Pound | | 2 | Feet (same as `1`) | Kilogram | | 3 | CentiMeter | Metric Ton | | 4 | Meter | Newton | | 5 | MilliMeter | KiloNewton | | 6 | DeciMeter | MegaNewton | | 7 | KiloMeter | DecaNewton | > Length code `2` is listed upstream as a duplicate of `Feet`, and testing confirms it: with English > base units, `SetInputUnitForLength(2)` makes `GetInputUnitForLength()` return `"Feet"`, and a node > sent at `x = 1` comes back as `12.0` in. Use `1` for feet and ignore `2`. ```python s.SetInputUnits(4, 5) # Meter, KiloNewton print(s.GetInputUnitForLength()) # -> "Meter" print(s.GetInputUnitForForce()) # -> "KiloNewton" ``` ### SetInputUnits changes what you send, not what you get back They change how values you **write** are interpreted, and how the model **displays** them. They do not touch how values you read look, but they are **not harmless** — every value you send after calling them is taken in the new units, silently: ```python # English base units; input units set to Meter, KiloNewton s.SetInputUnits(4, 5) s.GetNodeCoordinates(2) # (120.0, 0, 0): still inches (base) s.CreateNode(3, 3.048, 0, 0) # 3.048 is taken as METERS s.GetNodeCoordinates(3) # (119.99976, 0, 0): returned in inches ``` If you need values back in a different unit, no input-unit setting will do it: convert them yourself. See [Base Units](/guides/base_units). --- ## Derived quantities you send The same rule holds for derived quantities. A distributed load sent as `-2` with input units m/kN is stored and returned as `-0.01142` kip/in in an English-base model, because `-2` kN/m is `-0.01142` kip/in. What we measured (STAAD.Pro 2025 25.0.1.424, openstaad 0.0.15), with **English** base units: | Sent value | Input units at send time | Returned (in / kip) | |---|---|---| | Node x = 120 | in / kip | 120.0 in | | Node x = 3.048 | m / kN | 119.99976 in | | Nodal FY = −10, MZ = 100 | in / kip | −10.0 kip, 100.0 kip·in | | Nodal FY = −10, MZ = 10 | m / kN | −2.24809 kip, 88.5073 kip·in | | UDL w = −0.5 | in / kip | −0.5 kip/in | | UDL w = −2 | m / kN | −0.01142 kip/in | | Conc. P = −5 at d1 = 60 | in / kip | −5.0 kip at 60.0 in | | Conc. P = −5 at d1 = 1.5 | m / kN | −1.124 kip at 59.055 in | The same model with **Metric** base units returns each value in m / kN, whichever input units it was sent in: a UDL sent as `-0.5` in kip/in reads `-87.56342` kN/m, and one sent as `-2` in kN/m reads `-2.0` kN/m. Every returned value was identical whether it was read with input units set to in/kip or to m/kN: input units never change what you read. --- ## Align input units with base units before writing The simplest safe habit is to set the input units to match the base units before writing, so sent and returned values share one system: ```python if s.GetBaseUnit() == "English": s.SetInputUnits(0, 0) # Inch, Kilopound else: s.SetInputUnits(4, 5) # Meter, KiloNewton ``` If you change them for a while, put them back. Anything else that writes to the same session, or the next script, inherits whatever you left. **A precision note:** when STAAD returns a value in inches that was sent in meters, it converts with **39.37 in/m**, not the exact `1 / 0.0254`. The result is off in the 6th significant digit — 3.048 m returns as 119.99976 in, not 120. The opposite direction (in → m) and every force conversion were exact in testing. Values written under one input unit and read after a base-unit switch came back exact, which suggests STAAD keeps each value in the units it was sent in and converts when it returns it. Compare round-tripped values with a tolerance, never with `==`. --- ## Checklist - Read `GetInputUnitForLength()` / `GetInputUnitForForce()` before sending values; every sent value is interpreted in those units. - Prefer aligning input units with base units before writing. - Never assume `SetInputUnits()` is harmless: it changes how all later writes are interpreted, even though it leaves already-read values untouched. - Restore the input units you found if you change them for one operation. - Compare round-tripped values with a tolerance — STAAD converts length with 39.37 in/m, not the exact inverse of 0.0254. --- ## Further reading - [Unit Systems](/guides/unit_systems) — how base units and input units work together. - [Base Units](/guides/base_units) — the units of every value you get back. - [SetInputUnits](/docs/session-file-root#SetInputUnits) — the function reference, alongside `SetInputUnitForLength`, `SetInputUnitForForce`, `GetInputUnitForLength` and `GetInputUnitForForce`. Source: https://www.openstaad.com/guides/input_units --- # Migration Guide: openstaad 0.0.x to 0.1 ## What changes and why The **legacy API** (standalone classes `Root()`, `Geometry()`, `Load()`, …) is **deprecated** in the `0.0.x` releases (it emits a `FutureWarning` on instantiation) and **will be removed in `0.1.0`**. The **new API** is a single import with one shared session: ```python from openstaad import ops s = ops.connect() # active STAAD.Pro instance (equivalent to Root()) # s = ops.connect(path) # a .STD already open, by path (equivalent to Root(path)) ``` **97% of the migration is mechanical:** method names **do not change**; you just collapse the multiple objects into a single session `s` and repoint the calls to `s.`. ## Mechanical migration (general case) **Before:** ```python from openstaad import Geometry, Root geometry = Geometry() root = Root() beams = geometry.GetBeamList() name = root.GetSTAADFile() ``` **After:** ```python from openstaad import ops s = ops.connect() beams = s.GetBeamList() name = s.GetSTAADFile() ``` ## Deprecated API The following 9 classes are deprecated; **all of their methods** are re-exposed with the **same name** on the `s` session: `Root`, `Geometry`, `Load`, `Output`, `Properties`, `View`, `Design`, `Command`, `Support` Of the 203 public methods in the legacy API, **197 have an identical name in `ops`** (direct migration). The remaining 6 are detailed below. --- ## ⚠️ Cases that are NOT a simple move ### 1. Renamed methods (3) | Legacy | New (`ops`) | Note | |---|---|---| | `GetElementGlobalOffset` | `GetElementGlobalOffSet` | capitalization change `Offset`→`OffSet` | | `GetElementOffsetSpec` | `GetElementOffSetSpec` | capitalization change `Offset`→`OffSet` | | `AddResponseSpectrumLoadEx` | `AddResponseSpectrumLoad` | **the signature also changes** (see below) | `AddResponseSpectrumLoad` **changes argument order/optionality**: ```python # Legacy: AddResponseSpectrumLoadEx(code_number, modal_combination, set_names_1, set_values_1, spectrum_data_pairs, set_names_2=None, set_values_2=None) # New: s.AddResponseSpectrumLoad(rsaCode, rsaCombination, varSet1Names, varSet1Vals, varSet2Names, varSet2Vals, varDataPairs) ``` The `data_pairs` move from 5th position (legacy) to **last** (new), and `set_names_2/values_2` are no longer optional. Requires manual review, not just a rename. ### 2. Removed methods with no direct equivalent (1) | Legacy | Replacement | |---|---| | `IsRelease(memb)` | **does not exist** in `ops`. Use `s.GetMemberReleaseSpecEx(beam, position)` and evaluate the release values yourself. | ### 3. Ignore (not real API) `make_safe_array_long` and `make_variant_vt_ref` showed up as "methods" only because the legacy API did `from openstaad.tools import *`. They are **not part of the public API** and need no migration. --- ## ⚠️ Behavior changes (same name, different result) These methods **keep their name** but their output changed (the new API was aligned to the official OpenSTAAD behavior). Review any code that relies on them: | Method(s) | Legacy | New | |---|---|---| | `GetNodeCoordinates`, `GetNodeIncidence`, `GetNodeDistance`, `GetBeamLength` | **rounded** to 3 decimals | **full precision** (no rounding) | | `GetApplicationVersion` | `"Version 1.2.3.4"` | `"1.2.3.4"` (no prefix) | | `GetAnalysisStatus` | dict key `"CPUTime(sec)"` | key `"CPUTime"` | | `NewSTAADFile` | created a `Staad_folder` subfolder; args had defaults | does **not** create folders; `(fileName, lengthUnit, forceUnit)` are required | | `SaveModel` | `SaveModel(silent: int)` | `SaveModel(saveSilent: bool = False)` | | several list getters | returned a `tuple` | return a `list` (low impact) | --- ## Migration prompt for an LLM Paste this prompt together with your script into any LLM: ``` CONTEXT — about the library: `openstaad` is an unofficial, community-built Python wrapper around the OpenSTAAD COM API used to automate STAAD.Pro. It is installed from PyPI with `pip install openstaad`, and its documentation lives at https://www.openstaad.com/docs. Only 0.0.x releases exist today; version 0.1.x is scheduled for late summer 2026 and removes the legacy class-based API (Root, Geometry, Load, …) in favor of the single `ops` session shown below. Migrate this `openstaad` script from the legacy API (pre-0.1) to the new `ops` API (0.1). STEP 0 — PRE-FLIGHT CHECK (do this FIRST; decide whether migration is even needed): Run these commands (or ask the user to run them) and interpret the output: a) Is a virtual environment active? python -c "import sys; print('venv active' if sys.prefix != sys.base_prefix else 'NO venv')" If "NO venv": warn the user to create/activate one before changing installed packages (Windows: py -m venv venv && venv\Scripts\activate ; macOS/Linux: python -m venv venv && source venv/bin/activate). b) Which openstaad is installed, and its version? pip show openstaad (read the "Version:" line) (fallback: python -c "import importlib.metadata as m; print(m.version('openstaad'))") If not installed: there is nothing to migrate against yet; install the target version first. c) Which version is available on PyPI? pip index versions openstaad (fallback: pip install "openstaad==" 2>&1) DECISION — do you need to apply this migration guide? - Installed version >= 0.1.0 -> legacy API is REMOVED -> migration REQUIRED. Continue. - Installed 0.0.x AND upgrading to the >= 0.1.0 on PyPI -> migration REQUIRED before upgrading. Continue. - Installed 0.0.x AND staying on 0.0.x -> migration OPTIONAL: the legacy API still works but emits FutureWarnings. Migrating now future-proofs the code and silences the warnings. Ask the user; continue only if they opt in. - openstaad NOT installed -> STOP: nothing to migrate; install the target version first. Only proceed to the steps below if the decision is that migration is needed (or the user chose to future-proof). WHAT TO REVIEW AND DO: 1. Imports: replace `from openstaad import Root, Geometry, Load, ...` with `from openstaad import ops`. 2. Connection: replace ALL class instances (Root(), Geometry(), Load(), Output(), Properties(), View(), Design(), Command(), Support()) with a SINGLE session: s = ops.connect() If any class received a path/filePath, use: s = ops.connect(path) 3. Calls: repoint every method to `s.` (e.g. geometry.GetBeamList() -> s.GetBeamList()). Method NAMES do NOT change, EXCEPT these renames: GetElementGlobalOffset -> GetElementGlobalOffSet GetElementOffsetSpec -> GetElementOffSetSpec AddResponseSpectrumLoadEx -> AddResponseSpectrumLoad (REVIEW the signature: data_pairs goes last and set_names_2/values_2 are no longer optional) 4. Removed method: if the code uses IsRelease(memb), it has NO direct equivalent; mark it with a TODO comment and suggest using s.GetMemberReleaseSpecEx(...) evaluating the release values. 5. Behavior changes to FLAG (name unchanged, but result differs): coordinates and lengths are NO longer rounded to 3 decimals; GetApplicationVersion no longer has the "Version " prefix; GetAnalysisStatus uses the key "CPUTime" (was "CPUTime(sec)"); NewSTAADFile no longer creates a folder and its 3 arguments are required; SaveModel now takes a bool. 6. Do not change business logic or the order of operations. Return the migrated code and, separately, a list of the points that need human review (IsRelease, AddResponseSpectrumLoad, and any dependency on the behavior changes). --- SCRIPT TO MIGRATE --- ``` Source: https://www.openstaad.com/guides/migration_guide --- # Node functions | OpenStaad Python > The most fundamental modeling primitive — beams, plates, and solids all connect to nodes and are defined from them. Node-related loads and definitions live in their own domains (Load, Group). Source: https://www.openstaad.com/docs/node Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddMultipleNodes **Description** Adds multiple the nodes. **Parameters** - `coordinates` (list): coordinates. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMultipleNodes([1, 2]) print(result) ``` ### AddNode Adds a node with specified coordinates in the current model This function adds a node with the specified coordinates to the current model and returns the node number automatically assigned. ##### Parameters - **fCoordX**: Node X coordinate in GLOBAL. - **fCoordY**: Node Y coordinate in GLOBAL. - **fCoordZ**: Node Z coordinate in GLOBAL. ##### Return values - ****: Node number assigned to this created node. - **0**: OK. - **-2004**: Unable to add node. ##### Example ```python # Example usage of AddNode from openstaad import ops # Instanciar el módulo Geometry s = ops.connect() # Ejecutar la función desde el módulo geometry node_id = s.AddNode(fCoordX, fCoordY, fCoordZ) ``` ### CreateElementNodeReleaseSpec **Description** Creates the element node release spec. **Parameters** - `node_id` (int): node id. - `dof_release` (list): dof release. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateElementNodeReleaseSpec(1, [1, 2]) print(result) ``` ### CreateMultipleNodes **Description** Creates multiple the nodes. **Parameters** - `node_ids` (list): node ids. - `nodeCoordinates` (list): node coordinates. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMultipleNodes([1, 2], [1, 2]) print(result) ``` ### CreateNode **Description** Creates the node. **Parameters** - `nNodeNo` (int): n node no. - `x` (float): x. - `y` (float): y. - `z` (float): z. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.CreateNode(1, 1.0, 1.0, 1.0) ``` ## Get ### GetBeamsConnectedAtNode **Description** Retrieve a list of beams connected to a specific node. **Parameters** - node (int): Node number. **Returns** list: List of beam numbers connected at the node. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module beams = s.GetBeamsConnectedAtNode(7) print(beams) ``` ### GetBucklingModeDisplacementAtNode **Description** Returns the buckling mode displacement at node. **Parameters** - `buckling_mode_no` (int): buckling mode no. - `node_no` (int): node no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBucklingModeDisplacementAtNode(1, 1) print(result) ``` ### GetLastNodeNo **Description** Retrieve the number of the last node in the STAAD model. **Parameters** - None **Returns** int: The last node number. **Example** ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module last_node = s.GetLastNodeNo() print(last_node) ``` ### GetModalDisplacementAtNode **Description** Returns the modal displacement at node. **Parameters** - `modeNo` (int): mode no. - `nodeNo` (int): node no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetModalDisplacementAtNode(1, 1) print(result) ``` ### GetNLNodeDisplacements **Description** Returns the NL node displacements. **Parameters** - `nodeNo` (int): node no. - `loadCaseNo` (int): load case no. - `loadStep` (int): load step. **Returns** tuple: A tuple of `(float, list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNLNodeDisplacements(1, 1, 1) print(result) ``` ### GetNodeCoordinates **Description** Get the (x, y, z) coordinates of a given node. **Parameters** - node (int): The node number to retrieve coordinates for. **Returns** tuple: A tuple of (x, y, z) coordinates, rounded to 3 decimals. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module x, y, z = s.GetNodeCoordinates(1) print(x,y,z) ``` ### GetNodeCount **Description** Get the total number of nodes in the STAAD model. **Parameters** - None **Returns** int: Total number of nodes. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module count = s.GetNodeCount() print(count) ``` ### GetNodeDisplacements **Description** Returns the node displacements. **Parameters** - `nodeNo` (int): node no. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNodeDisplacements(1, 1) print(result) ``` ### GetNodeDistance **Description** Compute the distance between two nodes. **Parameters** - nodeA (int): The first node number. - nodeB (int): The second node number. **Returns** float: Distance between the two nodes, rounded to 3 decimals. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module distance = s.GetNodeDistance(1, 5) print(distance) ``` ### GetNodeIncidence **Description** Get the incidence (x, y, z) of a given node. *Note: This method is equivalent to GetNodeCoordinates.* **Parameters** - node (int): The node number to retrieve incidence for. **Returns** tuple: A tuple of (x, y, z) incidence values, rounded to 3 decimals. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module x, y, z = s.GetNodeIncidence(2) print(x,y,z) ``` ### GetNodeIncidence_CIS2 **Description** Returns the node incidence CIS 2. **Parameters** - `nodeId` (int): node Id. **Returns** tuple: A tuple of `(str, float, float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNodeIncidence_CIS2(1) print(result) ``` ### GetNodeList **Description** Retrieve a list of all node numbers in the model. **Parameters** - None **Returns** list: List of all node numbers. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module nodes = s.GetNodeList() print(nodes) ``` ### GetNodeNumber **Description** Find the node number corresponding to a given set of coordinates. **Parameters** - x_y_z_coordinates (tuple): A tuple of (x, y, z) coordinates. **Returns** int: Node number at the given coordinates. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module node = s.GetNodeNumber((3.0, 0.0, 0.0)) print(node) ``` ### GetNodeUniqueID **Description** Returns the node unique ID. **Parameters** - `nodeNo` (int): node no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNodeUniqueID(1) print(result) ``` ### GetNoOfBeamsConnectedAtNode **Description** Get the number of beams connected at a specific node. **Parameters** - node (int): Node number. **Returns** int: Number of beams connected at the given node. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module count = s.GetNoOfBeamsConnectedAtNode(7) print(count) ``` ### GetNoOfSelectedNodes **Description** Get the number of selected nodes in the model. **Parameters** - None **Returns** int: Number of selected nodes. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module count = s.GetNoOfSelectedNodes() print(count) ``` ### GetPlateNodeCount **Description** Returns the plate node count. **Parameters** - `plateNo` (int): plate no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateNodeCount(1) print(result) ``` ### GetSelectedNodes **Description** Retrieve a list of currently selected nodes. **Parameters** - None **Returns** list: List of selected node numbers. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module selected = s.GetSelectedNodes() print(selected) ``` ## Set/Assign ### SetNodeAnnotationMode **Description** Sets the node annotation mode. **Parameters** - `dFlag` (bool): d flag. - `refreshFlag` (bool): refresh flag. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetNodeAnnotationMode(True, True) ``` ### SetNodeCoordinate **Description** Sets the node coordinate. **Parameters** - `nodeNo` (int): node no. - `x` (float): x. - `y` (float): y. - `z` (float): z. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetNodeCoordinate(1, 1.0, 1.0, 1.0) ``` ### SetNodeUniqueID **Description** Sets the node unique ID. **Parameters** - `nodeNo` (int): node no. - `uniqueID` (str): unique ID. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetNodeUniqueID(1, "value") ``` ## Delete ### ClearNodeSelection **Description** Clears the node selection. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ClearNodeSelection() ``` ### DeleteNode **Description** Deletes the node. **Parameters** - `nNodeNo` (int): n node no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.DeleteNode(1) ``` ### RemoveAllElementNodeReleaseSpec **Description** Removes the all element node release spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveAllElementNodeReleaseSpec() print(result) ``` ### RemoveElementNodeReleaseSpecFromPlate **Description** Removes the element node release spec from plate. **Parameters** - `plate_id` (int): plate id. - `node_id` (int): node id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveElementNodeReleaseSpecFromPlate(1, 1) print(result) ``` ## Select ### SelectEntitiesConnectedToNode **Description** Selects the entities connected to node. **Parameters** - `entityType` (int): entity type. - `nodeNo` (int): node no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SelectEntitiesConnectedToNode(1, 1) ``` ### SelectMultipleNodes **Description** Selects multiple the nodes. **Parameters** - `nodes` (list): nodes. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SelectMultipleNodes([1, 2]) print(result) ``` ### SelectNode **Description** Selects the node. **Parameters** - `nodeID` (int): node ID. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SelectNode(1) print(result) ``` ## Transform ### BreakBeamsAtSpecificNodes **Description** Calls the `BreakBeamsAtSpecificNodes` function on the OpenStaad `ops` session. **Parameters** - `nodeList` (list): node list. **Returns** tuple: A tuple of `(list[int], list[int])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.BreakBeamsAtSpecificNodes([1, 2]) print(result) ``` ### MergeNodes **Description** Merges the nodes. **Parameters** - `new_Id` (int): new Id. - `nodeList` (list): node list. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.MergeNodes(1, [1, 2]) print(result) ``` ## Is ### IsOrphanNode **Description** Checks whether orphan node. **Parameters** - `nodeNo` (int): node no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsOrphanNode(1) print(result) ``` --- # Member: Geometry functions | OpenStaad Python > The members themselves — add, delete, renumber, and query incidences between two nodes. Loads on members live in Load › Member Loads; section and material in Section & Material. Source: https://www.openstaad.com/docs/member/geometry Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddBeam Adds a beam/member with specified nodes in the current model This function adds a beam/member with the specified start and end nodes to the current model and returns the member number automatically assigned. ##### Parameters - **nNodeA**: Number ID of the STARTING end node (nodeA). - **nNodeB**: Number ID of the ENDING end node (nodeB). ##### Return values - ****: Member number ID assigned to this created member. - **-1**: Unable to add member. - **-2001**: Cannot find Node < nNodeA or nNodeB >. ##### Example ```python # Example usage of AddBeam # member_id = openstaad.Geometry.AddBeam(nNodeA, nNodeB) from openstaad import ops # Instanciar el módulo Geometry s = ops.connect() # Ejecutar la función desde el módulo geometry member_id = s.AddBeam(nNodeA, nNodeB) ``` ### AddMultipleBeams **Description** Adds multiple the beams. **Parameters** - `incidences` (list): incidences. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMultipleBeams([1, 2]) print(result) ``` ### CreateBeam **Description** Creates the beam. **Parameters** - `nBeamNo` (int): n beam no. - `nNodeStart` (int): n node start. - `nNodeEnd` (int): n node end. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.CreateBeam(1, 1, 1) ``` ### CreateMultipleBeams **Description** Creates multiple the beams. **Parameters** - `beam_ids` (list): beam ids. - `beam_incidences` (list): beam incidences. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMultipleBeams([1, 2], [1, 2]) print(result) ``` ## Get ### GetBeamLength **Description** Get the length of a beam identified by its number. **Parameters** - beam (int): Beam number. **Returns** float: Length of the beam, in model units, rounded to 3 decimals. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module length = s.GetBeamLength(1) print(length) ``` ### GetBeamList **Description** Retrieve a list of all beam (member) numbers. **Parameters** - None **Returns** list: List of beam numbers. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module beams = s.GetBeamList() print(beams) ``` ### GetBeamsInView **Description** Returns the beams in view. **Parameters** - `nBeamList` (list): n beam list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamsInView([1, 2]) print(result) ``` ### GetIntersectBeamsCount Returns the number of new beams that will be created if the specified list of beams are intersected. This method can be used to get the count of beams that can be used to define the size of the output array while using the API `OSGeometryUI::IntersectBeams`. ##### Parameters - **BeamNosArray**: Array of beam numbers. If the array is either null or empty, then all members in the current model will be considered. (Long) - **dTolerance**: Tolerance to be used for finding beam intersection. Should not be a negative value. Unit: meter for Metric and inch for English in Base Unit (float/double). ##### Return values - Returns the number of beams that satisfy the criteria. ##### Example ```python from openstaad import ops # Instanciar el módulo Geometry s = ops.connect() # Obtener el número de nuevos beams que se crearían al intersectar los beams 1, 2 y 3 con una tolerancia de 0.01 count = s.GetIntersectBeamsCount([1, 2, 3], 0.01) ``` ### GetLastBeamNo **Description** Get the number of the last beam in the model. **Parameters** - None **Returns** int: Last beam number. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module last_beam = s.GetLastBeamNo() print(last_beam) ``` ### GetMemberCount **Description** Get the number of members (beams) in the model. **Parameters** - None **Returns** int: Number of members. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module count = s.GetMemberCount() print(count) ``` ### GetMemberDesignParameters **Description** Returns the member design parameters. **Parameters** - `design_ref_id` (int): design ref id. - `member_no` (int): member no. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberDesignParameters(1, 1) print(result) ``` ### GetMemberGlobalOffSet **Description** Returns the member global off set. **Parameters** - `beam_id` (int): beam id. - `member_offset_position` (int): member offset position. **Returns** tuple: A tuple of `float` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberGlobalOffSet(1, 1) print(result) ``` ### GetMemberIncidence **Description** Get the start and end node numbers for a given beam. **Parameters** - beam (int): Beam number. **Returns** tuple: Start and end node numbers as a tuple (start, end). **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module start_node, end_node = s.GetMemberIncidence(1) print(start_node,end_node) ``` ### GetMemberIncidence_CIS2 **Description** Returns the member incidence CIS 2. **Parameters** - `memberId` (int): member Id. **Returns** tuple: A tuple of `(str, int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberIncidence_CIS2(1) print(result) ``` ### GetMemberLocalOffSet **Description** Returns the member local off set. **Parameters** - `beam_id` (int): beam id. - `member_offset_position` (int): member offset position. **Returns** tuple: A tuple of `float` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberLocalOffSet(1, 1) print(result) ``` ### GetMemberUniqueID **Description** Returns the member unique ID. **Parameters** - `memberNo` (int): member no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberUniqueID(1) print(result) ``` ### GetNoOfBeamsInView **Description** Returns the number of the beams in view. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoOfBeamsInView() print(result) ``` ### GetNoOfSelectedBeams **Description** Get the number of selected beams in the model. **Parameters** - None **Returns** int: Number of selected beams. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module count = s.GetNoOfSelectedBeams() print(count) ``` ### GetPMemberCount **Description** Get the count of PMembers in the model. **Parameters** - None **Returns** int: Count of PMembers. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module p_member_count = s.GetPMemberCount() print(p_member_count) ``` ### GetSelectedBeams **Description** Retrieve a list of currently selected beams. **Parameters** - None **Returns** list: List of selected node numbers. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module selected_beams = s.GetSelectedBeams() ``` ## Set/Assign ### SetMemberUniqueID **Description** Sets the member unique ID. **Parameters** - `beamNo` (int): beam no. - `uniqueID` (str): unique ID. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetMemberUniqueID(1, "value") ``` ## Delete ### ClearMemberSelection **Description** Clear the current selection of members in the model. **Parameters** - None **Returns** None **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module s.ClearMemberSelection() ``` ### DeleteBeam **Description** Deletes the beam. **Parameters** - `BeamNo` (int): beam no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.DeleteBeam(1) ``` ## Select ### SelectBeam **Description** Selects the beam. **Parameters** - `beamID` (int): beam ID. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SelectBeam(1) print(result) ``` ### SelectEntitiesConnectedToMember **Description** Selects the entities connected to member. **Parameters** - `entityType` (int): entity type. - `memberNo` (int): member no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SelectEntitiesConnectedToMember(1, 1) ``` ### SelectMembersParallelTo **Description** Selects the members parallel to. **Parameters** - `bstrAxis` (str): bstr axis. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SelectMembersParallelTo("value") ``` ### SelectMultipleBeams **Description** Select multiple beams based on a provided list of beam numbers. **Parameters** - lista (list): A list of beam numbers to select. **Returns** None **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module s.SelectMultipleBeams([1, 3, 4]) ``` ## Transform ### IntersectBeams **Description** Computes the intersection of the beams. **Parameters** - `method` (int): method. - `beamList` (list): beam list. - `tolerance` (float): tolerance. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.IntersectBeams(1, [1, 2], 1.0) print(result) ``` ### MergeBeams **Description** Merges the beams. **Parameters** - `beamList` (list): beam list. - `newId` (int): new Id. - `property_id` (int): property id. - `beta_angle` (float): beta angle. - `material_name` (str): material name. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.MergeBeams([1, 2], 1, 1, 1.0, "value") print(result) ``` ### RenumberBeam **Description** Renumbers the beam. **Parameters** - `oldBeamNo` (int): old beam no. - `newBeamNo` (int): new beam no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RenumberBeam(1, 1) print(result) ``` ### SplitBeam **Description** Splits the beam. **Parameters** - `beamNo` (int): beam no. - `nodes` (int): nodes. - `distToNodes` (list): dist to nodes. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SplitBeam(1, 1, [1, 2]) ``` ### SplitBeamInEqlParts **Description** Splits the beam in eql parts. **Parameters** - `nBeamNo` (int): n beam no. - `nParts` (int): n parts. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SplitBeamInEqlParts(1, 1) ``` ## Execute ### DoTranslationalRepeat **Description** Performs the translational repeat. **Parameters** - `link_bays` (bool): link bays. - `open_base` (bool): open base. - `axis_dir` (int): axis dir. - `spacing_list` (list): spacing list. - `no_of_bays` (int): no of bays. - `renumber_bays` (bool): renumber bays. - `renumber_list` (list): renumber list. - `geometry_only_flag` (bool): geometry only flag. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DoTranslationalRepeat(True, True, 1, [1, 2], 1, True, [1, 2], True) print(result) ``` ## Is ### IsBeam **Description** Checks whether beam. **Parameters** - `beam_no` (int): beam no. - `tol_angle` (float): tol angle. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsBeam(1, 1.0) print(result) ``` ### IsColumn **Description** Checks whether column. **Parameters** - `column_no` (int): column no. - `tol_angle` (float): tol angle. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsColumn(1, 1.0) print(result) ``` --- # Member: Section & Material functions | OpenStaad Python > Links each member to a cross-section (from Section/Property) and a material (from Material), plus its beta angle — what the member is made of, not its shape in space. Source: https://www.openstaad.com/docs/member/section-material Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateBeamPropertyFromTable **Description** Creates a beam section property from the STAAD.Pro section table and returns its property ID, ready to be passed to [`AssignBeamProperty`](/docs/member/section-material#AssignBeamProperty). **Parameters** - `country_code` (int): Country/section-table code. See table below. - `section_name` (str): Name of the section, exactly as it appears in the STAAD.Pro table (e.g. `"W12X26"`). - `type_spec` (int): Type specification number. See table below. - `add_spec_1` (float): Free spacing for a double profile (`0.0` if not applicable). - `add_spec_2` (float): Reserved; set to `0.0`. ##### Country Codes | Code | Country | |------|------------------------| | 1 | American | | 2 | Australian | | 3 | British | | 4 | Canadian | | 5 | Chinese | | 6 | Dutch | | 7 | European | | 8 | French | | 9 | German | | 10 | Indian | | 11 | Japanese | | 12 | Russian | | 13 | SouthAfrican | | 14 | Spanish | | 15 | Venezuelan | | 16 | Korean | | 17 | Aluminum | | 18 | American cold formed | | 19 | Indian cold formed | | 20 | Mexican | | 21 | American Steel Joist | | 22 | AITCTimber | | 23 | Lysaght cold formed | | 24 | British cold formed | | 25 | Canadian Timber | | 26 | Butler cold formed | | 27 | Kingspan cold formed | | 28 | RCeco cold formed | | 29 | Japanese cold formed | | 30 | Australian cold formed| | 31 | Russian cold formed | | 32 | STOASChM | | 33 | Jindal | | 34 | European cold formed | | 35 | Tata Structura | | 36 | Brazilian | | 37 | APL Apollo Tubes | ##### Type specification (`type_spec`) | Value | Type spec. | Description | |-------|------------|-------------------------------------------------------| | 0 | ST | | | 2 | D | Double profile. | | 5 | T | Tee section cut from an I-section (aluminum). | **Returns** int: The new property ID. **Example** ```python from openstaad import ops s = ops.connect() property_id = s.CreateBeamPropertyFromTable(1, "W12X26", 0, 0.0, 0.0) print(property_id) ``` ### CreateBeamPropertyFromTableComposite **Description** Creates the beam property from table composite. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `spec_type` (int): spec type. - `additional_spec_list` (list): additional spec list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateBeamPropertyFromTableComposite(1, "value", 1, [1, 2]) print(result) ``` ### CreateBeamPropertyFromTableEx **Description** Creates the beam property from table ex. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `solid_shape_type` (int): solid shape type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateBeamPropertyFromTableEx(1, "value", 1) print(result) ``` ### CreateBeamPropertyFromTableWithCoverPlates **Description** Creates the beam property from table with cover plates. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `spec_type` (int): spec type. - `additional_spec_list` (list): additional spec list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateBeamPropertyFromTableWithCoverPlates(1, "value", 1, [1, 2]) print(result) ``` ## Get ### GetBeamMaterialName **Description** Returns the beam material name. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamMaterialName(1) print(result) ``` ### GetBeamProperty **Description** Returns the beam property. **Parameters** - `beam_id` (int): beam id. **Returns** tuple: eight floats, `(width, depth, ax, ay, az, ix, iy, iz)`. In the model tested, `ix` behaved as the torsional constant (much smaller than `iy` and `iz`). Values come back in the model's [base units](/guides/base_units): width and depth in `m` or `in`, areas in `m²` or `in²`, and inertias in `m⁴` or `in⁴`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamProperty(1) print(result) ``` ### GetBeamPropertyAll **Description** Returns the beam property all. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamPropertyAll(1) print(result) ``` ### GetBeamSectionDisplayName **Description** Returns the beam section display name. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamSectionDisplayName(1) print(result) ``` ### GetBeamSectionName **Description** Returns the section name assigned to a beam. **Parameters** - `beam_id` (int): Beam number ID. **Returns** str: The section name as STAAD.Pro reports it. See the following table for examples of probable section names: | Sl No. | Section Type | In STD file | GetBeamSectionName | |--------|----------------------------------------------|-------------------------------|----------------------------| | 1 | Standard steel database section | TABLE ST W36X925 | W36X925 | | | | TABLE D W36X925 SP 1 | W36X925 | | | | 5 TABLE SD L20205 SP 1 | L20205 | | 2 | Tube and pipe definition | 8 TABLE ST PIPE OD 2 ID 1 | PIPE | | | | 8 TABLE ST TUBE TH 1 WT 2 DT 3| TUBE | | 3 | Prismatic | 3 PRIS YD 1 ZD 2 YB 2 ZB 3 | Prismatic Tee | | | | 8 PRIS YD 3 ZD 1 ZB 2 | Prismatic Trapezoid | | 4 | Tapered | 3 TAPERED 1 2 3 1 2 3 1 | Taper | | 5 | Assigned profile | 3 ASSIGN ANGLE DOUBLE | Assign Double Angle | | 6 | User provided table | 14 TO 23 UPT 2 LANG40404 | LANG40404 | **Example** ```python from openstaad import ops s = ops.connect() name = s.GetBeamSectionName(1) print(name) ``` ### GetBeamSectionPropertyRefNo **Description** Returns the section property reference number assigned to a beam. **Parameters** - `beam_id` (int): Beam number ID. **Returns** int: Reference number of the section property assigned to the beam, or `0` if none is assigned. **Example** ```python from openstaad import ops s = ops.connect() ref_no = s.GetBeamSectionPropertyRefNo(1) print(ref_no) ``` ### GetBeamSectionPropertyTypeNo **Description** Returns the beam section property type no. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamSectionPropertyTypeNo(1) print(result) ``` ### GetBeamSectionPropertyValuesEx **Description** Returns the beam section property values ex. **Parameters** - `beam_id` (int): beam id. **Returns** tuple: A tuple of `(int, list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamSectionPropertyValuesEx(1) print(result) ``` ### GetIsotropicMaterialAssignedBeamCount **Description** Returns the isotropic material assigned beam count. **Parameters** - `material_name` (str): material name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialAssignedBeamCount("value") print(result) ``` ### GetIsotropicMaterialAssignedBeamList **Description** Returns the isotropic material assigned beam list. **Parameters** - `material_name` (str): material name. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialAssignedBeamList("value") print(result) ``` ### GetSectionPropertyAssignedBeamCount **Description** Returns the section property assigned beam count. **Parameters** - `prof_type` (int): prof type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionPropertyAssignedBeamCount(1) print(result) ``` ### GetSectionPropertyAssignedBeamList **Description** Returns the section property assigned beam list. **Parameters** - `prof_type` (int): prof type. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionPropertyAssignedBeamList(1) print(result) ``` ## Set/Assign ### AssignBeamProperty **Description** Assigns a previously created section property to one or more beams. **Parameters** - `beam_ids` (int or list[int]): Beam number ID, or a list of beam number IDs, to assign the property to. - `property_id` (int): Numeric ID of the section property, as returned by a `Create*PropertyFromTable`/`CreatePrismatic*Property` function. **Returns** bool: `True` if the assignment succeeded, `False` otherwise. **Notes** Internally this wraps the OpenSTAAD COM call, which reports these codes on failure (all collapsed to `False` by `ops`): | Code | Meaning | |--------|---------------------------------------------| | 0 | OK. | | -106 | `beam_ids` array dimension error. | | -3006 | Invalid member number ID(s). | | -6001 | Invalid section / assigned property ID. | | -6002 | Library error: property assignment. | **Example** ```python from openstaad import ops s = ops.connect() property_id = s.CreateBeamPropertyFromTable(1, "W12X26", 0, 0.0, 0.0) ok = s.AssignBeamProperty([1, 2, 3], property_id) print(ok) ``` ### AssignMaterialToMember **Description** Assigns a material to one or more members. **Parameters** - `material_name` (str): Name of an existing material in the model (e.g. `"STEEL"`, `"CONCRETE"`). - `member_ids` (int or list[int]): Member number ID, or a list of member number IDs. **Returns** int: the raw OpenSTAAD result code — `1` if the assignment succeeded, `0` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignMaterialToMember("STEEL", [1, 2, 3]) print(result) ``` ## Delete ### RemoveMaterialFromBeam **Description** Removes the material from beam. **Parameters** - `beam_id` (int): beam id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMaterialFromBeam(1) print(result) ``` ### RemovePropertyFromBeam **Description** Removes the property from beam. **Parameters** - `beam_id` (int): beam id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemovePropertyFromBeam(1) print(result) ``` --- # Member: Specifications functions | OpenStaad Python > Member behavior modifiers — end releases, offsets, and truss / tension-only / compression-only / cable specs. Changes how a member acts, not its geometry. Source: https://www.openstaad.com/docs/member/specifications Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateMemberCableSpec **Description** Creates the member cable spec. **Parameters** - `tension_or_unstressed_len` (int): tension or unstressed len. - `spec_value` (float): spec value. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberCableSpec(1, 1.0) print(result) ``` ### CreateMemberCableSpecEx **Description** Creates the member cable spec ex. **Parameters** - `tension_or_unstressed_len` (int): tension or unstressed len. - `spec_value` (float): spec value. - `tension_end_node_indicator` (int): tension end node indicator. - `self_weight_factor_x` (float): self weight factor x. - `self_weight_factor_y` (float): self weight factor y. - `self_weight_factor_z` (float): self weight factor z. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberCableSpecEx(1, 1.0, 1, 1.0, 1.0, 1.0) print(result) ``` ### CreateMemberCompressionSpec **Description** Creates the member compression spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberCompressionSpec() print(result) ``` ### CreateMemberIgnoreStiffSpec **Description** Creates the member ignore stiff spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberIgnoreStiffSpec() print(result) ``` ### CreateMemberInactiveSpec **Description** Creates the member inactive spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberInactiveSpec() print(result) ``` ### CreateMemberOffsetSpec **Description** Creates the member offset spec. **Parameters** - `offset_location` (int): offset location. - `offset_with_respect_to` (int): offset with respect to. - `offset_x` (float): offset x. - `offset_y` (float): offset y. - `offset_z` (float): offset z. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberOffsetSpec(1, 1, 1.0, 1.0, 1.0) print(result) ``` ### CreateMemberPartialReleaseSpec **Description** Creates the member partial release spec. **Parameters** - `location` (int): location. - `dof_release` (list): dof release. - `factor` (list): factor. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberPartialReleaseSpec(1, [1, 2], [1, 2]) print(result) ``` ### CreateMemberReleaseSpec **Description** Creates a MEMBER RELEASE specification, to be assigned to a beam end. **Parameters** - `offset_location` (int): Location on the member: start (`0`) or end (`1`). - `dof_values` (list[int], 6 elements): Release state for FX, FY, FZ, MX, MY, MZ — `0` = no release, `1` = released. - `spring_constant_values` (list[float], 6 elements): Spring constants KFX, KFY, KFZ, KMX, KMY, KMZ (used where the matching `dof_values` entry indicates a spring release). **Returns** int: A status/reference code from STAAD.Pro for this call: | Code | Meaning | |-------|-----------------------------------------------------------------------------------------------------------------------| | 0 | OK. | | -106 | A one-dimensional long array is expected for `dof_values` and a one-dimensional double array for `spring_constant_values`. | | -108 | The array size is smaller than expected (should be 6). | | -6020 | Library error: could not create the MEMBER RELEASE specification. | **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberReleaseSpec(1, [0, 0, 0, 1, 1, 1], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) print(result) ``` ### CreateMemberTensionSpec **Description** Creates the member tension spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberTensionSpec() print(result) ``` ### CreateMemberTrussSpec **Description** Creates the member truss spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberTrussSpec() print(result) ``` ## Get ### GetBetaAngle **Description** Returns the beta angle. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBetaAngle(1) print(result) ``` ### GetCountOfBreakableBeamsAtSpecificNodes **Description** Returns the count of breakable beams at specific nodes. **Parameters** - `nodeList` (list): node list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetCountOfBreakableBeamsAtSpecificNodes([1, 2]) print(result) ``` ### GetInactiveMemberCount **Description** Returns the inactive member count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetInactiveMemberCount() print(result) ``` ### GetInactiveMemberList **Description** Returns the inactive member list. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetInactiveMemberList() print(result) ``` ### GetMemberReleaseSpec **Description** Returns the member release spec. **Parameters** - `member_no` (int): member no. - `end` (int): end. **Returns** tuple: A tuple of `(list[int], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberReleaseSpec(1, 1) print(result) ``` ### GetMemberReleaseSpecEx **Description** Returns the release specification for a member at the given end. **Parameters** - `beam_id` (int): Beam number ID. - `release_spec_position` (int): Member end: start (`0`) or end (`1`). **Returns** tuple: `(release, spring, mp_factor, mp_factor_list)`, where: | # | Value | Meaning | |---|------------------|-------------------------------------------------------------------------------------------------------------------------------| | 1 | `release` (list[int], 6) | Release state per DOF (FX, FY, FZ, MX, MY, MZ): no release/spring = `0`, release = `1`, spring = `-1`, only MP defined = `-3`, MPX/MPY/MPZ defined = `-2`. | | 2 | `spring` (list[float], 6) | Spring constant per DOF, where `release` indicates a spring. | | 3 | `mp_factor` (float) | Partial moment release factor (shared by MX, MY, MZ). | | 4 | `mp_factor_list` (list[float], 3) | Partial moment release factor per rotational DOF (MX, MY, MZ), when individually defined. | **Example** ```python from openstaad import ops s = ops.connect() release, spring, mp_factor, mp_factor_list = s.GetMemberReleaseSpecEx(1, 0) print(release, spring) ``` ### GetMemberSpecCode **Description** Returns the type of member specification attached to a member. **Parameters** - `member_id` (int): Member number ID. **Returns** int: The member specification type code. See table below. ##### Spec code values | Value | Member Specification Type | |-------|---------------------------| | 0 | Truss member | | 1 | Tension-only member | | 2 | Compression-only member | | 3 | Cable only | | 4 | Joist member | | -1 | Other | For additional information, see Section "TR.23 Axial Member Specifications" of the Technical Reference Manual. **Example** ```python from openstaad import ops s = ops.connect() spec_code = s.GetMemberSpecCode(1) print(spec_code) ``` ## Set/Assign ### AssignBetaAngle **Description** Assigns the beta angle. **Parameters** - `beam_ids` (list): beam ids. - `beta_angle` (float): beta angle. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignBetaAngle([1, 2], 1.0) print(result) ``` ### AssignMemberSpecToBeam **Description** Assigns a previously created member specification (truss, tension-only, compression-only, cable, or joist) to one or more beams. **Parameters** - `beam_ids` (int or list[int]): Beam number ID, or a list of beam number IDs. - `spec_id` (int): ID of a member specification created with a function such as `CreateMemberTrussSpec`. **Returns** bool: `True` if the assignment succeeded, `False` otherwise. **Notes** The underlying OpenSTAAD COM call reports these codes on failure (all collapsed to `False` by `ops`): | Code | Meaning | |--------|-----------------------------------------------------| | 0 | OK. | | -106 | A one-dimensional long array is expected. | | -6017 | Library error: could not assign the specification. | **Example** ```python from openstaad import ops s = ops.connect() spec_id = s.CreateMemberTrussSpec() ok = s.AssignMemberSpecToBeam([1, 2, 3], spec_id) print(ok) ``` ## Delete ### DeleteMemberReleaseSpec **Description** Deletes the member release spec. **Parameters** - `beam_id` (int): beam id. - `release_location` (int): release location. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteMemberReleaseSpec(1, 1) print(result) ``` ### DeleteMemberSpec **Description** Deletes the member spec. **Parameters** - `spec_id` (int): spec id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteMemberSpec(1) print(result) ``` ### RemoveMemberCableSpecFromBeam **Description** Removes the member cable spec from beam. **Parameters** - `beam_id` (int): beam id. - `tension_or_length` (int): tension or length. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberCableSpecFromBeam(1, 1) print(result) ``` ### RemoveMemberCompressionSpecFromBeam **Description** Removes the member compression spec from beam. **Parameters** - `beam_id` (int): beam id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberCompressionSpecFromBeam(1) print(result) ``` ### RemoveMemberIgnoreStiffSpecFromBeam **Description** Removes the member ignore stiff spec from beam. **Parameters** - `beam_id` (int): beam id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberIgnoreStiffSpecFromBeam(1) print(result) ``` ### RemoveMemberInactiveSpecFromBeam **Description** Removes the member inactive spec from beam. **Parameters** - `beam_id` (int): beam id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberInactiveSpecFromBeam(1) print(result) ``` ### RemoveMemberOffsetSpecFromBeam **Description** Removes the member offset spec from beam. **Parameters** - `beam_id` (int): beam id. - `release_location` (int): release location. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberOffsetSpecFromBeam(1, 1) print(result) ``` ### RemoveMemberReleaseSpecFromBeam **Description** Removes the member release spec from beam. **Parameters** - `beam_id` (int): beam id. - `release_location` (int): release location. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberReleaseSpecFromBeam(1, 1) print(result) ``` ### RemoveMemberTensionSpecFromBeam **Description** Removes the member tension spec from beam. **Parameters** - `beam_id` (int): beam id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberTensionSpecFromBeam(1) print(result) ``` ### RemoveMemberTrussSpecFromBeam **Description** Removes the member truss spec from beam. **Parameters** - `beam_id` (int): beam id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberTrussSpecFromBeam(1) print(result) ``` --- # Member: Fireproofing functions | OpenStaad Python > Fireproofing material and thickness on members — adds to self-weight for fire-rated assemblies; doesn’t change analytical stiffness. Source: https://www.openstaad.com/docs/member/fireproofing Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateMemberFireProofingSpec **Description** Creates the member fire proofing spec. **Parameters** - `fire_proof_type` (int): fire proof type. - `thickness_value` (float): thickness value. - `density` (float): density. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberFireProofingSpec(1, 1.0, 1.0) print(result) ``` ## Get ### GetFireProofDataForBeam **Description** Returns the fire proof data for beam. **Parameters** - `beam_id` (int): beam id. **Returns** tuple: A tuple of `(int, float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFireProofDataForBeam(1) print(result) ``` ### GetFireProofedBeamCount **Description** Returns the fire proofed beam count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFireProofedBeamCount() print(result) ``` ### GetFireProofedBeamList **Description** Returns the fire proofed beam list. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFireProofedBeamList() print(result) ``` ### GetFireProofingSpecAssignedBeamCount **Description** Returns the fire proofing spec assigned beam count. **Parameters** - `index` (int): index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFireProofingSpecAssignedBeamCount(1) print(result) ``` ### GetFireProofingSpecAssignedBeamList **Description** Returns the fire proofing spec assigned beam list. **Parameters** - `index` (int): index. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFireProofingSpecAssignedBeamList(1) print(result) ``` ### GetFireProofingSpecCount **Description** Returns the fire proofing spec count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFireProofingSpecCount() print(result) ``` ### GetFireProofingSpecDetails **Description** Returns the fire proofing spec details. **Parameters** - `index` (int): index. **Returns** tuple: A tuple of `(int, float, float, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFireProofingSpecDetails(1) print(result) ``` ## Delete ### RemoveMemberFireProofingSpecFromBeam **Description** Removes the member fire proofing spec from beam. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMemberFireProofingSpecFromBeam(1) print(result) ``` --- # Member: Custom Attributes functions | OpenStaad Python > User-defined attributes and metadata attached to members for tagging and downstream workflows. Source: https://www.openstaad.com/docs/member/custom-attributes Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateMemberAttribute **Description** Creates the member attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_Value` (str): str value. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMemberAttribute("value", "value") print(result) ``` ## Get ### GetMemberAttributeCount **Description** Returns the member attribute count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberAttributeCount() print(result) ``` ### GetMemberAttributeList **Description** Returns the member attribute list. **Parameters** None. **Returns** tuple: A tuple of `(list[str], list[str], raw)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberAttributeList() print(result) ``` ### GetMemberCountByAttribute **Description** Returns the member count by attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_Value` (str): str value. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberCountByAttribute("value", "value") print(result) ``` ### GetMemberCountByAttributeIndex **Description** Returns the member count by attribute index. **Parameters** - `index` (int): index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberCountByAttributeIndex(1) print(result) ``` ### GetMemberListByAttribute **Description** Returns the member list by attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_Value` (str): str value. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberListByAttribute("value", "value") print(result) ``` ### GetMemberListByAttributeIndex **Description** Returns the member list by attribute index. **Parameters** - `index` (int): index. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberListByAttributeIndex(1) print(result) ``` ## Set/Assign ### AssignMemberAttribute **Description** Assigns the member attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_Value` (str): str value. - `member_list` (bool): member list. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignMemberAttribute("value", "value", True) print(result) ``` ## Delete ### DeleteMemberAttribute **Description** Deletes the member attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_Value` (str): str value. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteMemberAttribute("value", "value") print(result) ``` --- # Member: Results functions | OpenStaad Python > Per-member results after analysis — end forces, moments, displacements, and section stresses. Read-only. Source: https://www.openstaad.com/docs/member/results Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Get ### GetBeamConstants **Description** Returns the beam constants. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamConstants(1) print(result) ``` ### GetIntermediateMemberAbsTransDisplacements **Description** Returns the intermediate member abs trans displacements. **Parameters** - `memberNo` (int): member no. - `distance` (float): distance. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIntermediateMemberAbsTransDisplacements(1, 1.0, 1) print(result) ``` ### GetIntermediateMemberForcesAtDistance **Description** Returns the intermediate member forces at distance. **Parameters** - `memberNo` (int): member no. - `distance` (float): distance. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIntermediateMemberForcesAtDistance(1, 1.0, 1) print(result) ``` ### GetIntermediateMemberTransDisplacements **Description** Returns the intermediate member trans displacements. **Parameters** - `memberNo` (int): member no. - `distance` (bool): distance. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIntermediateMemberTransDisplacements(1, True, 1) print(result) ``` ### GetMaxBeamStresses **Description** Returns the max beam stresses. **Parameters** - `beamNo` (int): beam no. - `loadCaseNo` (int): load case no. **Returns** tuple: A tuple of `(float, int, float, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMaxBeamStresses(1, 1) print(result) ``` ### GetMemberEndDisplacements **Description** Returns the member end displacements. **Parameters** - `memberNo` (int): member no. - `end` (int): end. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberEndDisplacements(1, 1, 1) print(result) ``` ### GetMemberEndForces **Description** Returns the member end forces. **Parameters** - `memberNo` (int): member no. - `end` (int): end. - `loadCaseNo` (int): load case no. - `LocalOrGlobal` (int): local or global. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberEndForces(1, 1, 1, 1) print(result) ``` ### GetMinMaxAxialForce **Description** Returns the min max axial force. **Parameters** - `memberNo` (int): member no. - `loadCaseNo` (int): load case no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMinMaxAxialForce(1, 1) print(result) ``` ### GetMinMaxBendingMoment **Description** Returns the min max bending moment. **Parameters** - `memberNo` (int): member no. - `dir` (str): dir. - `loadCaseNo` (int): load case no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMinMaxBendingMoment(1, "value", 1) print(result) ``` ### GetMinMaxShearForce **Description** Returns the min max shear force. **Parameters** - `memberNo` (int): member no. - `dir` (str): dir. - `loadCaseNo` (int): load case no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMinMaxShearForce(1, "value", 1) print(result) ``` ### GetPMemberEndForces **Description** Returns the p member end forces. **Parameters** - `memberNo` (int): member no. - `end` (int): end. - `loadCaseNo` (int): load case no. - `LocalOrGlobal` (int): local or global. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPMemberEndForces(1, 1, 1, 1) print(result) ``` ### GetPMemberIntermediateForcesAtDistance **Description** Returns the p member intermediate forces at distance. **Parameters** - `memberNo` (int): member no. - `distance` (bool): distance. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPMemberIntermediateForcesAtDistance(1, True, 1) print(result) ``` --- # Member: View/Annotation functions | OpenStaad Python > Member labels, highlighting, and annotation in the viewport. Visual only. Source: https://www.openstaad.com/docs/member/view-annotation Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Set/Assign ### SetBeamAnnotationMode **Description** Sets the beam annotation mode. **Parameters** - `Type` (int): type. - `DWFlags` (int): DW flags. - `RefreshFlag` (bool): refresh flag. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetBeamAnnotationMode(1, 1, True) ``` ## View ### HideAllMembers **Description** Hides the all members. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.HideAllMembers() ``` ### HideMember **Description** Hides the member. **Parameters** - `IDMember` (int): ID member. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.HideMember(1) ``` ### HideMembers **Description** Hides the members. **Parameters** - `NMembers` (value): n members. - `NaMemberNos` (list[int]): na member nos. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.HideMembers(1, [1, 2]) ``` ### ShowAllMembers **Description** Shows the all members. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowAllMembers() ``` ### ShowMember **Description** Shows the member. **Parameters** - `nMember` (int): n member. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowMember(1) ``` ### ShowMembers **Description** Shows the members. **Parameters** - `NMembers` (value): n members. - `NaMemberNos` (list[int]): na member nos. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowMembers(1, [1, 2]) ``` --- # Plate: Geometry functions | OpenStaad Python > The plate/shell elements — add, delete, and query three- and four-node plate incidences. Thickness comes from Thickness & Specifications; pressures live in Plate › Loads. Source: https://www.openstaad.com/docs/plate/geometry Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddMultiplePlates **Description** Adds multiple the plates. **Parameters** - `incidences` (list): incidences. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMultiplePlates([1, 2]) print(result) ``` ### AddPlate **Description** Adds the plate. **Parameters** - `nNodeA` (int): n node a. - `nNodeB` (int): n node b. - `nNodeC` (int): n node c. - `nNodeD` (int, optional (default `0`)): n node d. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddPlate(1, 1, 1, 1) print(result) ``` ### CreateMultiplePlates **Description** Creates multiple the plates. **Parameters** - `plate_ids` (list): plate ids. - `plate_incidences` (list): plate incidences. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateMultiplePlates([1, 2], [1, 2]) print(result) ``` ### CreatePlate **Description** Creates the plate. **Parameters** - `nPlateNo` (int): n plate no. - `nNodeA` (int): n node a. - `nNodeB` (int): n node b. - `nNodeC` (int): n node c. - `nNodeD` (int, optional (default `0`)): n node d. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.CreatePlate(1, 1, 1, 1, 1) ``` ## Get ### GetAreaOfPlates **Description** Returns the area of plates. **Parameters** - `plateList` (list[int]): plate list. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAreaOfPlates([1, 2]) print(result) ``` ### GetElementGlobalOffSet **Description** Returns the element global off set. **Parameters** - `plate_id` (int): plate id. - `plate_node_index` (int): plate node index. **Returns** tuple: A tuple of `float` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementGlobalOffSet(1, 1) print(result) ``` ### GetElementMaterialName **Description** Returns the element material name. **Parameters** - `element_id` (int): element id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementMaterialName(1) print(result) ``` ### GetGeneratedQuadPanelIncidences **Description** Returns the generated quad panel incidences. **Parameters** None. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetGeneratedQuadPanelIncidences() print(result) ``` ### GetIsotropicMaterialAssignedPlateCount **Description** Returns the isotropic material assigned plate count. **Parameters** - `material_name` (str): material name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialAssignedPlateCount("value") print(result) ``` ### GetIsotropicMaterialAssignedPlateList **Description** Returns the isotropic material assigned plate list. **Parameters** - `material_name` (str): material name. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialAssignedPlateList("value") print(result) ``` ### GetLastPlateNo **Description** Returns the last the plate no. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLastPlateNo() print(result) ``` ### GetNoOfGeneratedQuadPanels **Description** Returns the number of the generated quad panels. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoOfGeneratedQuadPanels() print(result) ``` ### GetNoOfSelectedPlates **Description** Returns the number of the selected plates. **Parameters** None. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoOfSelectedPlates() print(result) ``` ### GetPlateCount **Description** Returns the plate count. **Parameters** None. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateCount() print(result) ``` ### GetPlateIncidence **Description** Returns the plate incidence. **Parameters** - `plateNo` (int): plate no. **Returns** tuple: A tuple of `(int, int, int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateIncidence(1) print(result) ``` ### GetPlateIncidence_CIS2 **Description** Returns the plate incidence CIS 2. **Parameters** - `plateId` (int): plate Id. **Returns** tuple: A tuple of `(str, raw)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateIncidence_CIS2(1) print(result) ``` ### GetPlateList **Description** Returns the plate list. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateList() print(result) ``` ### GetPlateMaterialName **Description** Returns the plate material name. **Parameters** - `plate_id` (int): plate id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateMaterialName(1) print(result) ``` ### GetPlateUniqueID **Description** Returns the plate unique ID. **Parameters** - `plateNo` (int): plate no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateUniqueID(1) print(result) ``` ### GetSelectedPlates **Description** Returns the selected plates. **Parameters** - `isSorted` (bool, optional (default `False`)): is sorted. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSelectedPlates(True) print(result) ``` ## Set/Assign ### AssignMaterialToPlate **Description** Assigns the material to plate. **Parameters** - `material_name` (str): material name. - `plate_ids` (list): plate ids. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignMaterialToPlate("value", [1, 2]) print(result) ``` ### SetPlateUniqueID **Description** Sets the plate unique ID. **Parameters** - `plateNo` (int): plate no. - `uniqueID` (str): unique ID. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetPlateUniqueID(1, "value") ``` ## Delete ### ClearPlateSelection **Description** Clears the plate selection. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ClearPlateSelection() ``` ### DeletePlate **Description** Deletes the plate. **Parameters** - `nPlateNo` (int): n plate no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.DeletePlate(1) ``` ### RemoveMaterialFromPlate **Description** Removes the material from plate. **Parameters** - `plate_ids` (list): plate ids. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMaterialFromPlate([1, 2]) print(result) ``` ### RemovePropertyFromPlate **Description** Removes the property from plate. **Parameters** - `plate_id` (int): plate id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemovePropertyFromPlate(1) print(result) ``` ## Select ### SelectEntitiesConnectedToPlate **Description** Selects the entities connected to plate. **Parameters** - `entityType` (int): entity type. - `plateNo` (int): plate no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SelectEntitiesConnectedToPlate(1, 1) ``` ### SelectMultiplePlates **Description** Selects multiple the plates. **Parameters** - `plates` (list): plates. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SelectMultiplePlates([1, 2]) print(result) ``` ### SelectPlate **Description** Selects the plate. **Parameters** - `nPlateNo` (int): n plate no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SelectPlate(1) print(result) ``` ## View ### HidePlate **Description** Hides the plate. **Parameters** - `nPlate` (int): n plate. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.HidePlate(1) ``` --- # Plate: Thickness & Specifications functions | OpenStaad Python > Plate thickness, material, and behavior specs (plane-stress, in-plane/bending releases) for shell elements. Source: https://www.openstaad.com/docs/plate/thickness-specifications Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateElementIgnoreInplaneRotnSpec **Description** Creates the element ignore inplane rotn spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateElementIgnoreInplaneRotnSpec() print(result) ``` ### CreateElementLocalZOffsetSpec **Description** Creates the element local z offset spec. **Parameters** - `node1_localz_offset` (float): node 1 localz offset. - `node2_localz_offset` (float): node 2 localz offset. - `node3_localz_offset` (float): node 3 localz offset. - `node4_localz_offset` (float): node 4 localz offset. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateElementLocalZOffsetSpec(1.0, 1.0, 1.0, 1.0) print(result) ``` ### CreateElementOffsetSpec **Description** Creates the element offset spec. **Parameters** - `offset_direction` (int): offset direction. - `plate_node_index` (int): plate node index. - `x_offset` (float): x offset. - `y_offset` (float): y offset. - `z_offset` (float): z offset. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateElementOffsetSpec(1, 1, 1.0, 1.0, 1.0) print(result) ``` ### CreateElementPlaneStressSpec **Description** Creates the element plane stress spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateElementPlaneStressSpec() print(result) ``` ### CreatePlateThicknessProperty **Description** Creates the plate thickness property. **Parameters** - `thickness_list` (list): thickness list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePlateThicknessProperty([1, 2]) print(result) ``` ## Get ### GetElementLocalOffset **Description** Returns the element local offset. **Parameters** - `plate_id` (int): plate id. - `plate_node_index` (int): plate node index. **Returns** tuple: A tuple of `float` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementLocalOffset(1, 1) print(result) ``` ### GetElementOffSetSpec **Description** Returns the element off set spec. **Parameters** - `plate_id` (int): plate id. - `plate_node_index` (int): plate node index. **Returns** tuple: A tuple of `(int, raw)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementOffSetSpec(1, 1) print(result) ``` ### GetElementOffsetSpecCount **Description** Returns the element offset spec count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementOffsetSpecCount() print(result) ``` ### GetPlateThickness **Description** Returns the plate thickness. **Parameters** - `plate_no` (int): plate no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateThickness(1) print(result) ``` ### GetThicknessPropertyAssignedPlateCount **Description** Returns the thickness property assigned plate count. **Parameters** - `property_reference_id` (int): property reference id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetThicknessPropertyAssignedPlateCount(1) print(result) ``` ### GetThicknessPropertyAssignedPlateList **Description** Returns the thickness property assigned plate list. **Parameters** - `property_reference_id` (int): property reference id. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetThicknessPropertyAssignedPlateList(1) print(result) ``` ## Set/Assign ### AssignElementSpecToPlate **Description** Assigns the element spec to plate. **Parameters** - `plate_ids` (list): plate ids. - `spec_no` (int): spec no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignElementSpecToPlate([1, 2], 1) print(result) ``` ### AssignPlateThickness **Description** Assigns the plate thickness. **Parameters** - `plate_ids` (list): plate ids. - `thickness_property_id` (int): thickness property id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignPlateThickness([1, 2], 1) print(result) ``` ## Delete ### RemoveAllElementOffsetSpec **Description** Removes the all element offset spec. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveAllElementOffsetSpec() print(result) ``` ### RemoveElementIgnoreInplaneRotnSpecFromPlate **Description** Removes the element ignore inplane rotn spec from plate. **Parameters** - `plate_id` (int): plate id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveElementIgnoreInplaneRotnSpecFromPlate(1) print(result) ``` ### RemoveElementPlaneStressSpecFromPlate **Description** Removes the element plane stress spec from plate. **Parameters** - `plate_id` (int): plate id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveElementPlaneStressSpecFromPlate(1) print(result) ``` --- # Plate: Loads functions | OpenStaad Python > Pressure and hydrostatic loads on plates — this is where loads on Plate elements are defined. Source: https://www.openstaad.com/docs/plate/loads Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddElementHydrostaticPressure **Description** Adds the element hydrostatic pressure. **Parameters** - `plateIds` (list): plate ids. - `varLoadDirection` (int): var load direction. - `varInterpolateDirection` (int): var interpolate direction. - `varMinLoad` (float): var min load. - `varMaxLoad` (float): var max load. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddElementHydrostaticPressure([1, 2], 1, 1, 1.0, 1.0) print(result) ``` ### AddElementPressure **Description** Adds the element pressure. **Parameters** - `plateIds` (list): plate ids. - `varDirection` (int): var direction. - `varPressure` (float): var pressure. - `varX1` (float): var x 1. - `varY1` (float): var y 1. - `varX2` (float): var x 2. - `varY2` (float): var y 2. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddElementPressure([1, 2], 1, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddElementTrapPressureEx **Description** Adds the element trap pressure ex. **Parameters** - `PlateIDs` (list): plate i ds. - `LoadDirection` (int): load direction. - `LoadVaryDirection` (int): load vary direction. - `StartPressure` (float): start pressure. - `EndPressure` (float): end pressure. - `Pressure3` (float): pressure 3. - `Pressure4` (float): pressure 4. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddElementTrapPressureEx([1, 2], 1, 1, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddSeismicDefElementWeight **Description** Adds the seismic def element weight. **Parameters** - `pressure` (float): pressure. - `elementList` (list): element list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSeismicDefElementWeight(1.0, [1, 2]) print(result) ``` ## Get ### GetElementConcLoadCount **Description** Returns the element conc load count. **Parameters** - `varPlateNo` (int): var plate no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementConcLoadCount(1) print(result) ``` ### GetElementConcLoads **Description** Returns the element conc loads. **Parameters** - `varPlateNo` (int): var plate no. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementConcLoads(1) print(result) ``` ### GetElementLoadInfo **Description** Returns the element load info. **Parameters** - `loadIndex` (int): load index. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementLoadInfo(1) print(result) ``` ### GetElementPressureLoadCount **Description** Returns the element pressure load count. **Parameters** - `varPlateNo` (int): var plate no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementPressureLoadCount(1) print(result) ``` ### GetElementPressureLoads **Description** Returns the element pressure loads. **Parameters** - `varPlateNo` (int): var plate no. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementPressureLoads(1) print(result) ``` --- # Plate: Custom Attributes functions | OpenStaad Python > User-defined attributes and metadata attached to plate elements. Source: https://www.openstaad.com/docs/plate/custom-attributes Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateElementAttribute **Description** Creates the element attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_value` (str): str value. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateElementAttribute("value", "value") print(result) ``` ## Get ### GetElementCountByAttribute **Description** Returns the element count by attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_value` (str): str value. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementCountByAttribute("value", "value") print(result) ``` ### GetElementListByAttribute **Description** Returns the element list by attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_value` (str): str value. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElementListByAttribute("value", "value") print(result) ``` ## Set/Assign ### AssignElementAttribute **Description** Assigns the element attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_Value` (str): str value. - `element_list` (bool): element list. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignElementAttribute("value", "value", True) print(result) ``` ## Delete ### DeleteElementAttribute **Description** Deletes the element attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_value` (str): str value. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteElementAttribute("value", "value") print(result) ``` --- # Plate: Results functions | OpenStaad Python > Per-plate results after analysis — center and corner stresses, moments, and shears. Read-only. Source: https://www.openstaad.com/docs/plate/results Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Get ### GetAllPlateCenterForces **Description** Returns the all plate center forces. **Parameters** - `plateNo` (int): plate no. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllPlateCenterForces(1, 1) print(result) ``` ### GetAllPlateCenterMoments **Description** Returns the all plate center moments. **Parameters** - `plateNo` (int): plate no. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllPlateCenterMoments(1, 1) print(result) ``` ### GetAllPlateCenterPrincipalStressesAndAngles **Description** Returns the all plate center principal stresses and angles. **Parameters** - `plateNo` (int): plate no. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllPlateCenterPrincipalStressesAndAngles(1, 1) print(result) ``` ### GetAllPlateCenterPrincipalStressesAndAnglesEx **Description** Returns the all plate center principal stresses and angles ex. **Parameters** - `plateNo` (int): plate no. - `loadCaseNo` (int): load case no. **Returns** tuple: A tuple of `(list[float], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllPlateCenterPrincipalStressesAndAnglesEx(1, 1) print(result) ``` ### GetAllPlateCenterStressesAndMoments **Description** Returns the all plate center stresses and moments. **Parameters** - `plateNo` (int): plate no. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllPlateCenterStressesAndMoments(1, 1) print(result) ``` ### GetPlateCenterNormalPrincipalStresses **Description** Returns the plate center normal principal stresses. **Parameters** - `plateNo` (int): plate no. - `loadCaseNo` (int): load case no. **Returns** tuple: A tuple of `(float, float, float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateCenterNormalPrincipalStresses(1, 1) print(result) ``` ### GetPlateCenterVonMisesStresses **Description** Returns the plate center von mises stresses. **Parameters** - `plateNo` (int): plate no. - `loadCaseNo` (int): load case no. **Returns** tuple: A tuple of `(float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateCenterVonMisesStresses(1, 1) print(result) ``` ### GetPlateCornerForces **Description** Returns the plate corner forces. **Parameters** - `plateNo` (int): plate no. - `cornerCode` (int): corner code. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateCornerForces(1, 1, 1) print(result) ``` ### GetPlateSectionPropertyRefNo **Description** Returns the plate section property ref no. **Parameters** - `PlateNo` (int): plate no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateSectionPropertyRefNo(1) print(result) ``` ### GetPlateStressAtPoint **Description** Returns the plate stress at point. **Parameters** - `plateNo` (int): plate no. - `loadNo` (int): load no. - `stressPoint` (list): stress point. - `facingPoint` (list[float]): facing point. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateStressAtPoint(1, 1, [1, 2], [1, 2]) print(result) ``` ### GetResultantForceAlongLineForPlateList **Description** Returns the resultant force along line for plate list. **Parameters** - `plateList` (list): plate list. - `nplates` (int): nplates. - `loadIdList` (list): load Id list. - `startNode` (list): start node. - `endNode` (list): end node. - `isTransformForceToGlobal` (int): is transform force to global. - `firstNode` (int): first node. - `secondNode` (int): second node. - `thirdNode` (int): third node. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetResultantForceAlongLineForPlateList([1, 2], 1, [1, 2], [1, 2], [1, 2], 1, 1, 1, 1) print(result) ``` --- # Solid (3D) functions | OpenStaad Python > Eight-node solid (brick) elements — geometry, material, and stress results. Loads on solids are applied through the Load domain. Source: https://www.openstaad.com/docs/solid-3d Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddMultipleSolids **Description** Adds multiple the solids. **Parameters** - `incidences` (list): incidences. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMultipleSolids([1, 2]) print(result) ``` ### AddSolid **Description** Adds the solid. **Parameters** - `nodeA` (int): node a. - `nodeB` (int): node b. - `nodeC` (int): node c. - `nodeD` (int): node d. - `nodeE` (int): node e. - `nodeF` (int): node f. - `nodeG` (int, optional (default `0`)): node g. - `nodeH` (int, optional (default `0`)): node h. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSolid(1, 1, 1, 1, 1, 1, 1, 1) print(result) ``` ### CreateSolid **Description** Creates the solid. **Parameters** - `solidNo` (int): solid no. - `nodeA` (int): node a. - `nodeB` (int): node b. - `nodeC` (int): node c. - `nodeD` (int): node d. - `nodeE` (int): node e. - `nodeF` (int): node f. - `nodeG` (int, optional (default `0`)): node g. - `nodeH` (int, optional (default `0`)): node h. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.CreateSolid(1, 1, 1, 1, 1, 1, 1, 1, 1) ``` ## Get ### GetAllSolidNormalStresses **Description** Returns the all solid normal stresses. **Parameters** - `nSolidNo` (int): n solid no. - `nCorner` (int): n corner. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllSolidNormalStresses(1, 1, 1) print(result) ``` ### GetAllSolidPrincipalStresses **Description** Returns the all solid principal stresses. **Parameters** - `nSolidNo` (int): n solid no. - `nCorner` (int): n corner. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllSolidPrincipalStresses(1, 1, 1) print(result) ``` ### GetAllSolidShearStresses **Description** Returns the all solid shear stresses. **Parameters** - `nSolidNo` (int): n solid no. - `nCorner` (int): n corner. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllSolidShearStresses(1, 1, 1) print(result) ``` ### GetAllSolidVonMisesStresses **Description** Returns the all solid von mises stresses. **Parameters** - `nSolidNo` (int): n solid no. - `nCorner` (int): n corner. - `loadCaseNo` (int): load case no. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAllSolidVonMisesStresses(1, 1, 1) print(result) ``` ### GetIsotropicMaterialAssignedSolidCount **Description** Returns the isotropic material assigned solid count. **Parameters** - `material_name` (str): material name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialAssignedSolidCount("value") print(result) ``` ### GetIsotropicMaterialAssignedSolidList **Description** Returns the isotropic material assigned solid list. **Parameters** - `material_name` (str): material name. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialAssignedSolidList("value") print(result) ``` ### GetLastSolidNo **Description** Returns the last the solid no. **Parameters** None. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLastSolidNo() print(result) ``` ### GetNoOfSelectedSolids **Description** Returns the number of the selected solids. **Parameters** None. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoOfSelectedSolids() print(result) ``` ### GetSelectedSolids **Description** Returns the selected solids. **Parameters** - `isSorted` (bool, optional (default `False`)): is sorted. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSelectedSolids(True) print(result) ``` ### GetSolidCount **Description** Returns the solid count. **Parameters** None. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSolidCount() print(result) ``` ### GetSolidIncidence **Description** Returns the solid incidence. **Parameters** - `solidNo` (int): solid no. **Returns** tuple: A tuple of `int` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSolidIncidence(1) print(result) ``` ### GetSolidIncidence_CIS2 **Description** Returns the solid incidence CIS 2. **Parameters** - `solidId` (int): solid Id. **Returns** tuple: A tuple of `(str, raw)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSolidIncidence_CIS2(1) print(result) ``` ### GetSolidList **Description** Returns the solid list. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSolidList() print(result) ``` ### GetSolidMaterialName **Description** Returns the solid material name. **Parameters** - `solid_id` (int): solid id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSolidMaterialName(1) print(result) ``` ### GetSolidUniqueID **Description** Returns the solid unique ID. **Parameters** - `solidNo` (int): solid no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSolidUniqueID(1) print(result) ``` ## Set/Assign ### AssignMaterialToSolid **Description** Assigns the material to solid. **Parameters** - `material_name` (str): material name. - `solid_ids` (list): solid ids. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignMaterialToSolid("value", [1, 2]) print(result) ``` ### SetSolidUniqueID **Description** Sets the solid unique ID. **Parameters** - `solidNo` (int): solid no. - `uniqueID` (str): unique ID. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetSolidUniqueID(1, "value") ``` ## Delete ### ClearSolidSelection **Description** Clears the solid selection. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ClearSolidSelection() ``` ### DeleteSolid **Description** Deletes the solid. **Parameters** - `solidID` (int): solid ID. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.DeleteSolid(1) ``` ### RemoveMaterialFromSolid **Description** Removes the material from solid. **Parameters** - `solid_id_list` (list): solid id list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveMaterialFromSolid([1, 2]) print(result) ``` ## Select ### SelectEntitiesConnectedToSolid **Description** Selects the entities connected to solid. **Parameters** - `entityType` (int): entity type. - `solidNo` (int): solid no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SelectEntitiesConnectedToSolid(1, 1) ``` ### SelectMultipleSolids **Description** Selects multiple the solids. **Parameters** - `solids` (list): solids. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SelectMultipleSolids([1, 2]) print(result) ``` ### SelectSolid **Description** Selects the solid. **Parameters** - `solidID` (int): solid ID. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SelectSolid(1) print(result) ``` ## View ### HideSolid **Description** Hides the solid. **Parameters** - `nSolid` (int): n solid. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.HideSolid(1) ``` --- # Parametric Surface functions | OpenStaad Python > Parametric surfaces used to generate plate meshes — define, mesh, and query the surface, its regions, and density points. Source: https://www.openstaad.com/docs/parametric-surface Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddCircularRegionToSurface **Description** Adds the circular region to surface. **Parameters** - `surfaceNo` (int): surface no. - `x` (float): x. - `y` (float): y. - `z` (float): z. - `radius` (float): radius. - `divisions` (int): divisions. - `density` (int): density. - `is_opening` (bool, optional (default `False`)): is opening. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddCircularRegionToSurface(1, 1.0, 1.0, 1.0, 1.0, 1, 1, True) print(result) ``` ### AddDensityLineToSurface **Description** Adds the density line to surface. **Parameters** - `surfaceNo` (int): surface no. - `x1` (float): x 1. - `y1` (float): y 1. - `z1` (float): z 1. - `density1` (int): density 1. - `x2` (float): x 2. - `y2` (float): y 2. - `z2` (float): z 2. - `density2` (int): density 2. - `divisions` (int): divisions. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddDensityLineToSurface(1, 1.0, 1.0, 1.0, 1, 1.0, 1.0, 1.0, 1, 1) print(result) ``` ### AddDensityPointToSurface **Description** Adds the density point to surface. **Parameters** - `surfaceNo` (int): surface no. - `pointData` (list): point data. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.AddDensityPointToSurface(1, [1, 2]) ``` ### AddParametricSurfaceToModel **Description** Adds the parametric surface to model. **Parameters** - `surfaceNo` (int): surface no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddParametricSurfaceToModel(1) print(result) ``` ### AddPolygonalRegionToSurface **Description** Adds the polygonal region to surface. **Parameters** - `surfaceNo` (int): surface no. - `regionData` (list): region data. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.AddPolygonalRegionToSurface(1, [1, 2]) ``` ### CreateParametricSurfaceThicknessProperty **Description** Creates the parametric surface thickness property. **Parameters** - `node_thickness_list` (list): node thickness list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateParametricSurfaceThicknessProperty([1, 2]) print(result) ``` ### DefineParametricSurface **Description** Defines the parametric surface. **Parameters** - `name` (str): name. - `type` (int): type. - `origin_Node` (int): origin node. - `x_vertex_node` (int): x vertex node. - `y_vertex_node` (int): y vertex node. - `vertices_list` (list): vertices list. - `auto_generate` (bool): auto generate. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DefineParametricSurface("value", 1, 1, 1, 1, [1, 2], True) print(result) ``` ## Get ### GetParametricSurfaceCount **Description** Returns the parametric surface count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetParametricSurfaceCount() print(result) ``` ### GetParametricSurfaceInfo **Description** Returns the parametric surface info. **Parameters** - `surfaceNo` (int): surface no. **Returns** tuple: A tuple of `(str, str, int, int, int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetParametricSurfaceInfo(1) print(result) ``` ### GetParametricSurfaceInfoEx **Description** Returns the parametric surface info ex. **Parameters** - `surfaceNo` (int): surface no. **Returns** tuple: A tuple of `(str, int, str, int, float, int, int, bool, int, int, int, int, int, int, int, int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetParametricSurfaceInfoEx(1) print(result) ``` ### GetParametricSurfaceMeshData **Description** Returns the parametric surface mesh data. **Parameters** - `surfaceNo` (int): surface no. **Returns** tuple: A tuple of `(list[int], list[int])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetParametricSurfaceMeshData(1) print(result) ``` ### GetParametricSurfaceMeshInfo **Description** Returns the parametric surface mesh info. **Parameters** - `surfaceNo` (int): surface no. **Returns** tuple: A tuple of `(int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetParametricSurfaceMeshInfo(1) print(result) ``` ### GetParametricSurfaceSubType **Description** Returns the parametric surface sub type. **Parameters** - `surfaceName` (str): surface name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetParametricSurfaceSubType("value") print(result) ``` ### GetParametricSurfaceUniqueID **Description** Returns the parametric surface unique ID. **Parameters** - `surface_name` (str): surface name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetParametricSurfaceUniqueID("value") print(result) ``` ### GetResultantForceAlongLineForParametricSurface **Description** Returns the resultant force along line for parametric surface. **Parameters** - `parametricSurfaceName` (str): parametric surface name. - `nplates` (int): nplates. - `loadId` (int): load Id. - `startNode` (list): start node. - `endNode` (list): end node. - `facingNode` (list): facing node. - `isTransformForceToGlobal` (int): is transform force to global. - `firstNode` (int): first node. - `secondNode` (int): second node. - `thirdNode` (int): third node. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetResultantForceAlongLineForParametricSurface("value", 1, 1, [1, 2], [1, 2], [1, 2], 1, 1, 1, 1) print(result) ``` ## Set/Assign ### CommitParametricSurfaceMesh **Description** Commits the parametric surface mesh. **Parameters** - `surfaceNo` (int): surface no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.CommitParametricSurfaceMesh(1) print(result) ``` ### SetParametricSurfaceSubType **Description** Sets the parametric surface sub type. **Parameters** - `surfaceName` (str): surface name. - `subType` (str): sub type. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetParametricSurfaceSubType("value", "value") ``` ### SetParametricSurfaceUniqueID **Description** Sets the parametric surface unique ID. **Parameters** - `surface_name` (str): surface name. - `unique_id` (str): unique id. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetParametricSurfaceUniqueID("value", "value") ``` ## Delete ### RemoveParametricSurfaceMesh **Description** Removes the parametric surface mesh. **Parameters** - `surfaceNo` (int): surface no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveParametricSurfaceMesh(1) print(result) ``` ## View ### HideSurface **Description** Hides the surface. **Parameters** - `nSurface` (int): n surface. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.HideSurface(1) ``` --- # Physical Member functions | OpenStaad Python > Groups several analytical beams into one physical member, so a continuous column split by intermediate nodes is designed as a single unit. Source: https://www.openstaad.com/docs/physical-member Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreatePhysicalMember **Description** Creates a physical member from specified analytical members. **Parameters** - member_list (list): List of analytical member IDs (array of type int) that form the physical member. **Returns** None **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module s.CreatePhysicalMember([5, 9]) ``` ## Get ### GetAnalyticalMemberCountForPhysicalMember **Description** Get the count of analytical members associated with a given physical member. **Parameters** - p_member (int): The physical member number. **Returns** int: Count of associated analytical members. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module am_count = s.GetAnalyticalMemberCountForPhysicalMember(5) print(am_count) ``` ### GetAnalyticalMembersForPhysicalMember **Description** Retrieve the list of analytical member IDs associated with a given physical member. **Parameters** - p_member (int): The physical member number. **Returns** list: List of analytical member IDs associated with the given physical member. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module am_list = s.GetAnalyticalMembersForPhysicalMember(5) print(am_list) ``` ### GetLastPhysicalMemberNo **Description** Get the number of the last physical member in the model. **Parameters** - None **Returns** int: Last physical member number. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module last_pm = s.GetLastPhysicalMemberNo() print(last_pm) ``` ### GetNoOfSelectedPhysicalMembers **Description** Get the number of selected physical members in the model. **Parameters** - None **Returns** int: Number of selected physical members. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module selected_count = s.GetNoOfSelectedPhysicalMembers() print(selected_count) ``` ### GetPhysicalMemberCount **Description** Get the total count of physical members in the model. **Parameters** - None **Returns** int: Total number of physical members. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module pm_count = s.GetPhysicalMemberCount() print(pm_count) ``` ### GetPhysicalMemberList **Description** Retrieve a list of all physical member numbers in the model. **Parameters** - None **Returns** list: List of physical member numbers. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module pm_list = s.GetPhysicalMemberList() print(pm_list) ``` ### GetPhysicalMemberUniqueID **Description** Get the unique identifier for a given physical member. **Parameters** - p_member (int): The physical member number. **Returns** int: Unique ID associated with the physical member. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module unique_id = s.GetPhysicalMemberUniqueID(1) print(unique_id) ``` ### GetSelectedPhysicalMembers **Description** Returns the selected physical members. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSelectedPhysicalMembers() print(result) ``` ## Set/Assign ### SetPhysicalMemberUniqueID Sets the unique string ID (GUID) for the specified physical member. > **Nota:** Este método no es compatible con modelos físicos. ##### Parameters - **nPhyMembNo**: Long variable for holding the physical member number ID for which the GUID is intended to be set. - **szGUID**: String variable for holding the GUID to be set. ##### Return values - Returns nothing. The GUID is set for the specified physical member. ##### Example ```python from openstaad import ops # Instanciar el módulo Geometry s = ops.connect() # Asignar un GUID al miembro físico número 10 s.SetPhysicalMemberUniqueID(10, "123e4567-e89b-12d3-a456-426614174000") ``` ## Delete ### ClearPhysicalMemberSelection **Description** Clears the physical member selection. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ClearPhysicalMemberSelection() ``` ### DeletePhysicalMember **Description** Delete a physical member given its number. **Parameters** - p_member (int): The physical member number to delete. **Returns** None **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module s.DeletePhysicalMember(1) ``` ## Select ### SelectMultiplePhysicalMembers Selects multiple physical members in the current model. This function allows you to select several physical members at once by specifying their numbers. The selection can be used for further operations or queries within the model. ##### Parameters - **PhysicalMemberNosArray**: Array of physical member numbers to select. If the array is null or empty, no members will be selected. (Long) ##### Return values - Returns nothing. The specified physical members are selected in the current model context. ##### Example ```python from openstaad import ops # Instanciar el módulo Geometry s = ops.connect() # Seleccionar múltiples miembros físicos con los números 1, 2 y 3 s.SelectMultiplePhysicalMembers([1, 2, 3]) ``` ### SelectPhysicalMember Highlights the specified physical member in the current model. This function resalta (selecciona) el miembro físico especificado por su número, permitiendo realizar operaciones o consultas posteriores sobre él. ##### Parameters - **nPhyMembNo**: The physical member number to highlight/select. ##### Return values - Returns nothing. The specified physical member is highlighted in the model context. ##### Example ```python from openstaad import ops # Instanciar el módulo Geometry s = ops.connect() # Resaltar el miembro físico número 5 s.SelectPhysicalMember(5) ``` --- # Material functions | OpenStaad Python > Material definitions (isotropic, 2D/3D orthotropic) — modulus, density, Poisson, thermal. Assigned to members, plates, and solids. Source: https://www.openstaad.com/docs/material Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateIsotropicMaterialAluminum **Description** Creates the isotropic material aluminum. **Parameters** - `material_name` (str): material name. - `elasticity_mod` (float): elasticity mod. - `poisson` (float): poisson. - `shear_mod` (float): shear mod. - `density` (float): density. - `thermal_exp` (float): thermal exp. - `damping_ratio` (float): damping ratio. - `physical_flag` (int): physical flag. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateIsotropicMaterialAluminum("value", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1) print(result) ``` ### CreateIsotropicMaterialConcrete **Description** Creates the isotropic material concrete. **Parameters** - `name` (str): name. - `elasticity` (float): elasticity. - `poisson` (float): poisson. - `shear_modulus` (float): shear modulus. - `density` (float): density. - `alpha` (float): alpha. - `damping_ratio` (float): damping ratio. - `compressive_strength` (float): compressive strength. - `physical` (int): physical. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateIsotropicMaterialConcrete("value", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1) print(result) ``` ### CreateIsotropicMaterialProperties **Description** Creates the isotropic material properties. **Parameters** - `material_name` (str): material name. - `elasticity_mod` (float): elasticity mod. - `poisson` (float): poisson. - `shear_mod` (float): shear mod. - `density` (float): density. - `coef_thermal_exp` (float): coef thermal exp. - `damp_ratio` (float): damp ratio. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateIsotropicMaterialProperties("value", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### CreateIsotropicMaterialPropertiesEx **Description** Creates the isotropic material properties ex. **Parameters** - `material_name` (str): material name. - `elasiticity` (float): elasiticity. - `poisson` (float): poisson. - `shear_modulus` (float): shear modulus. - `density` (float): density. - `alpha` (float): alpha. - `damping_ratio` (float): damping ratio. - `fy` (float): fy. - `fu` (float): fu. - `ry` (float): ry. - `rt` (float): rt. - `fcu` (float): fcu. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateIsotropicMaterialPropertiesEx("value", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### CreateIsotropicMaterialSteel **Description** Creates the isotropic material steel. **Parameters** - `name` (str): name. - `elasticity_mod` (float): elasticity mod. - `poisson_ratio` (float): poisson ratio. - `shear_modulus` (float): shear modulus. - `density` (float): density. - `thermal_expansion` (float): thermal expansion. - `damping_ratio` (float): damping ratio. - `tensile_strength` (float): tensile strength. - `yield_strength` (float): yield strength. - `tensile_ratio` (float): tensile ratio. - `yield_ratio` (float): yield ratio. - `is_physical` (int): is physical. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateIsotropicMaterialSteel("value", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1) print(result) ``` ### CreateIsotropicMaterialTimber **Description** Creates the isotropic material timber. **Parameters** - `material_name` (str): material name. - `elasticity` (float): elasticity. - `poisson` (float): poisson. - `shear_modulus` (float): shear modulus. - `density` (float): density. - `thermal_expansion` (float): thermal expansion. - `damping_ratio` (float): damping ratio. - `physical_flag` (int): physical flag. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateIsotropicMaterialTimber("value", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1) print(result) ``` ## Get ### GetIsotropicMaterialCount **Description** Returns the isotropic material count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialCount() print(result) ``` ### GetIsotropicMaterialProperties **Description** Returns the isotropic material properties. **Parameters** - `material_number` (int): material number. **Returns** tuple: A tuple of `(raw, raw)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialProperties(1) print(result) ``` ### GetIsotropicMaterialPropertiesAssigned **Description** Returns the isotropic material properties assigned. **Parameters** - `material_no` (int): material no. **Returns** tuple: A tuple of `(raw, raw, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialPropertiesAssigned(1) print(result) ``` ### GetIsotropicMaterialPropertiesEx **Description** Returns the isotropic material properties ex. **Parameters** - `material_number` (int): material number. **Returns** tuple: A tuple of `(raw, raw)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIsotropicMaterialPropertiesEx(1) print(result) ``` ### GetMaterialProperty **Description** Returns the material property. **Parameters** - `MaterialName` (str): material name. **Returns** tuple: five floats, `(E, poisson, density, alpha, damping)`. | Slot | Value | Unit (Metric / English base) | |---|---|---| | 1 | Modulus of elasticity | `kN/m²` / `kip/in²` | | 2 | Poisson's ratio | dimensionless | | 3 | Density | `kN/m³` / `kip/in³` | | 4 | Thermal expansion coefficient | unchanged by the base unit | | 5 | Critical damping ratio | dimensionless | See [Base Units](/guides/base_units). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMaterialProperty("value") print(result) ``` ### GetMaterialPropertyEx **Description** Returns the material property ex. **Parameters** - `material_name` (str): material name. **Returns** tuple: A tuple of `float` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMaterialPropertyEx("value") print(result) ``` ### GetOrthotropic2DMaterialCount **Description** Returns the orthotropic 2 d material count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOrthotropic2DMaterialCount() print(result) ``` ### GetOrthotropic2DMaterialProperties **Description** Returns the orthotropic 2 d material properties. **Parameters** - `material_no` (int): material no. **Returns** tuple: A tuple of `float` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOrthotropic2DMaterialProperties(1) print(result) ``` ### GetOrthotropic3DMaterialCount **Description** Returns the orthotropic 3 d material count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOrthotropic3DMaterialCount() print(result) ``` ### GetOrthotropic3DMaterialProperties **Description** Returns the orthotropic 3 d material properties. **Parameters** - `material_no` (int): material no. **Returns** tuple: A tuple of `float` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOrthotropic3DMaterialProperties(1) print(result) ``` ### GetTypeForIsotropicMaterial **Description** Returns the type for isotropic material. **Parameters** - `material_name` (str): material name. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetTypeForIsotropicMaterial("value") print(result) ``` ## Set/Assign ### SetMaterialName **Description** Sets the material name. **Parameters** - `material_name` (str): material name. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetMaterialName("value") ``` ### SetTypeToIsotropicMaterial **Description** Sets the type to isotropic material. **Parameters** - `material_name` (str): material name. - `material_type` (int): material type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetTypeToIsotropicMaterial("value", 1) print(result) ``` ## Delete ### DeleteMaterial **Description** Deletes the material. **Parameters** - `material_name` (str): material name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteMaterial("value") print(result) ``` --- # Section/Property: Standard Table Sections functions | OpenStaad Python > Cross-sections from built-in country steel tables (AISC and others). Applied to members in Member › Section & Material. Source: https://www.openstaad.com/docs/section-property/standard-table-sections Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateAnglePropertyFromTable **Description** Creates the angle property from table. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `specification_type_no` (int): specification type no. - `add_spec` (float): add spec. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateAnglePropertyFromTable(1, "value", 1, 1.0) print(result) ``` ### CreateAssignProfileProperty **Description** Creates the assign profile property. **Parameters** - `profile_type` (int): profile type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateAssignProfileProperty(1) print(result) ``` ### CreateChannelPropertyFromTable **Description** Creates the channel property from table. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `spec_type` (int): spec type. - `additional_spec_1` (float): additional spec 1. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateChannelPropertyFromTable(1, "value", 1, 1.0) print(result) ``` ### CreatePipePropertyFromTable **Description** Creates the pipe property from table. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `spec_type` (int): spec type. - `additional_spec_1` (float): additional spec 1. - `additional_spec_2` (float): additional spec 2. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePipePropertyFromTable(1, "value", 1, 1.0, 1.0) print(result) ``` ### CreatePrismaticTeeProperty **Description** Creates the prismatic tee property. **Parameters** - `total_section_depth` (float): total section depth. - `flange_width` (float): flange width. - `stem_depth` (float): stem depth. - `stem_width` (float): stem width. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePrismaticTeeProperty(1.0, 1.0, 1.0, 1.0) print(result) ``` ### CreatePropertyFromUserTable **Description** Creates the property from user table. **Parameters** - `section_name` (str): section name. - `table_no` (int): table no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePropertyFromUserTable("value", 1) print(result) ``` ### CreateTaperedTubeProperty **Description** Creates the tapered tube property. **Parameters** - `tube_type` (int): tube type. - `start_member_section_depth` (float): start member section depth. - `end_member_section_depth` (float): end member section depth. - `section_thickness` (float): section thickness. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateTaperedTubeProperty(1, 1.0, 1.0, 1.0) print(result) ``` ### CreateTeePropertyFromTable **Description** Creates the tee property from table. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `spec_type` (int): spec type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateTeePropertyFromTable(1, "value", 1) print(result) ``` ### CreateTubePropertyFromTable **Description** Creates the tube property from table. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `spec_type` (int): spec type. - `add_spec_1` (float): add spec 1. - `add_spec_2` (float): add spec 2. - `add_spec_3` (float): add spec 3. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateTubePropertyFromTable(1, "value", 1, 1.0, 1.0, 1.0) print(result) ``` ### CreateWideFlangePropertyFromTable **Description** Creates the wide flange property from table. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. - `spec_type` (int): spec type. - `specs_list` (list): specs list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateWideFlangePropertyFromTable(1, "value", 1, [1, 2]) print(result) ``` ## Get ### GetAlphaAngleForSection **Description** Returns the alpha angle of a section, in radians — the angle between the section's principal axis and its geometric axis. **Parameters** - `spec_property_id` (int): ID of the section property. **Returns** float: The alpha angle, in radians. **Example** ```python from openstaad import ops s = ops.connect() alpha = s.GetAlphaAngleForSection(1) print(alpha) ``` ### GetDefaultStandardProfileDBFolder **Description** Returns the default standard profile DB folder. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetDefaultStandardProfileDBFolder() print(result) ``` ### GetPublishedProfileName **Description** Returns the published profile name. **Parameters** - `staad_profile_name` (str): staad profile name. - `country_code` (int): country code. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPublishedProfileName("value", 1) print(result) ``` ### GetSTAADProfileName **Description** Returns the STAAD profile name. **Parameters** - `published_name` (str): published name. - `country_code` (int): country code. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSTAADProfileName("value", 1) print(result) ``` ### GetStandardProfileDBFolder **Description** Returns the standard profile DB folder. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetStandardProfileDBFolder() print(result) ``` ### GetStandardSectionDatabaseName **Description** Returns the standard section database name. **Parameters** - `section_property_id` (int): section property id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetStandardSectionDatabaseName(1) print(result) ``` ### GetStandardSectionName **Description** Returns the standard section name. **Parameters** - `section_reference_id` (int): section reference id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetStandardSectionName(1) print(result) ``` ### GetStandardSectionTableName **Description** Returns the standard section table name. **Parameters** - `section_reference_id` (int): section reference id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetStandardSectionTableName(1) print(result) ``` ### GetUserProvidedTableSectionCount **Description** Returns the user provided table section count. **Parameters** - `table_id` (int): table id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUserProvidedTableSectionCount(1) print(result) ``` ### GetUserProvidedTableSectionList **Description** Returns the user provided table section list. **Parameters** - `table_id` (int): table id. **Returns** list: A list of strings. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUserProvidedTableSectionList(1) print(result) ``` ### GetUserProvidedTableSectionProperties **Description** Returns the user provided table section properties. **Parameters** - `table_id` (int): table id. - `section_name` (str): section name. - `property_count` (int, optional (default `24`)): property count. **Returns** tuple: A tuple of `(int, list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUserProvidedTableSectionProperties(1, "value", 1) print(result) ``` ### GetUserProvidedTableSectionPropertyCount **Description** Returns the user provided table section property count. **Parameters** - `upt_table_id` (int): upt table id. - `section_name` (str): section name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUserProvidedTableSectionPropertyCount(1, "value") print(result) ``` ### GetUserProvidedTableSectionType **Description** Returns the user provided table section type. **Parameters** - `table_id` (int): table id. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUserProvidedTableSectionType(1) print(result) ``` ## Set/Assign ### SetStandardProfileDBFolder **Description** Sets the standard profile DB folder. **Parameters** - `folder_name` (str): folder name. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetStandardProfileDBFolder("value") print(result) ``` ## Execute ### ComputeWallWindPressureProfile **Description** Calls the `ComputeWallWindPressureProfile` function on the OpenStaad `ops` session. **Parameters** - `loadingCode` (int): loading code. - `windSpeed` (float): wind speed. - `bldgClass` (int): bldg class. - `bldgType` (int): bldg type. - `expCat` (int): exp cat. - `bEscarpment` (bool): b escarpment. - `varUnitsData` (list): var units data. - `varEscarpmentData` (list): var escarpment data. - `varBldgData` (list): var bldg data. - `wallType` (int): wall type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.ComputeWallWindPressureProfile(1, 1.0, 1, 1, 1, True, [1, 2], [1, 2], [1, 2], 1) print(result) ``` ### ComputeWallWindPressureProfileASCE72016 **Description** Calls the `ComputeWallWindPressureProfileASCE72016` function on the OpenStaad `ops` session. **Parameters** - `windSpeed` (float): wind speed. - `heightAboveSeaLvl` (float): height above sea lvl. - `bldgClass` (int): bldg class. - `bldgType` (int): bldg type. - `expCat` (int): exp cat. - `bEscarpment` (bool): b escarpment. - `varUnitsData` (list): var units data. - `varEscarpmentData` (list): var escarpment data. - `varBldgData` (list): var bldg data. - `wallType` (int): wall type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.ComputeWallWindPressureProfileASCE72016(1.0, 1.0, 1, 1, 1, True, [1, 2], [1, 2], [1, 2], 1) print(result) ``` ## Is ### IsStandardDatabaseSection **Description** Checks whether standard database section. **Parameters** - `section_reference_id` (int): section reference id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsStandardDatabaseSection(1) print(result) ``` --- # Section/Property: UPT Profiles functions | OpenStaad Python > User-Provided Table sections — custom cross-sections defined in an external table and referenced by members. Source: https://www.openstaad.com/docs/section-property/upt-profiles Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddUPTPropertyANGLE **Description** Adds the UPT property ANGLE. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `depth_of_angle` (float): depth of angle. - `width_of_angle` (float): width of angle. - `flange_thickness` (float): flange thickness. - `gyration_radius` (float): gyration radius. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyANGLE(1, "value", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddUPTPropertyCHANNEL **Description** Adds the UPT property CHANNEL. **Parameters** - `table_reference_id` (int): table reference id. - `stn_name` (str): stn name. - `cro_sec_area` (value): cro sec area. - `sectn_depth` (float): sectn depth. - `web_Thickness` (float): web thickness. - `top_flange_width` (float): top flange width. - `top_flange_thickness` (float): top flange thickness. - `torsional_constant` (value): torsional constant. - `moi_l_y` (float): moi l y. - `moi_l_z` (float): moi l z. - `c_z` (float): c z. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyCHANNEL(1, "value", 1, 1.0, 1.0, 1.0, 1.0, 1, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddUPTPropertyDOUBLEANGLE **Description** Adds the UPT property DOUBLEANGLE. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `depth_angle` (float): depth angle. - `width_angle` (float): width angle. - `flanges_thickness` (float): flanges thickness. - `distance_between_two_angles` (bool): distance between two angles. - `torsional_constant` (value): torsional constant. - `moi_y` (float): moi y. - `moi_z` (float): moi z. - `dist_z_top_section` (bool): dist z top section. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyDOUBLEANGLE(1, "value", 1.0, 1.0, 1.0, True, 1, 1.0, 1.0, True, 1.0, 1.0) print(result) ``` ### AddUPTPropertyGENERAL **Description** Adds the UPT property GENERAL. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `cross_section_area` (value): cross section area. - `section_depth` (float): section depth. - `thickness_parallel_depth` (float): thickness parallel depth. - `width_of_section` (float): width of section. - `thickness_parallel_flange` (float): thickness parallel flange. - `torsional_constant` (value): torsional constant. - `moi_y` (float): moi y. - `moi_z` (float): moi z. - `section_modulus_z` (float): section modulus z. - `section_modulus_y` (float): section modulus y. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. - `plastic_modulus_z` (float): plastic modulus z. - `plastic_modulus_y` (float): plastic modulus y. - `warping_constant` (value): warping constant. - `depth_of_web` (float): depth of web. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyGENERAL(1, "value", 1, 1.0, 1.0, 1.0, 1.0, 1, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1, 1.0) print(result) ``` ### AddUPTPropertyISECTION **Description** Adds the UPT property ISECTION. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `depth_of_web` (float): depth of web. - `thickness_of_web` (float): thickness of web. - `depth_of_web1` (float): depth of web 1. - `width_of_top_flange` (float): width of top flange. - `thickness_of_top_flange` (float): thickness of top flange. - `width_of_bottom_flange` (float): width of bottom flange. - `thickness_of_bottom_flange` (float): thickness of bottom flange. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. - `torsional_constant` (value): torsional constant. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyISECTION(1, "value", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1) print(result) ``` ### AddUPTPropertyPIPE **Description** Adds the UPT property PIPE. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `out_diameter` (value): out diameter. - `in_diameter` (value): in diameter. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyPIPE(1, "value", 1, 1, 1.0, 1.0) print(result) ``` ### AddUPTPropertyPRISMATIC **Description** Adds the UPT property PRISMATIC. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `cross_section_area` (value): cross section area. - `torsional_constant` (value): torsional constant. - `moment_of_inertia_y` (float): moment of inertia y. - `moment_of_inertia_z` (float): moment of inertia z. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. - `depth_y` (float): depth y. - `depth_z` (float): depth z. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyPRISMATIC(1, "value", 1, 1, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddUPTPropertyTEE **Description** Adds the UPT property TEE. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `cross_section_area` (value): cross section area. - `section_depth` (float): section depth. - `top_flange_width` (float): top flange width. - `top_flange_thickness` (float): top flange thickness. - `web_thickness` (float): web thickness. - `torsional_constant` (value): torsional constant. - `moi_y` (float): moi y. - `moi_z` (float): moi z. - `dist_z_top_section` (bool): dist z top section. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyTEE(1, "value", 1, 1.0, 1.0, 1.0, 1.0, 1, 1.0, 1.0, True, 1.0, 1.0) print(result) ``` ### AddUPTPropertyTUBE **Description** Adds the UPT property TUBE. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `cross_section_area` (value): cross section area. - `section_depth` (float): section depth. - `top_flange_width` (float): top flange width. - `top_flange_thickness` (float): top flange thickness. - `torsional_constant` (value): torsional constant. - `moi_y` (float): moi y. - `moi_z` (float): moi z. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyTUBE(1, "value", 1, 1.0, 1.0, 1.0, 1, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddUPTPropertyWIDEFLANGE **Description** Adds the UPT property WIDEFLANGE. **Parameters** - `table_ref_id` (int): table ref id. - `stn_name` (str): stn name. - `cro_sec_area` (value): cro sec area. - `sectn_depth` (float): sectn depth. - `web_Thickness` (float): web thickness. - `top_flange_width` (float): top flange width. - `top_flange_thickness` (float): top flange thickness. - `torsional_constant` (value): torsional constant. - `moi_l_y` (float): moi l y. - `moi_l_z` (float): moi l z. - `shear_area_y` (float): shear area y. - `shear_area_z` (float): shear area z. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyWIDEFLANGE(1, "value", 1, 1.0, 1.0, 1.0, 1.0, 1, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddUPTPropertyWIDEFLANGECOMPOSITE **Description** Adds the UPT property WIDEFLANGECOMPOSITE. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `profile_spec_list` (list): profile spec list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyWIDEFLANGECOMPOSITE(1, "value", [1, 2]) print(result) ``` ### AddUPTPropertyWIDEFLANGEUNEQUAL **Description** Adds the UPT property WIDEFLANGEUNEQUAL. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. - `profile_spec_list` (list): profile spec list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddUPTPropertyWIDEFLANGEUNEQUAL(1, "value", [1, 2]) print(result) ``` ### CreatePropertyFromUPTTable **Description** Creates the property from UPT table. **Parameters** - `table_id` (int): table id. - `section_name` (str): section name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePropertyFromUPTTable(1, "value") print(result) ``` ### CreateUPTTable **Description** Creates the UPT table. **Parameters** - `table_type` (int): table type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateUPTTable(1) print(result) ``` ### CreateUPTTableEx **Description** Creates the UPT table ex. **Parameters** - `table_ref_id` (int): table ref id. - `table_type` (int): table type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateUPTTableEx(1, 1) print(result) ``` ## Get ### GetUptGeneralProfileBoundaryPoints **Description** Returns the Upt general profile boundary points. **Parameters** - `table_number_id` (int): table number id. - `section_name` (str): section name. - `is_inner` (bool): is inner. **Returns** tuple: A tuple of `(list[float], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUptGeneralProfileBoundaryPoints(1, "value", True) print(result) ``` ### GetUptGeneralProfilePointsCount **Description** Returns the Upt general profile points count. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. **Returns** tuple: A tuple of `(int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUptGeneralProfilePointsCount(1, "value") print(result) ``` ## Delete ### RemovePropertyFromUPTTable **Description** Removes the property from UPT table. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemovePropertyFromUPTTable(1, "value") print(result) ``` ### RemoveUPTTable **Description** Removes the UPT table. **Parameters** - `table_ref_id` (int): table ref id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveUPTTable(1) print(result) ``` --- # Section/Property: Prismatic/General Properties functions | OpenStaad Python > Prismatic/general sections defined by raw properties (area, Iy, Iz, J…) rather than a catalog shape. Source: https://www.openstaad.com/docs/section-property/prismatic-general-properties Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreatePrismaticCircleProperty **Description** Creates the prismatic circle property. **Parameters** - `circle_diameter` (float): circle diameter. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePrismaticCircleProperty(1.0) print(result) ``` ### CreatePrismaticGeneralProperty **Description** Creates the prismatic general property. **Parameters** - `property_value_list` (list): property value list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePrismaticGeneralProperty([1, 2]) print(result) ``` ### CreatePrismaticRectangleProperty **Description** Creates the prismatic rectangle property. **Parameters** - `depth_along_y_axis` (float): depth along y axis. - `depth_along_z_axis` (float): depth along z axis. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePrismaticRectangleProperty(1.0, 1.0) print(result) ``` ### CreatePrismaticTrapezoidalProperty **Description** Creates the prismatic trapezoidal property. **Parameters** - `section_depth` (float): section depth. - `top_fiber_section_width` (float): top fiber section width. - `bottom_fiber_section_width` (float): bottom fiber section width. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePrismaticTrapezoidalProperty(1.0, 1.0, 1.0) print(result) ``` ### CreateTaperedIProperty **Description** Creates the tapered i property. **Parameters** - `property_value_list` (list): property value list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateTaperedIProperty([1, 2]) print(result) ``` ## Get ### GetThicknessPropertyCount **Description** Returns the thickness property count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetThicknessPropertyCount() print(result) ``` ### GetThicknessPropertyList **Description** Returns the thickness property list. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetThicknessPropertyList() print(result) ``` ### GetThicknessPropertyValues **Description** Returns the thickness property values. **Parameters** - `property_reference_id` (int): property reference id. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetThicknessPropertyValues(1) print(result) ``` --- # Section/Property: Query & Attributes functions | OpenStaad Python > Query section properties — area, moments of inertia, dimensions — for any assigned or table section. Source: https://www.openstaad.com/docs/section-property/query-attributes Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Get ### GetAssignedAttributeByIndex **Description** Returns the assigned attribute by index. **Parameters** - `attribute_index` (int): attribute index. **Returns** tuple: A tuple of `(str, str)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAssignedAttributeByIndex(1) print(result) ``` ### GetAssignedAttributeCount **Description** Returns the assigned attribute count. **Parameters** - `member_id` (int): member id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAssignedAttributeCount(1) print(result) ``` ### GetCentroidLocationForSection **Description** Returns the centroid location for section. **Parameters** - `property_id` (int): property id. **Returns** tuple: A tuple of `(float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetCentroidLocationForSection(1) print(result) ``` ### GetCountofSectionPropertyValuesEx **Description** Returns the countof section property values ex. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetCountofSectionPropertyValuesEx() print(result) ``` ### GetMaxSectionDisplacement **Description** Returns the max section displacement. **Parameters** - `memberNo` (int): member no. - `dir` (str): dir. - `loadCaseNo` (int): load case no. **Returns** tuple: A tuple of `(float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMaxSectionDisplacement(1, "value", 1) print(result) ``` ### GetPID **Description** Returns the PID. **Parameters** - `EntityNo` (int): entity no. - `EntityType` (int): entity type. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPID(1, 1) print(result) ``` ### GetPropertyUniqueID **Description** Returns the property unique ID. **Parameters** - `property_unique_id` (int): property unique id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPropertyUniqueID(1) print(result) ``` ### GetRecordForSection **Description** Returns the record for section. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetRecordForSection(1, "value") print(result) ``` ### GetSectionPropertyCount **Description** Returns the section property count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionPropertyCount() print(result) ``` ### GetSectionPropertyCountry **Description** Returns the section property country. **Parameters** - `sec_ref_no` (int): sec ref no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionPropertyCountry(1) print(result) ``` ### GetSectionPropertyList **Description** Returns the section property list. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionPropertyList() print(result) ``` ### GetSectionPropertyName **Description** Returns the section property name. **Parameters** - `sctn_prop_id` (int): sctn prop id. **Returns** str: A string value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionPropertyName(1) print(result) ``` ### GetSectionPropertyType **Description** Returns the section property type. **Parameters** - `sec_ref_no` (int): sec ref no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionPropertyType(1) print(result) ``` ### GetSectionPropertyValues **Description** Returns the 10 basic section property values for an assigned profile type. **Parameters** - `prof_type` (int): Assigned profile type code: | Profile type | Value | |---------------------|-------| | AssignAngle | 0 | | AssignDoubleAngle | 1 | | AssignBeam | 2 | | AssignColumn | 3 | | AssignChannel | 4 | **Returns** tuple: A 10-element tuple of floats, in this order: `(width, depth, ax, ay, az, ix, iy, iz, tf, tw)`. | # | Value | Meaning | |---|-------|--------------------------------------------------------------------------------------| | 1 | width | Section width (WID). | | 2 | depth | Section depth (DEP). | | 3 | ax | Cross-sectional area (Ax). | | 4 | ay | Shear area in local y axis; if zero, shear deformation is ignored in analysis (Ay). | | 5 | az | Shear area in local z axis; if zero, shear deformation is ignored in analysis (Az). | | 6 | ix | Moment of inertia about local z axis (Ix). | | 7 | iy | Moment of inertia about local y axis (Iy). | | 8 | iz | Torsional constant (Iz). | | 9 | tf | Top flange thickness (Tf). | | 10| tw | Web thickness (Tw). | **Example** ```python from openstaad import ops s = ops.connect() width, depth, ax, ay, az, ix, iy, iz, tf, tw = s.GetSectionPropertyValues(2) print(width, depth, ax) ``` ### GetSectionPropertyValuesEx **Description** Returns the section property values ex. **Parameters** - `section_property_id` (int): section property id. **Returns** tuple: A tuple of `(int, list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionPropertyValuesEx(1) print(result) ``` ### GetSectionTableNo **Description** Returns the section table no. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSectionTableNo(1) print(result) ``` ### GetShapeCode **Description** Returns the shape code. **Parameters** - `country_code` (int): country code. - `section_name` (str): section name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetShapeCode(1, "value") print(result) ``` ## Set/Assign ### SetPID **Description** Sets the PID. **Parameters** - `EntityNo` (int): entity no. - `EntityType` (int): entity type. - `PropertyID` (int): property ID. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetPID(1, 1, 1) ``` ### SetPropertyUniqueID **Description** Sets the property unique ID. **Parameters** - `property_number` (int): property number. - `property_unique_id` (str): property unique id. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetPropertyUniqueID(1, "value") ``` ### UpdatePropertiesToDesignSection **Description** Updates the properties to design section. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.UpdatePropertiesToDesignSection() print(result) ``` ## Delete ### DeleteProperty **Description** Deletes the property. **Parameters** - `property_id` (int): property id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteProperty(1) print(result) ``` ### RemoveAttribute **Description** Removes the attribute. **Parameters** - `attribute_name` (str): attribute name. - `str_value` (str): str value. - `member_ids` (list): member ids. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveAttribute("value", "value", [1, 2]) print(result) ``` --- # Load: Load Cases functions | OpenStaad Python > Primary load cases — the containers every applied load belongs to. Create and query cases before adding nodal, member, or area loads. Source: https://www.openstaad.com/docs/load/load-cases Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddReferenceLoad **Description** Adds the reference load. **Parameters** - `varRefLoadCaseNoIds` (list): var ref load case no ids. - `varFactorList` (list): var factor list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddReferenceLoad([1, 2], [1, 2]) print(result) ``` ### AddSeismicLoad **Description** Adds the seismic load. **Parameters** - `loadDirection` (int): load direction. - `factor` (float): factor. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSeismicLoad(1, 1.0) print(result) ``` ### CreateNewPrimaryLoad **Description** Creates the new primary load. **Parameters** - `primaryLoadTitle` (str): primary load title. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateNewPrimaryLoad("value") print(result) ``` ### CreateNewPrimaryLoadEx **Description** Creates the new primary load ex. **Parameters** - `primaryLoadTitle` (str): primary load title. - `loadType` (int): load type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateNewPrimaryLoadEx("value", 1) print(result) ``` ### CreateNewPrimaryLoadEx2 **Description** Creates the new primary load ex 2. **Parameters** - `primaryLoadTitle` (str): primary load title. - `loadType` (int): load type. - `loadCaseNo` (int): load case no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateNewPrimaryLoadEx2("value", 1, 1) print(result) ``` ### CreateNewReferenceLoad **Description** Creates the new reference load. **Parameters** - `nodeNo` (int): node no. - `referenceLoadCaseTitle` (str): reference load case title. - `loadType` (int): load type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateNewReferenceLoad(1, "value", 1) print(result) ``` ## Get ### GetActiveLoad **Description** Returns the active load. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetActiveLoad() print(result) ``` ### GetAttribute **Description** Returns the attribute. **Parameters** - `lLoadCase` (int): l load case. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAttribute(1) print(result) ``` ### GetConcForceCount **Description** Returns the conc force count. **Parameters** - `nBeamNo` (int): n beam no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetConcForceCount(1) print(result) ``` ### GetConcForces **Description** Returns the conc forces. **Parameters** - `nBeamNo` (int): n beam no. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetConcForces(1) print(result) ``` ### GetConcMomentCount **Description** Returns the conc moment count. **Parameters** - `nBeamNo` (int): n beam no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetConcMomentCount(1) print(result) ``` ### GetConcMoments **Description** Returns the conc moments. **Parameters** - `nBeamNo` (int): n beam no. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetConcMoments(1) print(result) ``` ### GetInfluenceArea **Description** Returns the influence area. **Parameters** - `varfMinX` (float): varf min x. - `varfMaxX` (float): varf max x. - `varfMinY` (float): varf min y. - `varfMaxY` (float): varf max y. - `varfMinZ` (float): varf min z. - `varfMaxZ` (float): varf max z. - `varnDirection` (int): varn direction. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetInfluenceArea(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1) print(result) ``` ### GetLinearVaryingLoadCount **Description** Returns the linear varying load count. **Parameters** - `nBeamNo` (int): n beam no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLinearVaryingLoadCount(1) print(result) ``` ### GetLinearVaryingLoads **Description** Returns the linear varying loads. **Parameters** - `nBeamNo` (int): n beam no. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLinearVaryingLoads(1) print(result) ``` ### GetLoadCaseTitle **Description** Returns the load case title. **Parameters** - `varLoadNo` (int): var load no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadCaseTitle(1) print(result) ``` ### GetLoadItemsCount **Description** Returns the load items count. **Parameters** - `loadCaseNo` (int): load case no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadItemsCount(1) print(result) ``` ### GetLoadItemType **Description** Returns the load item type. **Parameters** - `loadCaseNo` (int): load case no. - `loadItemIndex` (int): load item index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadItemType(1, 1) print(result) ``` ### GetLoadType **Description** Returns the load type. **Parameters** - `varLoadNo` (int): var load no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadType(1) print(result) ``` ### GetLoadTypeCount **Description** Returns the load type count. **Parameters** - `loadType` (int): load type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadTypeCount(1) print(result) ``` ### GetNLLoadStep **Description** Returns the NL load step. **Parameters** - `loadCaseNo` (int): load case no. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNLLoadStep(1) print(result) ``` ### GetNoOfSetsInReferenceLoad **Description** Returns the number of the sets in reference load. **Parameters** - `nIndex` (int): n index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoOfSetsInReferenceLoad(1) print(result) ``` ### GetPrimaryLoadCaseCount **Description** Returns the primary load case count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPrimaryLoadCaseCount() print(result) ``` ### GetPrimaryLoadCaseNumbers **Description** Returns the primary load case numbers. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPrimaryLoadCaseNumbers() print(result) ``` ### GetReferenceLoadByIndex **Description** Returns the reference load by index. **Parameters** - `nIndex` (int): n index. **Returns** tuple: A tuple of `(list[int], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetReferenceLoadByIndex(1) print(result) ``` ### GetReferenceLoadCaseCount **Description** Returns the reference load case count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetReferenceLoadCaseCount() print(result) ``` ### GetReferenceLoadCaseNumbers **Description** Returns the reference load case numbers. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetReferenceLoadCaseNumbers() print(result) ``` ### GetReferenceLoadCaseTitle **Description** Returns the reference load case title. **Parameters** - `varLoadNo` (int): var load no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetReferenceLoadCaseTitle(1) print(result) ``` ### GetReferenceLoadCount **Description** Returns the reference load count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetReferenceLoadCount() print(result) ``` ### GetReferenceLoadType **Description** Returns the reference load type. **Parameters** - `varLoadNo` (int): var load no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetReferenceLoadType(1) print(result) ``` ## Set/Assign ### SetASDLoadAttribute **Description** Sets the ASD load attribute. **Parameters** - `loadCaseRefID` (int): load case ref ID. - `strengthType` (int): strength type. - `allowStressIncrease` (bool): allow stress increase. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetASDLoadAttribute(1, 1, True) print(result) ``` ### SetLoadActive **Description** Sets the load active. **Parameters** - `loadNumber` (int): load number. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetLoadActive(1) print(result) ``` ### SetLoadType **Description** Sets the load type. **Parameters** - `loadCaseNumber` (int): load case number. - `loadType` (int): load type. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetLoadType(1, 1) print(result) ``` ### SetLSDLoadAttribute **Description** Sets the LSD load attribute. **Parameters** - `loadCaseRefID` (int): load case ref ID. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetLSDLoadAttribute(1) print(result) ``` ### SetReferenceLoadActive **Description** Sets the reference load active. **Parameters** - `nLoadCaseNo` (int): n load case no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetReferenceLoadActive(1) print(result) ``` ## Delete ### ClearPrimaryLoadCase **Description** Clears the primary load case. **Parameters** - `varLoadCaseNos` (list): var load case nos. - `isReferenceLoad` (bool): is reference load. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.ClearPrimaryLoadCase([1, 2], True) print(result) ``` ### ClearReferenceLoadCase **Description** Clears the reference load case. **Parameters** - `varLoadCaseNos` (list): var load case nos. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.ClearReferenceLoadCase([1, 2]) print(result) ``` ### RemoveAttribute **Description** Removes the attribute. **Parameters** - `lLoadCase` (int): l load case. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveAttribute(1) print(result) ``` ## Is ### IsDynamicLoadIncluded **Description** Checks whether dynamic load included. **Parameters** - `nLoadCase` (int): n load case. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsDynamicLoadIncluded(1) print(result) ``` --- # Load: Nodal Loads & Definitions functions | OpenStaad Python > Loads and enforced displacements applied at nodes — joint loads/moments and support settlements. This is where loads on nodes are defined. Source: https://www.openstaad.com/docs/load/nodal-loads-definitions Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddNodalLoad **Description** Adds the nodal load. **Parameters** - `nodeIds` (list): node ids. - `forceInXDir` (float): force in x dir. - `forceInYDir` (float): force in y dir. - `forceInZDir` (float): force in z dir. - `momentInXDir` (float): moment in x dir. - `momentInYDir` (float): moment in y dir. - `momentInZDir` (float): moment in z dir. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddNodalLoad([1, 2], 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddSeismicDefFloorWeight **Description** Adds the seismic def floor weight. **Parameters** - `rangeType` (int): range type. - `loadDirection` (int): load direction. - `pressure` (float): pressure. - `grpOrOneWay` (int): grp or one way. - `yMIN` (float): y MIN. - `yMAX` (float): y MAX. - `zMIN` (float): z MIN. - `zMAX` (float): z MAX. - `xMIN` (float): x MIN. - `xMAX` (float): x MAX. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSeismicDefFloorWeight(1, 1, 1.0, 1, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddSeismicDefinition **Description** Adds the seismic definition. **Parameters** - `varType` (int): var type. - `varAccidental` (int): var accidental. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSeismicDefinition(1, 1) print(result) ``` ### AddSeismicDefJointWeight **Description** Adds the seismic def joint weight. **Parameters** - `weight` (float): weight. - `nodeList` (list): node list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSeismicDefJointWeight(1.0, [1, 2]) print(result) ``` ### AddSeismicDefMemberWeight **Description** Adds the seismic def member weight. **Parameters** - `varSeismicType` (int): var seismic type. - `loadType` (int): load type. - `weight` (float): weight. - `startDist` (float): start dist. - `endDist` (float): end dist. - `memberList` (list): member list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSeismicDefMemberWeight(1, 1, 1.0, 1.0, 1.0, [1, 2]) print(result) ``` ### AddSeismicDefSelfWeight **Description** Adds the seismic def self weight. **Parameters** - `varWeightFactor` (float): var weight factor. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSeismicDefSelfWeight(1.0) print(result) ``` ### AddSeismicDefWallArea **Description** Adds the seismic def wall area. **Parameters** - `nTypeNo` (int): n type no. - `direction` (str): direction. - `sizeArray` (list): size array. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSeismicDefWallArea(1, "value", [1, 2]) print(result) ``` ## Get ### GetNodalLoadCount **Description** Returns the nodal load count. **Parameters** - `nNodeNo` (int): n node no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNodalLoadCount(1) print(result) ``` ### GetNodalLoadInfo **Description** Returns the nodal load info. **Parameters** - `loadIndex` (int): load index. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNodalLoadInfo(1) print(result) ``` ### GetNodalLoads **Description** Returns the nodal loads. **Parameters** - `nNodeNo` (int): n node no. **Returns** tuple: A tuple of `list[float]` values, one per output slot. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNodalLoads(1) print(result) ``` ## Set/Assign ### ModifySeismicDefinitionParams **Description** Calls the `ModifySeismicDefinitionParams` function on the OpenStaad `ops` session. **Parameters** - `varParamName` (str): var param name. - `varValue` (float): var value. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.ModifySeismicDefinitionParams("value", 1.0) print(result) ``` --- # Load: Member Loads functions | OpenStaad Python > Loads on members — uniform, concentrated, trapezoidal, and temperature. This is where loads on Member elements are defined. Source: https://www.openstaad.com/docs/load/member-loads Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddMemberAreaLoad **Description** Adds the member area load. **Parameters** - `beamIds` (list): beam ids. - `load` (float): load. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberAreaLoad([1, 2], 1.0) print(result) ``` ### AddMemberConcForce **Description** Adds the member conc force. **Parameters** - `beamIds` (list): beam ids. - `varDirection` (int): var direction. - `varForce` (float): var force. - `varD1` (float): var d 1. - `varD2` (float): var d 2. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberConcForce([1, 2], 1, 1.0, 1.0, 1.0) print(result) ``` ### AddMemberConcMoment **Description** Adds the member conc moment. **Parameters** - `beamIds` (list): beam ids. - `varDirection` (int): var direction. - `varMoment` (float): var moment. - `varD1` (float): var d 1. - `varD2` (float): var d 2. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberConcMoment([1, 2], 1, 1.0, 1.0, 1.0) print(result) ``` ### AddMemberFixedEnd **Description** Adds the member fixed end. **Parameters** - `beamIds` (list): beam ids. - `loadStart` (list[float]): load start. - `loadEnd` (list[float]): load end. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberFixedEnd([1, 2], [1, 2], [1, 2]) print(result) ``` ### AddMemberFloorLoad **Description** Adds the member floor load. **Parameters** - `varPressure` (float): var pressure. - `varYMIN` (float): var YMIN. - `varYMAX` (float): var YMAX. - `varZMIN` (float): var ZMIN. - `varZMAX` (float): var ZMAX. - `varXMIN` (float): var XMIN. - `varXMAX` (float): var XMAX. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberFloorLoad(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddMemberFloorLoadEx **Description** Adds the member floor load ex. **Parameters** - `rangeType` (int): range type. - `loadDirection` (int): load direction. - `pressure` (float): pressure. - `grpOrOneWay` (int): grp or one way. - `yMIN` (float): y MIN. - `yMAX` (float): y MAX. - `zMIN` (float): z MIN. - `zMAX` (float): z MAX. - `xMIN` (float): x MIN. - `xMAX` (float): x MAX. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberFloorLoadEx(1, 1, 1.0, 1, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddMemberLinearVari **Description** Adds the member linear vari. **Parameters** - `memberIds` (list): member ids. - `varDirection` (int): var direction. - `varW1` (float): var w 1. - `varW2` (float): var w 2. - `varW3` (float): var w 3. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberLinearVari([1, 2], 1, 1.0, 1.0, 1.0) print(result) ``` ### AddMemberTrapezoidal **Description** Adds the member trapezoidal. **Parameters** - `memberIds` (list): member ids. - `varDirection` (int): var direction. - `varW1` (float): var w 1. - `varW2` (float): var w 2. - `varD1` (float): var d 1. - `varD2` (float): var d 2. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberTrapezoidal([1, 2], 1, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddMemberUniformForce **Description** Adds the member uniform force. **Parameters** - `beamIds` (list): beam ids. - `varDirection` (int): var direction. - `varForce` (float): var force. - `varD1` (float): var d 1. - `varD2` (float): var d 2. - `varD3` (float): var d 3. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberUniformForce([1, 2], 1, 1.0, 1.0, 1.0, 1.0) print(result) ``` ### AddMemberUniformMoment **Description** Adds the member uniform moment. **Parameters** - `beamIds` (list): beam ids. - `varDirection` (int): var direction. - `varMoment` (float): var moment. - `varD1` (float): var d 1. - `varD2` (float): var d 2. - `varD3` (float): var d 3. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddMemberUniformMoment([1, 2], 1, 1.0, 1.0, 1.0, 1.0) print(result) ``` ## Get ### GetBeamCountAtFloor **Description** Returns the beam count at floor. **Parameters** - `varfMinX` (float): varf min x. - `varfMaxX` (float): varf max x. - `varfMinY` (float): varf min y. - `varfMaxY` (float): varf max y. - `varfMinZ` (float): varf min z. - `varfMaxZ` (float): varf max z. - `varnDirection` (int): varn direction. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBeamCountAtFloor(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1) print(result) ``` ### GetMemberLoadInfo **Description** Returns the member load info. **Parameters** - `loadIndex` (int): load index. **Returns** tuple: A tuple of `(int, list[float], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberLoadInfo(1) print(result) ``` ### GetTrapLoadCount **Description** Returns the trap load count. **Parameters** - `nBeamNo` (int): n beam no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetTrapLoadCount(1) print(result) ``` ### GetTrapLoads **Description** Returns the trap loads. **Parameters** - `nBeamNo` (int): n beam no. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetTrapLoads(1) print(result) ``` ### GetUDLLoadCount **Description** Returns the UDL load count. **Parameters** - `nBeamNo` (int): n beam no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUDLLoadCount(1) print(result) ``` ### GetUDLLoads **Description** Returns the UDL loads. **Parameters** - `nBeamNo` (int): n beam no. **Returns** tuple: `(list[int], list[float], list[float], list[float], list[float])`, one entry per UDL on the beam. The second list holds the load magnitude, in `kN/m` (Metric base) or `kip/in` (English base); see [Base Units](/guides/base_units). For example, a `-10` kN/m load reads `-10.0` in a Metric-base model and `-0.0571016` in an English-base one. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUDLLoads(1) print(result) ``` ### GetUNIMomentCount **Description** Returns the UNI moment count. **Parameters** - `nBeamNo` (int): n beam no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUNIMomentCount(1) print(result) ``` ### GetUNIMoments **Description** Returns the UNI moments. **Parameters** - `nBeamNo` (int): n beam no. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUNIMoments(1) print(result) ``` ## Transform ### MergeLoadsOnBeam **Description** Merges the loads on beam. **Parameters** - `varBeamToKeep` (int): var beam to keep. - `varBeamToMerge` (int): var beam to merge. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.MergeLoadsOnBeam(1, 1) print(result) ``` ### SplitLoadsOnBeam **Description** Splits the loads on beam. **Parameters** - `varBeamOld` (int): var beam old. - `varBeamNew` (int): var beam new. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.SplitLoadsOnBeam(1, 1) print(result) ``` ## Execute ### BeginLoadMerging **Description** Calls the `BeginLoadMerging` function on the OpenStaad `ops` session. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.BeginLoadMerging() print(result) ``` ### EndLoadMerging **Description** Calls the `EndLoadMerging` function on the OpenStaad `ops` session. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.EndLoadMerging() print(result) ``` --- # Load: Environmental/Physical Loads functions | OpenStaad Python > Seismic, wind, snow, and other definition-based loads, plus self-weight and floor/area loads. Source: https://www.openstaad.com/docs/load/environmental-physical-loads Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddNotionalLoad **Description** Adds the notional load. **Parameters** - `varPrimaryLoadCaseList` (list): var primary load case list. - `varPLFactorList` (list): var PL factor list. - `varPLDirectionList` (list): var PL direction list. - `varReferenceLoadCaseList` (list): var reference load case list. - `varRLFactorList` (list): var RL factor list. - `varRLDirectionList` (list): var RL direction list. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddNotionalLoad([1, 2], [1, 2], [1, 2], [1, 2], [1, 2], [1, 2]) print(result) ``` ### AddResponseSpectrumLoad **Description** Adds the response spectrum load. **Parameters** - `rsaCode` (int): rsa code. - `rsaCombination` (int): rsa combination. - `varSet1Names` (list): var set 1 names. - `varSet1Vals` (list): var set 1 vals. - `varSet2Names` (list): var set 2 names. - `varSet2Vals` (list): var set 2 vals. - `varDataPairs` (list): var data pairs. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddResponseSpectrumLoad(1, 1, [1, 2], [1, 2], [1, 2], [1, 2], [1, 2]) print(result) ``` ### AddSelfWeightInXYZ **Description** Adds the self weight in XYZ. **Parameters** - `varInDirection` (int): var in direction. - `varLoadFactor` (float): var load factor. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSelfWeightInXYZ(1, 1.0) print(result) ``` ### AddSelfWeightInXYZToGeometry **Description** Adds the self weight in XYZ to geometry. **Parameters** - `varGeomNumberIDs` (list): var geom number i ds. - `varInDirection` (int): var in direction. - `varLoadFactor` (float): var load factor. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSelfWeightInXYZToGeometry([1, 2], 1, 1.0) print(result) ``` ### AddStrainLoad **Description** Adds the strain load. **Parameters** - `elementIds` (list): element ids. - `varAxialElong` (float): var axial elong. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddStrainLoad([1, 2], 1.0) print(result) ``` ### AddTemperatureLoad **Description** Adds the temperature load. **Parameters** - `elementIds` (list): element ids. - `varTempAxialElong` (float): var temp axial elong. - `varTempDiffTopAndBtm` (float): var temp diff top and btm. - `varTemDiffSide` (float): var tem diff side. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddTemperatureLoad([1, 2], 1.0, 1.0, 1.0) print(result) ``` ### AddWindDefinition **Description** Adds the wind definition. **Parameters** - `varTypeNo` (int): var type no. - `varTypeName` (str): var type name. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddWindDefinition(1, "value") print(result) ``` ### AddWindDefinitionASCE7Parameters **Description** Adds the wind definition ASCE 7 parameters. **Parameters** - `varTypeNo` (int): var type no. - `code` (int): code. - `windSpeed` (float): wind speed. - `heightAboveSeaLvl` (float): height above sea lvl. - `bldgclass` (int): bldgclass. - `bldgtype` (int): bldgtype. - `expCat` (int): exp cat. - `varEscarpment` (bool): var escarpment. - `wallType` (int): wall type. - `varIsFlexible` (bool): var is flexible. - `varEscarpmentData` (list): var escarpment data. - `varbldgData` (list): varbldg data. - `varUnitsData` (list): var units data. - `varFactorsUserInput` (list): var factors user input. - `varFactors` (list): var factors. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddWindDefinitionASCE7Parameters(1, 1, 1.0, 1.0, 1, 1, 1, True, 1, True, [1, 2], [1, 2], [1, 2], [1, 2], [1, 2]) print(result) ``` ### AddWindExposure **Description** Adds the wind exposure. **Parameters** - `varTypeNo` (int): var type no. - `varExposureFactor` (float): var exposure factor. - `varNodeArray` (list): var node array. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddWindExposure(1, 1.0, [1, 2]) print(result) ``` ### AddWindIntensity **Description** Adds the wind intensity. **Parameters** - `varTypeNo` (int): var type no. - `varIntensity` (list): var intensity. - `varHeight` (list): var height. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddWindIntensity(1, [1, 2], [1, 2]) print(result) ``` ### AddWindLoad **Description** Adds the wind load. **Parameters** - `varTypeNo` (int): var type no. - `varDirection` (int): var direction. - `dFraction` (float): d fraction. - `varOpenStructure` (int): var open structure. - `dYMIN` (float): d YMIN. - `dYMAX` (float): d YMAX. - `dZMIN` (float): d ZMIN. - `dZMAX` (float): d ZMAX. - `dXMIN` (float): d XMIN. - `dXMAX` (float): d XMAX. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddWindLoad(1, 1, 1.0, 1, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0) print(result) ``` ## Get ### GetBasePressures **Description** Returns the base pressures. **Parameters** - `loadCaseNo` (int): load case no. - `nodelist` (list): nodelist. **Returns** tuple: A tuple of `(list[float], list[float], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBasePressures(1, [1, 2]) print(result) ``` ### GetNotionalLoadByIndex **Description** Returns the notional load by index. **Parameters** - `nIndex` (int): n index. **Returns** list: A list of values. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNotionalLoadByIndex(1) print(result) ``` ### GetNotionalLoadCount **Description** Returns the notional load count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNotionalLoadCount() print(result) ``` ## Delete ### DeleteWindDefinition **Description** Deletes the wind definition. **Parameters** - `nTypeNo` (int): n type no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteWindDefinition(1) print(result) ``` ## Execute ### PerformCableAnalysis **Description** Performs the cable analysis. **Parameters** - `NoOfIterations` (int): no of iterations. - `PrintOption` (int): print option. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.PerformCableAnalysis(1, 1) ``` ### PerformCableAnalysisEx **Description** Performs the cable analysis ex. **Parameters** - `AdvancedCableAnalysis` (int): advanced cable analysis. - `AdvOptions` (list): adv options. - `Params` (list): params. - `PrintOption` (int): print option. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.PerformCableAnalysisEx(1, [1, 2], [1, 2], 1) print(result) ``` --- # Load: Load Lists functions | OpenStaad Python > The active load list — which cases and combinations are active for the next command or query. Source: https://www.openstaad.com/docs/load/load-lists Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateLoadList **Description** Creates the load list. **Parameters** - `listType` (int): list type. - `loadCaseList` (list): load case list. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateLoadList(1, [1, 2]) print(result) ``` ## Get ### GetAssignmentListForLoadType **Description** Returns the assignment list for load type. **Parameters** - `loadType` (int): load type. - `loadIndex` (int): load index. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAssignmentListForLoadType(1, 1) print(result) ``` ### GetListSizeForLoadType **Description** Returns the list size for load type. **Parameters** - `loadType` (int): load type. - `loadIndex` (int): load index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetListSizeForLoadType(1, 1) print(result) ``` ### GetLoadCountInLoadList **Description** Returns the load count in load list. **Parameters** - `varLoadListIndex` (int): var load list index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadCountInLoadList(1) print(result) ``` ### GetLoadListCount **Description** Returns the load list count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadListCount() print(result) ``` ### GetLoadsInLoadList **Description** Returns the loads in load list. **Parameters** - `varLoadListIndex` (int): var load list index. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadsInLoadList(1) print(result) ``` ## Delete ### DeleteLoadList **Description** Deletes the load list. **Parameters** - `varLoadListIndex` (int): var load list index. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteLoadList(1) print(result) ``` --- # Load: Combinations & Envelopes functions | OpenStaad Python > Factored combinations (e.g. 1.2D + 1.6L) and min/max envelopes of primary cases, used for design. Source: https://www.openstaad.com/docs/load/combinations-envelopes Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddAutoCombinationRepeat **Description** Adds the auto combination repeat. **Parameters** - `varCode` (str): var code. - `varCategory` (str): var category. - `varLoadList` (list): var load list. - `varStartLoadCaseNo` (int): var start load case no. - `varGeneratedLCS` (int): var generated LCS. - `bVarReference` (bool): b var reference. - `bVarNotional` (bool): b var notional. - `dVarNotionalLoadFactor` (float): d var notional load factor. - `bVarGB50017` (bool): b var GB 50017. - `nVarFloor` (int): n var floor. - `bVarX` (bool): b var x. - `bVarNegtiveX` (bool): b var negtive x. - `bVarZ` (bool): b var z. - `bVarNegtiveZ` (bool): b var negtive z. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddAutoCombinationRepeat("value", "value", [1, 2], 1, 1, True, True, 1.0, True, 1, True, True, True, True) print(result) ``` ### AddAutoLoadCombinations **Description** Adds the auto load combinations. **Parameters** - `loadCombCode` (str): load comb code. - `loadCombCategory` (str): load comb category. - `loadList` (list): load list. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddAutoLoadCombinations("value", "value", [1, 2]) print(result) ``` ### AddLoadAndFactorToCombination **Description** Adds the load and factor to combination. **Parameters** - `loadCombNo` (int): load comb no. - `loadNo` (int): load no. - `factor` (float): factor. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddLoadAndFactorToCombination(1, 1, 1.0) print(result) ``` ### AddLoadCasesToEnvelop **Description** Adds the load cases to envelop. **Parameters** - `varEnvNo` (int): var env no. - `varLoadCaseList` (list): var load case list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddLoadCasesToEnvelop(1, [1, 2]) print(result) ``` ### AddRepeatLoad **Description** Adds the repeat load. **Parameters** - `varLoadCaseList` (list): var load case list. - `varFactorList` (list): var factor list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddRepeatLoad([1, 2], [1, 2]) print(result) ``` ### CreateLoadEnvelop **Description** Creates the load envelop. **Parameters** - `envelopNumber` (int): envelop number. - `envelopType` (int): envelop type. - `loadCaseList` (list): load case list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateLoadEnvelop(1, 1, [1, 2]) print(result) ``` ### CreateNewLoadCombination **Description** Creates the new load combination. **Parameters** - `loadCombTitle` (str): load comb title. - `loadCombNo` (int): load comb no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateNewLoadCombination("value", 1) print(result) ``` ## Get ### GetEnvelopeCount **Description** Returns the envelope count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetEnvelopeCount() print(result) ``` ### GetEnvelopeIDs **Description** Returns the envelope i ds. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetEnvelopeIDs() print(result) ``` ### GetLoadAndFactorForCombination **Description** Returns the load and factor for combination. **Parameters** - `varLoadCombNo` (int): var load comb no. **Returns** tuple: A tuple of `(list[int], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadAndFactorForCombination(1) print(result) ``` ### GetLoadCombinationCaseCount **Description** Returns the load combination case count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadCombinationCaseCount() print(result) ``` ### GetLoadCombinationCaseNumbers **Description** Returns the load combination case numbers. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadCombinationCaseNumbers() print(result) ``` ### GetLoadEnvelopeDetails **Description** Returns the load envelope details. **Parameters** - `EnvNo` (int): env no. **Returns** tuple: A tuple of `(int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadEnvelopeDetails(1) print(result) ``` ### GetLoadListfromLoadEnvelope **Description** Returns the load listfrom load envelope. **Parameters** - `EnvNo` (int): env no. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetLoadListfromLoadEnvelope(1) print(result) ``` ### GetNoLoadFactorDirectionInNotionalLoad **Description** Returns the no load factor direction in notional load. **Parameters** - `nIndex` (int): n index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoLoadFactorDirectionInNotionalLoad(1) print(result) ``` ### GetNoLoadFactorInRepeatLoad **Description** Returns the no load factor in repeat load. **Parameters** - `nIndex` (int): n index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoLoadFactorInRepeatLoad(1) print(result) ``` ### GetNoOfLoadAndFactorPairsForCombination **Description** Returns the number of the load and factor pairs for combination. **Parameters** - `varLoadCombNo` (int): var load comb no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoOfLoadAndFactorPairsForCombination(1) print(result) ``` ### GetRepeatLoadByIndex **Description** Returns the repeat load by index. **Parameters** - `nIndex` (int): n index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetRepeatLoadByIndex(1) print(result) ``` ### GetRepeatLoadCount **Description** Returns the repeat load count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetRepeatLoadCount() print(result) ``` ## Delete ### DeleteLoadEnvelop **Description** Deletes the load envelop. **Parameters** - `varEnvNo` (int): var env no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteLoadEnvelop(1) print(result) ``` ### DeletePrimaryLoadCases **Description** Deletes the primary load cases. **Parameters** - `varLoadCaseNos` (list): var load case nos. - `varIsReferenceLoads` (bool): var is reference loads. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeletePrimaryLoadCases([1, 2], True) print(result) ``` ### DeleteReferenceLoadCases **Description** Deletes the reference load cases. **Parameters** - `varLoadCaseNos` (list): var load case nos. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteReferenceLoadCases([1, 2]) print(result) ``` ### RemoveLoadCasesFromEnvelop **Description** Removes the load cases from envelop. **Parameters** - `varEnvNo` (int): var env no. - `varLoadCaseList` (list): var load case list. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveLoadCasesFromEnvelop(1, [1, 2]) print(result) ``` ## Is ### IsCombinationCase **Description** Checks whether combination case. **Parameters** - `nLoadCase` (int): n load case. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsCombinationCase(1) print(result) ``` --- # Support functions | OpenStaad Python > Restraints at nodes — fixed, pinned, roller, inclined, elastic, and mat supports — plus reading support reactions after analysis. Source: https://www.openstaad.com/docs/support Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddControlDependentRelation **Description** Adds the control dependent relation. **Parameters** - `control_node` (int): control node. - `rigid_type` (int): rigid type. - `fx` (int): fx. - `fy` (int): fy. - `fz` (int): fz. - `mx` (int): mx. - `my` (int): my. - `mz` (int): mz. - `dependent_node_list` (list): dependent node list. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddControlDependentRelation(1, 1, 1, 1, 1, 1, 1, 1, [1, 2]) print(result) ``` ### AddSupportDisplacement **Description** Adds the support displacement. **Parameters** - `nodeIds` (list): node ids. - `varDirection` (int): var direction. - `varDispValue` (float): var disp value. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddSupportDisplacement([1, 2], 1, 1.0) print(result) ``` ### CreateElasticFooting **Description** Creates the elastic footing. **Parameters** - `length` (float): length. - `width` (float): width. - `direction` (int): direction. - `subgrade` (float): subgrade. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateElasticFooting(1.0, 1.0, 1, 1.0) print(result) ``` ### CreateElasticMat **Description** Creates the elastic mat. **Parameters** - `direction` (int): direction. - `subgrade` (float): subgrade. - `printFlag` (bool): print flag. - `springType` (int): spring type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateElasticMat(1, 1.0, True, 1) print(result) ``` ### CreateInclinedSupport **Description** Creates the inclined support. **Parameters** - `inclinedType` (int): inclined type. - `refType` (int): ref type. - `refNode` (int): ref node. - `coord` (list[float]): coord. - `releaseSpec` (list): release spec. - `springSpec` (list): spring spec. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateInclinedSupport(1, 1, 1, [1, 2], [1, 2], [1, 2]) print(result) ``` ### CreatePlateMat **Description** Creates the plate mat. **Parameters** - `direction` (int): direction. - `subgrades` (list[float]): subgrades. - `printFlag` (bool): print flag. - `springType` (int): spring type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreatePlateMat(1, [1, 2], True, 1) print(result) ``` ### CreateSupportFixed **Description** Creates a fully fixed support definition, ready to be assigned to nodes with [`AssignSupportToNode`](/docs/support#AssignSupportToNode) or [`AssignSupportToNodes`](/docs/support#AssignSupportToNodes). **Parameters** None. **Returns** int: The new support definition's ID. **Example** ```python from openstaad import ops s = ops.connect() fixed_support = s.CreateSupportFixed() s.AssignSupportToNode(1, fixed_support) ``` This example creates a fixed support and assigns it to node 1. ### CreateSupportFixedBut **Description** Creates the support fixed but. **Parameters** - `ReleaseSpec` (list): release spec. - `SpringSpec` (list): spring spec. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateSupportFixedBut([1, 2], [1, 2]) print(result) ``` ### CreateSupportPinned **Description** Creates a pinned support definition — free to rotate about the local y and z axes, fixed in every other degree of freedom — ready to be assigned to nodes with [`AssignSupportToNode`](/docs/support#AssignSupportToNode) or [`AssignSupportToNodes`](/docs/support#AssignSupportToNodes). **Parameters** None. **Returns** int: The new support definition's ID. **Example** ```python from openstaad import ops s = ops.connect() pinned_support = s.CreateSupportPinned() s.AssignSupportToNode(2, pinned_support) ``` This example creates a pinned support and assigns it to node 2. ## Get ### GetCountOfElasticFooting **Description** Returns the count of elastic footing. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetCountOfElasticFooting() print(result) ``` ### GetCountOfElasticMat **Description** Returns the count of elastic mat. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetCountOfElasticMat() print(result) ``` ### GetCountOfPlateMat **Description** Returns the count of plate mat. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetCountOfPlateMat() print(result) ``` ### GetElasticFootingAssignmentList **Description** Returns the elastic footing assignment list. **Parameters** - `supportid` (int): supportid. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElasticFootingAssignmentList(1) print(result) ``` ### GetElasticFootingDetail **Description** Returns the elastic footing detail. **Parameters** - `supportid` (int): supportid. **Returns** tuple: A tuple of `(float, float, int, float, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElasticFootingDetail(1) print(result) ``` ### GetElasticMatAssignmentList **Description** Returns the elastic mat assignment list. **Parameters** - `supportid` (int): supportid. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElasticMatAssignmentList(1) print(result) ``` ### GetElasticMatDetail **Description** Returns the elastic mat detail. **Parameters** - `supportid` (int): supportid. **Returns** tuple: A tuple of `(int, float, bool, int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetElasticMatDetail(1) print(result) ``` ### GetMatInfluenceAreas **Description** Returns the mat influence areas. **Parameters** - `nodelist` (list): nodelist. **Returns** tuple: A tuple of `(list[float], list[float], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMatInfluenceAreas([1, 2]) print(result) ``` ### GetPlateMatAssignmentList **Description** Returns the plate mat assignment list. **Parameters** - `plateMatNo` (int): plate mat no. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateMatAssignmentList(1) print(result) ``` ### GetPlateMatDetail **Description** Returns the plate mat detail. **Parameters** - `plateMatNo` (int): plate mat no. **Returns** tuple: A tuple of `(int, float, float, float, int, int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateMatDetail(1) print(result) ``` ### GetPlateMatSupportId **Description** Returns the plate mat support Id. **Parameters** - `plateMatIndex` (int): plate mat index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetPlateMatSupportId(1) print(result) ``` ### GetSupportCount **Description** Returns the total number of supports defined in the model. **Parameters** None. **Returns** int: The number of supports. **Example** ```python from openstaad import ops s = ops.connect() count = s.GetSupportCount() print(f"Number of supports: {count}") ``` ### GetSupportInformation **Description** Returns the support information. **Parameters** - `nodeNo` (int): node no. **Returns** tuple: A tuple of `(raw, list[int], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSupportInformation(1) print(result) ``` ### GetSupportInformationEx **Description** Returns the support information ex. **Parameters** - `nodeNo` (int): node no. **Returns** tuple: A tuple of `(int, int, list[int], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSupportInformationEx(1) print(result) ``` ### GetSupportName **Description** Returns the support name. **Parameters** - `supportNo` (int): support no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSupportName(1) print(result) ``` ### GetSupportNodes **Description** Returns the list of nodes that have a support assigned. **Parameters** None. **Returns** list: A list of node numbers with a support assigned. **Example** ```python from openstaad import ops s = ops.connect() nodes = s.GetSupportNodes() print(nodes) ``` ### GetSupportReactions **Description** Returns the support reactions. **Parameters** - `nodeNo` (int): node no. - `loadCaseNo` (int): load case no. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSupportReactions(1, 1) print(result) ``` ### GetSupportType **Description** Returns the support type assigned to a node. **Parameters** - `nodeNo` (int): Number of the node to query. **Returns** int: The support type code for the node (see the STAAD.Pro Technical Reference Manual for the type-code mapping). For the release/spring breakdown of a support, see [`GetSupportInformation`](/docs/support#GetSupportInformation). **Example** ```python from openstaad import ops s = ops.connect() support_type = s.GetSupportType(3) print(f"Support type at node 3: {support_type}") ``` ### GetSupportUniqueID **Description** Returns the support unique ID. **Parameters** - `supportNo` (int): support no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSupportUniqueID(1) print(result) ``` ## Set/Assign ### AssignSupportToEntityList **Description** Assigns the support to entity list. **Parameters** - `supportid` (int): supportid. - `entitylist` (list[int]): entitylist. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignSupportToEntityList(1, [1, 2]) print(result) ``` ### AssignSupportToNode **Description** Assigns a previously created support definition to a **single** node. For several nodes at once, use [`AssignSupportToNodes`](/docs/support#AssignSupportToNodes). **Parameters** - `NodeID` (int): A single node number. Any integer type is accepted, including NumPy integers. - `SupportID` (int): ID of a support definition, as returned by [`CreateSupportFixed`](/docs/support#CreateSupportFixed), [`CreateSupportPinned`](/docs/support#CreateSupportPinned), or a similar `Create*Support*` function. **Returns** bool: `True` if STAAD.Pro accepted the assignment. **Raises** `TypeError` if `NodeID` is not a single integer. Lists, tuples and arrays are rejected with a message pointing to [`AssignSupportToNodes`](/docs/support#AssignSupportToNodes). **Example** ```python from openstaad import ops s = ops.connect() pinned = s.CreateSupportPinned() s.AssignSupportToNode(5, pinned) ``` This example creates a pinned support and assigns it to node 5. **Why collections are rejected** The underlying OpenSTAAD COM method processes one node per call. Passing it an array assigns only the first element and reports no error, which produces a model that analyzes cleanly with the wrong boundary conditions. This function therefore fails loudly instead: ```python s.AssignSupportToNode([5, 6, 7, 8], pinned) # TypeError: NodeID expects a single integer; for several use AssignSupportToNodes() ``` See [`AssignSupportToNodes`](/docs/support#AssignSupportToNodes) for the multiple-node case. ### AssignSupportToNodes **Description** Assigns a previously created support definition to **one or more** nodes. **Parameters** - `NodeIDs` (int or Iterable[int]): A single node number, or any collection of them — `list`, `tuple`, `range`, generator or NumPy array. Integer types include NumPy integers. - `SupportID` (int): ID of a support definition, as returned by [`CreateSupportFixed`](/docs/support#CreateSupportFixed), [`CreateSupportPinned`](/docs/support#CreateSupportPinned), or a similar `Create*Support*` function. **Returns** bool: `True` if **every** assignment was accepted. **Raises** `TypeError` if `NodeIDs` is not an integer or a collection of integers. The message identifies the offending element by index, e.g. `NodeIDs[2] expects an integer, not str`. **Example** ```python from openstaad import ops s = ops.connect() pinned = s.CreateSupportPinned() s.AssignSupportToNodes([5, 6, 7, 8], pinned) s.AssignSupportToNodes(range(5, 9), pinned) # equivalent s.AssignSupportToNodes(5, pinned) # a single node also works ``` **Note** This function is not part of the official OpenSTAAD API. It exists because the COM method behind it assigns one node per call; see [`AssignSupportToNode`](/docs/support#AssignSupportToNode). ### SetSupportUniqueID **Description** Sets the support unique ID. **Parameters** - `supportNo` (int): support no. - `guid` (str): guid. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetSupportUniqueID(1, "value") ``` ## Delete ### DeleteAllControlDependentRelations **Description** Deletes the all control dependent relations. **Parameters** None. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteAllControlDependentRelations() print(result) ``` ### DeleteSupport **Description** Deletes the support. **Parameters** - `supportNo` (int): support no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteSupport(1) print(result) ``` ### RemoveElasticFooting **Description** Removes the elastic footing. **Parameters** - `supportid` (int): supportid. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveElasticFooting(1) print(result) ``` ### RemoveElasticFootingFromNode **Description** Removes the elastic footing from node. **Parameters** - `nodeid` (int): nodeid. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveElasticFootingFromNode(1) print(result) ``` ### RemoveElasticMat **Description** Removes the elastic mat. **Parameters** - `supportid` (int): supportid. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveElasticMat(1) print(result) ``` ### RemoveElasticMatFromNode **Description** Removes the elastic mat from node. **Parameters** - `nodeid` (int): nodeid. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemoveElasticMatFromNode(1) print(result) ``` ### RemovePlateMat **Description** Removes the plate mat. **Parameters** - `supportId` (int): support Id. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemovePlateMat(1) print(result) ``` ### RemovePlateMatFromPlate **Description** Removes the plate mat from plate. **Parameters** - `plateNo` (int): plate no. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.RemovePlateMatFromPlate(1) print(result) ``` ### RemoveSupportFromNode **Description** Removes the support from node. **Parameters** - `NodeIDs` (list): node i ds. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.RemoveSupportFromNode([1, 2]) ``` --- # Group functions | OpenStaad Python > Named collections of nodes, beams, plates, or solids for batch selection and assignment — an organizing tool, not a structural element. Source: https://www.openstaad.com/docs/group Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateGroup **Description** Creates the group. **Parameters** - `group_type` (int): group type. - `group_name` (str): group name. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.CreateGroup(1, "value") ``` ### CreateGroupEx **Description** Creates the group ex. **Parameters** - `groupType` (int): group type. - `groupName` (str): group name. - `entityList` (list): entity list. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateGroupEx(1, "value", [1, 2]) print(result) ``` ## Get ### GetGroupCount **Description** Get the count of groups for a specified group type. **Parameters** - grouptype index (int): The type of group. | Index | Group Type | |-------|--------------------------------------| | 1 | Nodes | | 2 | Members | | 3 | Plates | | 4 | Solids | | 5 | Geometry (Members, Plates and Solids)| | 6 | Floor (Floor beam) | **Returns** int: Number of groups of the given type. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module group_count = s.GetGroupCount(6) print(group_count) ``` ### GetGroupCountAll **Description** Returns the group count all. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetGroupCountAll() print(result) ``` ### GetGroupEntities **Description** Retrieve a list of entities (typically beams) within a specified group. **Parameters** - group_name (str): The name of the group. **Returns** list: List of entity numbers belonging to the group. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module entities = s.GetGroupEntities("_DLOAD") print(entities) ``` ### GetGroupEntityCount Returns the number of entities in a specified group in the current model. This function retrieves the count of entities (such as members, nodes, etc.) that belong to a given group name in the current model. ##### Parameters - **groupName**: Name of the group for which the entity count is required. ##### Return values - ****: Number of entities in the specified group. - **-1**: Unable to find the group or error occurred. ##### Example ```python from openstaad import ops # Instanciar el módulo Geometry s = ops.connect() # Obtener el número de entidades en el grupo "Group1" entity_count = s.GetGroupEntityCount("Group1") ``` ### GetGroupNames **Description** Retrieve the names of groups for a specified group type. **Parameters** - grouptype index (int): The type of group. | Index | Group Type | |-------|--------------------------------------| | 1 | Nodes | | 2 | Members | | 3 | Plates | | 4 | Solids | | 5 | Geometry (Members, Plates and Solids)| | 6 | Floor (Floor beam) | **Returns** list: List of group names. **Example** To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() #Execute the function from geometry module group_names = s.GetGroupNames(6) print(group_names) ``` ## Set/Assign ### UpdateGroup **Description** Updates the group. **Parameters** - `groupName` (str): group name. - `update_option` (int): update option. - `entityList` (list): entity list. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.UpdateGroup("value", 1, [1, 2]) ``` ## Delete ### DeleteGroup **Description** Deletes the group. **Parameters** - `groupName` (str): group name. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.DeleteGroup("value") ``` ## Select ### SelectGroup **Description** Selects the group. **Parameters** - `bstrGroup` (str): bstr group. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SelectGroup("value") print(result) ``` --- # Analysis (Command) functions | OpenStaad Python > Runs the solver — static, P-Delta, buckling, direct, and cable — and reports analysis status. Results are read via Global Results and each element’s Results section. Source: https://www.openstaad.com/docs/analysis-command Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddDirectAnalysisDefinitionParameter **Description** Adds the direct analysis definition parameter. **Parameters** - `pParamType` (int): p param type. - `members` (list): members. - `param` (float): param. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddDirectAnalysisDefinitionParameter(1, [1, 2], 1.0) print(result) ``` ## Get ### GetAnalysisErrorMessages **Description** Returns the analysis error messages. **Parameters** - `modelPath` (Optional[str], optional (default `None`)): model path. **Returns** list: A list of strings. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAnalysisErrorMessages(1) print(result) ``` ### GetAnalysisStatus #### Retrieve the analysis status of your model This document explains how to retrieve the analysis status of your model using OpenStaad python. ##### Description Get analysis status for any STD model. ##### Function type This function retrieves a value from the open staad file ##### Example To use this function see the following example: ```python from openstaad import ops # instantiate the root module s = ops.connect() # Execute the analyze function from root module. status = s.GetAnalysisStatus() print(status) ``` ### GetAnalysisWarningMessages **Description** Returns the analysis warning messages. **Parameters** - `modelPath` (Optional[str], optional (default `None`)): model path. **Returns** list: A list of strings. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetAnalysisWarningMessages(1) print(result) ``` ### GetStaticCheckResult **Description** Returns the static check result. **Parameters** - `loadCaseNo` (int): load case no. **Returns** tuple: A tuple of `(list[float], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetStaticCheckResult(1) print(result) ``` ## Set/Assign ### SetCheckIrregularitiesCommand **Description** Sets the check irregularities command. **Parameters** - `DesignCode` (int): design code. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetCheckIrregularitiesCommand(1) print(result) ``` ### SetCheckSoftStoryCommand **Description** Sets the check soft story command. **Parameters** - `DesignCode` (int): design code. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetCheckSoftStoryCommand(1) print(result) ``` ### SetFloorDiaphragmBaseCommand **Description** Sets the floor diaphragm base command. **Parameters** - `baseElevationValue` (float): base elevation value. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetFloorDiaphragmBaseCommand(1.0) print(result) ``` ## Delete ### DeleteAllAnalysisCommands **Description** Deletes the all analysis commands. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteAllAnalysisCommands() print(result) ``` ### DeleteCheckIrregularitiesCommand **Description** Deletes the check irregularities command. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteCheckIrregularitiesCommand() print(result) ``` ### DeleteCheckSoftStoryCommand **Description** Deletes the check soft story command. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteCheckSoftStoryCommand() print(result) ``` ### DeleteDirectAnalysisDefinition **Description** Deletes the direct analysis definition. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteDirectAnalysisDefinition() print(result) ``` ### DeleteDirectAnalysisDefinitionParameter **Description** Deletes the direct analysis definition parameter. **Parameters** - `pParamType` (int): p param type. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteDirectAnalysisDefinitionParameter(1) print(result) ``` ### DeleteFloorDiaphragmBaseCommand **Description** Deletes the floor diaphragm base command. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DeleteFloorDiaphragmBaseCommand() print(result) ``` ## Execute ### Analyze This document provides details on how to perform analysis using OpenStaad Python. #### Overview > **Note:** Ensure that the Staad.PRO file is open and valid before running the analysis. The `Analyze` function does not return results directly; you need to use other functions to extract analysis results. The `Analyze` function in OpenStaad Python allows users to run structural analysis on their Staad.PRO models programmatically. This is particularly useful for automating workflows and integrating analysis into larger Python-based applications. #### Example Usage ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() # Run the analysis s.Analyze() print("Analysis completed successfully.") ``` #### Key Points - Ensure that the Staad.PRO file is open and valid before running the analysis. - The `Analyze` function does not return results directly; you need to use other functions to extract analysis results. --- For more details, refer to the [Official OpenStaad Documentation](https://docs.bentley.com/LiveContent/web/STAAD.Pro%20Help-v14/en/GUID-93E26CB6-E60E-4175-920A-72D504639722.html). ### AnalyzeEx **Description** Runs analysis on the ex. **Parameters** - `silentMode` (int): silent mode. - `hiddenMode` (int): hidden mode. - `waitTillComplete` (int): wait till complete. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AnalyzeEx(1, 1, 1) print(result) ``` ### AnalyzeModel **Description** Runs analysis on the model. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.AnalyzeModel() ``` ### PerformAnalysis **Description** Performs the analysis. **Parameters** - `printOption` (int): print option. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.PerformAnalysis(1) ``` ### PerformBucklingAnalysis **Description** Performs the buckling analysis. **Parameters** - `MaxNoOfIterations` (int): max no of iterations. - `PrintOption` (int): print option. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.PerformBucklingAnalysis(1, 1) ``` ### PerformBucklingAnalysisEx **Description** Performs the buckling analysis ex. **Parameters** - `Method` (int): method. - `MaxNoOfIterations` (int): max no of iterations. - `PrintOption` (int): print option. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.PerformBucklingAnalysisEx(1, 1, 1) print(result) ``` ### PerformDirectAnalysis **Description** Performs the direct analysis. **Parameters** - `Option` (int): option. - `Params` (list): params. - `AddOptions` (list): add options. - `PrintOption` (int): print option. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.PerformDirectAnalysis(1, [1, 2], [1, 2], 1) print(result) ``` ### PerformNonlinearAnalysisEx **Description** Performs the nonlinear analysis ex. **Parameters** - `PrintOption` (int): print option. - `Arclength` (float): arclength. - `NoOfIterations` (int): no of iterations. - `Tolerance` (float): tolerance. - `Steps` (int): steps. - `Rebuild` (int): rebuild. - `AddGeometricStiffness` (int): add geometric stiffness. - `DispLimitData` (list): disp limit data. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.PerformNonlinearAnalysisEx(1, 1.0, 1, 1.0, 1, 1, 1, [1, 2]) print(result) ``` ### PerformPDeltaAnalysisEx **Description** Performs the p delta analysis ex. **Parameters** - `NoOfIterations` (int): no of iterations. - `PrintOption` (int): print option. - `bSmallDelta` (int): b small delta. - `AddGeometricStiffness` (int): add geometric stiffness. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.PerformPDeltaAnalysisEx(1, 1, 1, 1) print(result) ``` ### PerformPDeltaAnalysisNoConverge **Description** Performs the p delta analysis no converge. **Parameters** - `NoOfIterations` (int): no of iterations. - `PrintOption` (int): print option. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.PerformPDeltaAnalysisNoConverge(1, 1) ``` ## Is ### IsAnalyzing **Description** Checks whether STAAD.Pro is currently analyzing. **Parameters** None. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsAnalyzing() print(result) ``` --- # Global Results functions | OpenStaad Python > Model-wide results after analysis — frequencies, mass participation, base shear, and buckling factors. Per-element forces live in the Results sections. Source: https://www.openstaad.com/docs/global-results Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Get ### GetBucklingFactor **Description** Returns the buckling factor. **Parameters** - `buckling_mode_no` (int): buckling mode no. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetBucklingFactor(1) print(result) ``` ### GetIntermediateDeflectionAtDistance **Description** Returns the intermediate deflection at distance. **Parameters** - `memberNo` (int): member no. - `distance` (bool): distance. - `loadCaseNo` (int): load case no. **Returns** tuple: A tuple of `(float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetIntermediateDeflectionAtDistance(1, True, 1) print(result) ``` ### GetModalMassParticipationFactors **Description** Returns the modal mass participation factors. **Parameters** - `modeNo` (int): mode no. **Returns** tuple: A tuple of `(float, float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetModalMassParticipationFactors(1) print(result) ``` ### GetModeFrequency **Description** Returns the mode frequency. **Parameters** - `modeNo` (int): mode no. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetModeFrequency(1) print(result) ``` ### GetNoOfBucklingFactors **Description** Returns the number of the buckling factors. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoOfBucklingFactors() print(result) ``` ### GetNoOfModesExtracted **Description** Returns the number of the modes extracted. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetNoOfModesExtracted() print(result) ``` ### GetTimeHistoryIntegrationStepInfo **Description** Returns the time history integration step info. **Parameters** None. **Returns** tuple: A tuple of `(float, raw)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetTimeHistoryIntegrationStepInfo() print(result) ``` ### GetTimeHistoryResponse **Description** Returns the time history response. **Parameters** - `load_case` (int): load case. - `node_no` (int): node no. - `dof_no` (int): dof no. - `response_type` (int): response type. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetTimeHistoryResponse(1, 1, 1, 1) print(result) ``` ### GetTimeHistoryResponseAtTime **Description** Returns the time history response at time. **Parameters** - `load_case` (int): load case. - `node_no` (int): node no. - `dof_no` (int): dof no. - `response_type` (int): response type. - `at_time` (float): at time. **Returns** tuple: A tuple of `(float, raw)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetTimeHistoryResponseAtTime(1, 1, 1, 1, 1.0) print(result) ``` ### GetTimeHistoryResponseMinMax **Description** Returns the time history response min max. **Parameters** - `load_case` (int): load case. - `node_no` (int): node no. - `dof_no` (int): dof no. - `response_type` (int): response type. **Returns** tuple: A tuple of `(float, float, float, float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetTimeHistoryResponseMinMax(1, 1, 1, 1) print(result) ``` ### GetUptGeneralStressLocationPoints **Description** Returns the Upt general stress location points. **Parameters** - `table_reference_id` (int): table reference id. - `section_name` (str): section name. **Returns** tuple: A tuple of `(list[float], list[float])`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUptGeneralStressLocationPoints(1, "value") print(result) ``` ## Is ### AreResultsAvailable **Description** Checks whether results available. **Parameters** None. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AreResultsAvailable() print(result) ``` ### IsBucklingAnalysisResultsAvailable **Description** Checks whether buckling analysis results available. **Parameters** None. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsBucklingAnalysisResultsAvailable() print(result) ``` --- # Design (Steel) functions | OpenStaad Python > Steel code checks and design — assign design commands, groups, and parameters, then read design/check ratios. Runs after analysis. Source: https://www.openstaad.com/docs/design-steel Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateDesignBrief **Description** Creates the design brief. **Parameters** - `design_code` (int): design code. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateDesignBrief(1) print(result) ``` ### CreateSteelDesignCommand **Description** Creates the steel design command. **Parameters** - `NDesignCode` (int): n design code. - `NCommandNo` (int): n command no. - `IntValues` (list): int values. - `FloatValues` (list): float values. - `StringValues` (list): string values. - `NAssignList` (list): n assign list. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.CreateSteelDesignCommand(1, 1, [1, 2], [1, 2], [1, 2], [1, 2]) ``` ## Get ### GetDesignBriefCode **Description** Returns the design brief code. **Parameters** - `design_ref_id` (int): design ref id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetDesignBriefCode(1) print(result) ``` ### GetMemberDesignSectionName **Description** Returns the member design section name. **Parameters** - `beamNo` (int): beam no. **Returns** str: A string value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberDesignSectionName(1) print(result) ``` ### GetMemberSteelDesignMaxFailureRatio **Description** Returns the member steel design max failure ratio. **Parameters** None. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberSteelDesignMaxFailureRatio() print(result) ``` ### GetMemberSteelDesignMinFailureRatio **Description** Returns the member steel design min failure ratio. **Parameters** None. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberSteelDesignMinFailureRatio() print(result) ``` ### GetMemberSteelDesignRatio **Description** Returns the member steel design ratio. **Parameters** - `beamNo` (int): beam no. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberSteelDesignRatio(1) print(result) ``` ### GetMemberSteelDesignResults **Description** Returns the member steel design results. **Parameters** - `beamNo` (int): beam no. **Returns** tuple: A tuple of `(str, str, float, float, int, float, str, str, list[float], float)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMemberSteelDesignResults(1) print(result) ``` ### GetMultipleMemberSteelDesignMaxRatio **Description** Returns the multiple member steel design max ratio. **Parameters** - `beamNo` (int): beam no. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMultipleMemberSteelDesignMaxRatio(1) print(result) ``` ### GetMultipleMemberSteelDesignRatio **Description** Returns the multiple member steel design ratio. **Parameters** - `param_blk_name` (str): param blk name. - `beam_no` (int): beam no. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMultipleMemberSteelDesignRatio("value", 1) print(result) ``` ### GetMultipleMemberSteelDesignResults **Description** Returns the multiple member steel design results. **Parameters** - `param_blk_name` (str): param blk name. - `beam_no` (int): beam no. **Returns** tuple: A tuple of `(str, str, float, float, int, str, str)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMultipleMemberSteelDesignResults("value", 1) print(result) ``` ### GetSteelDesignParameterBlockCount **Description** Returns the steel design parameter block count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSteelDesignParameterBlockCount() print(result) ``` ### GetSteelDesignParameterBlockNameByIndex **Description** Returns the steel design parameter block name by index. **Parameters** - `index` (int): index. **Returns** str: A string value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetSteelDesignParameterBlockNameByIndex(1) print(result) ``` ## Set/Assign ### AssignDesignCommand **Description** Assigns the design command. **Parameters** - `design_ref_id` (int): design ref id. - `design_command_name` (str): design command name. - `design_command_value` (str): design command value. - `member_ids` (list[int]): member ids. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignDesignCommand(1, "value", "value", [1, 2]) print(result) ``` ### AssignDesignGroup **Description** Assigns the design group. **Parameters** - `design_ref_id` (int): design ref id. - `design_group_name` (str): design group name. - `design_group_value` (str): design group value. - `same_as_member` (int): same as member. - `member_ids` (list[int]): member ids. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignDesignGroup(1, "value", "value", 1, [1, 2]) print(result) ``` ### AssignDesignParameter **Description** Assigns the design parameter. **Parameters** - `design_ref_id` (int): design ref id. - `design_param` (str): design param. - `design_param_value` (str): design param value. - `member_ids` (list[int]): member ids. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.AssignDesignParameter(1, "value", "value", [1, 2]) print(result) ``` ### SetDesignResults **Description** Sets the design results. **Parameters** - `utilization` (int): utilization. - `color` (bool): color. - `showValues` (bool): show values. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetDesignResults(1, True, True) print(result) ``` ## Is ### IsMultipleMemberSteelDesignResultsAvailable **Description** Checks whether multiple member steel design results available. **Parameters** None. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsMultipleMemberSteelDesignResultsAvailable() print(result) ``` --- # View functions | OpenStaad Python > Drives the STAAD.Pro viewport — views, zoom/pan/rotate, visibility, selection, and annotation. Visual only; it never changes the model. Source: https://www.openstaad.com/docs/view Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### CreateNewViewForSelections **Description** Creates the new view for selections. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateNewViewForSelections() print(result) ``` ### CreateNewViewForSelectionsEx **Description** Creates the new view for selections ex. **Parameters** - `windowOptions` (int): window options. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateNewViewForSelectionsEx(1) print(result) ``` ### OpenView **Description** Opens the view. **Parameters** - `viewName` (str): view name. - `windowOptions` (bool): window options. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.OpenView("value", True) print(result) ``` ## Get ### GetFlagForHiddenEntities **Description** Returns the flag for hidden entities. **Parameters** None. **Returns** int: An integer value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFlagForHiddenEntities() print(result) ``` ### GetInterfaceMode **Description** Returns the interface mode. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetInterfaceMode() print(result) ``` ### GetScaleCount **Description** Returns the scale count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetScaleCount() print(result) ``` ### GetScaleValueByType **Description** Returns the scale value by type. **Parameters** - `scaleTypeId` (int): scale type Id. **Returns** float: A numeric value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetScaleValueByType(1) print(result) ``` ### GetScaleValues **Description** Returns the scale values. **Parameters** None. **Returns** list: A list of numbers (floats). **Example** ```python from openstaad import ops s = ops.connect() result = s.GetScaleValues() print(result) ``` ### GetWindowCount **Description** Returns the window count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetWindowCount() print(result) ``` ### GetWindowTitle **Description** Returns the window title. **Parameters** - `id` (int): id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetWindowTitle(1) print(result) ``` ## Set/Assign ### RenameView **Description** Renames the view. **Parameters** - `viewName` (str): view name. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.RenameView("value") print(result) ``` ### SaveView **Description** Saves the view. **Parameters** - `viewName` (str): view name. - `overWrite` (bool): over write. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SaveView("value", True) print(result) ``` ### SetActiveWindow **Description** Sets the active window. **Parameters** - `id` (int): id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetActiveWindow(1) print(result) ``` ### SetDiagramMode **Description** Sets the diagram mode. **Parameters** - `which` (int): which. - `showFlag` (bool): show flag. - `refreshFlag` (bool): refresh flag. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetDiagramMode(1, True, True) ``` ### SetFlagForHiddenEntities **Description** Sets the flag for hidden entities. **Parameters** - `flag` (int): flag. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetFlagForHiddenEntities(1) print(result) ``` ### SetInterfaceMode **Description** Sets the interface mode. **Parameters** - `interfaceMode` (int): interface mode. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetInterfaceMode(1) ``` ### SetLabel **Description** Sets the label. **Parameters** - `which` (int): which. - `showFlag` (bool): show flag. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetLabel(1, True) print(result) ``` ### SetModeSectionPage **Description** Sets the mode section page. **Parameters** - `interfaceMode` (int): interface mode. - `sectionNumber` (int): section number. - `pageNumber` (int): page number. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetModeSectionPage(1, 1, 1) ``` ### SetReactionAnnotationMode **Description** Sets the reaction annotation mode. **Parameters** - `dFlag` (bool): d flag. - `refreshFlag` (bool): refresh flag. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetReactionAnnotationMode(True, True) ``` ### SetScaleValueByType **Description** Sets the scale value by type. **Parameters** - `scaleTypeId` (int): scale type Id. - `value` (float): value. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetScaleValueByType(1, 1.0) print(result) ``` ### SetScaleValues **Description** Sets the scale values. **Parameters** - `ScalesList` (list): scales list. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetScaleValues([1, 2]) print(result) ``` ### SetSectionView **Description** Sets the section view. **Parameters** - `plane` (int): plane. - `minVal` (float): min val. - `maxVal` (float): max val. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetSectionView(1, 1.0, 1.0) ``` ### SetWindowPosition **Description** Sets the window position. **Parameters** - `xTop` (float): x top. - `yTop` (float): y top. - `xWindow` (float): x window. - `yWindow` (float): y window. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetWindowPosition(1.0, 1.0, 1.0, 1.0) ``` ## Delete ### CloseActiveWindow **Description** Closes the active window. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CloseActiveWindow() print(result) ``` ### DetachView **Description** Detaches the view. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.DetachView() print(result) ``` ## Select ### SelectByItemList **Description** Selects the by item list. **Parameters** - `entityType` (int): entity type. - `nItems` (int): n items. - `itemList` (list): item list. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SelectByItemList(1, 1, [1, 2]) ``` ### SelectByMissingAttribute **Description** Selects the by missing attribute. **Parameters** - `attributeCode` (int): attribute code. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SelectByMissingAttribute(1) ``` ### SelectInverse **Description** Selects the inverse. **Parameters** - `entityType` (int): entity type. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SelectInverse(1) ``` ## View ### HideEntity **Description** Hides the entity. **Parameters** - `nEntity` (int): n entity. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.HideEntity(1) ``` ### RefreshView **Description** Refreshes the view. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.RefreshView() ``` ### RotateDown **Description** Rotates the down. **Parameters** - `dDegrees` (float): d degrees. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.RotateDown(1.0) ``` ### RotateLeft **Description** Rotates the left. **Parameters** - `dDegrees` (float): d degrees. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.RotateLeft(1.0) ``` ### RotateRight **Description** Rotates the right. **Parameters** - `dDegrees` (float): d degrees. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.RotateRight(1.0) ``` ### RotateUp **Description** Rotates the up. **Parameters** - `dDegrees` (float): d degrees. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.RotateUp(1.0) ``` ### ShowBack **Description** Shows the back. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowBack() ``` ### ShowBottom **Description** Shows the bottom. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowBottom() ``` ### ShowFront **Description** Shows the front. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowFront() ``` ### ShowIsometric **Description** Shows the isometric. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowIsometric() ``` ### ShowLeft **Description** Shows the left. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowLeft() ``` ### ShowPlan **Description** Shows the plan. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowPlan() ``` ### ShowRight **Description** Shows the right. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowRight() ``` ### SpinLeft **Description** Calls the `SpinLeft` function on the OpenStaad `ops` session. **Parameters** - `Degrees` (value): degrees. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SpinLeft(1) ``` ### SpinRight **Description** Calls the `SpinRight` function on the OpenStaad `ops` session. **Parameters** - `Degrees` (value): degrees. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SpinRight(1) ``` ### ZoomAll **Description** Zooms the all. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ZoomAll() ``` ### ZoomExtentsMainView **Description** Zooms the extents main view. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ZoomExtentsMainView() ``` ## Export ### CopyPicture **Description** Copies the picture. **Parameters** None. **Returns** tuple: A tuple of `(int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.CopyPicture() print(result) ``` ### ExportView **Description** Exports the view. **Parameters** - `FileLocation` (str): file location. - `FileName` (str): file name. - `FileFormat` (int): file format. - `Overwrite` (bool): overwrite. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.ExportView("value", "value", 1, True) print(result) ``` --- # Table/Report functions | OpenStaad Python > STAAD.Pro report tables and sheets — create reports and read/write individual cells. Reporting output, not modeling. Source: https://www.openstaad.com/docs/table-report Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### AddTable **Description** Adds the table. **Parameters** - `report_no` (int): report no. - `table_name` (str): table name. - `row_count` (int): row count. - `col_count` (int): col count. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.AddTable(1, "value", 1, 1) print(result) ``` ### CreateReport **Description** Creates the report. **Parameters** - `report_title` (str): report title. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.CreateReport("value") print(result) ``` ## Get ### GetCellValue **Description** Returns the cell value. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. **Returns** str: A string value returned by STAAD.Pro for this call. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetCellValue(1, 1, 1, 1) print(result) ``` ### GetCountryTableNo **Description** Returns the country table no. **Parameters** - `beam_id` (int): beam id. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetCountryTableNo(1) print(result) ``` ### GetReportCount **Description** Returns the report count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetReportCount() print(result) ``` ### GetTableCount **Description** Returns the table count. **Parameters** - `report_no` (int): report no. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetTableCount(1) print(result) ``` ### GetUserProvidedTableCount **Description** Returns the user provided table count. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUserProvidedTableCount() print(result) ``` ### GetUserProvidedTableList **Description** Returns the user provided table list. **Parameters** None. **Returns** list: A list of integers. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUserProvidedTableList() print(result) ``` ### GetUserProvidedTableNo **Description** Returns the user provided table no. **Parameters** - `table_index` (int): table index. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetUserProvidedTableNo(1) print(result) ``` ## Set/Assign ### RenameTable **Description** Renames the table. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `table_name` (str): table name. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.RenameTable(1, 1, "value") ``` ### ResizeTable **Description** Resizes the table. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_nos` (int): row nos. - `col_nos` (int): col nos. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ResizeTable(1, 1, 1, 1) ``` ### SaveReport **Description** Saves the report. **Parameters** - `report_no` (int): report no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SaveReport(1) ``` ### SaveReportAll **Description** Saves the report all. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SaveReportAll() ``` ### SaveTable **Description** Saves the table. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SaveTable(1, 1) ``` ### SetCellTextBold **Description** Sets the cell text bold. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellTextBold(1, 1, 1, 1) ``` ### SetCellTextColor **Description** Sets the cell text color. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. - `red` (int): red. - `green` (int): green. - `blue` (int): blue. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellTextColor(1, 1, 1, 1, 1, 1, 1) ``` ### SetCellTextHorzAlignment **Description** Sets the cell text horz alignment. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. - `align` (int): align. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellTextHorzAlignment(1, 1, 1, 1, 1) ``` ### SetCellTextItalic **Description** Sets the cell text italic. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellTextItalic(1, 1, 1, 1) ``` ### SetCellTextSize **Description** Sets the cell text size. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. - `size` (float): size. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellTextSize(1, 1, 1, 1, 1.0) ``` ### SetCellTextSizeAll **Description** Sets the cell text size all. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `size` (float): size. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellTextSizeAll(1, 1, 1.0) ``` ### SetCellTextUnderline **Description** Sets the cell text underline. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellTextUnderline(1, 1, 1, 1) ``` ### SetCellTextVertAlignment **Description** Sets the cell text vert alignment. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. - `align` (int): align. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellTextVertAlignment(1, 1, 1, 1, 1) ``` ### SetCellValue **Description** Sets the cell value. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `col_no` (int): col no. - `value` (str): value. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetCellValue(1, 1, 1, 1, "value") ``` ### SetColumnHeader **Description** Sets the column header. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `col_no` (int): col no. - `header` (str): header. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetColumnHeader(1, 1, 1, "value") ``` ### SetColumnUnitString **Description** Sets the column unit string. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `col_no` (int): col no. - `unit_string` (str): unit string. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetColumnUnitString(1, 1, 1, "value") ``` ### SetRowHeader **Description** Sets the row header. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. - `row_no` (int): row no. - `header` (str): header. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetRowHeader(1, 1, 1, "value") ``` ## Delete ### DeleteReport **Description** Deletes the report. **Parameters** - `report_no` (int): report no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.DeleteReport(1) ``` ### DeleteTable **Description** Deletes the table. **Parameters** - `report_no` (int): report no. - `table_no` (int): table no. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.DeleteTable(1, 1) ``` --- # Session/File (Root) functions | OpenStaad Python > The STAAD.Pro session and file — open/close .STD files, set active units, read job info, and trigger analysis from the top-level object. Source: https://www.openstaad.com/docs/session-file-root Every function is a method of the session `s = ops.connect()` (`from openstaad import ops`). ## Create ### NewSTAADFile ##### Description This function creates a .STD file with specified length and force units. ##### Function type This function execute an action over the open staad file ##### Example To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() # Execute de analize funcion from root module. s.NewSTAADFile() ``` ### OpenSTAADFile **Description** Opens the STAAD file. **Parameters** - `file` (str): file. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.OpenSTAADFile("value") ``` ## Get ### GetApplicationDesktopSize **Description** Returns the application desktop size. **Parameters** None. **Returns** tuple: A tuple of `(int, int)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetApplicationDesktopSize() print(result) ``` ### GetApplicationVersion #### Retrieve the version of the application This document explains how to retrieve the version of the application using OpenStaad python. ##### Description Returns the application version number as text and in individual parts. ##### Function type This function retrieves a value from the open staad file ##### Example To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() # Execute de analize funcion from root module. staad_version = s.GetApplicationVersion() print(staad_version) ``` ### GetBaseUnit #### Retrieve the base unit of your model This document explains how to retrieve the base unit of your model using OpenStaad python. ##### Description Returns the base unit for the currently open .STD file. The base unit decides the units of every value OpenStaad hands back to your script: - **Metric** — values derived from a length are in meters (`m`), values derived from a force are in kilonewtons (`kN`). - **English** — values derived from a length are in inches (`in`), values derived from a force are in kilopounds (`kip`). This is independent of the model's input units (the `UNIT` command): `SetInputUnits` does not change what the getters return. See the [Base Units guide](/guides/base_units) for the full rules and a conversion pattern. ##### Function type This function retrieves a value from the open staad file ##### Returns `str`: `"Metric"` or `"English"`. ##### Example To use this function see the following example: ```python from openstaad import ops # instantiate the root module s = ops.connect() # Execute the analyze function from root module. units = s.GetBaseUnit() print(units) ``` ### GetErrorMessage **Description** Returns the error message. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetErrorMessage() print(result) ``` ### GetFullJobInfo **Description** Returns the full job info. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetFullJobInfo() print(result) ``` ### GetInputUnitForForce ##### Description Retrieves the input unit of force of the currently open .STD file. ##### Function type This function retrive a value from the open staad file ##### Example To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() # Execute de analize funcion from root module. force_units = s.GetInputUnitForForce() print(force_units) ``` ### GetInputUnitForLength ##### Description Retrieves the input unit of length of the currently open .STD file. ##### Function type This function retrive a value from the open staad file ##### Example To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() # Execute de analize funcion from root module. length_units = s.GetInputUnitForLength() print(length_units) ``` ### GetMainWindowHandle **Description** Returns the main window handle. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetMainWindowHandle() print(result) ``` ### GetOutputUnitForDensity **Description** Returns the output unit for density. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForDensity() print(result) ``` ### GetOutputUnitForDimension **Description** Returns the output unit for dimension. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForDimension() print(result) ``` ### GetOutputUnitForDisplacement **Description** Returns the output unit for displacement. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForDisplacement() print(result) ``` ### GetOutputUnitForDistForce **Description** Returns the output unit for dist force. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForDistForce() print(result) ``` ### GetOutputUnitForDistMoment **Description** Returns the output unit for dist moment. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForDistMoment() print(result) ``` ### GetOutputUnitForForce **Description** Returns the output unit for force. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForForce() print(result) ``` ### GetOutputUnitForMoment **Description** Returns the output unit for moment. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForMoment() print(result) ``` ### GetOutputUnitForRotation **Description** Returns the output unit for rotation. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForRotation() print(result) ``` ### GetOutputUnitForSectArea **Description** Returns the output unit for sect area. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForSectArea() print(result) ``` ### GetOutputUnitForSectDimension **Description** Returns the output unit for sect dimension. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForSectDimension() print(result) ``` ### GetOutputUnitForSectInertia **Description** Returns the output unit for sect inertia. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForSectInertia() print(result) ``` ### GetOutputUnitForSectModulus **Description** Returns the output unit for sect modulus. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForSectModulus() print(result) ``` ### GetOutputUnitForStress **Description** Returns the output unit for stress. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetOutputUnitForStress() print(result) ``` ### GetProcessHandle **Description** Returns the process handle. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetProcessHandle() print(result) ``` ### GetProcessId **Description** Returns the process Id. **Parameters** None. **Returns** raw: The raw return value from the underlying OpenSTAAD COM call. Refer to the official Bentley OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetProcessId() print(result) ``` ### GetShortJobInfo **Description** Returns the short job info. **Parameters** None. **Returns** tuple: A tuple of `(str, str, str)`. **Example** ```python from openstaad import ops s = ops.connect() result = s.GetShortJobInfo() print(result) ``` ### GetSTAADFile ##### Description Retrieves the name of the current .STD file.. ##### Function type This function retrive a value from the open staad file ##### Example To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() # Execute de analize funcion from root module. file_name = s.GetSTAADFile() print(file_name) ``` ### GetSTAADFileFolder ##### Description Retrieves only the path of the current .STD file. ##### Function type This function retrive a value from the open staad file ##### Example To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() # Execute de analize funcion from root module. path = s.GetSTAADFileFolder() print(path) ``` ## Set/Assign ### SaveModel ##### Description This function saves the current structure with optional silent mode. ##### Function type This function retrive a value from the open staad file ##### Example To use this function see the following example: ```python from openstaad import ops # Connect to the running STAAD.Pro session s = ops.connect() # Execute de analize funcion from root module. status = s.GetAnalysisStatus() print(status) ``` ### SetCheckForIdenticalEntity **Description** Sets the check for identical entity. **Parameters** - `entityType` (int): entity type. - `checkFlag` (bool): check flag. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetCheckForIdenticalEntity(1, True) print(result) ``` ### SetFullJobInfo **Description** Sets the full job info. **Parameters** - `job_name` (str): job name. - `job_client` (str, optional (default `''`)): job client. - `eng_name` (str, optional (default `''`)): eng name. - `eng_date` (str, optional (default `''`)): eng date. - `job_number` (str, optional (default `''`)): job number. - `revision` (str, optional (default `''`)): revision. - `part_name` (str, optional (default `''`)): part name. - `reference` (str, optional (default `''`)): reference. - `checker_name` (str, optional (default `''`)): checker name. - `checker_date` (str, optional (default `''`)): checker date. - `approver_name` (str, optional (default `''`)): approver name. - `approval_date` (str, optional (default `''`)): approval date. - `comments` (str, optional (default `''`)): comments. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetFullJobInfo("value", "value", "value", "value", "value", "value", "value", "value", "value", "value", "value", "value", "value") ``` ### SetInputUnitForForce **Description** Sets the input unit for force. **Parameters** - `forceUnit` (int): force unit code. | Code | Force unit | |---|---| | 0 | Kilopound | | 1 | Pound | | 2 | Kilogram | | 3 | Metric Ton | | 4 | Newton | | 5 | KiloNewton | | 6 | MegaNewton | | 7 | DecaNewton | These units govern the values you **send**, not the values returned. See [Input Units](/guides/input_units) for how they work, and [Base Units](/guides/base_units) for the values returned. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetInputUnitForForce(1) print(result) ``` ### SetInputUnitForLength **Description** Sets the input unit for length. **Parameters** - `lengthUnit` (int): length unit code. | Code | Length unit | |---|---| | 0 | Inch | | 1 | Feet | | 2 | Feet (duplicate of `1`) | | 3 | CentiMeter | | 4 | Meter | | 5 | MilliMeter | | 6 | DeciMeter | | 7 | KiloMeter | The official OpenSTAAD reference lists code `2` as a second `Feet`; testing on STAAD.Pro 2025 confirms `2` behaves exactly like `1`. Use `1`. These units govern the values you **send**, not the values returned. See [Input Units](/guides/input_units) for how they work, and [Base Units](/guides/base_units) for the values returned. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetInputUnitForLength(1) print(result) ``` ### SetInputUnits **Description** Sets the input units. **Parameters** - `lengthUnit` (int): length unit code. - `forceUnit` (int): force unit code. **Length codes** | Code | Length unit | |---|---| | 0 | Inch | | 1 | Feet | | 2 | Feet (duplicate of `1`) | | 3 | CentiMeter | | 4 | Meter | | 5 | MilliMeter | | 6 | DeciMeter | | 7 | KiloMeter | The official OpenSTAAD reference lists code `2` as a second `Feet`; testing on STAAD.Pro 2025 confirms `2` behaves exactly like `1`. Use `1`. **Force codes** | Code | Force unit | |---|---| | 0 | Kilopound | | 1 | Pound | | 2 | Kilogram | | 3 | Metric Ton | | 4 | Newton | | 5 | KiloNewton | | 6 | MegaNewton | | 7 | DecaNewton | These units govern the values you **send**, not the values returned. See [Input Units](/guides/input_units) for how they work, and [Base Units](/guides/base_units) for the values returned. **Returns** value: See the official OpenSTAAD API reference for this method's exact return semantics. **Example** ```python from openstaad import ops s = ops.connect() result = s.SetInputUnits(1, 1) print(result) ``` ### SetShortJobInfo **Description** Sets the short job info. **Parameters** - `job_name` (str): job name. - `job_id` (str): job id. - `job_status` (str): job status. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetShortJobInfo("value", "value", "value") ``` ### SetSilentMode **Description** Sets the silent mode. **Parameters** - `silent` (bool): silent. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetSilentMode(True) ``` ### SetUnits **Description** Sets the units. **Parameters** - `uType` (int): u type. - `strUnit` (str): str unit. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.SetUnits(1, "value") ``` ### UpdateStructure **Description** Updates the structure. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.UpdateStructure() ``` ## Delete ### CloseSTAADFile **Description** Closes the STAAD file. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.CloseSTAADFile() ``` ### Quit **Description** Calls the `Quit` function on the OpenStaad `ops` session. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.Quit() ``` ## View ### ShowApplication **Description** Shows the application. **Parameters** None. **Returns** None: This function does not return a value. **Example** ```python from openstaad import ops s = ops.connect() s.ShowApplication() ``` ## Is ### IsPhysicalModel **Description** Checks whether physical model. **Parameters** None. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsPhysicalModel() print(result) ``` ### IsZUp **Description** Checks whether z up. **Parameters** None. **Returns** bool: `True` if the call succeeded, `False` otherwise. **Example** ```python from openstaad import ops s = ops.connect() result = s.IsZUp() print(result) ```