Parametric sketcher

Drawing an ACS section from scratch and editing it — the Draw Polygon and Draw Arc tools, drawn voids and the rules that refuse a shape ACS cannot represent, the geometry table, and the dimension, angle and radius constraints that hold it all together.

Overview

The ACS parametric sketcher is where a concrete section is drawn and then edited. It covers two things that are really one workflow:

• Creating geometry — the Draw Polygon and Draw Arc tools author an outline, and the same two tools cut voids into it. No template need be involved.
• Editing geometry — dimensional and geometric constraints that survive editing, page refresh and analysis re-runs. Constraints are stored as first-class records in the database, not as ephemeral UI state, so a locked dimension or angle stays locked across sessions.

Everything you draw is immediately editable by every constraint feature described below, and everything described below applies equally to a drawn section and a templated one.

Drawing a section outline

A section does not have to start from a template.

When you would draw instead of using a template

The eight templates are the faster route whenever one of them fits — they carry named dimensions, they rebuild themselves when you change one, and they reopen for editing as the template they are. Reach for the drawing tools when no template describes the section:

• A shape that is not in the list at all — a stepped or haunched beam, a corbel, a plinth, a bridge cross-head, an existing member surveyed off a drawing.
• A void the templates cannot give you. Only Hollow Circular and Box Girder produce voids, and only at the positions those templates define. A service duct, a post-tensioning blockout, a drainage void or a cast-in penetration anywhere else has to be drawn. Before the drawing tools existed there was no way to create one at all.
• A section that has already left its template behind. Editing a template’s geometry directly clears its template provenance, so if you have already dragged a vertex, the parametric dimensions are gone and you are drawing anyway.

Where a template does fit, use it and then edit — the drawing tools do not replace an outline, and there is no advantage to redrawing a rectangle by hand.

The two ways in

There are two entry points, and they lead to the same place.

On a section with no geometry, the canvas shows two equal-weight panels either side of a dividing slash: Use a template (Start from a standard shape) and Sketch from scratch (Draw the outline yourself). Neither is the default and neither is demoted — the template route is genuinely faster for standard shapes. Clicking Sketch from scratch arms Draw Polygon immediately, dismisses the panels, and hands focus to the canvas so the keyboard shortcuts below work straight away.

On a section that already has geometry, use the canvas tool palette at the bottom of the canvas. Its second group is the sketch group: Draw Polygon, Draw Arc, and the Geometry Table. Arming a tool from here behaves identically — the only difference is that a section already exists, so a closed ring becomes a void rather than the outline (see Drawing a void).

On a narrow canvas the sketch group may move to the ⋯ (More tools) dropdown at the end of the palette. Draw Polygon (P) and Draw Arc (A) keep their keyboard shortcuts even when overflowed, so pressing the key reaches them without opening the menu. Geometry Table has no shortcut and is only reachable from the menu when it has overflowed. See Tool palette overflow for full details.

To draw an outline:

1. Select Draw Polygon from the canvas tool palette, or press P. On an empty section, click Sketch from scratch in the canvas.
2. Click on the canvas to place each vertex. Hold Shift to constrain the next segment to 45° increments, or type a distance to fix the segment length before you click.
3. Click the start vertex — the larger handle, labelled Close once the ring can be closed — to close the outline.

Materials are not part of what you draw

A drawn ring carries no material of its own. ACS holds one concrete grade for the whole section, and drawing does not change that: there are no per-region materials, and no per-ring material picker, because the analysis engine has no per-region concrete — not in fibre integration, the ULS stress block, fire isotherms or shear.

The grade is assigned where it always was: the General tab in the left panel, under MATERIALS → CONCRETE. Rebar and PT strand grades sit directly below it.

The only thing a ring you draw needs to decide is its role — outline or void — and that is inferred from where it lands rather than chosen. See Drawing a void.

Curved faces — the Draw Arc tool

Draw Arc (press A) places a curved segment instead of a straight one. It shares the outline you are already drawing, so you can switch between Draw Polygon and Draw Arc part-way round a ring — a beam with three straight faces and a curved soffit is one continuous outline, not two.

Both sub-modes take three clicks, and the sub-mode toggle sits just above the tool palette while the tool is active:

• 3-point — click the arc’s start, then a point on the arc, then its end. The through-point decides which way the arc bulges, so nothing else needs setting.
• Radius — click the arc’s start, then its end, then a third click whose height above the start–end chord sets the radius (or type the radius before you click). Which side of the chord the arc bulges toward comes from the explicit Left / Right buttons on the toggle, never from where the third click lands.

Left and Right are as you see them on the canvas, looking along the chord from the arc’s start toward its end.

An arc that ends on the start vertex closes the outline with that arc, rather than adding a second vertex on top of the first. That is how a circular column is drawn: one arc out to the far side and a second arc back. It works in both sub-modes, though the click that finishes the ring differs — in 3-point the end click is the one that lands on the start vertex and closes it; in Radius you land the end click on the start vertex and the following radius click closes it.

