StructuralModel

StructuralModel contains loading definitions, support conditions, and other structural configuration.

Structure

public class StructuralModel
{
    public Loading Loading { get; set; }
    public Bearing Bearing { get; set; }
    public DappedEnds DappedEnds { get; set; }
    public StrippingAndHandling StrippingAndHandling { get; set; }
    public Shoring Shoring { get; set; }
    public VibrationAnalysis VibrationAnalysis { get; set; }
}

Loading

Applied loads on the beam.

var loading = design.StructuralModel.Loading;

// Self-weight configuration
double multiplier = loading.SelfWeightMultiplier;
loading.SelfWeightMultiplier = 1.0;

// Access load collections
var pointLoads = loading.PointLoads;
var distributedLoads = loading.DistributedLoads;
var moments = loading.AppliedMoments;

Loading Properties

Property	Type	Description
`SelfWeightMultiplier`	double	Factor applied to self-weight
`PointLoads`	List	Concentrated loads
`DistributedLoads`	List	Uniform and varying distributed loads
`AppliedMoments`	List	Applied moment loads
`LateralLoads`	List	Lateral (horizontal) loads

Point Load Properties

Property	Type	Unit	Description
`Location`	double	inches	Distance from left end
`Magnitude`	double	lbs	Load magnitude
`LoadType`	LoadType	-	Dead, Live, etc.
`Description`	string	-	Load description

Distributed Load Properties

Property	Type	Unit	Description
`StartLocation`	double	inches	Start position
`EndLocation`	double	inches	End position
`StartMagnitude`	double	lbs/in	Load at start
`EndMagnitude`	double	lbs/in	Load at end
`LoadType`	LoadType	-	Dead, Live, etc.

Example: Adding Loads

var design = await client.PullBeamDesignerAsync();
var loading = design.StructuralModel.Loading;

// Set self-weight
loading.SelfWeightMultiplier = 1.0;

// Add a point load
loading.PointLoads.Add(new PointLoad
{
    Location = 120,        // 10 feet from left
    Magnitude = 5000,      // 5000 lbs
    LoadType = LoadType.Dead,
    Description = "Equipment load"
});

// Add a distributed load
loading.DistributedLoads.Add(new DistributedLoad
{
    StartLocation = 0,
    EndLocation = 240,     // Full span
    StartMagnitude = 100,  // 100 lbs/in
    EndMagnitude = 100,
    LoadType = LoadType.Live,
    Description = "Uniform live load"
});

await client.PushBeamDesignerAsync("", design);

Bearing

Support conditions at beam ends and intermediate locations.

var bearing = design.StructuralModel.Bearing;

// Access bearing properties
var leftSupport = bearing.LeftEnd;
var rightSupport = bearing.RightEnd;
var intermediateSupports = bearing.IntermediateSupports;

Bearing Properties

Property	Type	Description
`LeftEnd`	EndBearing	Left end support
`RightEnd`	EndBearing	Right end support
`IntermediateSupports`	List	Interior supports

EndBearing Properties

Property	Type	Unit	Description
`BearingLength`	double	inches	Bearing pad length
`BearingWidth`	double	inches	Bearing pad width
`IsFixed`	bool	-	Fixed vs pinned support
`SupportType`	SupportType	-	Support classification

Example: Bearing Configuration

var design = await client.PullBeamDesignerAsync();
var bearing = design.StructuralModel.Bearing;

// Configure left end bearing
bearing.LeftEnd.BearingLength = 8;    // 8" bearing
bearing.LeftEnd.BearingWidth = 12;
bearing.LeftEnd.IsFixed = false;       // Pinned

// Configure right end bearing
bearing.RightEnd.BearingLength = 8;
bearing.RightEnd.BearingWidth = 12;
bearing.RightEnd.IsFixed = false;

await client.PushBeamDesignerAsync("", design);

DappedEnds

Dapped (notched) end configurations.

var dappedEnds = design.StructuralModel.DappedEnds;

// Check if ends are dapped
bool leftDapped = dappedEnds.LeftEnd.IsDapped;
bool rightDapped = dappedEnds.RightEnd.IsDapped;

DappedEnd Properties

Property	Type	Unit	Description
`IsDapped`	bool	-	Whether end is dapped
`DapLength`	double	inches	Horizontal dap dimension
`DapDepth`	double	inches	Vertical dap dimension
`ReentrantRadius`	double	inches	Corner radius

