STAAD.Pro Geometry Modeling

Instructions

• Define the shorthand once per script: geo = staad.Geometry

Creating Elements

• geo.AddNode(x, y, z) → node ID — coordinates are raw base-unit values, no conversion applied at all regardless of the current input unit setting (live-verified: AddNode(10.0, ...) while GetInputUnitForLength() reports "Meter" still reads back as 10.0, not 393.7). Convert the user's value to base units yourself before calling.
• geo.AddBeam(startNode, endNode) → beam ID
• geo.AddPlate(n1, n2, n3, n4) → plate ID — pass 4 separate int args, NOT a list
• Triangle: the API always takes 4 args; pass 0 as a sentinel for the missing 4th node → geo.AddPlate(n1, n2, n3, 0)
• geo.AddSolid(n1, n2, n3, n4, n5, n6, n7, n8) → solid ID

Bulk Creation (more efficient than loops)

• geo.AddMultipleNodes([[x,y,z], ...]) → list of node IDs
• geo.AddMultipleBeams([[start,end], ...]) → list of beam IDs
• geo.AddMultiplePlates([[n1,n2,n3,n4], ...]) → list of plate IDs
• Triangle rows: each row must have exactly 4 ints; use 0 as the sentinel 4th element → [n1, n2, n3, 0]
• geo.AddMultipleSolids([[n1..n8], ...]) → list of solid IDs (rows of 6/7/8 nodes are auto-padded with 0)

Explicit-ID Bulk Creation

Same as the Add* bulk functions above but with caller-chosen IDs (thin Python-side loops around CreateNode/CreateBeam/CreatePlate — not raw COM batch calls):

geo.CreateMultipleNodes(node_ids, [[x1,y1,z1], [x2,y2,z2], ...])   # node_ids and coordinate rows must be same length
geo.CreateMultipleBeams(beam_ids, [[start1,end1], [start2,end2], ...])
geo.CreateMultiplePlates(plate_ids, [[n1,n2,n3,n4], ...])          # triangle rows: 0 as 4th node

Explicit ID Creation

Units gotcha: despite the official docs describing the only difference from AddNode/etc. as "lets you choose the ID", CreateNode (and therefore CreateMultipleNodes, which loops it) actually also converts coordinates from the current input unit setting to base — the opposite of AddNode's raw pass-through. Live-verified: CreateNode(id, 10.0, 0, 0) while GetInputUnitForLength() reports "Meter" stores 393.7 (base inches), not 10.0. If you need a specific node ID AND want raw/base-unit coordinates like AddNode, convert to base units yourself first, same as any other input-unit-consuming setter.

• geo.CreateNode(nodeNo, x, y, z) — creates node with a specific ID; consumes current input units, converted to base for storage
• geo.CreateBeam(beamNo, startNode, endNode) — beam with specific ID (references existing node IDs, no coordinates — no units concern)
• geo.CreatePlate(plateNo, nA, nB, nC, nD) — plate with specific ID
• Triangle: pass 0 for nD (the sentinel for a missing 4th node) → geo.CreatePlate(id, nA, nB, nC, 0)
• geo.CreateSolid(solidNo, nA, nB, nC, nD, nE, nF, nG, nH) — solid with specific ID

Shared Element ID Sequence

IMPORTANT: Beams, plates, and solids share a SINGLE continuous ID counter.

• If you create 10 beams (IDs 1–10) then 4 plates, plates get IDs 11–14, NOT 1–4
• NEVER assume element IDs start at 1 for each type
• Always retrieve actual IDs: geo.GetBeamList(), geo.GetPlateList(), geo.GetSolidList()

Quick Reference

Modifying Elements

• geo.SetNodeCoordinate(nodeNo, x, y, z) — move a node
• geo.DeleteNode(nodeNo) / geo.DeleteBeam(beamNo) / geo.DeletePlate(plateNo) / geo.DeleteSolid(solidNo)
• geo.MergeNodes(newId, nodeList) — merge coincident nodes
• geo.SplitBeamInEqlParts(beamNo, nParts) — split beam into equal segments
• geo.SplitBeam(beamNo, nodes, distToNodes) — split at specific distances
• geo.GetIntersectBeamsCount(beamList, tolerance) — count before calling IntersectBeams (empty beamList = all beams; tolerance in base units)
• geo.IntersectBeams(method, beamList, tolerance) — split beams at intersections
• geo.GetCountOfBreakableBeamsAtSpecificNodes(nodeList) — count before calling BreakBeamsAtSpecificNodes
• geo.BreakBeamsAtSpecificNodes(nodeList) → (brokenBeamIds, newBeamIds) tuple — break beams passing through the given nodes, copying attributes to the new segments
• geo.MergeBeams(beamList, newId, propId, betaAngle, material) — merge collinear beams
• geo.RenumberBeam(oldNo, newNo) — renumber a beam

