Horizontal alignments
The centreline — a continuous, station-referenced path of tangents, circular curves and clothoid spirals. Every surface, corridor, profile and section refers back to it.
Segment types
| Segment | Geometry | Defined by |
|---|---|---|
| Tangent | Straight line; constant bearing, zero curvature. | Start point, bearing, length. |
| Circular curve | Constant-radius arc; curvature κ = 1/R. | Radius (signed by turn direction) and arc length. |
| Clothoid (spiral) | Euler spiral; curvature changes linearly along its length. | End radius and length; the transition between a tangent and a curve (or two curves). Where superelevation runoff naturally lives. |
km+m.mm
(12+345.00). Bearing = degrees, 0° = North (+Y), clockwise.
Radius is stored signed: positive turns right, negative turns left.
Drawing in Plan
- Draw › Alignment (Ctrl+Shift+A) — click PIs to lay a tangent chain. Endpoints snap to nearby vertices.
- Draw › Curve (Ctrl+Shift+C) — fit a circular curve by PI + radius.
- Draw › Spiral (Ctrl+Shift+S) — add a clothoid by end radius + length.
- Esc — finish the tool.
The Alignment Builder dock
The precise, numeric way to build and edit. One row per segment, with these columns:
| Column | Editable? | Meaning |
|---|---|---|
| # | no | Segment index (0-based). |
| Type | no | Tangent / Curve / Spiral. |
| Start s | no | Cumulative start station (m). |
| Length | yes | Segment length (m); double-click to edit. |
| End s | no | End station (computed). |
| Radius | curves only | Magnitude shown; sign follows the turn direction. |
| Params | no | Tangent: bearing X°. Curve: left/right. Spiral: R: start → end (∞ for a straight end). |
Tangent lock (reflow)
The Tangent lock checkbox (default on) controls how edits propagate:
- On — editing a Length or Radius reflows every downstream segment to keep the centreline continuous (Civil-3D behaviour). Grip drags keep the PI tangent.
- Off — each segment is edited in place at its own anchor; gaps and kinks are allowed.
Add / Insert / Delete
| Action | Fields (defaults) |
|---|---|
| Add Tangent | First segment: E, N, Bearing, Length (0, 0, 0°, 50 m). Subsequent: start E/N/bearing locked to the previous end, only Length editable. Bearing 0–720°, length ≥ 0.001 m. |
| Add Curve | Radius (100 m, ≥ 0.01), Arc length (50 m), Direction (0 = right, 1 = left). Needs at least one segment first. |
| Add Spiral | End radius (100 m), Spiral length (30 m), Direction (pre-matched to the previous curve). Length must be > 0. |
| Insert … | Same fields, but spliced above the selected row and re-anchored to the previous segment's end. |
| Delete Selected | Removes the row and re-anchors the rest; refuses to empty the alignment. |
Deriving alignments from existing geometry
| Command | Result |
|---|---|
| Offset Alignment… | A true parallel alignment at a signed offset — per-element, so curves stay concentric (not a flat shift). You also give a cross-fall (default 2 %): when the parent has a design profile the offset gets one too, following the parent's crown dropped by cross-fall × offset. Both the plan AND the profile are dynamic — edit the parent's geometry or profile and every bonded offset re-derives. Cross-slope source picks what that profile follows: Constant cross-fall (the crown alone), or Cross-fall + corridor superelevation — the crown plus, station by station, the superelevation diagram of the corridor riding this centreline (Superelevation from names it; the default is the first corridor on the centreline). In a curve the edge then sits exactly where the corridor bakes the rotated lane edge (z = crown − cross-fall × |offset| + (offset − pivot) × e, right side up for a positive rate, pivot = the corridor's axis of rotation), so a curb return or corner corridor that targets it locks to the real level; editing the corridor's superelevation re-derives the edge. An offset is refused (nothing is created, and the Event Viewer says so) where the parallel does not exist: an arc whose offset reaches past its centre, a spiral the offset swallows, or the inside of a corner so sharp that the offset edge would fold back over itself. Headless: road.align.offset (parent, offset, cross_slope, super = 1, optional corridor). See Superelevation. |
| Alignment from Corridor… | Extract a centreline from a corridor edge / feature line. |
| Corridor Feature Lines (all)… | Extract every breakline string from a corridor at once. |
| Alignment from Existing (copy) | Duplicate an alignment. |
| Best Fit Alignment… | Least-squares alignment through a cloud of points. |
| Connected Alignment… | A fillet (tangent–arc–tangent, given a radius) joining the END of one alignment to the START of another — the manual curb return. It is bonded to both parents, so when a parent's end moves the fillet re-solves, and its profile re-ties to the two parents' levels. This is what lets you build an intersection by hand: offset the road edges, connect them into curb returns, and the whole web stays live under a centreline edit. |
| Curb Return… | The Civil-3D hand recipe for a corner: pick the two edge alignments (offset alignments of the two roads) and a radius; the curb return is the fillet arc tangent to both edges at their crossing, solved against the edge curves (a curved primary gets a true tangent point). Quadrant is Auto by default — the arc lies on the side of each edge away from that edge's own centreline, i.e. the corner outside both roads, so the drawing direction of the roads never matters; the four explicit choices (left/right of A, left/right of B) are for edges without a parent centreline. The arc is oriented with the junction on its left, which is the lane side of the Curb Return Fillets assembly (lane left, kerb + sidewalk right). Its profile has two VPIs locked to the edge profiles at the tangent points. The curb return is bonded to its two edges: move or re-profile a road and the edges re-offset, the arc re-solves on the new edges in its recorded quadrant and radius, and its profile ends re-tie (interior VPIs you added survive); editing its radius in Properties re-solves it too. Then run a corridor on it (Create Corridor…, assembly Curb Return Fillets; on a curb-return baseline the dialog defaults to a 2 m frequency and prefills Width target A / B from the arc's bond — its primary edge and the other road's centreline — and lists whole assemblies only, never the Composer's subassembly parts) and bind its region's width targets to the primary road's edge and the secondary road's centreline: at every station the lane widens to the nearer of the two and takes its outer level from that alignment's profile — width 0 at the primary tangent point, the secondary half-width at the secondary tangent point, no surface anywhere in the chain. Refusals (no crossing, radius too large, Auto without parents) are explained in the Event Viewer. The library ships the rest of Civil 3D's intersection assembly set, composed from the stock parts (Lane Superelevation AOR, Urban Curb Gutter General, Urban Sidewalk, Daylight General): Primary Road Full Section outside the intersection; Primary Road Part Section – Daylight Left/Right through a T (kerb, sidewalk and daylight only on the side away from the secondary) or Primary Road Lanes Only through a four-way box; Secondary Road Half Section – Daylight Left/Right for the secondary's approach up to the curb-return tangent point (its outer half; the corner fans fill the inner half); Secondary Road Full Section beyond. Split the primary's regions at @<curb return>.start/.end, end the secondary's region at the curb return's tangent point, and bind each lane's width/elevation targets and each daylight's surface target by name in Corridor Properties › Targets (every unnamed daylight takes the corridor's target surface by default). |
| Tie Profile to Crossing… | The manual Knotenpunkt level lock: pick a reference road (keeps its profile) and a road to adjust; the adjusted road's VPI at the crossing is moved — or inserted — so both centrelines meet at one design elevation there. An intersection is a single physical point, so this must hold or the curb returns and pavement come out wrong (see Junction level in the Design Issues audit). Undoable. |
| Junction (Intersection)… | The Civil-3D-style Create Intersection wizard where two alignments cross: pick primary/secondary road, corridor type (all crowns / primary crown maintained), curb radius (uniform or per corner) and half-widths. It is a macro over the manual tools: it generates the four edge offsets and then each corner as a manual curb return between the two edges (the same solver, the same edge-level profile and bond as Draw › Curb Return…), plus optional turn-lane flares; under primary crown maintained each corner corridor targets the primary's edge and the secondary's centreline (Civil 3D's set) and the secondary yields its whole box to the fans and the primary section and — with Create intersection corridors on — builds the corridor model from an assembly set: one assembly per section type (Curb return fillets, Primary road through section, Secondary road through section). Each entry can be an existing project assembly, or (auto) creates a ready-made flow assembly (Point/Link/Shape, editable in the Composer) under Intersection Assemblies. The four curb-return fillets are bundled into ONE multi-baseline corridor (Civil-3D style: the curb returns are baselines of a single Intersection Corridor), each baseline carrying its own assembly and width targets and staying live when a road moves. Roads that already run a corridor get their box region split and bound to Primary Road Lanes Only from the library set (both lanes at the road's half-width, no kerbs — the corner fans and their kerbs own the rest); a primary without a corridor gets one covering just the box. At a T, swap the primary's box region to the matching Primary Road Part Section – Daylight Left/Right in Corridor Properties to carry the far-side kerb and daylight through. An intersection is a single physical point, so both centrelines must reach it at the same design level; leave Tie road B's profile to the crossing level on (the default) and the secondary road's VPI at the crossing is moved — or inserted — to meet the primary's elevation, as one undoable edit. The tie is live: edit the primary road's profile or geometry later and the secondary re-ties itself at the crossing (editing the secondary is left to you, and any drift shows in the audit). Switch it off and you are warned instead, and the mismatch keeps showing in Design Issues as Junction level: nothing downstream errors on it, so an untied intersection looks built but is wrong. Editing a junction's curb radius or half-widths in Properties (per-corner radii and the crown type are editable there too) regenerates the curb returns, the edges and the carved box. Editing a curb return's own Fillet radius in Properties writes it into the junction's slot for that corner (the quadrant the arc actually lies in) and regenerates; one undo restores both. The standalone crown-aware pavement TIN is opt-in (off by default) — the corridor model itself is the intersection surface. The same model can be assembled manually: create your own curb-return / edge alignments, run corridors on them, then split regions and assign assemblies per region in Corridor Properties. |
| Roundabout (Kreisel)… | The VSS 40 263 Create Roundabout wizard. Check the leg alignments (a road passing through contributes two arms — the centre lands on the crossing of the first two checked legs) and leave the dimension fields at 0 to take them from the loaded design standard: ICD mid-range for the location (inside/outside built-up), circulatory width from the norm’s Fig. 5 curve, entry radius Rc2 and exit radius Ra2. The wizard generates the circulatory ring (a real full-circle alignment) and per arm the entry/exit curb arcs, each tangent to the leg edge and the ring — all normal, editable alignments grouped under the roundabout. The system is live: move a leg and the arcs re-solve; edit the ICD or radii in Properties and the model regenerates. Manual design works two ways: edit any generated piece by hand and it freezes (regeneration keeps your version from then on), or draw your own ring first and pick it under Circulatory ring — the roundabout adopts it, taking centre and diameter from your circle (accepted by measurement: any closed constant-radius alignment qualifies, whether one 360° arc or four 90° arcs). In Plan the roundabout draws its inscribed circle, island edge, inner-ring boundary and splitter islands live from the parameters; clicking any of them selects the roundabout. On creation the status bar reports the achieved deflection of the fastest through path (VSS 40 263 §17 demands > 45 gon — the anti-speeding core of the design); With Create the roundabout corridor on, ONE multi-baseline corridor is built: the circulatory carriageway on the ring (auto-created lane assembly at ring width) plus an apron baseline per entry/exit arc — and the ring rides a plane profile fitted through the leg levels at the arms (VSS: the whole roundabout lies on a plane ≤5 %). Carve leg corridors yields each leg corridor’s span inside the circle to the ring (nothing double-bakes). The corridor refreshes in place on regeneration, and assembly reassignments made in Corridor Properties survive. The always-on Design Issues audit re-checks every roundabout live against the standard: through deflection per entry (< 45 gon shows hard/red), circulatory width against the Fig. 5 curve, the ICD range for the location class (an Inside built-up area toggle in Properties), and the plane slope over 5 % — each issue carrying its norm citation. Headless callers run the same engine command as road.roundabout.create. |
| Multi-Leg Intersection… | A T / Y / N-way junction of several crossing alignments. Each leg can be checked on/off and given its own half-width, so a wide arterial can meet narrow side streets. One curb radius rounds every corner, or tick Different radius per corner to set each curb return individually; afterwards the junction's Properties dock lists one Curb R corner N (sorted legs) field per corner, and editing a curb return's own Fillet radius writes that corner's field. Moving a leg re-offsets its edges first and then re-solves every corner on them, in one undo step. Tick Create curb-return corridors (assembly set) to build one corner corridor per curb return: each corner is a manual curb return between the two adjacent leg edges (the same solver, edge-level profile and bond as Draw › Curb Return…), running the Curb Return Fillets assembly; corners on the first (primary) leg target its edge and the other leg's centreline, corners between two secondary legs target the two edges. Secondary legs yield their whole box to the fans and the primary section, so only the primary gets a box-only corridor when it has none. Tick Split crossing corridors (box + through sections) to carve the intersection box into the corridor already running on each leg and bind that leg's through section — the first checked leg is the primary and keeps its section across the box, while the others yield the middle to it, exactly like the two-road junction. A leg with no corridor of its own gets a box-only corridor covering just the intersection. Add turn-lane widening flares a turn pocket in on every leg (per-side), emitted as edge alignments tied to each road's profile — and optionally built as real corridors (3D pavement bodies) with a chosen assembly. |
Sight distance
Tools › Sight Distance Analysis… checks how far
the driver can actually see along a road, against the stopping sight
distance the loaded design standard requires at the
local design speed (the V_P bands). The sweep casts a true 3D sight line
from the driver’s eye (standard eye height, mid-lane offset) to a low object ahead and
tests it against the ground surfaces and — optionally — the road’s own baked
corridor surfaces, so a crest hides the target behind the design surface and an
inside-curve cut slope blocks it laterally (the VSS 40 090b Fig. 3 envelope,
computed). Results come back as pass/fail station bands with available vs
required distances. The Design Issues panel runs the same sweep coarsely
against the terrain and reports each failing band as a cited hard issue — tick
Include sight distance there to ask for it. It is off while you edit because it
is by far the most expensive check: it walks the line of sight outward at every station
and re-tests it against the ground, so on a large project it takes minutes while every
other criterion together takes milliseconds. The red markers in Plan and the panel’s
live list always cover the geometric criteria (radius, grade, K, clothoid, widening,
junction level). Headless
callers run road.sight.analyze. After a run, the Profile shows a SIGHT band under the grid (green = pass, red = fail) and the Plan flanks the failing station ranges in red. The audit also checks visibility triangles (VSS 40 273a): at every junction the yielding driver — observing from B = 3 m (5 m outside built-up) behind the priority road’s edge — must see the Tab. 1 sight distance along it in both directions at the local design speed, and every roundabout entry must see the required distance along the ring; blocked sight lines appear as hard, cited issues.
Modifying
Move (by X, Y), Rotate (around a
pivot), Mirror (across an axis/point) and
Delete act on the selected alignment — also on the
command line as MOVE / ROTATE / MIRROR /
DELETE. To grow an alignment rather than reshape it, select it and
type TANGENT, CURVE or SPIRAL: each one
continues the chain tangentially from its end (see
Commands). Editing an alignment automatically rebuilds every corridor
that references it (and extends a too-short vertical profile so the 3D ribbon
doesn't stop short).
Design-speed bands (VP)
A road does not have one speed. Swiss practice (and the design standards generally) separates VA — the stretch-wide speed that fixes the extreme elements and the cross-section — from VP, the point-wise speed that a location actually permits, which governs sight distance, vertical rounding and the superelevation assessment. The project speed in Tools ▸ Design Standard is the VA; the VP profile lives on the alignment as a list of bands.
Right-click the alignment in the Object Browser and choose
Derive Design-Speed Bands: each circular arc takes the
speed its radius permits from the standard's VP table (an
intermediate radius takes the next tabulated speed up),
tangents take VA, and a transition curve inherits the slower
of its neighbours. Tune the result in Properties as
station=speed; station=speed....
The audit then evaluates every speed-dependent rule at the local VP — minimum radius, minimum arc and maximum tangent lengths, crest and sag K-values — so a tight curve designed for 60 km/h is judged at 60, not at the project speed. It also checks the standard's speed diagram: where VP drops, the preceding element must be long enough for the driver to slow down at 0.8 m/s², otherwise the drop is reported as a Speed step.
Station equations (broken chainage)
When a revision shortens or lengthens a stretch after the chainage is already in drawings, stakes and land-acquisition files, re-numbering the whole road is not an option. Instead you place a station equation at the splice: everything before keeps its numbering, everything after continues from a new value — the classic «2+500 back = 2+580 ahead».
Enter them in the Properties dock of the alignment as
raw=ahead; raw=ahead... where raw is the true
distance from the alignment start and ahead the station to
display from there on; append d to make the numbering
count down after the point. Station labels in Plan, the Profile
station band and VPI labels, section captions and the Design Issues list
all switch to the project's numbers immediately.
Equations change numbering, never geometry. Every
computation — sampling, corridor bakes, volumes, exports of
coordinates — keeps running on the true distance from the start,
so adding an equation can never move the road. LandXML import/export
carries them as <StaEquation>.
Rail: cant
Cant is the rail equivalent of superelevation: the outer rail is raised through a curve so the resultant force stays near the track centre. The applied cant is the equilibrium cant G·V²/(127·R) capped at the standard's maximum, and what a faster train still feels above that is the cant deficiency.
Cant cannot step. One rail has to be lifted over a length, and every standard caps how fast — the working figure is 1 to 2.5 mm per metre of track. Where the alignment has a transition curve the curvature ramps and the cant ramps with it. Where a tangent runs straight into a circular curve there is nothing to ramp along, so a virtual ramp is used instead, half either side of the junction by default. A transition that is too short for the cant it must build up is left exactly as designed and reported instead, because shortening the ramp is a decision, not a rounding.
File › Import / Export › Import LandXML (and the same
entry on the Output ribbon) reads a file back: the alignments with their profiles and
broken chainage, and a surface if the file holds one, in one undoable step. An
alignment that carries <Cant> is a railway, so it
comes in categorised as rail with its cant profile attached — the way Civil 3D
reads one. A file holding neither alignments nor a surface says why rather than
reporting a quiet success. An alignment whose geometry cannot be read in full
— an element type the reader does not know, such as
<IrregularLine>, or an element that does not join the one
before it — is not imported rather than brought in as a
shorter piece: the import names it and what could not be read, and the other
alignments in the file come in as usual.
Cant travels in LandXML. Exporting an alignment that carries a
cant profile writes a <Cant> block with the applied cant at every
station the profile states, and reading a LandXML file back brings that cant with
the alignment. It is the one rail exchange every product in this field speaks, and
a file carrying cant describes a rail alignment rather than a road. Between
two stated stations a reader can only draw a straight line, so a transition law
(Bloss, cosine, sine, Helmert) survives a round trip at the stations it names, not
between them — state the intermediate stations if the shape matters.
Two rail criteria are in the always-on Design Issues list: Cant deficiency (a curve too sharp to cant enough at the design speed) and Cant ramp (cant changing faster than the standard allows). Both read the alignment's stored cant profile when it has one — the cant actually designed — and the equilibrium cant capped at the standard's maximum otherwise; in that case a curve that starts straight off a tangent, with no transition to build its cant along, is reported as No transition. The Rail menu's cant table and CSV export show the same diagram station by station.
Rail: turnouts and crossovers
Rail › Turnouts › Create Turnout / Crossover… branches a second track off a rail alignment at a station you pick. A turnout is named by its crossing 1:N — a 1:9 opens 6.34°, a 1:12 opens 4.76° — and by its lead radius; the built-in catalogues (UIC/EN 13803, AREMA, DB Ril 800) carry the usual pairings. The crossing angle is the angle between the two tracks, so a turnout laid in a curve carries the main track's curvature in addition to its own and still opens the catalogue angle: the frog sits the same distance off the main whether the track there is straight or curving. The lead keeps its catalogue length either way, because the steelwork does not stretch.
A crossover takes the train onto a parallel track: out to the crossing angle, a diagonal across the gap, then a reverse curve back onto the target's heading. It is solved against the real main track, so it lands on the given spacing and parallel to it on curved track as well as straight. Tick Snap to 2nd track and it measures the live distance and side to the track you name instead of trusting a typed spacing, so it follows that track when it moves. Past the frog the branch is an ordinary alignment: give it a profile, cant and a corridor like any other.
Diamonds, slips and three-way turnouts
A station throat is not made of simple turnouts alone, and the same Create Turnout / Crossover… command lays the rest of the family. A diamond (Kreuzung) is two tracks crossing at the crossing angle with no switching. A single slip (EKW) adds one connecting curve between the two tracks, a double slip (DKW) two; each connecting curve is the arc of the unit's radius tangent to one track before the crossing and to the other after it, so it leaves and arrives along the rails it joins. A double slip's two curves mirror each other through the crossing point: one runs from the main track before the crossing onto the crossing track after it, the other from the crossing track before the crossing onto the main track after it. A three-way turnout branches both ways from one point at the same crossing.
All of them are built in the frame of the track they sit on, so they open the catalogue angle in a curve exactly as a simple turnout does. The whole unit is one object: select it anywhere, and its connecting curves and second branch move, persist and export with it.
The turnout catalogue
Which turnouts exist is a property of the railway, not of this program:
DB works to Ril 800.0120, SBB to I-22046, an American railroad to its AREMA
portfolio, and most offices keep a table of their own. So catalogues are
files — catalogs/rail/*.xml beside the program,
in the same XML family as the design standards. Everything found there is
registered at startup, and a catalogue whose name matches a built-in table
replaces it. With no files at all the built-in tables still work, so the program
never comes up without turnouts.
Rail › Content › Turnout Catalog lists what is loaded, where each catalogue came from and what is in it. Load New Catalog reads a file and reports what is wrong with it if it will not parse; loading a catalogue of a name already present replaces it, which is how you refresh one you have edited. Unload drops a loaded file and brings the built-in of that name back.
A row carries the designation the drawing shows, what kind of unit it is
(turnout, crossover, single slip, double slip, diamond, three-way), which
hand, the crossing 1:N, the branch radius, and — where your table states them
— the lead length, the switch-blade length and the rail profile. Any further
column your source has is kept verbatim in <extra> rows, so a
catalogue round-trips without losing anything:
<yu3dTurnoutCatalog name="DB Ril 800.0120" unit="Metric (m)"
version="2015" source="Ril 800.0120 Tab. 1">
<turnout name="EW 60-500-1:12" kind="Turnout" hand="Both"
frog="12" radius="500" lead="33.23" blade="10.5" profile="60E1">
<extra key="Zungenvorrichtung" value="Federschiene"/>
</turnout>
</yu3dTurnoutCatalog>
Only the name, the crossing and the radius are required, and a diamond needs no radius at all. Create Turnout picks its unit from the loaded catalogues and takes the crossing and radius from that row; Custom hands both fields back for a unit no table describes. Slips, diamonds and three-way units are catalogued and laid out — see the section above.
The three catalogues that ship are a starting point: the
designations, crossings and branch radii of the common European, DB and AREMA
grundformen. The columns a real order needs come from your own approved table
— put that file in catalogs/rail/ under the same catalogue name
and it takes over.
Rail: the clearance envelope
The clearance gauge (Lichtraumprofil, structure gauge) is the cross-section outline that must stay clear of structures along a track. Rail › Clearance › Check Clearance sweeps it along the selected track and reports what fouls it.
What the sweep does at each station
The outline is not applied as drawn. Two things happen to it first:
- Curve widening. A vehicle sweeps wider than its own section.
The bogie centres cut the corner, so the inside of the curve gains
Lb² / (8R); the ends overhang outward, so the outside gains(Lv² − Lb²) / (8R), withLbthe bogie centre distance andLvthe vehicle length. A gauge that names no reference vehicle is not widened — which is what an outline already published “including widening” wants. - Cant tilt. The section is rigid with the track, so it rotates
with the running plane by
asin(cant / rail head distance)about the track centre at rail level. Positive cant raises the left rail. The rail head distance comes from the track’s own cant profile when it states one.
What it reports
Two things foul an envelope, and both are reported with the station, the offset and how far in the intrusion reaches:
- A surface passing through it — a cutting slope, a rock
face, a structure modelled as a surface. Name it with the
surfaceargument. With no name the check uses the document’s surface only when there is exactly one; with several it says so and checks track spacing only. Use the finished surface, not existing ground: existing ground still fills the cutting the design has yet to excavate, so sweeping against it reports the whole cutting as an infringement. - A neighbouring track’s envelope — every other Rail alignment in the document. Two envelopes that share no height band cannot foul each other however close they are in plan, so a track on a viaduct over another reports nothing. This is the track-spacing check a station throat needs.
The summary lands in the Event Viewer and every hit in a CSV beside the drawing (station, offset, height, intrusion, what fouled it), and the envelope itself becomes an object in the drawing — see below.
Where you see it
The check leaves a Clearance object in the Object Browser, under a group of that name, one per track. It owns the swept envelope, so the views draw it without re-running anything:
- Plan — the envelope’s outer edge down each side, as the track’s footprint, with the fouled stretches drawn in the warning colour and a marker at each intrusion, on the side it was found. Zoom out far enough and the markers drop away; the swath stays.
- Sections — the outline at the station on screen, over the ground and the corridor section, with a tick at each intrusion showing how far in it reaches, and the gauge named on the drawing. This is the view a clearance check is actually read in. The section snaps to the nearest swept station within half an interval; further out it draws nothing rather than showing you the wrong section.
- Profile — select the Clearance object and its long-section shows the envelope’s ceiling and floor along the track, so an overbridge soffit or a tunnel crown pinching the top of the gauge reads as a shape.
- 3D — the envelope as a swept solid along the track, with the fouled spans in their own colour.
Running the check again on the same track replaces that track’s object rather than adding a second one, and it is a normal undoable edit. The object is saved with the drawing, so a file opens with the envelope already drawn.
What this check is not
It is a geometric check of the outline you gave it. It is not a kinematic envelope: it does not model suspension travel, wear or the quasi-static roll of a real vehicle, and it proves no EN 15273 compliance. No product in this field does the kinematic case from alignment data alone — OpenRail’s swept envelope carries the same disclaimer — because the vehicle-dynamics input is the operator’s, not the alignment’s. Say that plainly to anyone who asks what a clean sweep proves.
Fouling points (Grenzzeichen)
At a turnout, the fouling point is where a vehicle standing on one route stops fouling the other. It is a setting-out item — surveyors stake it, and the German Grenzzeichen is a physical marker between the rails — so it is wanted as a number and a table as much as a symbol.
Rail › Clearance › Fouling Points walks every turnout in the drawing and stakes both routes: it leaves a Fouling object per turnout (in the same Clearance group), draws a bar across the track with the station beside it in Plan, and writes a setting-out CSV — turnout, route, station, X, Y, spacing, and the rule the answer was found under.
Geometrically it is the boundary of the track-spacing test above, read from the other
side: the two envelopes overlap near the switch and separate as the routes diverge.
The spacing that counts as separated comes from the loaded design standard’s
rail.foulingSpacingM; with none stated it is the two envelopes exactly
touching, with no safety allowance, and that is written into the report, the CSV and
the object’s own description. See
Design standards for how to state it.
Two routes that are already clear where they are closest never fouled each other, and the check reports no fouling point rather than naming the switch station as one. A turnout whose track cannot be walked past its switch station — a station off the end of the main, a route with no geometry — is reported as not checked, which is a different answer from “never foul”. Stations are the track’s own kilometrage, whatever it starts at.
A diamond or a slip is a crossing, not a switch: it has a fouling point on each side of the crossing on each track, four in all, and a three-way turnout gets a pair for its second branch as well. The level plan (Weichenhöhenplan) is a switch’s table — toe, frog, turnout end — so it declines a diamond or a slip and says how many it left out.
Gauge files
Which outline applies is a property of the railway: EN 15273 G1/G2, DB’s
GC per Ril 800.0130, an AREMA plate, an operator’s own. So gauges are
files, like the turnout catalogues: any *.xml in
catalogs/gauges/ beside the program, loaded at start-up, and a file
replaces a gauge of the same name.
<yu3dClearanceGauge name="DB GC Ril 800.0130" source="Ril 800.0130"
bogieCentres="20.0" vehicleLength="26.4">
<point offset="-1.575" height="0.000"/>
<point offset="-1.575" height="3.530"/>
<point offset="0.615" height="4.650"/>
<point offset="1.575" height="0.000"/>
</yu3dClearanceGauge>
Offsets are positive to the right of the centre line and heights positive
above top of rail, both in metres; the ring closes itself, so do not repeat
the first point. State bogieCentres and vehicleLength
together or not at all — a bogie base with no vehicle length would widen one
side and not the other, and the loader refuses it.
The three files that ship are a starting point and are marked as such inside: their vertices are indicative outlines at the right overall size, not the norm tables. Replace them with your office’s approved profile before any of this reaches a job. With no gauge files at all, the built-in is a plainly named placeholder rectangle — it is there so the sweep has something to run on, and it is not a standard.
Rail: the turnout level plan
A turnout is normally laid with little or no cant, so the main line’s cant has to be run out before the switch, and the two routes have to meet at the same level wherever they share track. Rail › Turnout › Level Plan is the document that says so with numbers — the Weichenhöhenplan ProVI produces per Ril 885.1102, which neither Civil 3D nor OpenRail has.
The characteristic points
- Switch toe (Weichenanfang) — where the branch leaves.
- Frog (Herzstück) — the crossing, at the end of the
lead curve,
R · atan(1/N)out along the branch. - Turnout end (Weichenende) — the end of the tangent beyond the frog. A turnout that does not state that tangent gets an underivable row saying so, not a plausible invented station.
They are derived from the same geometry the turnout is actually drawn with, so the table describes the turnout on the drawing rather than a parallel idealisation. Each point is tabulated on both routes; the frog’s main-side station is the exact foot of the perpendicular from the crossing.
Which level
Rails are given about the centre-line profile: high rail
+cant/2, low rail −cant/2. Our vertical alignment is
the centre line, so that is the honest datum — but railways that design to the
low rail read every value here cant/2 high. The datum is printed in the
CSV header for that reason: a level column with an unstated datum is the classic way
to build the right turnout at the wrong height.
The two checks
The worst applied cant anywhere over the turnout’s extent (not only at the three points — the run-out can be steep between them), and the level difference between the routes where they share a point. Past the frog the routes have separated, so the turnout end is tabulated and not checked.
Both limits are the railway’s: rail.turnoutMaxCantMm and
rail.turnoutLevelToleranceMm in the loaded
design standard. No standard that ships states
either, deliberately. With a limit absent the value is measured and checked
against nothing — which is not the same as passing, and every report,
the CSV and the object’s own description say so.
The result is a Levels object per turnout (in a group of that name), marking each point in Plan with its name and centre level, and a CSV: turnout, point, route, station, X, Y, centre level, both rails, cant, and whether the row was derivable.
Rail: when a derived answer goes out of date
The clearance envelope, the fouling points and the turnout level plan are baked: each holds an answer computed from other objects. Move the alignment, edit the profile, add a neighbouring track, slide the turnout, replace a gauge file, and the answer is still on the drawing, still looking authoritative, and no longer true. A clearance check that still says nothing fouls the envelope after the track moved is worse than no check at all, because somebody will believe it.
Each of these objects therefore records what it was baked from and notices when that changes. An object that has gone out of date is drawn washed out and labelled (out of date) in Plan, Sections and Profile, and its description in the Properties dock says which kind of change did it. Nothing is hidden — the last answer is still information — it simply stops reading as current.
Renaming an alignment does not invalidate anything: only the values that would change the answer are watched.
Tools › Rebuild Out-of-Date remakes every one of them, and the menu entry carries the count so you can see there is something to do without opening it. An object whose track, turnout or gauge has been deleted cannot be remade and keeps its last answer, still marked. (It used to sit under Rail › Clearance; it moved when surfaces started using the same machinery, since rebuilding a surface should not mean going into the Rail menu.)
Rebuilding is not automatic, deliberately. A clearance sweep over a large project takes seconds, and this program does not put that kind of work on the redraw path — the same reason Civil 3D leaves corridor auto-rebuild off by default. You ask; it does not guess.
Rail: a track from parameters
Rail › Alignment › Create Track by Parameters lays a rail alignment from a description instead of from clicks: start easting and northing, bearing (0 = north, clockwise), length, and radius — 0 for a straight, a negative radius to curve left. It is the parameterised sibling of the Alignment Builder, not a replacement for it.
It matters more than its size suggests. Every rail tool — turnouts, cant, clearance, fouling points, level plans, joint schedules — starts from a rail alignment, and until this existed there was no way to make one without a mouse. So none of them could be driven from an empty drawing by a script or by the AI command API, and none of their windows could have a regression script standing guard.
Rail: joints
A rail joint is an event along the line, not a shape across it, and no corridor can produce one. Rail › Track › Rail Joints lays them on the selected track and leaves a Joints schedule object.
Four kinds, and the colour in Plan is by kind because that is how the schedule is read: welded (recorded so the schedule is complete rather than silent), fishplated at rail length, insulated — a track-circuit and block boundary, which is signalling’s business — and an expansion device, which is structures’. Only the last two get their station labelled on the drawing: a fishplate every 25 m would be four hundred labels on a ten-kilometre line.
Joints are laid one every rail length on each rail, the right rail offset by the stagger, which is what jointed track is, starting at the track’s own start station. Every joint station — in the schedule, Set Joint, the Joint Table, the CSV and the import — is the track’s kilometrage: a track that starts at 1+000 has its first joint at 1000.00. Both rails’ joints, their kind and their coordinates go to a setting-out CSV.
Where the CSV goes. Every rail export writes
beside the drawing — literally, in the folder the document is saved
in. A document that has never been saved has nowhere to sit beside,
so nothing is written and the report says so: save it first, or name the file with
the file argument, which always works. It used to fall back to a bare
filename, which meant the process’s working directory — unpredictable,
and it littered whatever folder the program happened to be started from.
The two checks
The closest opposing pair — two joints facing each other on
the same sleeper is the thing a stagger rule exists to forbid — and the
longest rail the schedule implies. Both limits come from the loaded
standard as rail.jointStaggerM and
rail.maxRailLengthM; no standard that ships states either, so by default
the values are measured and checked against nothing, which the report
and the object both say.
A zero stagger is laid and then reported rather than refused. A tool that will not draw the mistake cannot report it either.
Placing one, and bringing a schedule in
The generator lays uniform track; the two kinds another discipline cares about are placed one at a time. Rail › Track › Set Joint takes a station, a rail and a kind: it changes the nearest joint on that rail when there is one within the snap distance, and puts a new one there when there is not — an insulated joint at a block boundary does not have to fall on a rail end. Tick Remove to take one out.
Import Joint Schedule reads back exactly the CSV the schedule exports, so the schedule can be kept in a spreadsheet and brought in — which is the workflow a railway actually has. Rows belonging to another track are skipped by name; a row whose station is off the end of the track is an error, not a silently dropped line, and the X and Y columns are re-derived from the station so an edited sheet does not have to keep them right.
Generated or authored. A schedule the generator laid is a pure function of the track, so when the track changes and the schedule is rebuilt it is laid again. A schedule you imported — from a CSV, from IFC, over the Civil 3D bridge — or touched with Set Joint or the table is authored: it holds decisions nothing can re-derive, and rebuilding it re-places the same joints at their stations on the changed track. It never re-lays them. One placed joint makes the whole schedule authored, because afterwards there is no telling the placed one from the laid ones. The Properties card and the table’s summary line say which kind you have. If the track is shortened past a joint’s station, that joint is kept, its note says “beyond the end of the track”, and deciding what to do with it is yours.
A joint whose station lies inside a turnout’s lead is reported, not prevented, and the message names the turnout. A joint in a switch panel is not something that gets built — but a tool that will not let you draw the mistake cannot tell you that you made it.
The schedule as a table
Rail › Track › Joint Table shows the whole schedule as a list: station, rail and kind on every row, editable in place, with Add and Remove, and the two checks summarised above it with the rule they were measured against. Apply is one undoable step — change three joints and undo once. Setting them one command at a time works for the handful of insulated joints on a line; it does not work for reading four hundred.
The last column is the note, and it is why the table exists as much as the editing is: a joint whose station falls inside a turnout’s lead is called out in red, naming the turnout. That check used to run only when a joint was placed by hand — which is the one way the mistake is least likely to arrive. A generated or imported schedule is now annotated the same way, so 25 m rails laid straight through a switch panel say so.
Stations may be typed anywhere on the track; each joint is re-placed on its own rail when the schedule is applied. A row is a station and a rail, and the coordinates follow from those — never the other way round.
What is not here
Sleepers and cable troughs are not joint objects, and not objects at all. They are cross-section work: the rail presets already model the sleeper layer and the ballast prism with real parameters, and a cable trough is a shape at an offset you add in the Assembly Designer. Building parallel objects for them would duplicate the assembly machinery.
No CWR stressing. Nothing here computes a stress-free temperature or a breathing length: that is thermal analysis on rail steel with the railway’s own stressing data, and a number produced without those inputs would be worse than none.
Design checks
Each circular curve is checked against the minimum radius for the active standard and design speed. Substandard curves are listed in the Design Issues dock (double-click to jump to the station) and marked on the Plan. The radius formula and the per-speed friction table are in the Formula reference.
Worked example
A 60 km/h road (AASHTO, emax 8%, f at 60 km/h = 0.17):