Professional Multi-Leg Rotary Design Engine

🚦 Integrated Multi-Leg Rotary Design + Geometry

Number of Legs (3–8):

Common Geometry

Weaving Width W (m): Entry Width e (m): Weaving Proportion p: ICD (m): Island Diameter (m): Entry Radius Re (m):

Turning Matrix (PCU/hr)

Algorithmic Geometric Design and Weaving Capacity Analysis for Multi-Leg Roundabouts

Domain: Transportation & Highway Infrastructure Engineering | Standard Focus: IRC:65-1976 / IRC:73-1980 / Highway Capacity Manual

1. Introduction

At-grade intersections represent the primary bottleneck in urban and rural highway networks. Among various intersection treatments, modern roundabouts (rotaries) provide an effective solution by converting direct crossing conflicts into mild-angle, continuous weaving movements. This eliminates right-angle collision vectors and eliminates signal-delay cycles.

The provided HTML/JavaScript source code implements a client-side engineering engine designed to automate the geometric sizing, circulation assignment, capacity evaluation, visual rendering, and CAD export of multi-leg roundabouts (ranging from 3 to 8 approaches). This article breaks down the mathematical, statutory, and computational foundations embedded within the code.

2. Standards & Governing Equations

The calculation algorithms inside the source code are anchored in standard civil engineering methodologies, primary among them being the Indian Roads Congress (IRC:65-1976 - Recommended Practice for Traffic Rotaries) and geometric alignment principles from IRC:73-1980.

2.1 Wardrop’s Weaving Capacity Equation

For non-turbo conventional rotaries, the practical capacity ($Q$) of each weaving section is determined using Wardrop's modified formula, codified in IRC:65 Clause 6.4:

Wardrop's Rotary Capacity Formula:
Q = [ 280 × W × (1 + e/W) × (1 - p/3) ] / [ 1 + (W / L) ]

Where:

  • Q = Capacity of the weaving section in Passenger Car Units per hour (PCU/hr).
  • W = Width of the weaving section in meters (typically $W = e + 1 \text{ to } 2 \text{ meters}$).
  • e = Average entry width of the intersecting legs in meters.
  • L = Length of the weaving section in meters, calculated dynamically along the outer perimeter.
  • p = Proportion of weaving traffic, defined as $(b + c) / (a + b + c + d)$, where $b$ and $c$ are cross-weaving flows and $a$ and $d$ are non-weaving flows.

2.2 Weaving Length Evaluation Geometry

The length of the weaving section ($L$) between two adjacent legs $i$ and $next = (i+1) \pmod n$ is calculated using the angular displacement ($\Delta$) around the Inscribed Circle Diameter ($ICD$):

Perimetric Arc Length Formula:
L = (Ï€ × ICD × Î”) / 180

2.3 Design Speed & Superelevation Mechanics

Vehicular stability within the circulatory roadway is governed by centripetal acceleration balance. According to IRC:65 Clause 4.6, the allowable design speed ($V$) in km/h relative to the rotary radius ($R = ICD / 2$) is computed via equilibrium dynamics:

Geometric Design Speed Metric:
V = √( 127 × R × (esup + f) )
  • R = Central radius of the circulatory roadway ($ICD / 2$).
  • esup = Maximum allowable superelevation (assumed at 0.07 or 7% as per IRC:73 Cl 5.3).
  • f = Coefficient of lateral friction (assumed as 0.15 for rural/urban design boundaries).

3. Code Structure & Architectural Workflow

The application follows a structured execution pipeline that handles user input, performs matrix accumulation, calculates capacity, and updates the view layer:

Functional Component JavaScript Function Engineering Responsibility
Interface Synthesizer generateInputs()
generateMatrix()		 Dynamically constructs HTML forms for $N$-leg angular orientations and an $N \times N$ origin-destination turning matrix.
Traffic Circulation Engine computeCirculation() Calculates cumulative link volumes across each circulatory arc using vector loop summation.
Hydraulic/Traffic Solver calculate() Executes geometry check, Wardrop capacity calculations, volume-to-capacity ($v/c$) ratio checks, critical section identification, and speed limits.
Vector Render Engine drawRotary() Generates scaled SVG graphics showing central islands, circulating lanes, approaches, and highlights critical sections in red.
CAD Interoperability Engine exportDXF() Generates ASCII DXF files for standard CAD software (AutoCAD, MicroStation).