Property IDs (PID)

A separate ID system from element numbers, shared across entity types via EntityType (1=Node, 2=Beam, 3=Plate, 4=Solid, 5=Surface — same convention as view.SelectByItemList):

geo.SetPID(entityNo, entityType, propertyID)
pid = geo.GetPID(entityNo, entityType)

Hidden Entities & Performance Flags

# Controls whether hidden nodes/plates are included in count/list queries
geo.SetFlagForHiddenEntities(flag)   # 0=All (default), 1=Ignore hidden, 2=Only hidden
flag = geo.GetFlagForHiddenEntities()

# Disable identical-entity checking to speed up bulk Add*/Create* calls
geo.SetCheckForIdenticalEntity(entityType, checkFlag)  # entityType: 1-5 as above

Selection

Selections are additive — always clear before starting a new selection.

Select* returns bool (True = OK), SelectMultiple*/Clear* return None on success. Query functions return a tuple of IDs (empty () when nothing is selected).

Clear*Selection() empties the entire accumulated selection (verified live across multiple SelectBeam/SelectMultipleBeams calls) — but it raises (e.g. OsNoBeamSelected) if the selection is already empty, so guard the call. See select-members.py for a reset_member_selection() helper.

Groups

Group types: 1=Nodes, 2=Members, 3=Plates, 4=Solids, 5=Geometry, 6=FloorBeam

Translational Repeat

Duplicate selected geometry along an axis. Returns bool — True on success, False on failure; always check the return value before reporting success. Max no_of_bays = 100 per call; split into multiple calls for more. Not supported on models containing enclosed zones — the call will return False in that case:

ok = geo.DoTranslationalRepeat(
    link_bays=True, open_base=False,
    axis_dir=0,  # 0=GX, 1=GY, 2=GZ
    spacing_list=[5.0, 5.0], no_of_bays=2,  # max no_of_bays 100
    renumber_bays=False, renumber_list=[],
    geometry_only_flag=False
)

Parametric Surfaces (Mesh Generation)

surf_id = geo.DefineParametricSurface(name, type, origin_Node, x_vertex_node, y_vertex_node, vertices_list, auto_generate)
geo.AddParametricSurfaceToModel(surf_id)
geo.CommitParametricSurfaceMesh(surf_id)

# After committing, query the generated mesh panels
count = geo.GetNoOfGeneratedQuadPanels()
nodeAs, nodeBs, nodeCs, nodeDs = geo.GetGeneratedQuadPanelIncidences()  # empty lists if count == 0

Types: 1=Wall, 2=Slab

Mesh introspection & lifecycle:

count = geo.GetParametricSurfaceCount()
node_count, element_count = geo.GetParametricSurfaceMeshInfo(surfaceNo)
node_ids, element_ids = geo.GetParametricSurfaceMeshData(surfaceNo)   # actual generated node/plate IDs
geo.RemoveParametricSurfaceMesh(surfaceNo)   # bool; removes the mesh but keeps the surface definition

# Extended info (preferred) — name, type, sub-type, vertex count, mesh size, divisions, meshing method,
# isQuad, origin/axis nodes, opening/region counts, density point/line counts (17 fields total)
info_ex = geo.GetParametricSurfaceInfoEx(surfaceNo)
# GetParametricSurfaceInfo(surfaceNo) also available — simpler 6-field subset (name, type, boundary/density counts, opening/region counts)
surface_name, surface_type, boundary_count, density_count, opening_count, region_count = geo.GetParametricSurfaceInfo(surfaceNo)

geo.SetParametricSurfaceSubType(surfaceName, subType)   # e.g. "FLOOR"
sub_type = geo.GetParametricSurfaceSubType(surfaceName)
geo.SetParametricSurfaceUniqueID(surfaceName, uniqueId)
uid = geo.GetParametricSurfaceUniqueID(surfaceName)

Mesh refinement — density points/lines and openings/regions:

geo.AddDensityPointToSurface(surfaceNo, pointData)
line_index = geo.AddDensityLineToSurface(surfaceNo, x1, y1, z1, density1, x2, y2, z2, density2, divisions)
ok = geo.AddCircularRegionToSurface(surfaceNo, x, y, z, radius, divisions, density, is_opening=False)
geo.AddPolygonalRegionToSurface(surfaceNo, regionData)

Physical Members

geo.CreatePhysicalMember(memberList)
pm_count = geo.GetPhysicalMemberCount()