Example: Dapped End

var design = await client.PullBeamDesignerAsync();

// Configure left end dap
var leftDap = design.StructuralModel.DappedEnds.LeftEnd;
leftDap.IsDapped = true;
leftDap.DapLength = 6;
leftDap.DapDepth = 8;
leftDap.ReentrantRadius = 0.5;

await client.PushBeamDesignerAsync("", design);

StrippingAndHandling

Lifting and handling configurations during production.

var handling = design.StructuralModel.StrippingAndHandling;

// Lifting point locations
var liftPoints = handling.LiftingPoints;

Properties

Property	Type	Description
`LiftingPoints`	List	Lifting point locations
`DynamicFactor`	double	Impact factor for handling
`SuctionLoad`	double	Form suction load

Shoring

Temporary support configuration.

var shoring = design.StructuralModel.Shoring;

// Access shore locations
var shores = shoring.ShoreLocations;

// Add a shore
shores.Add(new ShoreLocation
{
    Location = 120,  // 10 feet from left
    IsActive = true
});

Shoring Properties

Property	Type	Description
`ShoreLocations`	List	List of shore positions
`ShoreRemovalSequence`	List	Order of shore removal

VibrationAnalysis

Dynamic response parameters for vibration analysis.

var vibration = design.StructuralModel.VibrationAnalysis;

// Configure vibration parameters
vibration.DampingRatio = 0.02;  // 2% damping

Complete Example

using System;
using System.Threading.Tasks;
using ErikssonBeam.API.BeamClient;
using ErikssonBeam.API.BeamDesigner;

class StructuralModelExample
{
    static async Task ConfigureStructuralModel(ErikssonBeamClient client)
    {
        var design = await client.PullBeamDesignerAsync();
        var model = design.StructuralModel;

        // Loading
        model.Loading.SelfWeightMultiplier = 1.0;

        // Clear existing loads and add new ones
        model.Loading.DistributedLoads.Clear();
        model.Loading.DistributedLoads.Add(new DistributedLoad
        {
            StartLocation = 0,
            EndLocation = 240,
            StartMagnitude = 150,
            EndMagnitude = 150,
            LoadType = LoadType.Dead,
            Description = "Superimposed dead load"
        });

        model.Loading.DistributedLoads.Add(new DistributedLoad
        {
            StartLocation = 0,
            EndLocation = 240,
            StartMagnitude = 200,
            EndMagnitude = 200,
            LoadType = LoadType.Live,
            Description = "Design live load"
        });

        // Bearing
        model.Bearing.LeftEnd.BearingLength = 6;
        model.Bearing.LeftEnd.BearingWidth = 10;
        model.Bearing.RightEnd.BearingLength = 6;
        model.Bearing.RightEnd.BearingWidth = 10;

        await client.PushBeamDesignerAsync("", design);

        Console.WriteLine("Structural model configured");
    }

    static async Task DisplayStructuralModel(ErikssonBeamClient client)
    {
        var design = await client.PullBeamDesignerAsync();
        var model = design.StructuralModel;

        Console.WriteLine("=== Structural Model ===\n");

        // Loading summary
        Console.WriteLine("Loading:");
        Console.WriteLine($"  Self-Weight Multiplier: {model.Loading.SelfWeightMultiplier}");
        Console.WriteLine($"  Point Loads: {model.Loading.PointLoads?.Count ?? 0}");
        Console.WriteLine($"  Distributed Loads: {model.Loading.DistributedLoads?.Count ?? 0}");

        // Bearing summary
        Console.WriteLine("\nBearing:");
        Console.WriteLine($"  Left: {model.Bearing.LeftEnd.BearingLength}\" x {model.Bearing.LeftEnd.BearingWidth}\"");
        Console.WriteLine($"  Right: {model.Bearing.RightEnd.BearingLength}\" x {model.Bearing.RightEnd.BearingWidth}\"");

        // Dapped ends
        Console.WriteLine("\nDapped Ends:");
        Console.WriteLine($"  Left Dapped: {model.DappedEnds?.LeftEnd?.IsDapped ?? false}");
        Console.WriteLine($"  Right Dapped: {model.DappedEnds?.RightEnd?.IsDapped ?? false}");
    }
}