The closing arc runs to the start vertex itself, not to wherever the closing click landed. The click only has to come within a short distance on screen — which at a zoomed-out view can be tens of millimetres of real geometry — and the arc is measured against the chord it is stored against, so a circle drawn with an approximate closing click is still a circle. If correcting the chord makes the arc impossible (a typed radius that no longer spans it), the click is refused by name rather than quietly accepting the smaller one.

Backspace steps the gesture back one click — it clears a through-point or an end-point you have just placed before it starts removing committed vertices. Esc abandons the whole outline, part-finished arc included, and leaves the section untouched.

Switching between Draw Polygon and Draw Arc keeps the outline you are drawing, but discards a part-finished arc: the vertices stay, the half-placed curve does not.

The dashed preview is the arc that the next click will place, drawn through the same geometry the section is stored with. Where the cursor defines no arc at all — a through-point on the chord, or a radius too small to span it — the preview falls back to showing the plain chord rather than an approximate curve, and the click is refused by name.

Section properties for a curved outline are computed exactly from the arcs, not from a faceted approximation, so a circular column reports the area of a circle.

How a vertex position is decided

Each click resolves through five stages, in this order:

1. Grid snap — the cursor lands on the nearest grid intersection at the current grid size.
2. Shift 45° — holding Shift constrains the segment to the nearest 45° increment from the previous vertex.
3. Typed distance — typing a number fixes the segment at exactly that length.
4. Snap to existing geometry — within a short distance of an existing vertex or arc midpoint, the point lands exactly on it. Both the section outline and any voids the section already has are snap targets, so a void can be traced against the section it sits in rather than eyeballed. The snap distance is measured on screen, so it stays the same size however far you are zoomed in or out. Where two candidates are both in reach, the nearer one wins.
5. Constraint inference — when the segment is within 2° of horizontal, vertical, or parallel or perpendicular to an edge already in scope, the point moves onto that constraint exactly and a badge at the cursor names it. A fifth candidate, Tangent, is offered against an arc edge in scope; because tangency is a matter of position rather than direction, its tolerance is a distance — the current grid step — not 2°. The constraint is real: it is created when you close the ring. Draw Polygon only, and which edges are in scope depends on what the ring will become — see Constraints inferred while drawing.

Stage 5 does not apply to Draw Arc. Its clicks take the first four stages and stop there. The candidates describe a straight segment, and the segment an arc click is about to author is a curve — so an arc point is never moved onto one, and no constraint is inferred from an arc click. (Drawing a polygon against a curved edge is a different matter: that is where the Tangent candidate above comes from.) Clicks in the Arc tool land exactly where the first four stages put them.

Straight-edge midpoints, edge intersections and arc centres are not snap targets.

An explicit lock is never overridden. While a typed distance is in force, or while Shift is held, stage 4 is skipped entirely — the segment is the length you typed, or a true 45° segment, not the length or angle to a nearby vertex. Release Shift, or clear the distance (Esc, or Backspace back through the digits), if you would rather snap to geometry.

Stage 5 obeys the same rule, and extends it to the geometry snap: when any of those three placed the point, an inferred constraint is offered only if the point already satisfies it exactly. Inference labels an explicit input; it never moves one.

Backspace removes the last vertex you placed, one at a time, so you can back out of a wrong turn without starting again. (While you are typing a distance, Backspace edits the number instead; with Draw Arc, it clears a part-finished arc before it starts removing vertices.)

Turning inference off. The wand button in the top-left cluster (visible while a sketch tool is active) switches inference off. Its label says which state it is in — Infer when on, Infer off when off — and the setting is remembered in your browser. With it off, every vertex commits exactly where the first four stages put it and no further constraints are inferred.

Switching it off part-way through an outline keeps the constraints already accepted on the edges you have drawn. Those vertices were placed on their constraints when you clicked, and that cannot be undone by a later toggle — so the constraint stays as the visible, deletable record of why the vertex sits where it does. Delete it from the Constraints section of the General tab if you do not want it; abandoning the outline with Esc discards them all.

Reach for it when you are drawing a deliberate near-alignment. A drainage fall of 25 mm over a 1000 mm run is 1.43° off horizontal — inside the 2° tolerance — so with inference on it commits as exactly horizontal and picks up a Horizontal constraint. No other gesture avoids that: Shift snaps to 45°, a typed distance fixes the length rather than the angle, and deleting the constraint afterwards does not bring the 25 mm back, because the fall was dropped when the vertex was placed. Switch inference off before drawing it, or draw the fall steeper than 2° and correct it afterwards with an edge-length or angle dimension.

The crosshair preview shows the point a click would place, including the snap and any inferred constraint, so the position you see is the position you get.