# Selection (separate from beam selection)
geo.SelectPhysicalMember(physicalMemberId)
geo.SelectMultiplePhysicalMembers(physicalMemberList)
geo.ClearPhysicalMemberSelection()
geo.SetPhysicalMemberUniqueID(physicalMemberId, uniqueId)

Physical member introspection:

count = geo.GetPMemberCount()                         # total physical members (distinct from GetPhysicalMemberCount)
ids = geo.GetPhysicalMemberList()
last_id = geo.GetLastPhysicalMemberNo()
uid = geo.GetPhysicalMemberUniqueID(physicalMemberId)

sel_count = geo.GetNoOfSelectedPhysicalMembers()
selected_ids = geo.GetSelectedPhysicalMembers()

# Each physical member maps to 1+ underlying analytical (beam) members
analytical_count = geo.GetAnalyticalMemberCountForPhysicalMember(physicalMemberId)
analytical_ids = geo.GetAnalyticalMembersForPhysicalMember(physicalMemberId)

geo.DeletePhysicalMember(physicalMemberId)

Unique IDs (External Reference Strings)

• geo.SetNodeUniqueID(nodeNo, uniqueID) / geo.GetNodeUniqueID(nodeNo)
• geo.SetMemberUniqueID(beamNo, uniqueID) / geo.GetMemberUniqueID(beamNo)
• geo.SetPlateUniqueID(plateNo, uniqueID) / geo.GetPlateUniqueID(plateNo)
• geo.SetSolidUniqueID(solidNo, uniqueID) / geo.GetSolidUniqueID(solidNo)
• geo.SetPhysicalMemberUniqueID(physicalMemberId, uniqueId)

Floor Functions

• geo.GetFloorLevels() → list of unique vertical coordinates (base units) — nodes are grouped along the vertical axis (Y if Y-up, Z if Z-up) using a small tolerance
• geo.GetFloorNodesAtLevel(floorLevel) → sorted list of node numbers at that level (use a value from GetFloorLevels())
• geo.GetFloorBeamsAtLevel(floorLevel) → sorted list of beam numbers whose start AND end nodes are both at that level
• geo.IdentifyFloorBoundariesFromNodes(nodeIds) → number of floor boundaries (sub-floors) identified from a set of ≥3 coplanar, non-collinear, beam-connected node IDs — stores results internally for the three functions below
• geo.GetFloorBoundaryNodesByIndex(boundaryIndex) → list of node numbers forming boundary boundaryIndex (0-based) — call after IdentifyFloorBoundariesFromNodes
• geo.GetFloorBoundaryBeamsByIndex(boundaryIndex) → list of beam numbers in that boundary
• geo.GetFloorBoundaryAreaByIndex(boundaryIndex) → area of that boundary in current base units

CIS/2 Format Incidence (Interop)

Same incidence data as the standard Get*Incidence functions above, but each also returns a CIS/2 unique string ID as the first tuple element — used for CIS/2 (CIMsteel) interoperability exports:

unique_str_id, x, y, z = geo.GetNodeIncidence_CIS2(nodeId)
unique_str_id, start_node, end_node = geo.GetMemberIncidence_CIS2(memberId)
unique_str_id, n1, n2, n3, n4 = geo.GetPlateIncidence_CIS2(plateId)
unique_str_id, n1, n2, n3, n4, n5, n6, n7, n8 = geo.GetSolidIncidence_CIS2(solidId)

Examples

• portal-frame.py — create a simple portal frame with supports
• add-beam.py — add a single beam between two new nodes
• add-plate.py — create quad and triangular plates (shows the 0 triangle convention)
• select-members.py — select single and multiple beams

Gotchas

• Triangle plates use `0` as a sentinel: all plate functions always take exactly 4 node arguments; 0 tells STAAD the slot is empty (i.e., this is a 3-node element). See add-plate.py for a full example.
• AddPlate takes 4 separate int arguments, NOT a list — geo.AddPlate(n1, n2, n3, n4) not geo.AddPlate([n1,n2,n3,n4])
• After adding geometry in the same script, call staad.SetSilentMode(True) → staad.SaveModel(True) → staad.SetSilentMode(False) before assigning properties, supports, or loads — do NOT use UpdateStructure() (it discards unsaved in-memory geometry)
• Always use geo (OSGeometry) for selections — do NOT use OSView.SelectByItemList
• Beams, plates, and solids share one ID counter — never assume IDs start at 1 per type
• ClearMemberSelection() (and the node/plate/solid equivalents) empties the whole accumulated selection in one call, but raises OsNoBeamSelected/equivalent if the selection is already empty — never call it unconditionally; wrap it in try: geo.ClearMemberSelection() except Exception: pass, or check GetSelectedBeams() first. See select-members.py's reset_member_selection() for the reliable pattern