MIDAS CIVIL NX tools (MIDAS IT Europe)

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.

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.

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).

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).

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.

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).

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.35*Self weight(ST) + 1.5*LM1(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 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.

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 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, 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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.

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) — 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).