Backspace removes the last vertex you placed, one at a time, so you can back out of a wrong turn without starting again — along with the constraint inferred for the segment that vertex ended. (While you are typing a distance, Backspace edits the number instead.)

Press Esc at any point to abandon the outline in progress. The section is left untouched, and the accepted inferences are discarded with it.

Constraints inferred while drawing

Inference is what makes a drawn ring arrive already parametric rather than as edges the solver knows nothing about. Candidates relate the segment you are drawing to earlier edges of the ring itself — so drawing a rectangle at an angle picks up its perpendiculars and parallels, not just the axis-aligned cases horizontal and vertical cover — and, when the ring will become a void, to the rings that survive alongside it.

One exception: no candidate is offered if accepting it would leave a redundant vertex sitting in the middle of a straight edge. Such a vertex renumbers every edge after it, which is what cover overrides, fire declarations and edge-relative reinforcement are keyed on.

Three edges can be flattened that way, and each is checked at the moment it exists. While you place a vertex, only the edge before it is checked — the closing edge back to where you started, and the ring’s opening edge with it, do not exist until you close, and at placement time nobody knows whether the vertex you are placing is the last one. Checking them earlier guessed that it was, and lost a real snap on a routine shape: on a stepped soffit, drawing back onto the line of the opening edge dropped the vertical candidate for a vertex that was never going to be redundant.

The closing and opening edges are judged when the ring closes, against the ring you actually drew. If the last vertex you placed sits on the closing line because inference put it there, the ring still commits as drawn and the constraint that put it there is dropped, with a message naming it — the same message as any other constraint that could not be created. The case is easy to miss — draw a rectangle, then place a vertex part-way along what will become the bottom face, and a small deliberate step in that face is exactly what inference will flatten. The cursor badge shows the snap as it happens; if a bend was intended, undo and redraw it with inference off.

Parallel to the previous edge is one route to it; horizontal is the one to know about, because it arises from inference’s own success — once an edge has been snapped exactly horizontal, the next horizontal segment drawn from it is automatically on the same line. A perpendicular is never affected: a right angle cannot be straight on.

This only ever withholds the constraint, and only where inference would have moved the vertex to create the collinearity. A collinear vertex you place deliberately still commits — splitting a straight face into two edges to give them different cover is a legitimate thing to want — and if you placed it with Shift or a typed distance, the matching constraint is still offered, because nothing was substituted. The one place that offer is not kept is the closing seam: a constraint on the last edge you placed is dropped at close if that vertex sits on the closing line, whichever way it got there, and the message names it so it can be re-added from the action bar.

Which edges can be matched depends on what the ring will become. Drawing the section’s first outline, candidates relate the segment only to earlier edges of the same outline — nothing else survives that commit to be related to. Drawing a void into a section that already has an outline, the surviving rings join the scope too, so a duct face can be inferred parallel to the section face beside it and stay that way. The one exclusion is a circular hollow section: its bore is rebuilt from the diameter you type, so a constraint on it would be silently overwritten, and its edges are never offered.

Accepted candidates become real constraints when the ring closes, on the same undo step as the outline — one Ctrl+Z removes both. They appear in the Constraint List Panel, are honoured by the solver, and can be deleted like any other constraint. If one cannot be created, the outline still commits and a message names which constraint was dropped and why.

When an outline is refused

A refusal is a verdict, not a bug. ACS will not quietly reinterpret geometry: where a ring cannot describe something the section model can hold, it says which rule was broken and leaves the ring alone, rather than repairing it into a shape you did not draw. Every message below is the whole of a rule — there is no silent second behaviour behind any of them.

An outline that cannot describe a section is refused when you try to close it, and the refusal names the rule it broke:

A Draw Arc click is refused before anything is placed when the arc itself is impossible — a through-point lying on the chord (no arc passes through three points on a line), or a typed radius smaller than half the chord, which names the minimum radius that would work. The gesture is kept, so the next click retries it.

The outline you drew is kept on a refusal, so you can adjust it with Backspace rather than redraw it from scratch. Nothing is silently repaired — a section you did not draw is never substituted for one you did.

A click that lands exactly on the vertex you just placed is ignored rather than adding a second vertex in the same spot, so a double-click cannot leave the outline with a zero-length edge.

Which way round you trace the outline does not matter, and neither does where on the canvas you draw it. On commit the winding is normalised and the outline is moved to the origin, so a section drawn clockwise in one corner of the canvas and the same section drawn anticlockwise in another produce identical geometry, identical reinforcement, and identical coordinates in the BARS table and the report. This matches the templates, which all start at (0, 0).

A void is normalised too, but the other way round — a hole runs opposite to the outline it sits in, matching the voids the Hollow Circular and Box Girder templates produce. And it is not moved: it stays exactly where you drew it, because it is a hole in a section that is already positioned.

Drawing a void

Once a section has an outline, the same Draw Polygon and Draw Arc tools draw voids — there is no separate void tool, so a circular duct is drawn exactly like a circular column. What a closed ring becomes is decided by where it is, not by which tool drew it:

Drawing a void does not reset reinforcement. The outline and its edge indices are untouched, so every edge-relative bar, tendon and stirrup recipe still resolves. One Ctrl+Z removes the void in a single step.

Per-edge cover overrides do reset, because the void adds faces and every override is keyed to a face position. The Cover panel says so when it happens.

Voids that are refused

The collision check runs against the reinforcement as drawn on the canvas, not against the patterns that generated it — so it refuses exactly the bars you can see. A stirrup counts as swallowed if any part of its path enters the void, even where no corner of it does.

As with an outline, the ring you drew is kept on a refusal, so you can move it rather than redraw it.

A void outside the section

A void that lies outside the outline, or straddles its boundary, is accepted — drawing the hole first and moving the outline afterwards is a normal way to work, and the model can hold it.

It is never accepted silently. When it commits, a message says what happened and what it costs; the void is drawn with a dashed boundary and an OUTSIDE SECTION label; and a banner stays on the Properties tab for as long as the state lasts.

Section properties and analysis are unavailable while it lasts. A hole that is not in the section would subtract concrete that was never there, so the calculation is refused rather than answered with a plausible wrong number. Move the void inside the outline — or remove it — and everything resumes.

The section itself keeps saving normally throughout. Nothing you do is at risk; only the results are withheld. That is the difference between the two banners ACS can show you — see Two banners, two different problems.

Two banners, two different problems

ACS has two persistent messages that are easy to confuse. They mean opposite things, and the remedy differs.

The second one is the serious one, and its wording says so: “Your changes are not being saved. The section has geometry the server will not store, so every edit since then — materials, reinforcement and loads included — exists only in this browser tab. Correct the geometry and saving resumes by itself; leave or reload this page before then and that work is gone.”

It sits above the tabs rather than inside a panel deliberately: the whole document has stopped saving, so the loss is not confined to the tab the faulty geometry happens to live on. It clears when a save actually lands, never on a timer.

Overlapping voids no longer put you into the second state at all: the ring is refused when you close it, and an edit that would move one void onto another is refused too, whether it came from a drag, the geometry table or a constraint solve. The remaining routes into it are the geometry faults the drawing tools also refuse — a self-intersecting outline, or an arc the server cannot rebuild — reached by editing a section that already exists.

Drawing over an existing section

While a drawing tool is active, existing reinforcement stays visible but dimmed, and the existing geometry — outline edges, vertex handles, dimensions, padlocks, and void faces in fire-exposure edit mode — stops responding to clicks. Every canvas click places a vertex, so you can trace against the section without selecting a bar, editing a dimension or toggling a fire face by accident.

The drawing tools do not replace an outline. Once a section has one, every ring you close is either a void or a refusal. To replace an outline, draw the replacement so it does not surround the current section — it lands as a void — and then set its role to Outline in the geometry table, which counts what will be lost before it does anything.

Typing geometry: the geometry table

Everything the canvas lets you drag or click, the geometry table lets you type. It is the last button in the sketch group of the canvas tool palette, and it opens as a dialog over the canvas.

A ring selector at the top of the dialog chooses which ring you are editing — Outline, or Void 1, Void 2 and so on. Both tabs follow the selector, so voids are edited from the same place as the outline.

Vertices tab

One row per vertex, numbered the same way the canvas numbers them:

Coordinates are in the section frame, with y increasing upwards — the same frame as the report, the BARS table and the per-vertex dimensions on the canvas. The bottom face reads a smaller y than the top, never the other way round. Where the origin sits depends on how the section was made: an outline you drew is moved so its lowest-left corner is (0, 0), while a template is placed as that template defines it, so a circular column’s bottom face reads −D/2.

Deleting a row joins the two faces that meet at that vertex into one, which renumbers every face after it. Editing x or y renumbers nothing, so none of what follows applies to it.

Your bars and tendons move with the numbering. An edge pattern, an individual bar or a tendon further round the section keeps the face it was already on — it is re-pointed, not lost. What cannot be re-pointed is anything sitting on the two faces that just became one, or on the corner that has gone: nothing records whether you meant the new merged face or neither of the old ones. Rather than guess or quietly discard it, the dialog refuses the deletion and names what is in the way, so you can move or remove it first and then delete the vertex.

Fire exposure and per-edge cover reset instead of moving. Those are declarations about faces rather than things placed on them, and the conservative default — every face exposed, uniform cover — is a safe answer where a bar’s position is not. The dialog says which reset; undo restores the geometry but not the declarations.

A ring with no vertices to spare — a triangle, or a circle, which is stored as two arc edges — shows its Delete buttons greyed out, because removing one would leave no shape at all.

Lines tab

One row per edge, numbered within the ring you have selected:

