MIDAS CIVIL NX tools (MIDAS IT Europe)

com.midasiteurope/civil-nxVersion 0.7.1

Build, check and report on MIDAS CIVIL NX bridge models and design tendons, with MIDAS IT plugins.

Status

Responds684 msNov 14, 2026, 14:06 UTCAnswered our handshake without sign-in.

Registry data may be out of date

We could not refresh it, so this page shows the last copy.

Last checked: Nov 14, 2026, 14:06 UTC
Latency: 684 ms
Remotes responding: 1 of 1
Sign-in: No sign-in
Hosting: Hosted outside the EU (detected)
Registry data as of: Nov 14, 2026, 22:14 UTC

Data from the official MCP Registry, checked by run.zero. How we check

Connect

Streamable HTTP

https://midasiteurope.com/mcpResponds684 msNov 14, 2026, 14:06 UTC

No sign-in

Claude Code

claude mcp add --transport http civil-nx https://midasiteurope.com/mcp

Claude Desktop and claude.ai

1
2
3

Settings > Connectors > Add custom connector
Name: civil-nx
Remote MCP server URL: https://midasiteurope.com/mcp

Cursor

{
  "mcpServers": {
    "civil-nx": {
      "url": "https://midasiteurope.com/mcp"
    }
  }
}

VS Code

code --add-mcp '{"name":"civil-nx","type":"http","url":"https://midasiteurope.com/mcp"}'

Built your own server? run.zero hosts MCP servers on European infrastructure.

Host your own MCP server on run.zero

Tools

108 tools

Tools of MIDAS CIVIL NX tools (MIDAS IT Europe)
	Description		Read-only	Idempotent	Open world
