The Load & Support Diagram is used throughout the modern platform to plot a load and support diagram with all unfactored load types and supports. It uses diagram widget type "beamLoadSupport".

​
Implementation

{
    "type": "sheetTemplateWidgets",
    "attributes": {
        "type": "diagram",
        "diagram": [
            {
                "type": "beamLoadSupport"
            }
        ],
        "equation": [
            {
                "result": "{PARAMETERS}",
                "condition": "CONDITIONS"
            }
        ],
        "referenceId": "load_support_diagram"
    }
}

​
Plot Parameters

ParameterFormatExampleDescription
xDataarray of numbersremote.plot.xX coordinates along the beam
rnxm arrayx("r")Support locations from a traditional template r widget. Either rDict or r is required
rDictarray of dictsremote.plot.RSupport locations and types, from the solver. Either rDict or r is required
PLarray of dictsremote.plot.PLPoint load locations and magnitudes
DLarray of numbersremote.plot.DLDistributed load values at each X-coordinate
MLarray of dictsremote.plot.MLMoment load locations and magnitudes
ALarray of dictsremote.plot.ALAxial load locations and magnitudes
ADLarray of numbersremote.plot.ADLAxial distributed load values at each X-coordinate
lenConvertnumber0.001(defaults to 0.001) Conversion factor for lengths
dlConvertnumber1(defaults to 1) Conversion factor for distributed loads
loadLenConvertnumber1(defaults to 1) Conversion factor load lengths
lenUnitstring"m"(defaults to "m") Unit for lengths
plUnitstring"kN"(defaults to "kN") Unit for point loads
mlUnitstring"kNm"(defaults to "kNm") Unit for moment loads
dlUnitstring"kN/m"(defaults to "kN/m") Unit for distributed loads
dlAreaUnitstring"kPa"(defaults to "kPa") Unit for area distributed loads (i.e. the thing multiplied by the load width to get the magnitude)
columnbooleanfalse(defaults to false) Whether to plot diagram vertically, adjusting text locations appropriately
wallnumber0(defaults to 0) Height of the wall to display
openingsnx6 array[](defaults to []) Format: [["label", type, startY, heightY, startX, endX], ...]

​
Support Data Formats

​
Traditional r Widget Format

When using the traditional r widget for supports: 
r: [
    [0, 1, 1, 0],     // [location, Rx_restrained, Ry_restrained, Mz_restrained]
    [5000, 0, 1, 0],  // Pin support at 5m
    [10000, 1, 1, 1]  // Fixed support at 10m
]

​
Solver Support Format (rDict)

When using solver-generated support data: 
rDict: [
    {
        x: 0,
        type: "fixed",
        Rx: true,
        Ry: true,
        Mz: true
    },
    {
        x: 5000,
        type: "pin",
        Rx: false,
        Ry: true,
        Mz: false
    }
]

​
Load Data Formats

​
Point Loads (PL)

PL: [
    {
        x: 2500,       // Location along beam (mm)
        P: 150,        // Load magnitude (kN)
        label: "Dead Load",
        type: "dead"   // Load type for color coding
    }
]

​
Distributed Loads (DL)

xData: [0, 1000, 2000, 3000, 4000, 5000],
DL: [0, 5, 5, 8, 8, 0]  // Load values at each x coordinate

​
Area Distributed Loads

For loads applied over an area (like floor loads): 
{
    DL: area_load_intensity,     // Load per unit area (kPa)
    dlAreaUnit: "kPa",
    loadWidth: beam_tributary_width  // Width over which load is applied
}

​
Openings in Walls

For wall applications, you can specify openings: 
openings: [
    ["Window 1", "window", 1000, 1200, 2000, 4000],  // [label, type, startY, height, startX, endX]
    ["Door 1", "door", 0, 2100, 6000, 7500]
]

​
Example Implementation

{
    "type": "sheetTemplateWidgets",
    "attributes": {
        "type": "diagram",
        "diagram": [
            {
                "type": "beamLoadSupport"
            }
        ],
        "equation": [
            {
                "result": "{
                    xData: remote.plot.x,
                    rDict: remote.plot.R,
                    PL: remote.plot.PL,
                    DL: remote.plot.DL,
                    ML: remote.plot.ML,
                    lenUnit: \"m\",
                    plUnit: \"kN\",
                    dlUnit: \"kN/m\",
                    mlUnit: \"kNm\",
                    lenConvert: 0.001
                }",
                "condition": "@default"
            }
        ],
        "referenceId": "loads_supports",
        "label": "Loads and Supports",
        "showInSuperSummary": true
    }
}

​
Column/Wall Configuration

For vertical members, use the column configuration: 
{
    "result": "{
        xData: height_coordinates,
        PL: vertical_loads,
        DL: distributed_vertical_loads,
        rDict: support_conditions,
        column: true,
        wall: total_height,
        openings: wall_openings,
        lenUnit: \"m\",
        plUnit: \"kN\"
    }"
}

​
Integration with Templates

​
With Traditional Templates

{
    r: x("r"),              // From support table widget
    PL: point_load_data,    // From point load table
    DL: distributed_loads,  // From distributed load calculation
    // ...
}

​
With Solver Templates

{
    rDict: remote.plot.R,   // From beam solver
    PL: remote.plot.PL,     // From beam solver
    DL: remote.plot.DL,     // From beam solver
    // ...
}

​
Best Practices

  1. Unfactored Loads: This diagram shows unfactored loads - ensure you’re not passing factored values
  2. Load Types: Use consistent load type categorization (dead, live, wind, etc.)
  3. Units: Maintain consistent units throughout the diagram
  4. Support Definition: Choose between r and rDict based on your template architecture
  5. Color Coding: Different load types will be automatically color-coded
The Load & Support Diagram is ideal for showing the initial loading condition before load combinations are applied. It provides a clear view of the structural system for engineers to verify load placement and support conditions.
Ensure that either r or rDict is provided, but not both. The diagram requires one of these parameters to properly display support conditions.
For wall applications with openings, the diagram will automatically adjust the distributed load display to account for the openings, providing a realistic representation of load distribution.