A circular section is two edges, each a half-turn, so it gets two rows. It has no corners, so its Angle cells read — and cannot be edited, and its Radius cells are refused: a half-turn’s “radius” is the section’s own diameter, not an edge property, and the table cannot resize a circle by curving one of its two halves — that would leave a lune rather than a circle. Change the diameter on the canvas, or type a vertex coordinate on the Vertices tab: the two vertices sit at opposite ends of the diameter, so moving one resizes the section exactly.

On the outline, Edge n is the same edge the canvas labels En. On a void the two differ: this table counts from 1 within each ring, matching the Cover panel, while the canvas continues one sequence across the whole section — so Edge 2 on Void 1 may be E7 on the canvas. Use the Start → end vertices, not the edge number, when matching a void row to the canvas.

The padlocks in this table and the padlocks on the canvas are the same locks. Toggling one is reflected in the other, because both write the same constraint on the geometry.

What a typed value can and cannot do

Typing a dimension locks it. A length, an angle or a radius you type becomes a constraint at exactly the value you typed, and the padlock beside it lights up in the same step — on the canvas and in the table alike. Nothing you edit afterwards can quietly spend that number satisfying something else: it is held until you change it or remove the lock. The constraint is a real record — listed in the Constraint List Panel, deletable there or by clicking its padlock, and reverted along with the geometry by a single Ctrl+Z. The value stored is the value you typed, not a measurement taken afterwards.

Typing over a dimension that is already locked changes it. There is no unlock step. The same goes for a reference (parenthesised) dimension: typing over one promotes it to a lock at that value, because typing a number states an intent where a reference dimension only reports one.

Every value you type is applied by the same constraint solver that handles a vertex drag, so the locks you have set are honoured exactly as they are on the canvas. A value your locks cannot satisfy is refused, and the reason is shown in the dialog — the table keeps showing the value that is actually in force. Nothing is quietly adjusted to a number you did not ask for.

Where the lock itself cannot be created, you are told. Each locked dimension uses up a degree of freedom, so a heavily dimensioned ring eventually reaches the point where one more lock would conflict with the ones already there. When that happens the geometry still takes the number you typed — that much is always legal — but no constraint is created to hold it, and a notice says so and names what it conflicts with. Read it as a prompt to remove a lock you no longer need.

A locked radius can be changed by typing over it, exactly like a length or an angle. What the padlock still refuses is anything that would destroy the arc: clearing the cell to straighten the edge, or deleting either of the vertices the arc runs between. Unlock it first, or move the lock somewhere else.

Deleting a vertex next to an unlocked arc leaves the merged edge straight. The arc’s curvature is described relative to the line between its two ends, so carrying it onto the longer merged edge would quietly give you a different radius than the one you drew — the dialog names any dimension it removed instead.

Three edits behave in ways worth knowing about:

• Clearing the Radius cell straightens the arc. That removes the arc itself, so a radius lock on it can no longer apply. The dialog names the constraints it removed rather than leaving them listed but doing nothing.

• Setting a radius on a straight edge is refused. Which side the edge bulges towards is a decision the table cannot make for you — add the arc from the edge’s radius control on the canvas, which asks, and then set its radius here.

• An edit that would turn the ring inside out is refused. Moving a vertex past the far side of the section, or deleting the vertex that gives the ring its shape, can leave a valid outline that runs the opposite way round. Reinforcement placed against a face would then be measured from the wrong side, so the edit is refused and the table tells you to move the vertex somewhere that keeps the ring the same way round. (This is why it is refused here and normalised when you draw an outline: a fresh ring carries no reinforcement, cover or fire declarations to be re-pointed, and an existing section does.)

• Clearing the Radius cell is refused while any individual bar is placed on a corner. Straightening an edge gives back the vertex the rounded corner had absorbed, so the section gains a corner and every corner after it is renumbered — the same renumbering a vertex deletion causes, arrived at from the other direction. A bar anchored to a corner would end up on a different one. Move or remove the bar first. Adding or removing an arc from the canvas is refused for the same reason and with the same remedy: it is one rule, and both surfaces apply it. Changing an existing arc’s radius is unaffected — the edge stays curved and the corner count does not move.

• On a section with a rounded corner, deleting a vertex is refused while any individual bar is placed on a corner. Rounding a corner merges the two straight faces and the curve between them into a single corner for reinforcement purposes, so the section has fewer corners than it has vertices — and after a deletion there is no way to be certain which corner a bar was meant to sit on. The table asks you to remove or re-place the bar rather than moving it somewhere it may not belong. Sections with no curves are unaffected: their corners and vertices correspond exactly, and bars are re-pointed automatically as before.

• An edit that would flatten the ring, or fold it through itself, is refused. Typing a coordinate that puts a vertex in line with its neighbours leaves a shape with no area; typing one that folds a face across another leaves a figure-of-eight. Both are refused at the point of typing, naming which happened, rather than being accepted and failing later when the section properties are calculated. Curved edges are tested as the curves they are, the same way the drawing tool tests them, so an arc folded through the ring is refused here too. Typing an arc’s two ends onto the same point is refused as the zero-length edge it is, with the same wording the drawing tool uses.