`auto_structure_groups`Creates one structure group per section, per material, or per section + material pair, with the Auto Structure Groups plugin's own engine: it reads every element's section and material, names each group from the prefix and the section/material names (cleaned and cut to 40 characters, as in the plugin; elements with no section/material go to <prefix>UNASSIGNED), largest group first. Optional: include each group's nodes, skip groups with fewer than minElements elements, or write only the groups named in groups. A name that already exists is skipped unless existing: 'overwrite' — and then this run's members are ADDED to that group (CIVIL NX merges a write into an existing group; it never removes members). Previews unless apply: true with confirmPlanHash; the plugin's writer re-reads db/GRUP, writes in batches and checks the read-back. auto_structure_groups_undo reverses it.	Creates one structure group per section, per material, or per section + material pair, with the Auto Structure Groups plugin's own engine: it reads every element's section and material, names each group from the prefix and the section/material names (cleaned and cut to 40 characters, as in the plugin; elements with no section/material go to <prefix>UNASSIGNED), largest group first. Optional: include each group's nodes, skip groups with fewer than minElements elements, or write only the groups named in groups. A name that already exists is skipped unless existing: 'overwrite' — and then this run's members are ADDED to that group (CIVIL NX merges a write into an existing group; it never removes members). Previews unless apply: true with confirmPlanHash; the plugin's writer re-reads db/GRUP, writes in batches and checks the read-back. auto_structure_groups_undo reverses it.	No	No	No	No
`auto_structure_groups_undo`Reverses an auto_structure_groups run from the ledger: deletes the groups it created and puts every group it added members to back exactly as it was (from the snapshot taken just before the write). Refuses while a construction stage uses one of those groups, because deleting a group strips it from every stage. Default: the latest run not yet undone. Previews unless apply: true.	Reverses an auto_structure_groups run from the ledger: deletes the groups it created and puts every group it added members to back exactly as it was (from the snapshot taken just before the write). Refuses while a construction stage uses one of those groups, because deleting a group strips it from every stage. Default: the latest run not yet undone. Previews unless apply: true.	Yes	No	Not declared	No
`b2p_convert`Converts beam elements into a plate (or solid) mesh of their cross-section with the Beam to Plate plugin's own engine (1.0.6): every section CIVIL NX gives geometry for (rolled/fabricated steel, PSC, boxes, composite, tapered groups, VALUE, catalogue), solid concrete sections as a grid of plates or as solids, exact beam loads / nodal loads / temperatures moved onto the mesh, haunches, diaphragms, deck slabs joined, rigid links to whatever else meets the beam's nodes (staged per construction stage), virtual beams per row of plates, groups and composite casting stages carried across. Previews by default (totals, volume check, per-section verdict, notes, what is left behind such as tendons or lanes, problems, planHash) and writes nothing. With apply: true and confirmPlanHash it re-reads the model, refuses if the plan changed, and writes the plugin's way: nodes, thicknesses and elements written and read back, then links, loads, groups, stages, virtual beams, and only then the source beams deleted (deleteSourceBeams); a write that fails part way is rolled back by the plugin. The run is recorded for b2p_undo. Lengths are in the model's unit. Use b2p_survey first. Runs as a background job on the website (poll job_status).	Converts beam elements into a plate (or solid) mesh of their cross-section with the Beam to Plate plugin's own engine (1.0.6): every section CIVIL NX gives geometry for (rolled/fabricated steel, PSC, boxes, composite, tapered groups, VALUE, catalogue), solid concrete sections as a grid of plates or as solids, exact beam loads / nodal loads / temperatures moved onto the mesh, haunches, diaphragms, deck slabs joined, rigid links to whatever else meets the beam's nodes (staged per construction stage), virtual beams per row of plates, groups and composite casting stages carried across. Previews by default (totals, volume check, per-section verdict, notes, what is left behind such as tendons or lanes, problems, planHash) and writes nothing. With apply: true and confirmPlanHash it re-reads the model, refuses if the plan changed, and writes the plugin's way: nodes, thicknesses and elements written and read back, then links, loads, groups, stages, virtual beams, and only then the source beams deleted (deleteSourceBeams); a write that fails part way is rolled back by the plugin. The run is recorded for b2p_undo. Lengths are in the model's unit. Use b2p_survey first. Runs as a background job on the website (poll job_status).	Yes	No	No	No
`b2p_survey`Reads the model the way the Beam to Plate plugin (1.0.6) does and studies every section the chosen beams use, against CIVIL NX's own published properties (/ope/SECTPROP): whether the outline was READ correctly (A/Iyy/Izz vs published) and how far the PLATE model sits from it, the verdict (converts / blocked / not read, with the reason), the plugin's plate-or-solid suggestion with the mesh a solid would need, material slots of composite parts, the model's length/force units, the beams that cannot be converted and why, and an element estimate for the mesh. Choose beams with ONE of elementIds, sections, groups or useCivilSelection (default: every beam). Read-only; on the website it runs as a background job (poll job_status).	Reads the model the way the Beam to Plate plugin (1.0.6) does and studies every section the chosen beams use, against CIVIL NX's own published properties (/ope/SECTPROP): whether the outline was READ correctly (A/Iyy/Izz vs published) and how far the PLATE model sits from it, the verdict (converts / blocked / not read, with the reason), the plugin's plate-or-solid suggestion with the mesh a solid would need, material slots of composite parts, the model's length/force units, the beams that cannot be converted and why, and an element estimate for the mesh. Choose beams with ONE of elementIds, sections, groups or useCivilSelection (default: every beam). Read-only; on the website it runs as a background job (poll job_status).	Not declared	Yes	Not declared	No
`b2p_undo`Undoes a b2p_convert run from the ledger with the plugin's own Undo: removes the virtual beams, the plates/solids, the rigid links and construction-joint links, the converted loads and the nodes it made, gives the stages and boundary groups back, then puts the beams back with their beam loads, temperatures, releases, offsets, moved nodal loads and structure-group membership, and reads the model back. Resumable: if CIVIL NX refuses some deletes or the connection goes, the call says what is left and calling again with the same runId carries on (also after a background job that stopped). Afterwards (tidy, default on) it also removes the thickness records and the 'B2P mesh' group the run created when nothing uses them — the plugin's own Undo leaves both. Default run: the latest not undone. Previews unless apply: true; on the website the apply runs as a background job.	Undoes a b2p_convert run from the ledger with the plugin's own Undo: removes the virtual beams, the plates/solids, the rigid links and construction-joint links, the converted loads and the nodes it made, gives the stages and boundary groups back, then puts the beams back with their beam loads, temperatures, releases, offsets, moved nodal loads and structure-group membership, and reads the model back. Resumable: if CIVIL NX refuses some deletes or the connection goes, the call says what is left and calling again with the same runId carries on (also after a background job that stopped). Afterwards (tidy, default on) it also removes the thickness records and the 'B2P mesh' group the run created when nothing uses them — the plugin's own Undo leaves both. Default run: the latest not undone. Previews unless apply: true; on the website the apply runs as a background job.	Yes	No	Not declared	No
`bridge_reshape`Changes the geometry of the bridge in the open model in place, with the Bridge Reshaper plugin's own engine (1.0.6): new span lengths (the deck is stretched - each span keeps its element count), a skew for each support, a new horizontal alignment (straight, segments, fitted points, LandXML/DXF) and new deck levels (flat, grades with parabolic vertical curves, one-way or crowned cross slope). crossMembers 'parallel' (default) moves nodes only - every element, node, load, group, stage and lane keeps its id; 'square' re-meshes the deck with cross members square to the girders running on to the skewed support lines (straight decks of beam girders only, not with new levels). Loads, structure groups, construction stages, lanes, tapered groups and links follow the deck; beam loads in global axes, plane loads and lane end skews are turned with it; piers and abutments follow their supports ('follow' the skew, or 'rigid' keep their shape). Previews by default: the changes, the issues and a plan drawing (grey = as it is, blue = proposed), with a planHash; nothing is written. With apply: true and confirmPlanHash it re-reads the model, refuses if anything changed since the preview, writes, reads every written node and element back, and records the run for bridge_reshape_undo. Lengths and chainages in the model's unit. Use bridge_reshape_read first. Runs as a background job on the website (poll job_status).	Changes the geometry of the bridge in the open model in place, with the Bridge Reshaper plugin's own engine (1.0.6): new span lengths (the deck is stretched - each span keeps its element count), a skew for each support, a new horizontal alignment (straight, segments, fitted points, LandXML/DXF) and new deck levels (flat, grades with parabolic vertical curves, one-way or crowned cross slope). crossMembers 'parallel' (default) moves nodes only - every element, node, load, group, stage and lane keeps its id; 'square' re-meshes the deck with cross members square to the girders running on to the skewed support lines (straight decks of beam girders only, not with new levels). Loads, structure groups, construction stages, lanes, tapered groups and links follow the deck; beam loads in global axes, plane loads and lane end skews are turned with it; piers and abutments follow their supports ('follow' the skew, or 'rigid' keep their shape). Previews by default: the changes, the issues and a plan drawing (grey = as it is, blue = proposed), with a planHash; nothing is written. With apply: true and confirmPlanHash it re-reads the model, refuses if anything changed since the preview, writes, reads every written node and element back, and records the run for bridge_reshape_undo. Lengths and chainages in the model's unit. Use bridge_reshape_read first. Runs as a background job on the website (poll job_status).	Yes	No	No	No
`bridge_reshape_read`Reads the open model the way the Bridge Reshaper plugin (1.0.6) does: the deck (straight, in straight pieces kinked at half-joints or piers, or curved; beam girders, girders meshed as plates, or a spine (single-line) model with its pylons, stays and piers read as substructure; any length unit), its spans, supports and skews (Abutment A, Pier 1…, Abutment B, skew in degrees from square), girder/edge lines, bearings and substructure assemblies, its direction (tightest radius on a curve) and its levels (level at each abutment, grade, cross slope), with a plan drawing. Read-only; on the website it runs as a background job (poll job_status). Use it before bridge_reshape.	Reads the open model the way the Bridge Reshaper plugin (1.0.6) does: the deck (straight, in straight pieces kinked at half-joints or piers, or curved; beam girders, girders meshed as plates, or a spine (single-line) model with its pylons, stays and piers read as substructure; any length unit), its spans, supports and skews (Abutment A, Pier 1…, Abutment B, skew in degrees from square), girder/edge lines, bearings and substructure assemblies, its direction (tightest radius on a curve) and its levels (level at each abutment, grade, cross slope), with a plan drawing. Read-only; on the website it runs as a background job (poll job_status). Use it before bridge_reshape.	Not declared	Yes	Not declared	No
`bridge_reshape_undo`Undoes a bridge_reshape run from the ledger with the plugin's own Undo: every row the run overwrote is written back and every row it created is removed, so the model returns exactly. Refuses on a different model, or when the model was edited since the apply (force: true undoes anyway, overwriting those edits). Resumable: a step that fails is reported and calling again retries only what is left. Default run: the latest not undone. Previews unless apply: true; on the website the apply runs as a background job.	Undoes a bridge_reshape run from the ledger with the plugin's own Undo: every row the run overwrote is written back and every row it created is removed, so the model returns exactly. Refuses on a different model, or when the model was edited since the apply (force: true undoes anyway, overwriting those edits). Resumable: a step that fails is reported and calling again retries only what is left. Default run: the latest not undone. Previews unless apply: true; on the website the apply runs as a background job.	Yes	No	Not declared	No
`bridge_thermal_apply`Calculates the temperature actions for the deck and writes them with the Bridge Thermal Loads plugin's writer: EC1T_Uniform_Exp/_Con (type T, element or system temperature), EC1T_Diff_Heat/_Cool (type TPG: beam section temperature bands, or a linear gradient for Approach 1 and plates), and optionally EC1T_Bearing_* and EC1T_Comb_Max/_Min (USER). Temperatures are converted to the model's unit; the model is re-checked before writing, an undo record is kept before the first change, and every row is read back. Previews unless apply: true.	Calculates the temperature actions for the deck and writes them with the Bridge Thermal Loads plugin's writer: EC1T_Uniform_Exp/_Con (type T, element or system temperature), EC1T_Diff_Heat/_Cool (type TPG: beam section temperature bands, or a linear gradient for Approach 1 and plates), and optionally EC1T_Bearing_* and EC1T_Comb_Max/_Min (USER). Temperatures are converted to the model's unit; the model is re-checked before writing, an undo record is kept before the first change, and every row is read back. Previews unless apply: true.	No	No	Not declared	No
`bridge_thermal_calc`Calculates bridge temperature actions with the Bridge Thermal Loads plugin's own engine: shade air and effective bridge temperatures, the uniform ranges ΔT_N,con / ΔT_N,exp (and bearing ranges), the vertical temperature difference (linear Approach 1 or the non-linear code profile, as depth/temperature points), CS 454 / BS 5400 combined X − Y values, and the simultaneity combinations, each with its clause. Codes: EN 1991-1-5 + UK NA (default) or CEN, CS 454, BS 5400-2:2006 / 1978. Needs no model.	Calculates bridge temperature actions with the Bridge Thermal Loads plugin's own engine: shade air and effective bridge temperatures, the uniform ranges ΔT_N,con / ΔT_N,exp (and bearing ranges), the vertical temperature difference (linear Approach 1 or the non-linear code profile, as depth/temperature points), CS 454 / BS 5400 combined X − Y values, and the simultaneity combinations, each with its clause. Codes: EN 1991-1-5 + UK NA (default) or CEN, CS 454, BS 5400-2:2006 / 1978. Needs no model.	Not declared	Yes	Not declared	No
`bridge_thermal_read`Reads the open model the way the Bridge Thermal Loads plugin does: the deck from a structure group, element list or the CIVIL NX selection, grouped into sections (beams by section, plates by thickness), each with the proposed deck type, depths h and D, and its width-against-depth parts per material (read through the shared section library; catalogue sections from CIVIL NX's published properties). Also the units, the initial temperature and any EC1T_ cases already in the model. Read-only.	Reads the open model the way the Bridge Thermal Loads plugin does: the deck from a structure group, element list or the CIVIL NX selection, grouped into sections (beams by section, plates by thickness), each with the proposed deck type, depths h and D, and its width-against-depth parts per material (read through the shared section library; catalogue sections from CIVIL NX's published properties). Also the units, the initial temperature and any EC1T_ cases already in the model. Read-only.	Not declared	Yes	Not declared	No
`bridge_thermal_remove`Removes what the Bridge Thermal Loads plugin writes: every load case whose name starts with EC1T_ (also named sets and ones the plugin window wrote) and all temperature loads in them, on any element. Other load cases are not touched. An undo record is kept, so bridge_thermal_undo can put them back. Previews unless apply: true.	Removes what the Bridge Thermal Loads plugin writes: every load case whose name starts with EC1T_ (also named sets and ones the plugin window wrote) and all temperature loads in them, on any element. Other load cases are not touched. An undo record is kept, so bridge_thermal_undo can put them back. Previews unless apply: true.	Yes	No	Not declared	No
`bridge_thermal_undo`Undoes the latest bridge_thermal_apply or bridge_thermal_remove run (or the run named): deletes the EC1T_ cases present now and puts back the EC1T_ cases and loads saved before that run, merged into each element's current loads so other cases are kept. Refused in a different model or after a unit change; needs force if EC1T_ loads or the geometry changed since. Previews unless apply: true.	Undoes the latest bridge_thermal_apply or bridge_thermal_remove run (or the run named): deletes the EC1T_ cases present now and puts back the EC1T_ cases and loads saved before that run, merged into each element's current loads so other cases are kept. Refused in a different model or after a unit change; needs force if EC1T_ loads or the geometry changed since. Previews unless apply: true.	Yes	No	Not declared	No
`civil_combinations_quick`Writes general load combinations from plain factors, e.g. { name: "ULS1", factors: { "SW": 1.35, "SDL": 1.35, "LM1": 1.5 } } — for hand-picked combinations; for the full code set use ec_combinations_apply / cs454_combinations_apply. Each name is looked up: static load cases (ST), moving-load cases (MV) and existing combinations (CB) are recognised, and a combination made in the same call can be used in a later one; write "CS:<name>" for a construction-stage result, or a prefix when a name is in two places. type: add (default), envelope, abs, srss. Names ≤ 20 characters; a case listed twice is refused (CIVIL NX refuses the whole write). An existing name is refused unless replaceExisting: true. Previews unless apply: true with confirmPlanHash; civil_write_tables_undo reverses it.	Writes general load combinations from plain factors, e.g. { name: "ULS1", factors: { "SW": 1.35, "SDL": 1.35, "LM1": 1.5 } } — for hand-picked combinations; for the full code set use ec_combinations_apply / cs454_combinations_apply. Each name is looked up: static load cases (ST), moving-load cases (MV) and existing combinations (CB) are recognised, and a combination made in the same call can be used in a later one; write "CS:<name>" for a construction-stage result, or a prefix when a name is in two places. type: add (default), envelope, abs, srss. Names ≤ 20 characters; a case listed twice is refused (CIVIL NX refuses the whole write). An existing name is refused unless replaceExisting: true. Previews unless apply: true with confirmPlanHash; civil_write_tables_undo reverses it.	Yes	No	No	No
`civil_loads_supports`The fast way to add supports, point springs, beam end releases, self-weight, nodal loads, beam UDLs, plate pressures and element temperatures: describe WHERE (structure group, id ranges, a line, a box, a coordinate, or the extreme nodes of a group) and WHAT, and the tool finds the nodes / elements and builds the CONS, CNLD, BMLD and PRES rows itself — no table lookup, no reading NODE / ELEM, no rows to write. Values are in kN and m by default (units: { force, length }) and converted to the model's units; signs follow the global axes (w: -10 with dir GZ = 10 kN/m downward). Missing load cases (STLD), load groups and boundary groups are created. Examples: supports [{ at: { group: "GIRDERS", pick: "xmin" }, type: "pinned" }, { at: { group: "GIRDERS", pick: "xmax" }, type: "roller-x" }]; udl [{ on: { group: "GIRDERS" }, case: "SIDL", w: -12.5 }]; udl with range { axis: "x", from: 10, to: 20 } loads only that stretch; nodalLoads [{ at: { nodes: "101to121by2" }, case: "Wheel", F: [0, 0, -50] }]; pressure [{ on: { group: "DECK" }, case: "Surfacing", p: -2.4 }]; springs [{ at: { group: "PIERS", pick: "zmin" }, k: [1e5, 1e5, 5e5] }]; releases [{ on: { group: "CROSS-BEAMS" }, free: "My Mz" }]; selfWeight [{ case: "SW" }]; temperature [{ on: { group: "DECK" }, case: "T+", uniform: 15, gradientZ: 10 }]. The preview is a summary — counts, ids, and total force per load case to check against the intended load. Apply with apply: true and confirmPlanHash; every row is read back. Undo with civil_write_tables_undo (same ledger). Rules kept for you: CIVIL NX keeps one nodal load per case per node, so loads landing on the same node and case are summed (also with an existing one, with a warning); an existing support on a node is replaced; existing beam loads and pressures are kept and the new ones added.	The fast way to add supports, point springs, beam end releases, self-weight, nodal loads, beam UDLs, plate pressures and element temperatures: describe WHERE (structure group, id ranges, a line, a box, a coordinate, or the extreme nodes of a group) and WHAT, and the tool finds the nodes / elements and builds the CONS, CNLD, BMLD and PRES rows itself — no table lookup, no reading NODE / ELEM, no rows to write. Values are in kN and m by default (units: { force, length }) and converted to the model's units; signs follow the global axes (w: -10 with dir GZ = 10 kN/m downward). Missing load cases (STLD), load groups and boundary groups are created. Examples: supports [{ at: { group: "GIRDERS", pick: "xmin" }, type: "pinned" }, { at: { group: "GIRDERS", pick: "xmax" }, type: "roller-x" }]; udl [{ on: { group: "GIRDERS" }, case: "SIDL", w: -12.5 }]; udl with range { axis: "x", from: 10, to: 20 } loads only that stretch; nodalLoads [{ at: { nodes: "101to121by2" }, case: "Wheel", F: [0, 0, -50] }]; pressure [{ on: { group: "DECK" }, case: "Surfacing", p: -2.4 }]; springs [{ at: { group: "PIERS", pick: "zmin" }, k: [1e5, 1e5, 5e5] }]; releases [{ on: { group: "CROSS-BEAMS" }, free: "My Mz" }]; selfWeight [{ case: "SW" }]; temperature [{ on: { group: "DECK" }, case: "T+", uniform: 15, gradientZ: 10 }]. The preview is a summary — counts, ids, and total force per load case to check against the intended load. Apply with apply: true and confirmPlanHash; every row is read back. Undo with civil_write_tables_undo (same ledger). Rules kept for you: CIVIL NX keeps one nodal load per case per node, so loads landing on the same node and case are summed (also with an existing one, with a warning); an existing support on a node is replaced; existing beam loads and pressures are kept and the new ones added.	Yes	No	No	No
`civil_read_table`Reads one MIDAS database table (GET /db/<TABLE>) from the open model, e.g. NODE, ELEM, SECT, GRUP, STLD, STAG, LLAN, MVLDBS, LCOM-GEN. Returns rows keyed by id: the ids asked for, or the first `limit` rows. Read-only.	Reads one MIDAS database table (GET /db/<TABLE>) from the open model, e.g. NODE, ELEM, SECT, GRUP, STLD, STAG, LLAN, MVLDBS, LCOM-GEN. Returns rows keyed by id: the ids asked for, or the first `limit` rows. Read-only.	Not declared	Yes	Not declared	No
`civil_remove_loads`Takes loads out of the model without touching other load cases: CIVIL NX keeps every case's beam loads, nodal loads, pressures and temperatures of an element or node in ONE row, so a plain delete would take the other cases with it — this tool rewrites each row with the items that stay. loads [{ case, on \| at (optional selection; default everywhere), kinds (optional: nodal, udl, pressure, temperature, gradient, selfWeight) }] removes that case's loads; deleteCases [names] removes the cases' loads and then the load cases themselves; supports { at }, springs { at }, releases { on } remove those at the selected nodes / elements. Selections as in civil_loads_supports. Previews what goes (counts per kind, rows touched, combinations that would lose a case); apply: true with confirmPlanHash. civil_write_tables_undo puts everything back, load cases included.	Takes loads out of the model without touching other load cases: CIVIL NX keeps every case's beam loads, nodal loads, pressures and temperatures of an element or node in ONE row, so a plain delete would take the other cases with it — this tool rewrites each row with the items that stay. loads [{ case, on \| at (optional selection; default everywhere), kinds (optional: nodal, udl, pressure, temperature, gradient, selfWeight) }] removes that case's loads; deleteCases [names] removes the cases' loads and then the load cases themselves; supports { at }, springs { at }, releases { on } remove those at the selected nodes / elements. Selections as in civil_loads_supports. Previews what goes (counts per kind, rows touched, combinations that would lose a case); apply: true with confirmPlanHash. civil_write_tables_undo puts everything back, load cases included.	Yes	No	No	No
`civil_run_analysis`Runs the CIVIL NX analysis of the open model (doc/ANAL), so results can be read with the result tools straight after building or changing a model. Replaces the model's results; changes no model data. The model must have been saved to a file at least once (the API cannot analyse an unsaved model): saveFirst: true saves it over its file first. Previews unless apply: true. Can take minutes on a large model.	Runs the CIVIL NX analysis of the open model (doc/ANAL), so results can be read with the result tools straight after building or changing a model. Replaces the model's results; changes no model data. The model must have been saved to a file at least once (the API cannot analyse an unsaved model): saveFirst: true saves it over its file first. Previews unless apply: true. Can take minutes on a large model.	No	No	Yes	No
`civil_save_model`Saves the open CIVIL NX model: over its own file (doc/SAVE), or as a new .mcb file when path is given (doc/SAVEAS; a file of that name is overwritten). A model built from scratch must be saved once before it can be analysed. Previews unless apply: true.	Saves the open CIVIL NX model: over its own file (doc/SAVE), or as a new .mcb file when path is given (doc/SAVEAS; a file of that name is overwritten). A model built from scratch must be saved once before it can be analysed. Previews unless apply: true.	No	No	Not declared	No
`civil_status`Checks the MAPI connection to CIVIL NX and summarises the open model: units, moving load code, row counts per table, structure/boundary/load group names, static load cases, stages, general combinations, and the most recent runs recorded for this key. Read-only. Call this first.	Checks the MAPI connection to CIVIL NX and summarises the open model: units, moving load code, row counts per table, structure/boundary/load group names, static load cases, stages, general combinations, and the most recent runs recorded for this key. Read-only. Call this first.	Not declared	Yes	Not declared	No
`civil_write_tables`Creates, changes or deletes rows in any CIVIL NX database table through the MIDAS API — nodes, elements, materials, sections, thicknesses, supports, links, load cases, loads, groups, stages, combinations, anything the API manual lists — so a model can be built from scratch or changed where no plugin tool does it. Look up the table and its fields first with midas_docs_search / midas_docs_read (e.g. "db/ELEM"), and read the current rows with civil_read_table. writes is a list of steps run in order: { table, op: create (POST — new keys only, refused if a key exists) \| upsert (PUT — creates or changes; GRUP lists and CNLD/BMLD/PRES/RIGD items MERGE, they are never removed by a PUT) \| delete (DESTRUCTIVE — needs allowDestructive; a node takes its elements, an element its loads, a load case its loads), rows: { "<key>": {fields} } \| ids: [keys] }. The preview simulates every step over the current model: what each creates, changes (which fields) and deletes; it blocks keys that already exist on create, elements that refer to nodes, materials, sections or thicknesses that do not exist (CIVIL NX accepts a missing section silently), deletes and UNIT / MVCD writes without allowDestructive. Then apply: true with confirmPlanHash writes the steps (stopping at the first refusal), reads every touched row back and reports anything not stored as sent. civil_write_tables_undo puts every touched row back.	Creates, changes or deletes rows in any CIVIL NX database table through the MIDAS API — nodes, elements, materials, sections, thicknesses, supports, links, load cases, loads, groups, stages, combinations, anything the API manual lists — so a model can be built from scratch or changed where no plugin tool does it. Look up the table and its fields first with midas_docs_search / midas_docs_read (e.g. "db/ELEM"), and read the current rows with civil_read_table. writes is a list of steps run in order: { table, op: create (POST — new keys only, refused if a key exists) \| upsert (PUT — creates or changes; GRUP lists and CNLD/BMLD/PRES/RIGD items MERGE, they are never removed by a PUT) \| delete (DESTRUCTIVE — needs allowDestructive; a node takes its elements, an element its loads, a load case its loads), rows: { "<key>": {fields} } \| ids: [keys] }. The preview simulates every step over the current model: what each creates, changes (which fields) and deletes; it blocks keys that already exist on create, elements that refer to nodes, materials, sections or thicknesses that do not exist (CIVIL NX accepts a missing section silently), deletes and UNIT / MVCD writes without allowDestructive. Then apply: true with confirmPlanHash writes the steps (stopping at the first refusal), reads every touched row back and reports anything not stored as sent. civil_write_tables_undo puts every touched row back.	Yes	No	No	No
`civil_write_tables_undo`Puts every row a civil_write_tables run touched back as it was before the run: deletes rows it created, restores rows it changed or deleted (a merging table's row is replaced whole). Works on a run that stopped part-way too. Warns where a row changed after the run. What CIVIL NX deleted along with a row (elements on a deleted node, loads on a deleted element) is not part of the run and does not come back. Default: the latest run not yet undone. Previews unless apply: true.	Puts every row a civil_write_tables run touched back as it was before the run: deletes rows it created, restores rows it changed or deleted (a merging table's row is replaced whole). Works on a run that stopped part-way too. Warns where a row changed after the run. What CIVIL NX deleted along with a row (elements on a deleted node, loads on a deleted element) is not part of the run and does not come back. Default: the latest run not yet undone. Previews unless apply: true.	Yes	No	Not declared	No
`combination_contributions`Load Combination Contribution Analyzer, step 2. Splits one or more load combinations' results at a set of items into the load cases that produced them: for every item, output point (beam I/J and intermediate points, plate nodes and centre), component and max/min, the signed contribution of each case, its share of the gross, and the governing permutation written out with factors multiplied down (e.g. 1.35Self weight(ST) + 1.5LM1(MV:max)). Add superposes; an Envelope is resolved to the child that governs at each item (the governing child is counted per envelope); ABS gives \|f·R\| shares; SRSS energy shares. Moving-load, settlement and response-spectrum cases enter at their max or min end. Construction-stage cases are read at the final stage's last step. Cases are identified by type and name together. EVERY item is recomposed and must match the value CIVIL NX reports for the combination at the same item, part, component and sense — if any does not, the run stops and nothing is reported. Returns per combination: the cases ranked by share of the gross over the run, cases zero everywhere, envelope governing counts, and the critical item (largest \|value\|) per component and sense with its full breakdown; rows largest \|value\| first; csv: true stores every row. Tables: BEAM, TRUSS, PLATE (per unit length, local axes), ELASTICLINK, GENLINK, REACTION (supported nodes only — CIVIL NX answers other nodes with a made-up total; zero reaction rows it omits are read as zero), DISPLACEMENT. Items in set syntax (elements 101to148, nodes N1toN20, general links L5, elastic links EL7) and/or structure groups (for node tables: the group's nodes plus the nodes of its elements). Read-only (only /post/TABLE reads). Runs as a job on the website.	Load Combination Contribution Analyzer, step 2. Splits one or more load combinations' results at a set of items into the load cases that produced them: for every item, output point (beam I/J and intermediate points, plate nodes and centre), component and max/min, the signed contribution of each case, its share of the gross, and the governing permutation written out with factors multiplied down (e.g. 1.35Self weight(ST) + 1.5LM1(MV:max)). Add superposes; an Envelope is resolved to the child that governs at each item (the governing child is counted per envelope); ABS gives \|f·R\| shares; SRSS energy shares. Moving-load, settlement and response-spectrum cases enter at their max or min end. Construction-stage cases are read at the final stage's last step. Cases are identified by type and name together. EVERY item is recomposed and must match the value CIVIL NX reports for the combination at the same item, part, component and sense — if any does not, the run stops and nothing is reported. Returns per combination: the cases ranked by share of the gross over the run, cases zero everywhere, envelope governing counts, and the critical item (largest \|value\|) per component and sense with its full breakdown; rows largest \|value\| first; csv: true stores every row. Tables: BEAM, TRUSS, PLATE (per unit length, local axes), ELASTICLINK, GENLINK, REACTION (supported nodes only — CIVIL NX answers other nodes with a made-up total; zero reaction rows it omits are read as zero), DISPLACEMENT. Items in set syntax (elements 101to148, nodes N1toN20, general links L5, elastic links EL7) and/or structure groups (for node tables: the group's nodes plus the nodes of its elements). Read-only (only /post/TABLE reads). Runs as a job on the website.	Not declared	Yes	Not declared	No
`combination_tree`Load Combination Contribution Analyzer, step 1. Without name: lists the model's General-tab load combinations (LCOM-GEN) with type (ADD, ENVELOPE, ABS, SRSS), constituent count, whether it is a max/min pair, and whether it can be decomposed (refused: time-history, unknown analysis type, undefined constituents, self-reference, a constituent whose type differs from the case of that name) — plus the result tables the model has items for (BEAM, TRUSS, PLATE, ELASTICLINK, GENLINK, REACTION, DISPLACEMENT) with their components and units, structure groups, construction stages and the model's units. With name: that combination's full tree (nested combinations, factors, kinds), the effective factor of every load case over all Add paths (a case reached down several branches gets the sum of the path products), and the envelopes / ABS / SRSS inside it. Read-only.	Load Combination Contribution Analyzer, step 1. Without name: lists the model's General-tab load combinations (LCOM-GEN) with type (ADD, ENVELOPE, ABS, SRSS), constituent count, whether it is a max/min pair, and whether it can be decomposed (refused: time-history, unknown analysis type, undefined constituents, self-reference, a constituent whose type differs from the case of that name) — plus the result tables the model has items for (BEAM, TRUSS, PLATE, ELASTICLINK, GENLINK, REACTION, DISPLACEMENT) with their components and units, structure groups, construction stages and the model's units. With name: that combination's full tree (nested combinations, factors, kinds), the effective factor of every load case over all Add paths (a case reached down several branches gets the sum of the path products), and the envelopes / ABS / SRSS inside it. Read-only.	Not declared	Yes	Not declared	No
`concurrent_forces`Concurrent Force Reporter, step 2. For a set of items (elements, nodes, links), finds the load state that makes ONE key effect extreme at ONE key item (max, min or absolute max over the selected load cases and combinations, at every output point), then reports every item's results IN THAT SAME STATE — the coexistent forces a bearing, pier cap or connection check needs, not each item's own envelope. If the governing load is an envelope (or an Add containing one), it is resolved recursively to a single deterministic state (a weighted sum of static/stage cases, pinning each envelope to the child that governs at the key item), re-read at that state, and gated against the value MIDAS itself reports; it refuses rather than approximates. Near-ties are reported. Items: items in set syntax — elements 12 or 15to20, nodes N12, general links L12, elastic links EL12 (a range keeps only ids that exist) — and/or structure groups. keyItem must be in the set. Values come back in the units asked for (default the model's); plate results are per unit length. Read-only (only /post/TABLE result reads). Call concurrent_forces_setup first for names and keyEffect ids. Runs as a job on the website.	Concurrent Force Reporter, step 2. For a set of items (elements, nodes, links), finds the load state that makes ONE key effect extreme at ONE key item (max, min or absolute max over the selected load cases and combinations, at every output point), then reports every item's results IN THAT SAME STATE — the coexistent forces a bearing, pier cap or connection check needs, not each item's own envelope. If the governing load is an envelope (or an Add containing one), it is resolved recursively to a single deterministic state (a weighted sum of static/stage cases, pinning each envelope to the child that governs at the key item), re-read at that state, and gated against the value MIDAS itself reports; it refuses rather than approximates. Near-ties are reported. Items: items in set syntax — elements 12 or 15to20, nodes N12, general links L12, elastic links EL12 (a range keeps only ids that exist) — and/or structure groups. keyItem must be in the set. Values come back in the units asked for (default the model's); plate results are per unit length. Read-only (only /post/TABLE result reads). Call concurrent_forces_setup first for names and keyEffect ids. Runs as a job on the website.	Not declared	Yes	Not declared	No
`concurrent_forces_probe`Concurrent Force Reporter diagnostics. For each result source the plugin reads (beam, truss, plate, general link, elastic link, node reaction, node displacement), asks this CIVIL NX build with one item of that kind which table token answers, the columns it returns and how they map, the output-point tokens, and the result series published. Use it when concurrent_forces reports a missing table, column or series. Read-only.	Concurrent Force Reporter diagnostics. For each result source the plugin reads (beam, truss, plate, general link, elastic link, node reaction, node displacement), asks this CIVIL NX build with one item of that kind which table token answers, the columns it returns and how they map, the output-point tokens, and the result series published. Use it when concurrent_forces reports a missing table, column or series. Read-only.	Not declared	Yes	Not declared	No
`concurrent_forces_setup`Concurrent Force Reporter, step 1. Reads the open CIVIL NX model the way the plugin does when it connects and lists what a concurrent-forces run can use: every load case and combination (all ten LCOM tables) with how MIDAS addresses it, whether it is envelope-valued, and whether it is AVAILABLE — moving load, settlement, response spectrum, ABS and SRSS (anywhere down the combination tree) cannot give a coexistent state and are listed with the reason and the workaround; the items the model has per result source (beam/truss/plate elements, general/elastic links, node reactions/displacements); the key effects available for them (keyEffect ids such as BEAM:Moment-y, REACTION:FZ, ELASTICLINK:Axial, with units); structure groups (element and node ranges, links found on their nodes); construction stages with their step tokens; criteria and output positions; the model's units; whether results are published. Read-only. Use search to narrow a long case list; includeConstituents shows each combination's children.	Concurrent Force Reporter, step 1. Reads the open CIVIL NX model the way the plugin does when it connects and lists what a concurrent-forces run can use: every load case and combination (all ten LCOM tables) with how MIDAS addresses it, whether it is envelope-valued, and whether it is AVAILABLE — moving load, settlement, response spectrum, ABS and SRSS (anywhere down the combination tree) cannot give a coexistent state and are listed with the reason and the workaround; the items the model has per result source (beam/truss/plate elements, general/elastic links, node reactions/displacements); the key effects available for them (keyEffect ids such as BEAM:Moment-y, REACTION:FZ, ELASTICLINK:Axial, with units); structure groups (element and node ranges, links found on their nodes); construction stages with their step tokens; criteria and output positions; the model's units; whether results are published. Read-only. Use search to narrow a long case list; includeConstituents shows each combination's children.	Not declared	Yes	Not declared	No
`construction_stages`Builds a construction stage sequence with the Construction Stage Wizard plugin's bulk generator and writes it with its stage planner (which keeps composite sections and construction-stage load combinations intact, rewriting and restoring them when CIVIL NX would otherwise delete them). Structure groups are activated in order, groupsPerStage at a time; boundary and load groups (e.g. supports, self weight) ride in the first new stage; an optional temporary group per stage (e.g. a form traveller) is switched on and off with it; an optional final stage closes the sequence. mode 'append' adds after the model's existing stages; 'replace' replaces them all. Every stage is validated against the model's groups first. Previews unless apply: true; the write keeps a snapshot for stages_undo.	Builds a construction stage sequence with the Construction Stage Wizard plugin's bulk generator and writes it with its stage planner (which keeps composite sections and construction-stage load combinations intact, rewriting and restoring them when CIVIL NX would otherwise delete them). Structure groups are activated in order, groupsPerStage at a time; boundary and load groups (e.g. supports, self weight) ride in the first new stage; an optional temporary group per stage (e.g. a form traveller) is switched on and off with it; an optional final stage closes the sequence. mode 'append' adds after the model's existing stages; 'replace' replaces them all. Every stage is validated against the model's groups first. Previews unless apply: true; the write keeps a snapshot for stages_undo.	Yes	No	Not declared	No
`create_nodes`Creates nodes in the open CIVIL NX model from X, Y, Z coordinates with the Node Generator plugin's own engine: every check the plugin window makes (blank or non-numeric coordinates, bad or duplicate ids, ids above 999999, ids that already exist, coincident nodes within a tolerance), its numbering modes and its write rules. Give the points as nodes [{id?, x, y, z}] or as table (text pasted from Excel or a CSV; a header like ID,X,Y,Z is recognised, decimal commas and semicolon CSVs too). Coordinates are in inputUnit (m or mm) plus an optional origin offset, and are converted to the model's length unit. numbering: 'auto' continues after the highest existing node id; 'start' uses start + increment; 'column' keeps the ids given (default when every row has one). An id that already exists blocks the write unless overwrite: true, which MOVES those nodes (and the elements on them). Coincident nodes are reported first; choose coincident: 'skip' or 'create'. Previews unless apply: true with confirmPlanHash; new nodes go by POST (create-only, so a node made since the preview is never overwritten), overwrites by PUT, then db/NODE is read back. create_nodes_undo reverses it.	Creates nodes in the open CIVIL NX model from X, Y, Z coordinates with the Node Generator plugin's own engine: every check the plugin window makes (blank or non-numeric coordinates, bad or duplicate ids, ids above 999999, ids that already exist, coincident nodes within a tolerance), its numbering modes and its write rules. Give the points as nodes [{id?, x, y, z}] or as table (text pasted from Excel or a CSV; a header like ID,X,Y,Z is recognised, decimal commas and semicolon CSVs too). Coordinates are in inputUnit (m or mm) plus an optional origin offset, and are converted to the model's length unit. numbering: 'auto' continues after the highest existing node id; 'start' uses start + increment; 'column' keeps the ids given (default when every row has one). An id that already exists blocks the write unless overwrite: true, which MOVES those nodes (and the elements on them). Coincident nodes are reported first; choose coincident: 'skip' or 'create'. Previews unless apply: true with confirmPlanHash; new nodes go by POST (create-only, so a node made since the preview is never overwritten), overwrites by PUT, then db/NODE is read back. create_nodes_undo reverses it.	Yes	No	No	No
`create_nodes_undo`Reverses a create_nodes run from the ledger: deletes the nodes it created and moves every node it overwrote back to its earlier coordinates. Refuses while elements, structure groups or supports use the nodes it created (undo those first). Default: the latest create_nodes run not yet undone. Previews unless apply: true.	Reverses a create_nodes run from the ledger: deletes the nodes it created and moves every node it overwrote back to its earlier coordinates. Refuses while elements, structure groups or supports use the nodes it created (undo those first). Default: the latest create_nodes run not yet undone. Previews unless apply: true.	Yes	No	Not declared	No
`cs_stage_report`Makes the Construction Stage Reporter plugin's own reports of the open model's construction stages and returns download links (never the file inline): the Excel workbook (summary, stage matrices for structure/boundary/load groups, group tables, stage details, composite sections, displacements, beam results, warnings) and the A4 PDF (cover, summary, matrices, one page per stage with a picture of CIVIL NX's own view of that stage from /view/CAPTURE, and the warnings). Construction-stage displacements (series, default Summation) are included when the analysis has been run; members (as cs_stage_results) adds one beam result component. The MP4 animation is not available here — use the plugin in CIVIL NX. Read-only, but the pictures make CIVIL NX show each stage in turn. Runs as a job.	Makes the Construction Stage Reporter plugin's own reports of the open model's construction stages and returns download links (never the file inline): the Excel workbook (summary, stage matrices for structure/boundary/load groups, group tables, stage details, composite sections, displacements, beam results, warnings) and the A4 PDF (cover, summary, matrices, one page per stage with a picture of CIVIL NX's own view of that stage from /view/CAPTURE, and the warnings). Construction-stage displacements (series, default Summation) are included when the analysis has been run; members (as cs_stage_results) adds one beam result component. The MP4 animation is not available here — use the plugin in CIVIL NX. Read-only, but the pictures make CIVIL NX show each stage in turn. Runs as a job.	Not declared	Yes	Not declared	No
`cs_stage_results`Reads construction-stage analysis results the way the Construction Stage Reporter plugin does (POST /post/TABLE in the construction-stage family, every stage in one query at its last step; stages after the analysis stopped carry the stage before and are flagged published:false). displacements (default on): per stage the largest resultant \|D\| over all nodes, its node and DX/DY/DZ, in mm; nodes:[ids] adds those nodes' displacements per stage. members: beam forces or stresses of chosen beams — per stage the max/min of a component over the beams active in it, with element, output position (I…J) and section part; detailElements:[ids] (≤20) adds the values along those beams. Units are the model's (forces/moments) and mm (displacements). series is a construction-stage result series (default Summation; listSeries: true lists what the model publishes, e.g. Dead Load, Tendon Primary, Creep Secondary). Needs a construction-stage analysis already run in CIVIL NX. Read-only; may take a minute on big models.	Reads construction-stage analysis results the way the Construction Stage Reporter plugin does (POST /post/TABLE in the construction-stage family, every stage in one query at its last step; stages after the analysis stopped carry the stage before and are flagged published:false). displacements (default on): per stage the largest resultant \|D\| over all nodes, its node and DX/DY/DZ, in mm; nodes:[ids] adds those nodes' displacements per stage. members: beam forces or stresses of chosen beams — per stage the max/min of a component over the beams active in it, with element, output position (I…J) and section part; detailElements:[ids] (≤20) adds the values along those beams. Units are the model's (forces/moments) and mm (displacements). series is a construction-stage result series (default Summation; listSeries: true lists what the model publishes, e.g. Dead Load, Tendon Primary, Creep Secondary). Needs a construction-stage analysis already run in CIVIL NX. Read-only; may take a minute on big models.	Not declared	Yes	Not declared	No
`cs_stage_summary`Reads the construction stage definition of the open CIVIL NX model with the Construction Stage Reporter plugin's engine and returns, per stage: duration and day range, the structure groups activated (with age and element count) and deactivated (with redistribution), boundary groups activated (deformed/original position) and deactivated, load groups activated/deactivated (first/last day), composite section parts (db/CSCS) that start acting, and the elements and boundary entities active after it. Also the composite sections, the whole-model summary, and the plugin's consistency checks (a group deactivated before it was activated, groups no stage uses, elements never activated, groups a stage names but the model lacks…). Read-only. elementIds: true adds the activated/deactivated element ids per stage; groups: true adds a row per group.	Reads the construction stage definition of the open CIVIL NX model with the Construction Stage Reporter plugin's engine and returns, per stage: duration and day range, the structure groups activated (with age and element count) and deactivated (with redistribution), boundary groups activated (deformed/original position) and deactivated, load groups activated/deactivated (first/last day), composite section parts (db/CSCS) that start acting, and the elements and boundary entities active after it. Also the composite sections, the whole-model summary, and the plugin's consistency checks (a group deactivated before it was activated, groups no stage uses, elements never activated, groups a stage names but the model lacks…). Read-only. elementIds: true adds the activated/deactivated element ids per stage; groups: true adds a row per group.	Not declared	Yes	Not declared	No
`cs454_combinations_apply`Generates CS 454 assessment load combinations with the plugin's engine (Table A.1 γfL by combination 1–4 and limit state, adverse/relieving permanent variants, wind sub-case, ALL/SV/HB traffic with associated traffic, exclusive groups collapsed into envelopes, readable names) and writes them to an LCOM table with its commit; every row is read back by name. Previews unless apply: true.	Generates CS 454 assessment load combinations with the plugin's engine (Table A.1 γfL by combination 1–4 and limit state, adverse/relieving permanent variants, wind sub-case, ALL/SV/HB traffic with associated traffic, exclusive groups collapsed into envelopes, readable names) and writes them to an LCOM table with its commit; every row is read back by name. Previews unless apply: true.	Yes	No	Not declared	No
`cs454_combinations_read`Reads the open model the way the CS 454 Load Assessment Combinations plugin does: every static, construction-stage, settlement and moving load case with the Table A.1 action / CS 454 load model and assessment level it proposes, each tab's gate, the defaults, the option lists (actions, load models, levels, group templates) and the combinations already in the LCOM tables. Read-only.	Reads the open model the way the CS 454 Load Assessment Combinations plugin does: every static, construction-stage, settlement and moving load case with the Table A.1 action / CS 454 load model and assessment level it proposes, each tab's gate, the defaults, the option lists (actions, load models, levels, group templates) and the combinations already in the LCOM tables. Read-only.	Not declared	Yes	Not declared	No
`cs454_combinations_undo`Undoes the latest cs454_combinations_apply run (or the run named) with the plugin's cleanup: deletes the rows it wrote that still carry its names (referencing rows first), then restores every table it cleared at the original keys. Previews unless apply: true.	Undoes the latest cs454_combinations_apply run (or the run named) with the plugin's cleanup: deletes the rows it wrote that still carry its names (referencing rows first), then restores every table it cleared at the original keys. Previews unless apply: true.	Yes	No	Not declared	No
`cs454_lane_layout`Lays out CS 454 notional lanes, remaining areas, footways and strips on a carriageway cross-section with the CS454 - Moving Load Wizard's own layout engine (Table 5.9a, cl 5.10, ALL model 1 single/convoy, ALL model 2, SV/HB routes and SV/HB with ALL), and lists the case groups each loading needs. Needs no model — use it to answer layout questions or to choose inputs before cs454_moving_loads.	Lays out CS 454 notional lanes, remaining areas, footways and strips on a carriageway cross-section with the CS454 - Moving Load Wizard's own layout engine (Table 5.9a, cl 5.10, ALL model 1 single/convoy, ALL model 2, SV/HB routes and SV/HB with ALL), and lists the case groups each loading needs. Needs no model — use it to answer layout questions or to choose inputs before cs454_moving_loads.	Not declared	Yes	Not declared	No
`cs454_moving_loads`CS 454 assessment live loading with the CS454 - Moving Load Wizard plugin's own engine: notional lanes laid out on the carriageway (line lanes on a grillage, surface lanes on a plate deck), ALL model 1/2 vehicles up to the chosen level, SV and HB routes or SV/HB with ALL (every SV type / HB rating crossed with every ALL vehicle), fire engines, user-defined and Irish Rail vehicles, the moving load cases with remaining areas, and envelope load combinations per family — each written and read back. It reads the deck from the model the way the plugin does unless reference/surface/section.width are given, and accepts the plugin's exported settings file. Without apply it only previews (lanes, vehicles, cases, stages, blockers, planHash). With apply: true it writes, records the run for cs454_moving_loads_undo, and never overwrites lanes, vehicles or cases it did not write.	CS 454 assessment live loading with the CS454 - Moving Load Wizard plugin's own engine: notional lanes laid out on the carriageway (line lanes on a grillage, surface lanes on a plate deck), ALL model 1/2 vehicles up to the chosen level, SV and HB routes or SV/HB with ALL (every SV type / HB rating crossed with every ALL vehicle), fire engines, user-defined and Irish Rail vehicles, the moving load cases with remaining areas, and envelope load combinations per family — each written and read back. It reads the deck from the model the way the plugin does unless reference/surface/section.width are given, and accepts the plugin's exported settings file. Without apply it only previews (lanes, vehicles, cases, stages, blockers, planHash). With apply: true it writes, records the run for cs454_moving_loads_undo, and never overwrites lanes, vehicles or cases it did not write.	No	No	Yes	No
`cs454_moving_loads_read`Read-only: changes nothing in the model. Call it before cs454_moving_loads to see what the CS454 - Moving Load Wizard would do. Returns: existing (the lanes, vehicles, cases and groups already in the model, each marked if an earlier cs454_moving_loads run created it); laneKindSuggestion (LINE for beams, SURFACE for plates); deckRead (reference girder or plate edge, width, kerb offset, cross-beam group, skew — narrowed by deckFilter, reversed by trafficOtherWay); the lanes and cases the given settings would produce; config (the plugin's own settings file — pass it back as configFile); options (valid loadings, vehicles and Irish Rail trains). Takes the same inputs as cs454_moving_loads; the write permissions (codeChange, unitSwitch) only change which blockers are listed.	Read-only: changes nothing in the model. Call it before cs454_moving_loads to see what the CS454 - Moving Load Wizard would do. Returns: existing (the lanes, vehicles, cases and groups already in the model, each marked if an earlier cs454_moving_loads run created it); laneKindSuggestion (LINE for beams, SURFACE for plates); deckRead (reference girder or plate edge, width, kerb offset, cross-beam group, skew — narrowed by deckFilter, reversed by trafficOtherWay); the lanes and cases the given settings would produce; config (the plugin's own settings file — pass it back as configFile); options (valid loadings, vehicles and Irish Rail trains). Takes the same inputs as cs454_moving_loads; the write permissions (codeChange, unitSwitch) only change which blockers are listed.	Not declared	Yes	Not declared	No
`cs454_moving_loads_undo`Removes the lanes, vehicles, cases, envelopes and groups a cs454_moving_loads run wrote, using the plugin's own cleanup (cases and envelopes first, bottom up, at most 100 per call): anything edited since the run, or still used by something else, is kept. Previews unless apply: true.	Removes the lanes, vehicles, cases, envelopes and groups a cs454_moving_loads run wrote, using the plugin's own cleanup (cases and envelopes first, bottom up, at most 100 per call): anything edited since the run, or still used by something else, is kept. Previews unless apply: true.	Yes	No	Not declared	No
`cs455_assess`CS 455 ULS assessment of reinforced concrete beam sections with the plugin's own engine: reads the concurrent force rows (BEAMFORCE / BEAMFORCEVBM for envelopes and moving loads, kN·m; a moving-load case from a model analysed without 'Normal + Concurrent Force' is refused as NOT CONCURRENT) at the chosen element ends for the chosen combinations, and runs every row — N–M flexure by strain-compatibility equilibrium, shear (additive approach, links optional), torsion (cl 5.17–5.27) — or, with member set to a column, pier or pile, the CS 455 Section 7 checks (N_uz, slenderness and additional moments, biaxial bending Eq 7.7.2a, bar restraint 7.6, shear 7.10.1 / Eq 7.11) — with status per row (PASS / FAIL / BLOCKED / OUTSIDE RANGE OF VALIDITY) and the utilisation of each check. Read-only. Takes a while for many rows (a job on the website).	CS 455 ULS assessment of reinforced concrete beam sections with the plugin's own engine: reads the concurrent force rows (BEAMFORCE / BEAMFORCEVBM for envelopes and moving loads, kN·m; a moving-load case from a model analysed without 'Normal + Concurrent Force' is refused as NOT CONCURRENT) at the chosen element ends for the chosen combinations, and runs every row — N–M flexure by strain-compatibility equilibrium, shear (additive approach, links optional), torsion (cl 5.17–5.27) — or, with member set to a column, pier or pile, the CS 455 Section 7 checks (N_uz, slenderness and additional moments, biaxial bending Eq 7.7.2a, bar restraint 7.6, shear 7.10.1 / Eq 7.11) — with status per row (PASS / FAIL / BLOCKED / OUTSIDE RANGE OF VALIDITY) and the utilisation of each check. Read-only. Takes a while for many rows (a job on the website).	Not declared	Yes	Not declared	No
`cs455_describe_section`Start here when the user shares a reinforcement drawing, photo or schedule. Read from it: cover, for each face the layers (number of bars or spacing, and Ø - mm, inches or #US sizes are all accepted), side bars, links (Ø, legs, spacing); then call this tool. It reads one beam section from the open model through the shared MIDAS section library (outline checked against CIVIL NX's published properties), places the bars with the CS 455 plugin's own placement (cover to every edge) and RETURNS A DRAWING of the section with every bar placed - compare it with the user's drawing and correct rebar until they match (ask the user about anything the drawing does not show, e.g. cover). Then cs455_export_calc_sheet gives the report. Also returns what the plugin's engine derives: area, centroid, depth, usable_for_capacity, parts, the bars placed per schedule row (or why a row failed), and the model's concrete grade. Read-only.	Start here when the user shares a reinforcement drawing, photo or schedule. Read from it: cover, for each face the layers (number of bars or spacing, and Ø - mm, inches or #US sizes are all accepted), side bars, links (Ø, legs, spacing); then call this tool. It reads one beam section from the open model through the shared MIDAS section library (outline checked against CIVIL NX's published properties), places the bars with the CS 455 plugin's own placement (cover to every edge) and RETURNS A DRAWING of the section with every bar placed - compare it with the user's drawing and correct rebar until they match (ask the user about anything the drawing does not show, e.g. cover). Then cs455_export_calc_sheet gives the report. Also returns what the plugin's engine derives: area, centroid, depth, usable_for_capacity, parts, the bars placed per schedule row (or why a row failed), and the model's concrete grade. Read-only.	Not declared	Yes	Not declared	No
`cs455_export_calc_sheet`The report. Assesses one element end exactly as cs455_assess and writes the plugin's reference-format calculation sheet (.xlsx: A4 pages, title block, geometry, materials, reinforcement, section properties, sagging/hogging bending, shear and torsion with live formulas and charts (for a column, pier or pile: effective heights, N_uz, the governing biaxial bending and shear rows and a table of every row), summary of results, and a Summary sheet with demand, resistance and ratio per check). Returns a download link. Use the same rebar/links that cs455_describe_section confirmed against the user's drawing. Read-only on the model.	The report. Assesses one element end exactly as cs455_assess and writes the plugin's reference-format calculation sheet (.xlsx: A4 pages, title block, geometry, materials, reinforcement, section properties, sagging/hogging bending, shear and torsion with live formulas and charts (for a column, pier or pile: effective heights, N_uz, the governing biaxial bending and shear rows and a table of every row), summary of results, and a Summary sheet with demand, resistance and ratio per check). Returns a download link. Use the same rebar/links that cs455_describe_section confirmed against the user's drawing. Read-only on the model.	Not declared	Yes	Not declared	No
`culvert_analyse_and_check`On the culvert model built from the same inputs (refused if the open model's counts differ): runs the CIVIL NX analysis (unless analyse: false), reads the basic-case results (forces, reactions, displacements) and runs the plugin's checks — every Annex A2 combination and vehicle position: ULS flexure and shear, SLS stresses and crack width, detailing, bearing and uplift. Returns the verdict and the governing locations. Takes minutes: a job on the website.	On the culvert model built from the same inputs (refused if the open model's counts differ): runs the CIVIL NX analysis (unless analyse: false), reads the basic-case results (forces, reactions, displacements) and runs the plugin's checks — every Annex A2 combination and vehicle position: ULS flexure and shear, SLS stresses and crack width, detailing, bearing and uplift. Returns the verdict and the governing locations. Takes minutes: a job on the website.	No	No	Not declared	No
`culvert_build`Writes the 2D Culvert model exactly as the plugin's Build: units, user material, sections, frame, soil springs, supports, every basic load case with its loads, and the nested EN 1990 Annex A2 combinations; then reads the loads back and fails if CIVIL NX dropped any. Into the open model only if it is empty, or into a new document (newDocument: true — DESTRUCTIVE: CIVIL NX replaces the open model). Previews unless apply: true.	Writes the 2D Culvert model exactly as the plugin's Build: units, user material, sections, frame, soil springs, supports, every basic load case with its loads, and the nested EN 1990 Annex A2 combinations; then reads the loads back and fails if CIVIL NX dropped any. Into the open model only if it is empty, or into a new document (newDocument: true — DESTRUCTIVE: CIVIL NX replaces the open model). Previews unless apply: true.	Yes	No	Not declared	No
`culvert_build_undo`Deletes every row a culvert_build wrote (combinations, loads, load cases, springs, supports, groups, elements, nodes, sections, material) from the ledger's record, and puts back the model's units. A model replaced by newDocument cannot be brought back. Previews unless apply: true.	Deletes every row a culvert_build wrote (combinations, loads, load cases, springs, supports, groups, elements, nodes, sections, material) from the ledger's record, and puts back the model's units. A model replaced by newDocument cannot be brought back. Previews unless apply: true.	Yes	No	Not declared	No
`culvert_preview`Validates a 2D Culvert project with the plugin's own Eurocode core and returns what it would build: nodes, elements, soil springs, basic load cases (traffic unit cases), the EN 1990 Annex A2 combination counts (ULS, SLS characteristic, quasi-permanent) and the nested CIVIL NX combinations, check locations, earth-pressure basis (K0 / PD 6694-1 Annex B / cl 9.4 K*) and derived geometry. Needs no model.	Validates a 2D Culvert project with the plugin's own Eurocode core and returns what it would build: nodes, elements, soil springs, basic load cases (traffic unit cases), the EN 1990 Annex A2 combination counts (ULS, SLS characteristic, quasi-permanent) and the nested CIVIL NX combinations, check locations, earth-pressure basis (K0 / PD 6694-1 Annex B / cl 9.4 K*) and derived geometry. Needs no model.	Not declared	Yes	Not declared	No
`culvert_report`Runs the checks on the analysed culvert model (as culvert_analyse_and_check, without re-analysing unless analyse: true) and writes the plugin's report: format xlsx (default) = the calculation book in the MIDAS report format with result diagrams captured from CIVIL NX, pdf, or both (one run of the checks). Returns download links.	Runs the checks on the analysed culvert model (as culvert_analyse_and_check, without re-analysing unless analyse: true) and writes the plugin's report: format xlsx (default) = the calculation book in the MIDAS report format with result diagrams captured from CIVIL NX, pdf, or both (one run of the checks). Returns download links.	Not declared	Yes	Not declared	No
`dxf_import`Imports a DXF into the open CIVIL NX model with the Advanced DXF Importer plugin's engine: the same parse, layer mapping, clean-up and write as the plugin. Nodes and elements get new ids above the model's (existing rows are never overwritten); each layer's structure group is created or added to; blank properties become the plugin's DXF default material (C40/50), section (SB 500x300) and thickness (250), created or reused by name. Previews by default (writes nothing): the plan with id ranges, groups, default properties and any unit switch. To write, call again with the same inputs, apply: true and confirmPlanHash; the model is read again and the write refused if the plan changed. The write creates a master group DXF_<file> #<token> first, then the unit change, properties, nodes, elements and groups, then reads everything back to verify. The import journal is recorded so dxf_import_undo can remove exactly what it created, even after a partial failure. Inputs as for dxf_inspect, plus mergeExisting.	Imports a DXF into the open CIVIL NX model with the Advanced DXF Importer plugin's engine: the same parse, layer mapping, clean-up and write as the plugin. Nodes and elements get new ids above the model's (existing rows are never overwritten); each layer's structure group is created or added to; blank properties become the plugin's DXF default material (C40/50), section (SB 500x300) and thickness (250), created or reused by name. Previews by default (writes nothing): the plan with id ranges, groups, default properties and any unit switch. To write, call again with the same inputs, apply: true and confirmPlanHash; the model is read again and the write refused if the plan changed. The write creates a master group DXF_<file> #<token> first, then the unit change, properties, nodes, elements and groups, then reads everything back to verify. The import journal is recorded so dxf_import_undo can remove exactly what it created, even after a partial failure. Inputs as for dxf_inspect, plus mergeExisting.	Yes	No	Not declared	Yes
`dxf_import_undo`Removes what one dxf_import created, with the plugin's own removal rules: it refuses unless the import's master group is in the open model; deletes the import's elements, then its nodes, only where they still match the fingerprint taken before writing (anything edited since is kept, and a node another element uses is kept); deletes the groups and default properties it created once nothing uses them; switches the model's length unit back if the import changed it and it is unchanged since. Works after a partial import too. Default: the latest dxf_import not yet undone. Previews (what would be removed and kept) unless apply: true.	Removes what one dxf_import created, with the plugin's own removal rules: it refuses unless the import's master group is in the open model; deletes the import's elements, then its nodes, only where they still match the fingerprint taken before writing (anything edited since is kept, and a node another element uses is kept); deletes the groups and default properties it created once nothing uses them; switches the model's length unit back if the import changed it and it is unchanged since. Works after a partial import too. Default: the latest dxf_import not yet undone. Previews (what would be removed and kept) unless apply: true.	Yes	No	Not declared	No
`dxf_inspect`Reads a DXF with the Advanced DXF Importer plugin's own parser and clean-up and reports what an import would create: the file (version, encoding, entity counts, what is ignored or unsupported), its units, every layer with its entities and mapping, and the clean model — nodes, BEAM/TRUSS/PLATE elements per layer, structure groups, disconnected parts, and the clean-up operations (merged nodes, removed duplicates and zero-length segments, splits at crossings and T-junctions, hanging nodes). Needs no CIVIL NX model and changes nothing. Give the drawing as dxfText, dxfBase64 or url (4 MB inline, 25 MB by url). Use it to choose the mapping and settings before dxf_import. Lengths in the report are in the unit the import works in (importIn).	Reads a DXF with the Advanced DXF Importer plugin's own parser and clean-up and reports what an import would create: the file (version, encoding, entity counts, what is ignored or unsupported), its units, every layer with its entities and mapping, and the clean model — nodes, BEAM/TRUSS/PLATE elements per layer, structure groups, disconnected parts, and the clean-up operations (merged nodes, removed duplicates and zero-length segments, splits at crossings and T-junctions, hanging nodes). Needs no CIVIL NX model and changes nothing. Give the drawing as dxfText, dxfBase64 or url (4 MB inline, 25 MB by url). Use it to choose the mapping and settings before dxf_import. Lengths in the report are in the unit the import works in (importIn).	Not declared	Yes	Not declared	Yes
`ec_combinations_apply`Generates EN 1990 bridge load combinations with the Eurocode Load Combinations plugin's engine (6.10 / 6.10a+b, SLS characteristic / frequent / quasi-permanent, accidental 6.11, seismic 6.12; Annex A2 ψ by bridge type; recommended, UK or Irish annex factors; leading-action and exclusive-alternative logic) and writes them to an LCOM table with its commit: the target is re-read first, every row is read back. Previews unless apply: true.	Generates EN 1990 bridge load combinations with the Eurocode Load Combinations plugin's engine (6.10 / 6.10a+b, SLS characteristic / frequent / quasi-permanent, accidental 6.11, seismic 6.12; Annex A2 ψ by bridge type; recommended, UK or Irish annex factors; leading-action and exclusive-alternative logic) and writes them to an LCOM table with its commit: the target is re-read first, every row is read back. Previews unless apply: true.	Yes	No	Not declared	No
`ec_combinations_read`Reads the open model the way the Eurocode Load Combinations plugin does: every static, moving (characteristic/frequent pairs), construction-stage, settlement and response-spectrum case with the action and subtype the plugin proposes, the detected bridge type, the default scope and factors (EN 1990 Annex A2 recommended, UK NA or Irish NA), each tab's gate, and the combinations already in the LCOM tables. Read-only.	Reads the open model the way the Eurocode Load Combinations plugin does: every static, moving (characteristic/frequent pairs), construction-stage, settlement and response-spectrum case with the action and subtype the plugin proposes, the detected bridge type, the default scope and factors (EN 1990 Annex A2 recommended, UK NA or Irish NA), each tab's gate, and the combinations already in the LCOM tables. Read-only.	Not declared	Yes	Not declared	No
`ec_combinations_undo`Undoes the latest ec_combinations_apply run (or the run named) with the plugin's undo: deletes the rows it wrote that still carry its names, then restores the rows it deleted at their original keys. Previews unless apply: true.	Undoes the latest ec_combinations_apply run (or the run named) with the plugin's undo: deletes the rows it wrote that still carry its names, then restores the rows it deleted at their original keys. Previews unless apply: true.	Yes	No	Not declared	No
`ec_lane_layout`Lays out EN 1991-2 lanes on a carriageway cross-section with the Eurocode - Moving Load Wizard's own layout engine: Table 4.1 notional lanes and the remaining area, footways, the LM2 axle lane, the LM4 crowd lane, an LM3 special vehicle route and rail tracks, as the chosen loading needs, with each lane's role. Needs no model.	Lays out EN 1991-2 lanes on a carriageway cross-section with the Eurocode - Moving Load Wizard's own layout engine: Table 4.1 notional lanes and the remaining area, footways, the LM2 axle lane, the LM4 crowd lane, an LM3 special vehicle route and rail tracks, as the chosen loading needs, with each lane's role. Needs no model.	Not declared	Yes	Not declared	No
`ec_moving_loads`EN 1991-2 traffic loading with the Eurocode - Moving Load Wizard plugin's own engine: lanes laid out on the carriageway (line lanes on a grillage, surface lanes on a plate deck) for the chosen load groups gr1a / gr1b / gr3 / gr4 / gr5, fatigue models and rail (LM71, SW/0, SW/2, HSLM, Irish Rail trains), the MIDAS vehicles with the EN or UK alpha factors, and the moving load cases (characteristic / frequent) — each written and read back. It reads the deck from the model the way the plugin does unless reference/surface/section.width are given, and accepts the plugin's exported settings file. Without apply it only previews (lanes, vehicles, cases, stages, blockers, planHash). With apply: true it writes, records the run for ec_moving_loads_undo, and never overwrites lanes, vehicles or cases it did not write.	EN 1991-2 traffic loading with the Eurocode - Moving Load Wizard plugin's own engine: lanes laid out on the carriageway (line lanes on a grillage, surface lanes on a plate deck) for the chosen load groups gr1a / gr1b / gr3 / gr4 / gr5, fatigue models and rail (LM71, SW/0, SW/2, HSLM, Irish Rail trains), the MIDAS vehicles with the EN or UK alpha factors, and the moving load cases (characteristic / frequent) — each written and read back. It reads the deck from the model the way the plugin does unless reference/surface/section.width are given, and accepts the plugin's exported settings file. Without apply it only previews (lanes, vehicles, cases, stages, blockers, planHash). With apply: true it writes, records the run for ec_moving_loads_undo, and never overwrites lanes, vehicles or cases it did not write.	No	No	Yes	No
`ec_moving_loads_read`Read-only: changes nothing in the model. Call it before ec_moving_loads to see what the Eurocode - Moving Load Wizard would do. Returns: existing (the lanes, vehicles, cases and groups already in the model, each marked if an earlier ec_moving_loads run created it); laneKindSuggestion (LINE for beams, SURFACE for plates); deckRead (reference girder or plate edge, width, kerb offset, cross-beam group, skew — narrowed by deckFilter, reversed by trafficOtherWay); the lanes, lane roles and cases the given settings would produce; config (the plugin's own settings file — pass it back as configFile); options (valid load groups, vehicles and Irish Rail trains). Takes the same inputs as ec_moving_loads; the write permissions (codeChange, unitSwitch) only change which blockers are listed.	Read-only: changes nothing in the model. Call it before ec_moving_loads to see what the Eurocode - Moving Load Wizard would do. Returns: existing (the lanes, vehicles, cases and groups already in the model, each marked if an earlier ec_moving_loads run created it); laneKindSuggestion (LINE for beams, SURFACE for plates); deckRead (reference girder or plate edge, width, kerb offset, cross-beam group, skew — narrowed by deckFilter, reversed by trafficOtherWay); the lanes, lane roles and cases the given settings would produce; config (the plugin's own settings file — pass it back as configFile); options (valid load groups, vehicles and Irish Rail trains). Takes the same inputs as ec_moving_loads; the write permissions (codeChange, unitSwitch) only change which blockers are listed.	Not declared	Yes	Not declared	No
`ec_moving_loads_undo`Removes the lanes, vehicles, cases and groups an ec_moving_loads run wrote, using the plugin's own cleanup (cases first, bottom up, at most 100 per call): anything edited since the run, or still used by something else, is kept. Previews unless apply: true.	Removes the lanes, vehicles, cases and groups an ec_moving_loads run wrote, using the plugin's own cleanup (cases first, bottom up, at most 100 per call): anything edited since the run, or still used by something else, is kept. Previews unless apply: true.	Yes	No	Not declared	No
`ec_wind_apply`Calculates wind on the deck (EN 1991-1-4 §8, or CS 454 Appendix D with code: CS454) and writes it with the Wind Load Calculator plugin's adapter: one load case per global direction (EC1W_ for EN, C454W_ for CS 454), then beam loads (beam deck) or a pressure + fascia nodal loads (plate deck) on the target elements — one element written and read back first, then the rest, with a direction audit. Target: elementIds, a structure group, or (neither) the deck the plugin finds itself. Previews unless apply: true.	Calculates wind on the deck (EN 1991-1-4 §8, or CS 454 Appendix D with code: CS454) and writes it with the Wind Load Calculator plugin's adapter: one load case per global direction (EC1W_ for EN, C454W_ for CS 454), then beam loads (beam deck) or a pressure + fascia nodal loads (plate deck) on the target elements — one element written and read back first, then the rest, with a direction audit. Target: elementIds, a structure group, or (neither) the deck the plugin finds itself. Previews unless apply: true.	No	No	Not declared	No
`ec_wind_bridge`Calculates wind on a bridge deck with the Wind Load Calculator plugin's own engine (formerly Eurocode Wind Loads). code EN: EN 1991-1-4 §8 — v_b, q_p(z_e), c_sc_d, d_tot, the transverse (x), longitudinal (y) and vertical (z, at e = ±b/4) forces, wind with traffic. code CS454: CS 454 Appendix D — Vs, Vd, Vr, C_D (Figure D.6), C_L, parapet, longitudinal, vertical (at the centroid) and live-load wind, or the cl 5.33.1 simplified model. Returns the load cases the plugin would write. Needs no model.	Calculates wind on a bridge deck with the Wind Load Calculator plugin's own engine (formerly Eurocode Wind Loads). code EN: EN 1991-1-4 §8 — v_b, q_p(z_e), c_sc_d, d_tot, the transverse (x), longitudinal (y) and vertical (z, at e = ±b/4) forces, wind with traffic. code CS454: CS 454 Appendix D — Vs, Vd, Vr, C_D (Figure D.6), C_L, parapet, longitudinal, vertical (at the centroid) and live-load wind, or the cl 5.33.1 simplified model. Returns the load cases the plugin would write. Needs no model.	Not declared	Yes	Not declared	No
`ec_wind_read_deck`Reads the open model the way the Wind Load Calculator plugin does: finds the deck (or measures the elements / group given), and reports b, d, L, the soffit height, the span axis, whether the deck is beams or plates, and a structural-form guess. Read-only.	Reads the open model the way the Wind Load Calculator plugin does: finds the deck (or measures the elements / group given), and reports b, d, L, the soffit height, the span axis, whether the deck is beams or plates, and a structural-form guess. Read-only.	Not declared	Yes	Not declared	No
`ec_wind_remove`Removes what the Wind Load Calculator plugin writes: every EC1W_ and C454W_ load case, its load group, and their beam/pressure/nodal loads — whether this tool or the plugin window wrote them. Loads anyone else put on the same elements are kept. Previews unless apply: true.	Removes what the Wind Load Calculator plugin writes: every EC1W_ and C454W_ load case, its load group, and their beam/pressure/nodal loads — whether this tool or the plugin window wrote them. Loads anyone else put on the same elements are kept. Previews unless apply: true.	Yes	No	Not declared	No
`ec2_describe_section`Start here for an EN 1992 section check. Reads one beam section of the open model through the shared MIDAS section library (any CIVIL NX section family; composite deck slabs as separate regions; tapered sections per end), places the bars from the given schedule with the Eurocode Section Checker's own placement and, for a prestressed beam, the tendons - and RETURNS A DRAWING of the section with every bar and tendon. Compare it with the user's drawing and correct rebar / psc.tendons until they match, then call ec2_section_check. Also returns depth, width, area, the bars placed per schedule row (or why a row failed), the concrete class read from the model material and the member type / length the model suggests. An unknown sectionId is answered with the model's beam sections. Read-only.	Start here for an EN 1992 section check. Reads one beam section of the open model through the shared MIDAS section library (any CIVIL NX section family; composite deck slabs as separate regions; tapered sections per end), places the bars from the given schedule with the Eurocode Section Checker's own placement and, for a prestressed beam, the tendons - and RETURNS A DRAWING of the section with every bar and tendon. Compare it with the user's drawing and correct rebar / psc.tendons until they match, then call ec2_section_check. Also returns depth, width, area, the bars placed per schedule row (or why a row failed), the concrete class read from the model material and the member type / length the model suggests. An unknown sectionId is answered with the model's beam sections. Read-only.	Not declared	Yes	Not declared	No
`ec2_export_calc_sheet`The report. Runs the check exactly as ec2_section_check and writes the plugin's calculation sheet (.xlsx in the CS 455 reference format, EN 1992 content, live formulas): one sheet per section - geometry, materials, reinforcement (and tendons with P_m0 / P_m,inf), section properties, and the governing row of each check printed in full (sagging and hogging bending, shear, torsion, SLS stresses, crack width; prestressed / composite: transfer, stage stresses, interface shear, decompression) - plus a Summary sheet with demand, resistance and ratio per check. Returns a download link. Use the same inputs that ec2_describe_section confirmed against the user's drawing. Read-only on the model.	The report. Runs the check exactly as ec2_section_check and writes the plugin's calculation sheet (.xlsx in the CS 455 reference format, EN 1992 content, live formulas): one sheet per section - geometry, materials, reinforcement (and tendons with P_m0 / P_m,inf), section properties, and the governing row of each check printed in full (sagging and hogging bending, shear, torsion, SLS stresses, crack width; prestressed / composite: transfer, stage stresses, interface shear, decompression) - plus a Summary sheet with demand, resistance and ratio per check. Returns a download link. Use the same inputs that ec2_describe_section confirmed against the user's drawing. Read-only on the model.	Not declared	Yes	Not declared	No
`ec2_section_check`EN 1992-1-1 / EN 1992-2 check of concrete beam, column, pier and pile sections with the Eurocode Section Checker plugin's own engine. Reads the concurrent force sets at the chosen stations for the chosen combinations (BEAMFORCE for plain combinations; BEAMFORCEVBM for envelopes and moving loads, with the concurrency guard - a combination with no concurrent sets is checked at the corners of its force box, never mixed), then checks every row: ULS biaxial bending with axial force (fibre section), shear Vz and Vy (6.2), torsion (6.3), detailing; SLS stresses (7.2) and crack width (7.3) under characteristic / quasi-permanent rows; columns and piles to 5.8 (slenderness, imperfections, nominal curvature). Prestressed beams (psc): transfer stresses, stage-by-stage stresses with the girder alone and the composite section, ULS with the tendons' strain, shear with prestress, interface shear (6.2.5), decompression and crack width (Table 7.1N / 7.101N). Returns the verdict, the governing row of every check per section, the worst rows and what was not covered. Read-only; a job on the website.	EN 1992-1-1 / EN 1992-2 check of concrete beam, column, pier and pile sections with the Eurocode Section Checker plugin's own engine. Reads the concurrent force sets at the chosen stations for the chosen combinations (BEAMFORCE for plain combinations; BEAMFORCEVBM for envelopes and moving loads, with the concurrency guard - a combination with no concurrent sets is checked at the corners of its force box, never mixed), then checks every row: ULS biaxial bending with axial force (fibre section), shear Vz and Vy (6.2), torsion (6.3), detailing; SLS stresses (7.2) and crack width (7.3) under characteristic / quasi-permanent rows; columns and piles to 5.8 (slenderness, imperfections, nominal curvature). Prestressed beams (psc): transfer stresses, stage-by-stage stresses with the girder alone and the composite section, ULS with the tendons' strain, shear with prestress, interface shear (6.2.5), decompression and crack width (Table 7.1N / 7.101N). Returns the verdict, the governing row of every check per section, the worst rows and what was not covered. Read-only; a job on the website.	Not declared	Yes	Not declared	No
`export_result_tables`Exports one or more CIVIL NX tables (each like the preview_result_table arguments, full scope, no sampling) into one Excel workbook built by the exporter plugin: one sheet per table (and per sub-table; split above 1,048,575 rows), unit-labelled headers, numeric cells, and a 'Contents & Export Log' sheet listing each table's request, rows and any failure. format csv gives one CSV file per sheet instead. Returns download links (never the file inline) and a per-table summary; a table that fails is logged and the rest still export. Read-only. Can run long on big models, so it runs as a job on the website.	Exports one or more CIVIL NX tables (each like the preview_result_table arguments, full scope, no sampling) into one Excel workbook built by the exporter plugin: one sheet per table (and per sub-table; split above 1,048,575 rows), unit-labelled headers, numeric cells, and a 'Contents & Export Log' sheet listing each table's request, rows and any failure. format csv gives one CSV file per sheet instead. Returns download links (never the file inline) and a per-table summary; a table that fails is logged and the rest still export. Read-only. Can run long on big models, so it runs as a job on the website.	Not declared	Yes	Not declared	No
`job_status`Status, progress and (when finished) the result of a tool call that returned a jobId. Poll every few seconds until status is done or failed.	Status, progress and (when finished) the result of a tool call that returned a jobId. Poll every few seconds until status is done or failed.	Not declared	Yes	Not declared	No
`midas_docs_read`Reads one MIDAS help-centre article in full, as Markdown: headings, notes, input tables, and for the MIDAS API manual the URI, methods, JSON schema and JSON examples as code blocks. Also lists the article's images (links). Long articles come in parts: call again with nextOffset. Give the user the article's url when you rely on it. Needs no model and no account.	Reads one MIDAS help-centre article in full, as Markdown: headings, notes, input tables, and for the MIDAS API manual the URI, methods, JSON schema and JSON examples as code blocks. Also lists the article's images (links). Long articles come in parts: call again with nextOffset. Give the user the article's url when you rely on it. Needs no model and no account.	Not declared	Yes	Not declared	Yes
`midas_docs_search`Searches the MIDAS help centre (support.midasuser.com), live: the CIVIL NX and GEN NX online help (every dialog: what it does, where it is in the menus, each input), the MIDAS API (MAPI) JSON manual (every db/ table, its URI, methods, JSON schema and examples), FAQ, tutorials and release notes. Use it to answer how-to and what-does-this-input-mean questions, to check CIVIL NX behaviour before advising, and to find the JSON shape of a MAPI table. English articles. Returns the matching articles (id, title, area, section, snippet, link); read one in full with midas_docs_read. Areas default to CIVIL NX help + API manual + FAQ + tutorials. Needs no model and no account.	Searches the MIDAS help centre (support.midasuser.com), live: the CIVIL NX and GEN NX online help (every dialog: what it does, where it is in the menus, each input), the MIDAS API (MAPI) JSON manual (every db/ table, its URI, methods, JSON schema and examples), FAQ, tutorials and release notes. Use it to answer how-to and what-does-this-input-mean questions, to check CIVIL NX behaviour before advising, and to find the JSON shape of a MAPI table. English articles. Returns the matching articles (id, title, area, section, snippet, link); read one in full with midas_docs_read. Areas default to CIVIL NX help + API manual + FAQ + tutorials. Needs no model and no account.	Not declared	Yes	Not declared	Yes
`midas_library`Structured reference for writing a CIVIL NX model through the API (civil_write_tables): the material standard names CIVIL NX knows (46 concrete standards), material fields per type, grades known to work, every user section shape with the order of its dimensions (vSIZE), catalogue section examples, plate thickness, beam / truss / plate element rows and plate STYPE codes, support constraint strings, load case / self weight / nodal load / combination rows, creep-shrinkage and strength-gain code options — each with its source: MIDAS IT's open-source midas-civil-python library (MIT), the MIDAS API manual, or behaviour measured on live CIVIL NX. Also every option list in midas-civil-python (148): the 67 static load case types, beam / pressure / plane load options, combination types, the 15 moving-load codes with their standard vehicles (Eurocode LM1–LM4 incl. UK NA SV/SOV, fatigue and rail; Indian road and rail), point springs and elastic links, temperature, tendons and prestress, construction stages, response spectrum / time history, units and result components. The grade lists inside each standard and the steel section catalogues are CIVIL NX's own and published nowhere: the answer says how to confirm one safely. Topics: overview, materials, sections (shape: one shape), thickness, elements, supports, loads, moving_loads, boundaries, temperature, tendons, construction, dynamic, units, results, time_dependent, python; search alone looks through every list and vehicle. Needs no model and no account.	Structured reference for writing a CIVIL NX model through the API (civil_write_tables): the material standard names CIVIL NX knows (46 concrete standards), material fields per type, grades known to work, every user section shape with the order of its dimensions (vSIZE), catalogue section examples, plate thickness, beam / truss / plate element rows and plate STYPE codes, support constraint strings, load case / self weight / nodal load / combination rows, creep-shrinkage and strength-gain code options — each with its source: MIDAS IT's open-source midas-civil-python library (MIT), the MIDAS API manual, or behaviour measured on live CIVIL NX. Also every option list in midas-civil-python (148): the 67 static load case types, beam / pressure / plane load options, combination types, the 15 moving-load codes with their standard vehicles (Eurocode LM1–LM4 incl. UK NA SV/SOV, fatigue and rail; Indian road and rail), point springs and elastic links, temperature, tendons and prestress, construction stages, response spectrum / time history, units and result components. The grade lists inside each standard and the steel section catalogues are CIVIL NX's own and published nowhere: the answer says how to confirm one safely. Topics: overview, materials, sections (shape: one shape), thickness, elements, supports, loads, moving_loads, boundaries, temperature, tendons, construction, dynamic, units, results, time_dependent, python; search alone looks through every list and vehicle. Needs no model and no account.	Not declared	Yes	Not declared	No
`model_bridge_summary`Reads the open model's geometry tables and CIVIL NX's computed section properties and reports the bridge the Model to IFC plugin finds in it: girder lines, piers and pylons (station, elements, bearings, foundations), abutments, bearings, the deck alignment and its line/arc fit, the joined deck, every section in use with how its outline was rebuilt and its area difference from CIVIL NX, tendons, weightless members left out, volumes per material. Read-only; writes no file. Use it before model_to_ifc / model_to_dxf, or to sanity-check a model.	Reads the open model's geometry tables and CIVIL NX's computed section properties and reports the bridge the Model to IFC plugin finds in it: girder lines, piers and pylons (station, elements, bearings, foundations), abutments, bearings, the deck alignment and its line/arc fit, the joined deck, every section in use with how its outline was rebuilt and its area difference from CIVIL NX, tendons, weightless members left out, volumes per material. Read-only; writes no file. Use it before model_to_ifc / model_to_dxf, or to sanity-check a model.	Not declared	Yes	Not declared	No
`model_health_check`One read-only check of the open CIVIL NX model for anything that is likely wrong, grouped into areas with a red/amber/green status each. DATA (no analysis needed): the Model Report's fourteen QC checks plus warped / badly shaped plates, plates facing the other way from their neighbours, nodes lying on an element without being joined to it (mesh cracks, beams resting on girders unconnected), beam lines that flip direction or whose beta angle jumps, material values out of range (unit slips), sections with zero area or inertia, plates with no thickness, rigid and elastic links that cannot work, supports holding nothing, self weight missing / upward / counted twice in a combination, upward dead loads, load values 1000× out of line, beam loads on plates, moving loads with no lanes or vehicles, construction stages (elements never activated, loads on parts not yet built, stages with no supports, activation order), combinations (cycles, unfactored ULS, duplicates, cases never combined), empty or unused groups, and tendons that cannot be stressed. UNITS (typing slips): creep/shrinkage and strength-gain inputs (fck in MPa typed into a kN/m² box, humidity as a fraction, notional size in mm in a metre model, shrinkage strains not × 10⁻⁶, strength not matching the linked concrete grade), tendon area / strengths / duct diameter / anchorage slip, thermal coefficients, temperatures, section depths and plate thicknesses. TENDONS: cover — every profile point placed on its girder and compared with the section's top and soffit (outside the concrete, with the likely coordinate slip: mm in a metre model or the sign of z; clear cover under 50 mm); jacking stress against min(0.8 fpk, 0.9 fp0.1k) and slips, duct area against the steel, friction μ and wobble ranges, friction loss estimated from each profile, sharp bends, profiles longer than their elements, tendons on elements that do not join up. MOVING LOADS (Eurocode EN 1991-2 and CS 454 / CS 458 rules): the moving-load code against the v	One read-only check of the open CIVIL NX model for anything that is likely wrong, grouped into areas with a red/amber/green status each. DATA (no analysis needed): the Model Report's fourteen QC checks plus warped / badly shaped plates, plates facing the other way from their neighbours, nodes lying on an element without being joined to it (mesh cracks, beams resting on girders unconnected), beam lines that flip direction or whose beta angle jumps, material values out of range (unit slips), sections with zero area or inertia, plates with no thickness, rigid and elastic links that cannot work, supports holding nothing, self weight missing / upward / counted twice in a combination, upward dead loads, load values 1000× out of line, beam loads on plates, moving loads with no lanes or vehicles, construction stages (elements never activated, loads on parts not yet built, stages with no supports, activation order), combinations (cycles, unfactored ULS, duplicates, cases never combined), empty or unused groups, and tendons that cannot be stressed. UNITS (typing slips): creep/shrinkage and strength-gain inputs (fck in MPa typed into a kN/m² box, humidity as a fraction, notional size in mm in a metre model, shrinkage strains not × 10⁻⁶, strength not matching the linked concrete grade), tendon area / strengths / duct diameter / anchorage slip, thermal coefficients, temperatures, section depths and plate thicknesses. TENDONS: cover — every profile point placed on its girder and compared with the section's top and soffit (outside the concrete, with the likely coordinate slip: mm in a metre model or the sign of z; clear cover under 50 mm); jacking stress against min(0.8 fpk, 0.9 fp0.1k) and slips, duct area against the steel, friction μ and wobble ranges, friction loss estimated from each profile, sharp bends, profiles longer than their elements, tendons on elements that do not join up. MOVING LOADS (Eurocode EN 1991-2 and CS 454 / CS 458 rules): the moving-load code against the v	Not declared	Yes	Not declared	No
`model_qc_check`Runs the Model Report plugin's fourteen quality checks on the open CIVIL NX model: duplicate (coincident) nodes, orphan nodes, zero-length and duplicate elements, elements without material/section, unused properties, disconnected regions, support adequacy, load cases with no loads, loads on missing nodes/elements, combinations citing a missing case, elements in no structure group, length outliers and end releases that make a mechanism. Returns each check's result (pass / fail / not applicable / not run), severity, criterion, count and the ids involved, a model summary (counts, units) and what was read from each table. Reads only the tables the checks use (GET only). Read-only; on the website it runs as a job.	Runs the Model Report plugin's fourteen quality checks on the open CIVIL NX model: duplicate (coincident) nodes, orphan nodes, zero-length and duplicate elements, elements without material/section, unused properties, disconnected regions, support adequacy, load cases with no loads, loads on missing nodes/elements, combinations citing a missing case, elements in no structure group, length outliers and end releases that make a mechanism. Returns each check's result (pass / fail / not applicable / not run), severity, criterion, count and the ids involved, a model summary (counts, units) and what was read from each table. Reads only the tables the checks use (GET only). Read-only; on the website it runs as a job.	Not declared	Yes	Not declared	No
`model_report_export`Builds the Model Report plugin's 'Model report' for the open CIVIL NX model — cover, contents, materials, sections (with drawings), supports and springs, load cases, combinations and loads, nodes/elements/groups appendix, cross sections, tendons, CIVIL NX pictures, the QC checks and the data sources read — and returns it as download links: html (default), xlsx, docx and/or pdf, in English, French, German, Greek or Polish. Document details (project, client, job no., revision, author, checker, date …) go on the cover. Pictures are rendered by CIVIL NX (POST /view/CAPTURE, the user's own view is left as it is): by default the isometric model view and every figure saved in the model; choose model views, load views, saved figures and beam diagrams with `images` (model_report_images lists them), and the beam diagrams' legend format (exponential/fixed, decimals) there too. Otherwise reads only (GET, plus POST /post/TABLE for tendon coordinates). Runs as a job.	Builds the Model Report plugin's 'Model report' for the open CIVIL NX model — cover, contents, materials, sections (with drawings), supports and springs, load cases, combinations and loads, nodes/elements/groups appendix, cross sections, tendons, CIVIL NX pictures, the QC checks and the data sources read — and returns it as download links: html (default), xlsx, docx and/or pdf, in English, French, German, Greek or Polish. Document details (project, client, job no., revision, author, checker, date …) go on the cover. Pictures are rendered by CIVIL NX (POST /view/CAPTURE, the user's own view is left as it is): by default the isometric model view and every figure saved in the model; choose model views, load views, saved figures and beam diagrams with `images` (model_report_images lists them), and the beam diagrams' legend format (exponential/fixed, decimals) there too. Otherwise reads only (GET, plus POST /post/TABLE for tendon coordinates). Runs as a job.	Not declared	Yes	Not declared	No
`model_report_images`Lists the CIVIL NX pictures the Model Report can put in this model's report, with their keys: FE model views (iso, plan, front, side), the applied loads of each static load case, the figures saved in the model (/db/UFIG), and the beam diagrams on offer (each static case, combination and construction-stage part × components Fx…Mw). Pick from them with model_report_export images. Read-only (GET only); nothing is rendered.	Lists the CIVIL NX pictures the Model Report can put in this model's report, with their keys: FE model views (iso, plan, front, side), the applied loads of each static load case, the figures saved in the model (/db/UFIG), and the beam diagrams on offer (each static case, combination and construction-stage part × components Fx…Mw). Pick from them with model_report_export images. Read-only (GET only); nothing is rendered.	Not declared	Yes	Not declared	No
`model_to_dxf`Draws the open CIVIL NX model as DXF with the Model to IFC plugin's drawing engine: a 2D drawing file (DXF 2000: plan, elevation developed along the deck, hidden-line isometric, section cuts with hatched faces and tendon ducts, and every section in use dimensioned) and a 3D DXF (one polyface mesh per element, layered by role, DXF 2000 or R12). Cuts are given in metres: {kind:'cross', at: chainage} across the deck, {kind:'long', at: offset left of the centreline}, {kind:'level', at: height}, with depth = how far beyond the cut to draw; none given = one across mid-span, cutsAtSupports adds one at each pier and abutment. Only reads the model; returns download links.	Draws the open CIVIL NX model as DXF with the Model to IFC plugin's drawing engine: a 2D drawing file (DXF 2000: plan, elevation developed along the deck, hidden-line isometric, section cuts with hatched faces and tendon ducts, and every section in use dimensioned) and a 3D DXF (one polyface mesh per element, layered by role, DXF 2000 or R12). Cuts are given in metres: {kind:'cross', at: chainage} across the deck, {kind:'long', at: offset left of the centreline}, {kind:'level', at: height}, with depth = how far beyond the cut to draw; none given = one across mid-span, cutsAtSupports adds one at each pier and abutment. Only reads the model; returns download links.	Not declared	Yes	Not declared	No
`model_to_ifc`Exports the open CIVIL NX model to IFC with the Model to IFC plugin: real section outlines with voids, smooth tapers, tendons, composite deck slabs, materials, structure groups and stages; in IFC4.3 also the bridge structure (deck, piers, abutments, bearings, alignment); optionally the structural analysis model with loads, combinations, support reactions, and — for the series named in resultSeries — node displacements and member/plate forces; optionally a second file of the deformed shape for one load case or combination. Only reads the model. Returns download links (never the file inline) and the exporter's report (sections, volumes, bridge parts, checks). Results are read on demand and can take long on big models (one live model: 40 s for all displacements), which is why this runs as a job.	Exports the open CIVIL NX model to IFC with the Model to IFC plugin: real section outlines with voids, smooth tapers, tendons, composite deck slabs, materials, structure groups and stages; in IFC4.3 also the bridge structure (deck, piers, abutments, bearings, alignment); optionally the structural analysis model with loads, combinations, support reactions, and — for the series named in resultSeries — node displacements and member/plate forces; optionally a second file of the deformed shape for one load case or combination. Only reads the model. Returns download links (never the file inline) and the exporter's report (sections, volumes, bridge parts, checks). Results are read on demand and can take long on big models (one live model: 40 s for all displacements), which is why this runs as a job.	Not declared	Yes	Not declared	No
`pd6694_route_a`PD 6694-1 integral abutment earth pressures by the limit-equilibrium route (K*, cl.9.4.3/9.4.4) with the PD 6694-1 Integral Abutment plugin's own engine: thermal movement and design displacement, the route (A1/A2, or B / review when Annex A is needed), applicability checks, coefficients, and the four states EXPMAX/EXPMIN/CONMAX/CONMIN (force, peak pressure, resultant, moment per metre). Needs no model.	PD 6694-1 integral abutment earth pressures by the limit-equilibrium route (K*, cl.9.4.3/9.4.4) with the PD 6694-1 Integral Abutment plugin's own engine: thermal movement and design displacement, the route (A1/A2, or B / review when Annex A is needed), applicability checks, coefficients, and the four states EXPMAX/EXPMIN/CONMAX/CONMIN (force, peak pressure, resultant, moment per metre). Needs no model.	Not declared	Yes	Not declared	No
`pd6694_route_a_remove`Removes the four PD6694 EP limit-equilibrium load cases with their pressures, load groups and stage activations (the plugin's Remove). Other load cases are kept. Previews unless apply: true.	Removes the four PD6694 EP limit-equilibrium load cases with their pressures, load groups and stage activations (the plugin's Remove). Other load cases are kept. Previews unless apply: true.	Yes	No	Not declared	No
`pd6694_route_a_write`Writes the four PD 6694 limit-equilibrium states as plate pressures on one or two abutment wall groups, exactly as the plugin's Write button: same-model guard, the PD6694 EP load cases and groups, pressure items (other loads on the plates kept), then verification of the totals against the calculation; optionally activates them in a construction stage. Previews unless apply: true.	Writes the four PD 6694 limit-equilibrium states as plate pressures on one or two abutment wall groups, exactly as the plugin's Write button: same-model guard, the PD6694 EP load cases and groups, pressure items (other loads on the plates kept), then verification of the totals against the calculation; optionally activates them in a construction stage. Previews unless apply: true.	No	No	Not declared	No
`pd6694_ssi_plan`Read-only: changes nothing in the model. Call it before pd6694_ssi_run, with the same inputs, to check that the PD 6694-1 Annex A soil-structure interaction run can go ahead — it uses the plugin's own planner. Needs abutments[].group (the wall plates' structure group) and ssi.deckGroup; the soil and thermal inputs default to the plugin's values. Returns: abutments (per wall group: plates, spring nodes, piles), deltaK (the spring stiffness range), errors (blockers — pd6694_ssi_run refuses to start while any remain) and warnings (allowed, but worth showing the user).	Read-only: changes nothing in the model. Call it before pd6694_ssi_run, with the same inputs, to check that the PD 6694-1 Annex A soil-structure interaction run can go ahead — it uses the plugin's own planner. Needs abutments[].group (the wall plates' structure group) and ssi.deckGroup; the soil and thermal inputs default to the plugin's values. Returns: abutments (per wall group: plates, spring nodes, piles), deltaK (the spring stiffness range), errors (blockers — pd6694_ssi_run refuses to start while any remain) and warnings (allowed, but worth showing the user).	Not declared	Yes	Not declared	No
`pd6694_ssi_remove`Removes everything an SSI run left (design pressure cases, spring groups, analysis cases) and restores the model's own springs from the run's backup (the plugin's Remove SSI). Previews unless apply: true.	Removes everything an SSI run left (design pressure cases, spring groups, analysis cases) and restores the model's own springs from the run's backup (the plugin's Remove SSI). Previews unless apply: true.	Yes	No	Not declared	No
`pd6694_ssi_run`Runs the PD 6694-1 Annex A iteration with the plugin's own runner: Winkler springs on the walls (multi-linear), repeated analyses until the wall displacements settle, then the two design pressure cases written and the analysis set-up removed — keeping a backup of the model's own springs for undo. Takes minutes: on the website it runs as a job (poll job_status). Previews unless apply: true.	Runs the PD 6694-1 Annex A iteration with the plugin's own runner: Winkler springs on the walls (multi-linear), repeated analyses until the wall displacements settle, then the two design pressure cases written and the analysis set-up removed — keeping a backup of the model's own springs for undo. Takes minutes: on the website it runs as a job (poll job_status). Previews unless apply: true.	No	No	Not declared	No
`point_to_patch_apply`Converts the model's point loads (or a coordinate table) into dispersed patch loads with the Point to Patch Convertor's engine and writes them as PATCH_<case> load cases: plate decks get pressures on the plates the patch covers, grillages get UDLs on the members by the lever rule, total force conserved; units converted to the model's. The writer snapshots every row it touches, writes, and reads every item back with a force-equilibrium check. Previews unless apply: true.	Converts the model's point loads (or a coordinate table) into dispersed patch loads with the Point to Patch Convertor's engine and writes them as PATCH_<case> load cases: plate decks get pressures on the plates the patch covers, grillages get UDLs on the members by the lever rule, total force conserved; units converted to the model's. The writer snapshots every row it touches, writes, and reads every item back with a force-equilibrium check. Previews unless apply: true.	Yes	No	Not declared	No
`point_to_patch_dispersal`The Point to Patch Convertor's dispersal for one point load: the code's contact area (or the load-derived one), the spread through surfacing and slab to the mid-plane or neutral axis, the effective patch b_eff × l_eff and its pressure, with the clause. Presets cover EN 1991-2 LM1/LM2, the UK NA, CS 454 / HB, BS 5400 and Network Rail ballast/fill. Needs no model.	The Point to Patch Convertor's dispersal for one point load: the code's contact area (or the load-derived one), the spread through surfacing and slab to the mid-plane or neutral axis, the effective patch b_eff × l_eff and its pressure, with the clause. Presets cover EN 1991-2 LM1/LM2, the UK NA, CS 454 / HB, BS 5400 and Network Rail ballast/fill. Needs no model.	Not declared	Yes	Not declared	No
`point_to_patch_read`Reads the open model as the Point to Patch Convertor does: whether the deck is plates or a grillage, its levels and groups, the point loads (nodal and beam concentrated) per load case that could be dispersed, any PATCH_ cases already written, and every preset with what it still needs. Read-only.	Reads the open model as the Point to Patch Convertor does: whether the deck is plates or a grillage, its levels and groups, the point loads (nodal and beam concentrated) per load case that could be dispersed, any PATCH_ cases already written, and every preset with what it still needs. Read-only.	Not declared	Yes	Not declared	No
`point_to_patch_undo`Undoes the latest point_to_patch_apply run (or the run named) with the plugin's cleanup: every PRES / BMLD row the run touched is put back as it was, the PATCH_ cases it removed are restored and the ones it created deleted. Previews unless apply: true.	Undoes the latest point_to_patch_apply run (or the run named) with the plugin's cleanup: every PRES / BMLD row the run touched is put back as it was, the PATCH_ cases it removed are restored and the ones it created deleted. Previews unless apply: true.	Yes	No	Not declared	No
`preview_result_table`Reads one table from the open CIVIL NX model the way the exporter's 'Preview this table' does and returns its first rows (default 20, max 200) with unit-labelled headers, any sub-tables (e.g. reaction totals) and the exact POST /post/TABLE Argument sent. Result tables are a quick sample (first 20 nodes/elements, 3 load cases, 2 stage steps) with an estimate of the full row count; model tables are read whole. When no loadCases are given it also lists the model's load-case names (loadCasesInModel). Read-only (GET /db and POST /post/TABLE only). Results need an analysed model.	Reads one table from the open CIVIL NX model the way the exporter's 'Preview this table' does and returns its first rows (default 20, max 200) with unit-labelled headers, any sub-tables (e.g. reaction totals) and the exact POST /post/TABLE Argument sent. Result tables are a quick sample (first 20 nodes/elements, 3 load cases, 2 stage steps) with an estimate of the full row count; model tables are read whole. When no loadCases are given it also lists the model's load-case names (loadCasesInModel). Read-only (GET /db and POST /post/TABLE only). Results need an analysed model.	Not declared	Yes	Not declared	No
`result_table_catalog`Lists the CIVIL NX tables the Bulk Tabular Result Exporter plugin can export, with each one's id, MIDAS TABLE_TYPE or /db endpoint, components and the arguments it takes: analysis results (reactions, displacements, beam/truss/plate/solid forces and stresses, links, cables, tendons, modes, composite sections, construction stage tables, 'all columns' for any TABLE_TYPE), calculated pre-process tables, and every model data table (/db/NODE, ELEM, SECT, loads, stages, combinations…). Filter with scope, search or id. Needs no model. Use it to pick the table id for preview_result_table and export_result_tables.	Lists the CIVIL NX tables the Bulk Tabular Result Exporter plugin can export, with each one's id, MIDAS TABLE_TYPE or /db endpoint, components and the arguments it takes: analysis results (reactions, displacements, beam/truss/plate/solid forces and stresses, links, cables, tendons, modes, composite sections, construction stage tables, 'all columns' for any TABLE_TYPE), calculated pre-process tables, and every model data table (/db/NODE, ELEM, SECT, loads, stages, combinations…). Filter with scope, search or id. Needs no model. Use it to pick the table id for preview_result_table and export_result_tables.	Not declared	Yes	Not declared	No
`section_preview`Checks a cross-section's outlines with Section Designer's own rules (closed, not self-crossing, holes inside their outline, no overlaps, materials) and returns a PNG drawing of it — the outlines, numbered input vertices, the centroid and chain dimensions — plus the extents, areas and every vertex. Use it FIRST, and LOOK at the drawing: compare it with the user's sketch (overall width and depth, slab and web thicknesses, haunches, cells) and correct misreads before computing or writing anything. Needs no model. From a sketch: read every dimension and put the outline down as vertices in y (across, right +) and z (up), in the sketch's units (default mm). Holes are separate rings inside their outline; direction of travel does not matter. Rounded corners: fillet on that vertex; arcs between vertices: bulge; round bars or ducts: { circle }. Standard shapes can use a template (i_girder, box_girder) instead of vertices. Two materials (girder + slab): one part each, in construction order, each with its material.	Checks a cross-section's outlines with Section Designer's own rules (closed, not self-crossing, holes inside their outline, no overlaps, materials) and returns a PNG drawing of it — the outlines, numbered input vertices, the centroid and chain dimensions — plus the extents, areas and every vertex. Use it FIRST, and LOOK at the drawing: compare it with the user's sketch (overall width and depth, slab and web thicknesses, haunches, cells) and correct misreads before computing or writing anything. Needs no model. From a sketch: read every dimension and put the outline down as vertices in y (across, right +) and z (up), in the sketch's units (default mm). Holes are separate rings inside their outline; direction of travel does not matter. Rounded corners: fillet on that vertex; arcs between vertices: bulge; round bars or ducts: { circle }. Standard shapes can use a template (i_girder, box_girder) instead of vertices. Two materials (girder + slab): one part each, in construction order, each with its material.	Not declared	Yes	Not declared	No
`section_properties`Computes the full CIVIL NX property set of a section with Section Designer's solver: exact area, centroid, second moments, extreme fibres and perimeters from the outlines, and torsion J and shear areas ASY/ASZ from a finite-element mesh refined until all three settle to 0.5 % (converged: true). Composites (two or more parts) give each part alone (STIFF) and each construction stage transformed to the reference material (STIFF_SUM). Results use CIVIL's names (AREA, ASY, ASZ, RXX = J, RYY = Iyy, RZZ = Izz, …) in the section's units. Needs no model. Same section input as section_preview.	Computes the full CIVIL NX property set of a section with Section Designer's solver: exact area, centroid, second moments, extreme fibres and perimeters from the outlines, and torsion J and shear areas ASY/ASZ from a finite-element mesh refined until all three settle to 0.5 % (converged: true). Composites (two or more parts) give each part alone (STIFF) and each construction stage transformed to the reference material (STIFF_SUM). Results use CIVIL's names (AREA, ASY, ASZ, RXX = J, RYY = Iyy, RZZ = Izz, …) in the section's units. Needs no model. Same section input as section_preview.	Not declared	Yes	Not declared	No
`section_read`Without id: lists the model's sections (id, name, type, whether Section Designer stores it as outlines) and the next free id. With id: returns the section as outlines in section_preview's input format, in units (default mm). A drawn section (VALUE/GEN, PSC/VALU, COMPOSITE-GEN) comes back with its stored properties; any other type (DB/User shapes, PSC guide-curve sections, steel girders with stiffeners and riveted angles, composite girders, tapered) is rebuilt by the section library and checked against the properties CIVIL NX published, with a note saying what was recovered — edit it and write it back with section_write.	Without id: lists the model's sections (id, name, type, whether Section Designer stores it as outlines) and the next free id. With id: returns the section as outlines in section_preview's input format, in units (default mm). A drawn section (VALUE/GEN, PSC/VALU, COMPOSITE-GEN) comes back with its stored properties; any other type (DB/User shapes, PSC guide-curve sections, steel girders with stiffeners and riveted angles, composite girders, tapered) is rebuilt by the section library and checked against the properties CIVIL NX published, with a note saying what was recovered — edit it and write it back with section_write.	Not declared	Yes	Not declared	No
`section_write`Writes a section into the open CIVIL NX model exactly as Section Designer's Write button does: VALUE/GEN, PSC/VALU or COMPOSITE-GEN with its computed properties (CIVIL keeps them as sent), in the model's units read at the time of writing, then reads it back and compares every value sent. id defaults to the model's next free section id. Refuses unconverged results. If the id is taken it writes nothing and says by what (and how many elements use it); replacing needs replaceExisting: true — DESTRUCTIVE, only with the user's agreement. Previews unless apply: true with confirmPlanHash. Before applying, show the user the drawing (section_preview) and the properties and get their go-ahead. section_write_undo reverses it. Same section input as section_preview.	Writes a section into the open CIVIL NX model exactly as Section Designer's Write button does: VALUE/GEN, PSC/VALU or COMPOSITE-GEN with its computed properties (CIVIL keeps them as sent), in the model's units read at the time of writing, then reads it back and compares every value sent. id defaults to the model's next free section id. Refuses unconverged results. If the id is taken it writes nothing and says by what (and how many elements use it); replacing needs replaceExisting: true — DESTRUCTIVE, only with the user's agreement. Previews unless apply: true with confirmPlanHash. Before applying, show the user the drawing (section_preview) and the properties and get their go-ahead. section_write_undo reverses it. Same section input as section_preview.	Yes	No	No	No
`section_write_undo`Reverses a section_write run from the ledger: deletes the section it created (refused while elements use it), or writes back the section it replaced, then reads back. Default: the latest section_write run not yet undone. Previews unless apply: true.	Reverses a section_write run from the ledger: deletes the section it created (refused while elements use it), or writes back the section it replaced, then reads back. Default: the latest section_write run not yet undone. Previews unless apply: true.	Yes	No	Not declared	No
`skew_grillage`Generates a bridge deck (beam grillage or plate mesh) with the Skew Grillage Geometry Generator plugin's own engine: skew, unequal girders, plan curvature, multi-span, crossfall and vertical profile, automatic transverse section sizing and structure groups (GIRDERS, CROSS-BEAMS, END-BEAMS for the support-line members, SPAN-n, or DECK for plates). Without apply it only previews (counts, metrics, groups, planHash). With apply: true it writes to CIVIL NX exactly as the plugin does: it refuses a model that already holds geometry unless replaceExisting is set, creates default material/sections/thickness where the ids are missing, and records the run for skew_grillage_undo.	Generates a bridge deck (beam grillage or plate mesh) with the Skew Grillage Geometry Generator plugin's own engine: skew, unequal girders, plan curvature, multi-span, crossfall and vertical profile, automatic transverse section sizing and structure groups (GIRDERS, CROSS-BEAMS, END-BEAMS for the support-line members, SPAN-n, or DECK for plates). Without apply it only previews (counts, metrics, groups, planHash). With apply: true it writes to CIVIL NX exactly as the plugin does: it refuses a model that already holds geometry unless replaceExisting is set, creates default material/sections/thickness where the ids are missing, and records the run for skew_grillage_undo.	Yes	No	No	No
`skew_grillage_undo`Removes the deck a skew_grillage run wrote (its elements, nodes, new structure groups and any default properties nothing else uses). Refuses while lanes, other groups or other elements still depend on it. Previews unless apply: true.	Removes the deck a skew_grillage run wrote (its elements, nodes, new structure groups and any default properties nothing else uses). Refuses while lanes, other groups or other elements still depend on it. Previews unless apply: true.	Yes	No	Not declared	No
`slab_assess`Reads plate forces (PLATEFORCEUL, element local axes) for one orientation group and the given load cases, rotates them to the reinforcement direction and assesses every position with the plugin's own core (Denton, Wood-Armer, sandwich, Annex LL, CS 455). Returns counts, the worst elements with governing case/position, coverage and every gap (missing results are INCOMPLETE, never a pass). Read-only. Can take minutes on big models (a job on the website).	Reads plate forces (PLATEFORCEUL, element local axes) for one orientation group and the given load cases, rotates them to the reinforcement direction and assesses every position with the plugin's own core (Denton, Wood-Armer, sandwich, Annex LL, CS 455). Returns counts, the worst elements with governing case/position, coverage and every gap (missing results are INCOMPLETE, never a pass). Read-only. Can take minutes on big models (a job on the website).	Not declared	Yes	Not declared	No
`slab_capacities_from_bars`Calculation only: needs no model and changes nothing. Turns a slab's bar arrangement into the capacities the RC Slab & Shell Assessment routes need, with the plugin's own core. Use it to check a reinforcement layout by hand, or to see the capacities slab_assess will derive when given the same bars; to assess a model's plate forces use slab_assess (slab_explain_location for one element), and for a beam section cs455_assess. Give thickness_mm, fck and at least one face (top / bottom: cover_mm and one layer per bar direction); partial factors default to γc 1.5, γs 1.15, αcc 0.85, fyk 500 MPa. Returns per layer area, d, x, z, moment capacity (kNm/m) and force (kN/m), plus `assess` — ready to pass on: the Denton/Wood-Armer capacity pairs (top/bottom), the four Annex LL steel forces and the covers to the reinforcement centroid.	Calculation only: needs no model and changes nothing. Turns a slab's bar arrangement into the capacities the RC Slab & Shell Assessment routes need, with the plugin's own core. Use it to check a reinforcement layout by hand, or to see the capacities slab_assess will derive when given the same bars; to assess a model's plate forces use slab_assess (slab_explain_location for one element), and for a beam section cs455_assess. Give thickness_mm, fck and at least one face (top / bottom: cover_mm and one layer per bar direction); partial factors default to γc 1.5, γs 1.15, αcc 0.85, fyk 500 MPa. Returns per layer area, d, x, z, moment capacity (kNm/m) and force (kN/m), plus `assess` — ready to pass on: the Denton/Wood-Armer capacity pairs (top/bottom), the four Annex LL steel forces and the covers to the reinforcement centroid.	Not declared	Yes	Not declared	No
`slab_explain_location`The working behind one element's utilisation: reads that element's plate forces, picks its governing position and case (or the one given) and re-runs it through the plugin's explain_location — every route, face, utilisation and intermediate quantity (gamma, Wood-Armer branch, sandwich layer forces, Annex LL split). Same inputs as slab_assess plus element. Read-only.	The working behind one element's utilisation: reads that element's plate forces, picks its governing position and case (or the one given) and re-runs it through the plugin's explain_location — every route, face, utilisation and intermediate quantity (gamma, Wood-Armer branch, sandwich layer forces, Annex LL split). Same inputs as slab_assess plus element. Read-only.	Not declared	Yes	Not declared	No
`slab_survey`Reads the open model's plates (ELEM/NODE), structure groups, static cases and combinations (all LCOM tables) the way the RC Slab & Shell Assessment plugin does: orientation groups by plate normal (with a suggested in-plane reference direction) and every case with the sense it must be requested by. Read-only; use it before slab_assess.	Reads the open model's plates (ELEM/NODE), structure groups, static cases and combinations (all LCOM tables) the way the RC Slab & Shell Assessment plugin does: orientation groups by plate normal (with a suggested in-plane reference direction) and every case with the sense it must be requested by. Read-only; use it before slab_assess.	Not declared	Yes	Not declared	No
`sls_stress_check`The Stress Profile Generator's SLS report check (EN 1992-2 §7.2 concrete, EN 1993-2 §7.3 structural steel; normal stress σx at the fibres) over many elements × positions × combinations — or, with source stages, its construction-stage checks (fck(t) from CIVIL NX's concrete age, steel fy/γM0, tendons from CIVIL NX's tendon stresses). Every state is generated and matched with CIVIL NX as in stress_profile; composite parts are checked against their own concrete's fck. LIMITS ARE OPT-IN exactly as in the plugin: with no limit chosen the verdict is NO LIMIT APPLIED; nothing that could not be evaluated passes (INCOMPLETE). Combination categories (characteristic / frequent / quasi-permanent / none) are taken as given, else guessed from the name and reported. Returns the one verdict, the limits used, counts, the governing state, failures, what was not evaluated and why, per combination/stage and per element, and the plugin's SLS CSV as a download link. Read-only.	The Stress Profile Generator's SLS report check (EN 1992-2 §7.2 concrete, EN 1993-2 §7.3 structural steel; normal stress σx at the fibres) over many elements × positions × combinations — or, with source stages, its construction-stage checks (fck(t) from CIVIL NX's concrete age, steel fy/γM0, tendons from CIVIL NX's tendon stresses). Every state is generated and matched with CIVIL NX as in stress_profile; composite parts are checked against their own concrete's fck. LIMITS ARE OPT-IN exactly as in the plugin: with no limit chosen the verdict is NO LIMIT APPLIED; nothing that could not be evaluated passes (INCOMPLETE). Combination categories (characteristic / frequent / quasi-permanent / none) are taken as given, else guessed from the name and reported. Returns the one verdict, the limits used, counts, the governing state, failures, what was not evaluated and why, per combination/stage and per element, and the plugin's SLS CSV as a download link. Read-only.	Not declared	Yes	Not declared	No
`stage_groups`Creates structure groups with the Construction Stage Wizard plugin's group builder: pick a scope of elements, split it by rules (slice along X/Y/Z into n segments or at cuts, by section, material, element type, thickness, id ranges, existing groups), name them from a template, and resolve clashes with existing groups by policy. Typical use: segments of a deck for staged construction, e.g. rules [{kind:'slice', axis:'X', mode:'count', count:8, cuts:[]}] with naming {template:'Seg_{SLICE}'}. Previews unless apply: true; the write keeps a snapshot for stages_undo.	Creates structure groups with the Construction Stage Wizard plugin's group builder: pick a scope of elements, split it by rules (slice along X/Y/Z into n segments or at cuts, by section, material, element type, thickness, id ranges, existing groups), name them from a template, and resolve clashes with existing groups by policy. Typical use: segments of a deck for staged construction, e.g. rules [{kind:'slice', axis:'X', mode:'count', count:8, cuts:[]}] with naming {template:'Seg_{SLICE}'}. Previews unless apply: true; the write keeps a snapshot for stages_undo.	No	No	Not declared	No
`stages_undo`Restores the rows a stage_groups or construction_stages run changed, from the snapshot taken just before it wrote (the plugin's own restore). Default: the latest run not yet undone. Previews unless apply: true.	Restores the rows a stage_groups or construction_stages run changed, from the snapshot taken just before it wrote (the plugin's own restore). Default: the latest run not yet undone. Previews unless apply: true.	Yes	No	Not declared	No
`stress_element_loads`Reads what the Stress Profile Generator can show for chosen beam elements: each element's section (type, outline verified, composite parts, tapered), material, length, the load cases / combinations / envelopes CIVIL NX publishes results for (with kind and whether each is one concurrent state), the construction stages with results for that element (and, with stage, that stage's results such as Summation). Also lists the model's combinations with the SLS category the plugin would guess. Read-only; reads results with a few batched /post/TABLE requests. Use it before stress_profile or sls_stress_check.	Reads what the Stress Profile Generator can show for chosen beam elements: each element's section (type, outline verified, composite parts, tapered), material, length, the load cases / combinations / envelopes CIVIL NX publishes results for (with kind and whether each is one concurrent state), the construction stages with results for that element (and, with stage, that stage's results such as Summation). Also lists the model's combinations with the SLS category the plugin would guess. Read-only; reads results with a few batched /post/TABLE requests. Use it before stress_profile or sls_stress_check.	Not declared	Yes	Not declared	No
`stress_profile`The Stress Profile Generator's profile for ONE beam element: from CIVIL NX's beam forces and the true section outline it calculates σx (or σx from N / My / Mz, τ from Vz / Vy, von Mises, principal, Tresca) over the section at the chosen positions and loads, and checks every profile against CIVIL NX's own published stresses (effective PSC sections are drawn through CIVIL NX's stress points; composite sections part by part from CIVIL NX's per-part results; envelopes give CIVIL NX's values at the stress points plus the governing member or static part as a profile). Returns per profile: status (ok/unchecked/points/refused) with reasons, forces, extremes and where they occur, CIVIL NX vs calculated at stress points 1–4, per-part σx for composites, and min/max across the section at each depth. With `thermal` it gives the EN 1991-1-5 temperature stresses instead, split into total, restraint, self-equilibrating, uniform and linear parts (Type 3 heating/cooling with 100 mm surfacing, a user ΔT profile, or CIVIL NX's own section temperature; restraint free, full, axial, rotation, or CIVIL NX's forces of a load). Optional csv gives the plugin's CSV export as a download link. Read-only.	The Stress Profile Generator's profile for ONE beam element: from CIVIL NX's beam forces and the true section outline it calculates σx (or σx from N / My / Mz, τ from Vz / Vy, von Mises, principal, Tresca) over the section at the chosen positions and loads, and checks every profile against CIVIL NX's own published stresses (effective PSC sections are drawn through CIVIL NX's stress points; composite sections part by part from CIVIL NX's per-part results; envelopes give CIVIL NX's values at the stress points plus the governing member or static part as a profile). Returns per profile: status (ok/unchecked/points/refused) with reasons, forces, extremes and where they occur, CIVIL NX vs calculated at stress points 1–4, per-part σx for composites, and min/max across the section at each depth. With `thermal` it gives the EN 1991-1-5 temperature stresses instead, split into total, restraint, self-equilibrating, uniform and linear parts (Type 3 heating/cooling with 100 mm surfacing, a user ΔT profile, or CIVIL NX's own section temperature; restraint free, full, axial, rotation, or CIVIL NX's forces of a load). Optional csv gives the plugin's CSV export as a download link. Read-only.	Not declared	Yes	Not declared	No
`tendon_design`Designs the post- or pre-tensioning tendons of a concrete girder in the open model to EN 1992-1-1 with the Tendon Designer plugin's own engine, or reads the model's own tendons and checks them (mode improve, the default when tendons run along the girder). Reads the girder (a structure group, element list or the CIVIL NX selection; for improve it is picked from the tendons), its sections, supports and concrete, and the forces: construction-stage results when the model has stages (stage by stage for improve), else the static load cases named, plus an optional live envelope and ULS envelope combination. The girder is ONE girder line (a group holding several girders is split; girderLine picks one). Composite girders (precast + deck slab) are checked stage by stage (compositeMode) with the slab's own concrete, including the slab top; standard precast beams are pre-tensioned on their published strand positions, with debonded (sleeved) strands set or searched for by debonding, each end's length separately. Then auto-designs the layout (new), reads the tendons in (improve), or takes tendons the user gives as heights above the soffit with transverse distances (soffitTendons, e.g. an existing bridge's tendon schedule), and runs every check: stresses at transfer and in service, Magnel, load balancing, losses, ULS bending, cover, spacing, bend radius, anchorage zones. autoResolve tries the smallest change that clears failed checks. exportSoffitCsv returns the tendons as a soffit-height CSV (download link). The design is kept (designId) for tendon_write. Read-only.	Designs the post- or pre-tensioning tendons of a concrete girder in the open model to EN 1992-1-1 with the Tendon Designer plugin's own engine, or reads the model's own tendons and checks them (mode improve, the default when tendons run along the girder). Reads the girder (a structure group, element list or the CIVIL NX selection; for improve it is picked from the tendons), its sections, supports and concrete, and the forces: construction-stage results when the model has stages (stage by stage for improve), else the static load cases named, plus an optional live envelope and ULS envelope combination. The girder is ONE girder line (a group holding several girders is split; girderLine picks one). Composite girders (precast + deck slab) are checked stage by stage (compositeMode) with the slab's own concrete, including the slab top; standard precast beams are pre-tensioned on their published strand positions, with debonded (sleeved) strands set or searched for by debonding, each end's length separately. Then auto-designs the layout (new), reads the tendons in (improve), or takes tendons the user gives as heights above the soffit with transverse distances (soffitTendons, e.g. an existing bridge's tendon schedule), and runs every check: stresses at transfer and in service, Magnel, load balancing, losses, ULS bending, cover, spacing, bend radius, anchorage zones. autoResolve tries the smallest change that clears failed checks. exportSoffitCsv returns the tendons as a soffit-height CSV (download link). The design is kept (designId) for tendon_write. Read-only.	Not declared	Yes	Not declared	No
`tendon_write`Writes a tendon_design result into the open model with the Tendon Designer plugin's writer: the strand material and tendon property (or one already in the model), every tendon profile (TDNA) and its prestress (TDPL) in the prestress load case, one load group per tendon group, and - when a construction stage is named - each group's load group activated in its stage. With improve, the model's own tendons the design was read from are removed first (only while unchanged since). Refused when the model, the girder, or the loads the forces were read from changed, and while checks fail unless allowFailedChecks. The model is re-checked before writing, the journal is kept before the first change, and every row is read back. Previews unless apply: true.	Writes a tendon_design result into the open model with the Tendon Designer plugin's writer: the strand material and tendon property (or one already in the model), every tendon profile (TDNA) and its prestress (TDPL) in the prestress load case, one load group per tendon group, and - when a construction stage is named - each group's load group activated in its stage. With improve, the model's own tendons the design was read from are removed first (only while unchanged since). Refused when the model, the girder, or the loads the forces were read from changed, and while checks fail unless allowFailedChecks. The model is re-checked before writing, the journal is kept before the first change, and every row is read back. Previews unless apply: true.	Yes	No	Not declared	No
`tendon_write_undo`Undoes the latest tendon_write (or the run named), newest first: removes the tendons, prestress, property, material, load case and load groups it created, puts back the model tendons it removed, and takes its load groups out of the construction stages. Every row is checked against the model first; if anything was changed since, nothing is touched. Refused in a different model. Previews unless apply: true.	Undoes the latest tendon_write (or the run named), newest first: removes the tendons, prestress, property, material, load case and load groups it created, puts back the model tendons it removed, and takes its load groups out of the construction stages. Every row is checked against the model first; if anything was changed since, nothing is touched. Refused in a different model. Previews unless apply: true.	Yes	No	Not declared	No

Details

Registry status: Active
Published: Nov 11, 2026
Updated: Nov 11, 2026
Website: https://midasiteurope.com/llm⁠ (opens in a new tab)
Repository: Not given
Categories (suggested): Data and analytics Design and media Knowledge and notesSuggested categories are assigned automatically from the registry text and may be wrong. Verified operators can correct them.
GDPR: Not declared

Are you the operator? Claim this listing