4. Algorithm & Mechanics Deep Dive

4.1 Origin-Destination Matrix to Circulation Mapping

The core traffic routing algorithm is contained within computeCirculation(n). The algorithm accumulates link traffic by tracking vehicle movements along clockwise circulatory paths from entry leg $i$ to exit leg $j$:

function computeCirculation(n){
  let circulation = new Array(n).fill(0);

  for(let i=0; i<n; i++){
    for(let j=0; j<n; j++){
      if(i != j){
        let flow = parseFloat(document.getElementById(`T_${i}_${j}`).value);
        // Traverses circulatory segments clockwise from entry i to exit j
        for(let k = i; k != j; k = (k + 1) % n){
          circulation[k] += flow;
        }
      }
    }
  }
  return circulation;
}

The inner loop handles modular circular indexing via (k + 1) % n. This correctly registers every PCU onto each intermediate circulatory arc segment ($k$) until reaching exit $j$.

4.2 Capacity Analysis and Critical Section Search

The calculate() function evaluates performance across all $N$ sections of the rotary:

// Arc subtended angle logic handling zero-crossing boundary
let next = (i + 1) % n;
let delta = angles[next] - angles[i];
if(delta < 0) delta += 360;

// Wardrop Capacity Calculation
let L = (Math.PI * icd * delta) / 180;
let Q = turbo ? 1800 : (280 * W * (1 + e/W) * (1 - p/3)) / (1 + W/L);

// Operational Performance Metric
let sectionTraffic = circulation[i];
let vc = sectionTraffic / Q;

The maximum Volume-to-Capacity ratio ($v/c_{\text{max}}$) identifies the system bottleneck. A threshold of $v/c \le 0.85$ serves as the design acceptance limit, preserving a 15% reserve capacity to absorb random arrival surges without triggering boundary queues.

4.3 Scaled SVG Rendering & Vector Geometry

The engine builds a scalable vector graphics (SVG) diagram using standard viewport transformations:

let scale = 250 / (icd / 2); // Scales ICD radius to 250 canvas pixels
let outerRadius = (icd / 2) * scale;
let islandRadius = (island / 2) * scale;

Each access leg is plotted using polar-to-Cartesian coordinate conversions:

X1,2 = Xcenter + Rtarget × cos(θrad)
Y1,2 = Ycenter + Rtarget × sin(θrad)

Legs are rendered as lines, with the critical section ($v/c_{\text{max}}$) highlighted in red for easy visual identification during design reviews.

4.4 Native DXF Code Generation

The exportDXF() function generates CAD geometry natively by constructing ASCII-formatted ENTITIES tables. It outputs circular entities directly into standard CAD drawing units without external libraries:

0
SECTION
2
ENTITIES
0
CIRCLE
8
0
10
0
20
0
30
0
40
${icd/2}
...
0
ENDSEC
0
EOF

5. Engineering Assessment & Enhancement Roadmap

Expert Verdict: This light engine provides an effective, dependency-free tool for preliminary feasibility studies and academic demonstrations. It balances immediate browser execution with essential standard compliance.

To prepare this engine for advanced production-level design, several key enhancements should be made:

  1. Dynamic Weaving Ratio ($p$) Calculation: The current engine uses a static global parameter $p$. Calculating $p$ dynamically for each individual segment based on origin-destination matrices will yield higher local precision.
  2. Modern HCM / NCHRP 572 Integration: Wardrop's formula relies heavily on weaving mechanics. Modern roundabouts operate primarily on gap-acceptance theories (e.g., Highway Capacity Manual 6th Edition). Adding an HCM engine mode alongside the IRC framework would widen its regional applicability.
  3. Entry Deflection & Path Radius Mechanics: Adding checks for minimum entry deflection angles, as well as critical vehicle path radii ($R_1$ through $R_5$), would improve speed consistency and safety evaluations.
  4. Complex DXF Entity Output: Expanding the CAD export module to include road edge splines, splitter islands, and curb fillets alongside simple centerlines would improve drafting integration.