Each accepted edit is a single step, so one Ctrl+Z undoes one typed value.

Changing a ring’s role, and deleting one

The ring selector is also where a ring’s role is changed and where a ring is deleted. This is the only place in ACS that offers either.

• Role — setting a void’s role to Outline makes it the section outline. The previous outline cannot become a void of the ring inside it, so it is replaced, and reinforcement and tendons reset for the same reason they do on a redraw; the other voids go with them. Because that is the same loss a redraw causes, it asks the same question first: a confirmation counts what will be cleared and says which of it undo does not bring back, exactly as the redraw prompt does. Cancel leaves the section untouched. Once confirmed, the whole promotion is one step, so a single Ctrl+Z restores the previous section — apart from the fire and cover declarations, which the prompt already told you it would not. Every void runs the opposite way round to an outline — that is the convention, and drawn and template voids alike follow it — so promotion turns the ring round automatically. Curved rings included, a circular bore among them: reversing a curve moves each bulge to the segment it now leaves and flips its sense, which is what keeps the shape the same and only its direction different. A void that would not be a valid outline in its own right is refused, and the note names the rule it broke — it is the same five-rule gate the drawing tools apply, so it is any of the outline refusals above: too few vertices, an arc sweeping more than 315°, two neighbouring vertices in the same place, crossing edges, or no enclosed area. Crossings are judged on the curves themselves, so two arcs bulging through each other are caught here exactly as they are while drawing: promotion and the drawing tools run the same check, and there is no case where one accepts a ring the other would refuse.
• Delete ring — removes the selected void. The section outline cannot be deleted while it is the outline: make another ring the outline first (Role → Outline, above), which turns this one into a void, and then delete it. Removing a ring renumbers every face after it, so the fire exposure declarations and the per-edge cover overrides reset rather than silently re-pointing at faces you did not choose. The dialog says which reset, and undo restores the geometry but not the declarations.

A void that is part of a parametric circular hollow section can be neither edited nor deleted from the table: its geometry is rebuilt from the section’s diameters, so a typed value would be overwritten, and removing it would turn the hollow into a plain solid ring and lose the template the dialog reopens from. Change the inner diameter on the canvas instead. A void that is simply unfinished — too few vertices to be a shape yet — can still be deleted, since this is the only place that offers it.

Persisted locks

Every lock is a padlock, and there are only two places to click one. Beside the dimension it belongs to on the canvas, or in the matching column of the geometry table’s Lines tab. Those are the same lock seen twice — toggling either is reflected in the other, because both write one constraint on the geometry. There is no “lock” button in the on-canvas action bar; that bar authors geometric constraints (Parallel, Perpendicular, Equal length, Tangent, Equal radius, Coincident, Collinear, Symmetric, Midpoint, Horizontal, Vertical, Fix) and dimensional locks are not among them.

A lock always pins the value currently in force, exactly as displayed. To change it, type the new value into the dimension — on the canvas or in the table — rather than looking for a target field on the padlock.

Clicking a padlock is not the only way to create one. Typing a value into a dimension creates the lock at that value in the same step (see What a typed value can and cannot do). The padlock is then how you remove one, or how you lock a dimension at the value it already has without retyping it.

Dimension locks

A dimension lock pins one edge’s length to its current value. Click the padlock beside that edge’s length dimension on the canvas, or the padlock in the Length column of the Lines tab.

The lock is saved immediately as a constraint record. It persists across page refreshes and is visible in the Constraint List Panel.

Angle locks

An angle lock pins the interior angle at a vertex — the angle between the two edges meeting there — to its current value. Click the padlock beside that angle’s dimension on the canvas, or the padlock in the Angle column of the Lines tab.

The constraint record stores the target angle; the solver maintains it as surrounding geometry is edited.

Arc radius locks

An arc radius lock pins an arc segment’s radius to its current value, preventing it from changing as adjacent vertices or edges are modified. This is useful when a fillet radius must remain exact (e.g. a cover-radius requirement) while the surrounding rectilinear frame is dimensioned independently.

Click the padlock beside the arc’s radius dimension on the canvas — it is drawn with the dimension itself, so there is no arc to select first — or the padlock in the Radius column of the Lines tab.

Unlocking restores the arc to a free-radius state — the radius is free to change with the adjacent geometry.

:::note Migration note: Dimension, angle, and radius locks created before 2026-07-17 were stored as ephemeral React state and were lost on page refresh. Locks created on or after 2026-07-17 are persisted as constraint records and survive refresh. If you had locks in a section created before this date, re-add them after the update. :::

Vertex dragging with live constraint enforcement

Dragging a vertex on the ACS canvas triggers a VertexDragSession — a per-frame rough-solve that keeps all active constraints satisfied while the drag is in progress. The solver runs a lightweight forward pass on each pointer-move event, adjusting connected geometry to honour locks before rendering the updated preview.

Refuse-not-clamp for arcs

Dragging a vertex that ends an arc can ask for geometry the arc cannot keep — a chord its locked radius cannot span, or a position that would flip the arc to the other side of its chord. Such a move is refused, never clamped to the nearest arc that would fit: returning a geometrically inconsistent arc (one whose mid-point diverges from the computed centre) is worse than declining the move (§874).

The refusal takes one of two forms, and which one you get depends on when it happens:

• During the drag — every pointer move is a rough solve, and a frame the solver cannot satisfy is simply not drawn. The handle sticks at the last frame that solved and stays there until the pointer returns to somewhere the sketch can reach. Nothing is reverted; you are still mid-drag.
• On release — a fine solve tightens the rough result. If that refuses, the whole drag reverts to the geometry as it was before you pressed the mouse — not to the last frame you saw — and a toast titled Cannot move vertex opens with the kernel’s reason, verbatim, for example “Edge 2’s arc would flip to the other side of its chord — adjust the arc first or undo.” The toast names the problem and nothing else; it does not suggest a remedy.

Constraints honoured during drag

All constraint types active in the section are enforced per frame:

• Locked dimensions and angles are re-satisfied after each pointer move.
• Arc radius locks hold the radius fixed; the arc centre shifts to accommodate the moved endpoint.
• Coincident constraints keep coupled vertices co-located.

If a rough solve cannot satisfy every constraint, that frame is refused and the handle stays at the last frame that did solve — the same behaviour as an arc refusal. No partial or inconsistent geometry is displayed.

Editing a void

Everything on this page applies to a void exactly as it does to the outline. A void’s vertices drag, its edges carry length, angle and radius padlocks, and both are the same locks the geometry table shows — so a duct is edited where you see it rather than only by typing. Drawn and template voids alike; a box girder’s cells are editable without redrawing them.

Void handles appear when you hover the ring or select part of it, the same way the outline’s do.

Because a constraint can link a void to the outline, a drag on either can legitimately move the other — a duct held a fixed distance off the soffit follows the soffit when you drag it, and vice versa. Whatever moves, it moves as one step: a single Ctrl+Z puts it all back.

Dragging a void out of the section is allowed, and it is not clamped to keep it inside. The drag lands exactly where you gestured, the ring is flagged, and section properties and analysis are unavailable until it is back inside — the same state, message and banner as a void outside the section. Dragging the outline away from a void that was inside it is the same state and behaves identically.

Dragging a void onto another void is refused, and it is the one refusal on this page that undoes your gesture: the ring returns to where it was, and a message names the two voids. Overlapping holes would be double-counted, so the section could not be saved at all — and unlike a void outside the outline, there is no stage of modelling where two holes in the same place is what you meant. The same refusal covers the geometry table and a constraint solve that would do it, so no route can commit it. A pair that already overlaps stays editable: only an edit that creates the overlap is refused, so you can always drag the rings back apart.

If an edit ever leaves the section in some other state the server will not store — an outline edited until it crosses itself, for instance — a banner at the top of the editor says your changes are not being saved, and stays until the geometry is corrected and a save gets through. It is deliberately separate from the section-properties message, and the difference matters: see Two banners, two different problems.

The bore of a parametric circular hollow section is the one exception. It is rebuilt from the diameters you type, so a drag or a lock on it would be silently overwritten. It offers no drag handle and no padlock at all — change the inner diameter on the canvas instead. This is the same exclusion that applies to constraining it.

Constraint status and conflict UI

Status chip

The tool topbar — the strip above the editor, beside the save indicator — carries a constraint status chip summarising the sketch’s health at a glance. It has four states, and each carries its own icon so it is readable without colour:

The chip updates live as constraints are added, modified, or removed.

Conflict dialog

When a new constraint conflicts with the existing set, the Conflict dialog opens before the constraint is applied:

1. The incoming constraint is named, and the existing constraints it conflicts with are listed.
2. Add as driven — where offered — installs it as a reference dimension instead: it displays the measured value in parentheses without constraining the geometry, so you keep the readout without the conflict.
3. Cancel discards the new constraint and leaves the existing set untouched. It is the focused default.

Nothing in this dialog removes an existing constraint. To resolve a conflict by dropping one, cancel here and delete it from the Constraint List Panel.

The incoming constraint is named by what it locks and where — for example Distance 600.0 mm on edge 1, Angle 90.0° at vertex 3, or Radius 75.0 mm on edge 2. Edges and vertices are numbered from 1, matching the E1, E2, … and node labels the canvas draws when Element numbers or Node numbers is enabled.

No constraint is ever silently discarded. Every conflict requires an explicit decision.

Driven dimensions

A driven dimension is a reference readout. As the conflict dialog puts it: “A driven dimension displays the measured value in parentheses without constraining the geometry.” It reads (450.0) where a driving one reads 450.0, it moves with the geometry instead of holding it, and because it applies no force to the sketch it can never conflict with anything. Only the dimensional constraints — a length, an angle, a radius, or a cross-element distance — have a driven form; a Parallel or a Tangent has no value to report.

There are two ways to get one:

• Add as driven in the conflict dialog, when a lock you asked for would fight the constraints already in place. The dimension is installed driven, so you keep the number on the canvas without the conflict.
• Make driven in the Constraint List Panel — the parentheses button on a dimensional row, whose hover text reads “Driving — click to demote to a driven reference dimension”. Demoting removes a constraint from the solve, so it always succeeds.

And two ways back:

• Make driving on the same button, whose hover text reads “Driven (reference) — click to promote to driving at the measured value”.
• The padlock beside the dimension, on the canvas or in the geometry table’s Lines tab — clicking it on a driven dimension promotes it rather than removing it.

Either way the dimension is locked at the value currently measured, not at whatever it was locked at before it was demoted, and the promotion goes through the same gate as a new lock. If the measured value cannot be held alongside the other constraints, the conflict dialog opens naming them — this time with only Cancel to offer, since the dimension is already driven. Any other refusal (a collapsed edge that cannot be measured, for instance) shows as a toast titled Cannot change driven state.

This is the page’s answer to a conflict you want to keep the readout of. The other answer — cancel, then delete an existing constraint — is in the Constraint List Panel below.

Constraint List Panel

The Constraint List Panel lists every active constraint. It is the Constraints section of the left panel’s General tab — expand it there; it is collapsed by default and there is no tab of its own.

Each row carries, left to right:

Driven is a flag of its own, not a fourth state: a driven dimension is still ok, redundant or conflicting like any other row, and its badge says both.

Constraint values are not edited here — there is no value column. Type them into the dimension itself, on the canvas or in the geometry table’s Lines tab.

The panel is the same shared component used across GCS and LGS, so the vocabulary (glyphs, badge colours, driven-toggle behaviour) is consistent across all tools.

View options

The View Options panel controls which canvas overlays are visible. It is collapsed by default — click the View button in the top-right corner of the canvas to open or close it. Its state is remembered in your browser.

These labels are the same identifiers used in the geometry table, the conflict dialog, and error messages — enabling them is the quickest way to match a message’s Edge 3 or Vertex 2 to the canvas.

Auto-frame on load

When the editor opens a section that already has saved geometry, the canvas automatically calls Zoom to fit to frame the section in view. You do not need to click anything — the section is centred and sized to fill the canvas on every load.

If you prefer a specific zoom level, use the zoom controls or pinch-to-zoom after the auto-frame runs. Your zoom position is not persisted between sessions; the auto-frame always re-centres on load.

The same framing runs when you apply a template over a section that already exists. That replaces the outline with a different section rather than editing the current one, so no part of the old view is worth holding still — and without the re-frame, a template much shallower or much smaller than what it replaced could be drawn outside the visible area, leaving the canvas looking blank until you clicked the house icon.

Ordinary edits never re-frame. Dragging a vertex, typing a dimension into the geometry table and solving a constraint all leave the view exactly where you put it — the zoom you set up in order to make an edit survives the edit.

Keyboard shortcuts

On macOS, use ⌘ in place of Ctrl for undo and redo. Both also have buttons in the top-left of the canvas — and the keyboard shortcuts keep working after an undo empties the section, when those buttons are not on screen.

The locks have no keyboard shortcut, and no button either — they are padlocks. Click the one beside the dimension on the canvas, or in the matching column of the geometry table’s Lines tab. See Persisted locks.

Deleting a constraint has no keyboard shortcut either: use the delete control in the Constraint List Panel.

Tips

• A padlock locks the value you see — clicking it before or after you tidy the rough geometry seeds the lock identically, at the length, angle or radius as measured at that moment. To lock at a different value, type it into the dimension instead of clicking the padlock; that creates the lock at the typed value in one step.
• Use arc radius locks early when fillets must meet a cover specification; they prevent the radius drifting when you resize the surrounding frame.
• The status chip is the fastest way to check whether the sketch is fully constrained before running an analysis.
• If a drag ends in a Cannot move vertex toast, the reason it carries is the whole diagnosis. Where an arc is named, the usual fixes are to unlock or retype its radius, or to aim the vertex somewhere the arc can follow — and Ctrl+Z is never needed, because a refused release has already put everything back.

Next steps

• Constraint types — the full GCS constraint vocabulary applies to ACS: parallel, perpendicular, coincident, equal-length, equal-radius, midpoint, tangent, and symmetric constraints are all authored from the on-canvas action bar, and listed in the Constraints section of the General tab.
• Section geometry — drawing and editing the base geometry before applying constraints.
• Reinforcement — placing and configuring longitudinal bars after the geometry is constrained.