public RecProfile(double h, double b, IMaterial material, IBeam beam, ILoad load)
{
_height = h;
_widht = b;
if (h * b > _max_area)
{
_area = 0; throw new TooLargeArea(_max_area);
}
else
{
_area = h * b;
if (_area == 0)
{
throw new WrongDimensions();
}
}
_momentOFInertia = (b * Math.Pow(h, 3)) / 12;
_weight = _area * material.Density;
_fle_tension = (beam.maxMoment(load) + ((_weight * (Math.Pow(beam.Lenght, 2))) / 8)) / (_momentOFInertia / (h / 2));
_she_tension = (beam.maxForce(load) + beam.Lenght * _weight) * (1.5 * _height);
_fle_effort = _fle_tension / material.FlexuralStrenght;
_strenght = material.FlexuralStrenght;
_she_effort = _she_tension / material.ShearStrenght;
}
public void SetUpBeam()
{
var material = new Concrete(youngModulus: 30, withReinforcement: false);
var section = new RectangleSection(width: 300, height: 500);
var node1 = new FixedNode();
var node2 = new FixedNode();
var nodes = new Node[] { node1, node2 };
var span1 = new Span(
leftNode: node1,
length: 10,
rightNode: node2,
material: material,
section: section,
includeSelfWeight: false
);
var spans = new Span[] { span1 };
span1.ContinousLoads.Add(ContinousBendingMomentLoad.Create(span1, value: 50));
_beam = new Beam(spans, nodes, includeSelfWeight: false);
_beam.CalculationEngine.Calculate();
}
private void UpdateSettings()
{
this.m_BeamSnapshot = this.m_Beam;
this.m_ScanFrame = new double[m_Beam.Setup.BufferFrameSize, 8];
// this.m_ScanFrame = new double[this.m_BeamSnapshot.Setup.BufferFrameSize, 8];
this.m_TotalNumberOfScansInBuffer = this.m_BeamSnapshot.Setup.BufferFrameSize * this.m_BeamSnapshot.Setup.NumberOfFrames;
}
public I_Profile(double H, double B, double h, double t, IMaterial material, IBeam beam, ILoad load)
{
_height = H;
_widht = B;
_height2 = h;
_width2 = t;
hw = H - (2 * h);
bw = (B - t) / 2;
if (bw < 0 || hw < 0)
{
throw new WrongDimensions();
}
_area = (2 * B * h) + (t * (H - (2 * h)));
if (_area == 0)
{
throw new WrongDimensions();
}
if (_area > _max_area)
{
_area = 0; throw new TooLargeArea(_max_area);
}
_momentOFInertia = ((B * Math.Pow(H, 3)) / 12) - (2 * ((bw * Math.Pow(hw, 3)) / 12));
_weight = _area * material.Density;
_fle_tension = (beam.maxMoment(load) + ((_weight * (Math.Pow(beam.Lenght, 2))) / 8)) / (_momentOFInertia / (h / 2));
_she_tension = (beam.maxForce(load) + beam.Lenght * _weight) * (1.5 * hw);
_fle_effort = _fle_tension / material.FlexuralStrenght;
_strenght = material.FlexuralStrenght;
_she_effort = _she_tension / material.ShearStrenght;
}
public void SetUpBeam()
{
var material = new Concrete(youngModulus: 30);
var section = new RectangleSection(width: 300, height: 500);
var node1 = new FixedNode();
var node2 = new FixedNode();
var nodes = new Node[] { node1, node2 };
var span1 = new Span(
leftNode: node1,
length: 10,
rightNode: node2,
material: material,
section: section
);
var spans = new Span[] { span1 };
var startLoad = new LoadData(value: -150, position: 3);
var endLoad = new LoadData(value: -50, position: 8);
span1.ContinousLoads.Add(SpanExtendLoad.Create(span1, 10));
_beam = new Beam(spans, nodes);
_beam.Calculate();
}
void CreateStaticSchema()
{
if (BelkaObciazonaSilaSkupiona.IsChecked == true || BelkaZObciazeniemCiaglym.IsChecked == true)
{
image2.Source = new BitmapImage(new Uri("/WpfApplication1;component/Images/BelkaJedno.JPG"));
beam = new SingleBeam(beam_lenght);
}
if (WspornikObciazonySilaSkupiona.IsChecked == true || WspornikZObciazeniemCiaglym.IsChecked == true)
{
beam = new Bracket(beam_lenght);
}
if (BelkaObciazonaSilaSkupiona.IsChecked == true || WspornikObciazonySilaSkupiona.IsChecked == true)
{
load = new FocusForce(beam, load_value, center);
}
if (BelkaZObciazeniemCiaglym.IsChecked == true || WspornikZObciazeniemCiaglym.IsChecked == true)
{
load = new ContinuousLoad(beam, load_value);
}
beam.Reactions(load);
}
public void Startup()
{
_beam = new SanXinBeam(_beamScan, _beamState, _beamSetup);
analogCard = new AnalogOutCard(_pdao32Card, _beam, m_PackageManager);
analogCard.OnPowerOffDelegate += AnalogCard_OnPowerOffDelegate;
analogCard.actionScanDone += new Action <string>(ScanDoneAction);
analogCard.actionPerPreHeatDone += new Action(PerScanDone);
}
public ResultsContainer(IBeam beam)
{
_beam = beam;
NormalForce = new NormalForceResult(_beam);
Shear = new ShearResult(_beam);
BendingMoment = new BendingMomentResult(_beam);
HorizontalDeflection = new HorizontalDeflectionResult(_beam);
VerticalDeflection = new VerticalDeflectionResult(_beam);
Rotation = new RotationResult(_beam);
}
public FocusForce(IBeam beam, double valueFromTextbox1, double valueFromTextbox2)
{
_value = valueFromTextbox1;
if (beam.Lenght < valueFromTextbox2)
{
throw new XException(beam.Lenght);
}
else
{
_center_of_gravity = valueFromTextbox2;
}
}
public AnalogOutCard(ISignalCardOut signalCard, IBeam beamInterface, PackageManager packageManager)
{
this.m_SignalCard = signalCard;
this.m_Logger = LogManager.GetLogger("sanxinScan.log");
this.m_Beam = beamInterface;
this.m_PackageManager = packageManager;
bPreHeat = false;
m_sweepScanStatus = true;
// this.m_Builds = buildInterface;
this.UpdateSettings();
this.m_SignalCard.Initialize(this.m_Logger);
}
public static IBeam GetIBeamByType(string type)
{
var connectionString = "mongodb://34.235.84.44:27017";
var mongo_client = new MongoClient(connectionString);
var server = mongo_client.GetServer();
var database = server.GetDatabase("prosteel-db-development");
MongoCollection <IBeam> collection = database.GetCollection <IBeam>("ibeams");
IBeam beam = new IBeam();
var query = Query.EQ("Type", type);
beam = collection.FindOne(query);
return(beam);
}
public static void Main(string[] args)
{
IBeam woodenBeam1 = new WoodenBeam(12f);
IBeam woodenBeam2 = woodenBeam1.Clone();
IBeam steelBeam1 = new SteelBeam(24f);
IBeam steelBeam2 = steelBeam1.Clone();
Console.WriteLine(woodenBeam1.Info());
Console.WriteLine(woodenBeam2.Info());
Console.WriteLine(steelBeam1.Info());
Console.WriteLine(steelBeam2.Info());
Console.ReadKey();
}
void Awake()
{
Owner = GetComponent<Actor>();
GameObject tmp = Instantiate(Beam);
m_hBeam = tmp.GetComponent<IBeam>();
m_fDurationTime = ActiveTime;
m_hWeaponOff = new WeaponOff(this);
m_hWeaponOn = new WeaponOn(this);
m_hFire = new Fire(this);
m_hStartRecharging = new StartRecharging(this);
m_hRecharging = new Recharging(this);
m_hCurrent = m_hWeaponOff;
}
/***************************************************/
/**** Private method ****/
/***************************************************/
// Essentially the same as the create method; experimenting with when it gets called by the BHoM "push" component
protected bool Update(IEnumerable <Bar> bars)
{
//Access model
IDBIO1 RAMDataAccIDBIO = m_Application.GetDispInterfacePointerByEnum(EINTERFACES.IDBIO1_INT);
IModel IModel = m_Application.GetDispInterfacePointerByEnum(EINTERFACES.IModel_INT);
foreach (Bar bar in bars)
{
//Extract ID
int ID = (int)GetAdapterId(bar);
if (BH.Engine.Structure.Query.IsVertical(bar))
{
IColumn IColumn = IModel.GetColumn(ID);
ILayoutColumn ILayoutColumn = IModel.GetLayoutColumn(ID);
// Move column
double xStart = bar.StartNode.Position.X;
double yStart = bar.StartNode.Position.Y;
double zStart = bar.StartNode.Position.Z;
double xEnd = bar.EndNode.Position.X;
double yEnd = bar.EndNode.Position.Y;
double zEnd = bar.EndNode.Position.Z;
// Need level rather than offset for setting (still in progress)
ILayoutColumn.SetLayoutCoordinates2(xStart, yStart, zStart, xEnd, yEnd, zEnd);
// Change section property of column
IColumn.strSectionLabel = bar.Name;
}
else
{
IBeam IBeam = IModel.GetBeam(ID);
ILayoutBeam ILayoutBeam = IModel.GetLayoutBeam(ID);
// Change section property of column
IBeam.strSectionLabel = bar.Name;
}
}
return(true);
}
/***************************************************/
public static ISectionProperty ToBHoMSection(this IBeam ramBar)
{
//Create BHoM SectionProperty
ISectionProperty sectionProperty = new ExplicitSection();
IMaterialFragment Material = null;
if (ramBar.eMaterial == EMATERIALTYPES.EConcreteMat)
{
Material = Engine.Structure.Create.Concrete("Concrete");
}
else if (ramBar.eMaterial == EMATERIALTYPES.ESteelMat)
{
Material = Engine.Structure.Create.Steel("Steel");
}
else
{
Material = Engine.Structure.Create.Steel("Other");
}
sectionProperty.Material = Material;
sectionProperty.Name = ramBar.strSectionLabel;
return(sectionProperty);
}
/***************************************************/
private List <IBeam> ReadRamBeams(IModel ramModel)
{
//Get stories
IStories ramStories = ramModel.GetStories();
int numStories = ramStories.GetCount();
List <IBeam> allRamBeams = new List <IBeam>();
// Get all beams on each story
for (int i = 0; i < numStories; i++)
{
//Get beams
IBeams ramBeams = ramStories.GetAt(i).GetBeams();
int numBeams = ramBeams.GetCount();
// Convert beams
for (int j = 0; j < numBeams; j++)
{
IBeam ramBeam = ramBeams.GetAt(j);
allRamBeams.Add(ramBeam);
}
}
return(allRamBeams);
}
//private readonly SignalCardType m_SignalCardType;
// private IProcess m_ProcessManager;
// private ProcessState m_ProcessState;
//private readonly string[] m_PacketsSubscriptions = new string[] { IONamespace.Analyse.Control.HeatStartPlateBeamCurrentOverride, IONamespace.Analyse.Control.HeatStartPlate };
// public event BeamPackageCompleted OnPackageCompleted;
public BeamController(IBeam beam /*SignalCardType signalCardType*/)
{
_beam = beam;
//this.m_SignalCardType = signalCardType;
// this.m_PackageManager.OnPackageCompleted += new PackageOfficeEvent(this.OnPackageManagerPackageCompleted);
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private List <Bar> ReadBars(List <string> ids = null)
{
//Implement code for reading bars
List <Bar> bhomBars = new List <Bar>();
// Get stories
IStories IStories = m_Model.GetStories();
int numStories = IStories.GetCount();
// Get all elements on each story
for (int i = 0; i < numStories; i++)
{
//Get Columns
IColumns IColumns = IStories.GetAt(i).GetColumns();
int numColumns = IColumns.GetCount();
//Get Beams
IFloorType IFloorType = IStories.GetAt(i).GetFloorType();
ILayoutBeams ILayoutBeams = IFloorType.GetLayoutBeams();
IBeams IBeams = IStories.GetAt(i).GetBeams();
int numLayoutBeams = ILayoutBeams.GetCount();
int numBeams = IBeams.GetCount();
//Get Vertical Braces
IVerticalBraces IVBraces = IStories.GetAt(i).GetVerticalBraces();
int numVBraces = IVBraces.GetCount();
//Get Horizontal Braces
ILayoutHorizBraces ILayoutHorizBraces = IStories.GetAt(i).GetFloorType().GetLayoutHorizBraces();
IHorizBraces IHorizBraces = IStories.GetAt(i).GetHorizBraces();
int numHBraces = ILayoutHorizBraces.GetCount();
//Get Elevation
double dElevation = IStories.GetAt(i).dElevation;
// Convert Columns
for (int j = 0; j < numColumns; j++)
{
IColumn IColumn = IColumns.GetAt(j);
Bar bhomBar = BH.Adapter.RAM.Convert.ToBHoMObject(IColumn);
RAMFrameData ramFrameData = bhomBar.FindFragment <RAMFrameData>(typeof(RAMFrameData));
if (ramFrameData != null)
{
ramFrameData.FloorType = IFloorType.strLabel;
bhomBar.Fragments.AddOrReplace(ramFrameData);
}
bhomBars.Add(bhomBar);
}
// Convert Beams
for (int j = 0; j < numBeams; j++)
{
IBeam IBeam = IBeams.GetAt(j);
ILayoutBeam ILayoutBeam = ILayoutBeams.GetAt(j);
Bar bhomBar = BH.Adapter.RAM.Convert.ToBHoMObject(IBeam, ILayoutBeam, dElevation);
RAMFrameData ramFrameData = bhomBar.FindFragment <RAMFrameData>(typeof(RAMFrameData));
if (ramFrameData != null)
{
ramFrameData.FloorType = IFloorType.strLabel;
bhomBar.Fragments.AddOrReplace(ramFrameData);
}
bhomBars.Add(bhomBar);
}
// Convert Vertical Braces
for (int j = 0; j < numVBraces; j++)
{
IVerticalBrace IVerticalBrace = IVBraces.GetAt(j);
Bar bhomBar = BH.Adapter.RAM.Convert.ToBHoMObject(IVerticalBrace);
RAMFrameData ramFrameData = bhomBar.FindFragment <RAMFrameData>(typeof(RAMFrameData));
if (ramFrameData != null)
{
ramFrameData.FloorType = IFloorType.strLabel;
bhomBar.Fragments.AddOrReplace(ramFrameData);
}
bhomBars.Add(bhomBar);
}
// Convert Horizontal Braces
for (int j = 0; j < numHBraces; j++)
{
IHorizBrace IHorizBrace = IHorizBraces.GetAt(j);
ILayoutHorizBrace ILayoutHorizBrace = ILayoutHorizBraces.GetAt(j);
Bar bhomBar = BH.Adapter.RAM.Convert.ToBHoMObject(IHorizBrace, ILayoutHorizBrace, dElevation);
RAMFrameData ramFrameData = bhomBar.FindFragment <RAMFrameData>(typeof(RAMFrameData));
if (ramFrameData != null)
{
ramFrameData.FloorType = IFloorType.strLabel;
bhomBar.Fragments.AddOrReplace(ramFrameData);
}
bhomBars.Add(bhomBar);
}
}
return(bhomBars);
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private bool CreateCollection(IEnumerable <Bar> bhomBars)
{
//Code for creating a collection of bars in the software
List <Bar> bars = bhomBars.ToList();
//Get the stories in the model
IStories ramStories = m_Model.GetStories();
//Cycle through bars, split to beam and col lists, then add to corresponding story.
List <Bar> barBeams = new List <Bar>();
List <Bar> barCols = new List <Bar>();
foreach (Bar testBar in bars)
{
bool isBeam = Math.Abs(testBar.Tangent(true).DotProduct(Vector.ZAxis)) < 0.5;
if (isBeam)
{
barBeams.Add(testBar);
}
else
{
barCols.Add(testBar);
}
}
//Create beams per story, flat
foreach (Bar bar in barBeams)
{
string name = bar.Name;
ILayoutBeam ramBeam;
try
{
RAMId RAMId = new RAMId();
IStory barStory = bar.GetStory(StructuralUsage1D.Beam, ramStories);
IFloorType ramFloorType = barStory.GetFloorType();
ILayoutBeams ramBeams = ramFloorType.GetLayoutBeams();
double zStart = bar.StartNode.Position.Z.ToInch() - barStory.dElevation;
double zEnd = bar.EndNode.Position.Z.ToInch() - barStory.dElevation;
// Get beam fragment cantilever data
double startCant = 0;
double endCant = 0;
bool isStubCant = false;
RAMFrameData ramFrameData = bar.FindFragment <RAMFrameData>(typeof(RAMFrameData));
if (ramFrameData != null)
{
startCant = ramFrameData.StartCantilever;
endCant = ramFrameData.EndCantilever;
isStubCant = ramFrameData.IsStubCantilever;
}
if (isStubCant.Equals("True") || isStubCant.Equals("1")) //Check bool per RAM or GH preferred boolean context
{
SCoordinate startPt, endPt;
if (startCant > 0) // Ensure startPt corresponds with support point
{
startPt = bar.EndNode.Position.ToRAM();
endPt = bar.StartNode.Position.ToRAM();
}
else
{
startPt = bar.StartNode.Position.ToRAM();
endPt = bar.EndNode.Position.ToRAM();
}
ramBeam = ramBeams.AddStubCantilever(bar.SectionProperty.Material.ToRAM(), startPt.dXLoc, startPt.dYLoc, 0, endPt.dXLoc, endPt.dYLoc, 0); // No Z offsets, beams flat on closest story
}
else
{
// Get support points
Vector barDir = bar.Tangent(true);
Point startSupPt = BH.Engine.Geometry.Modify.Translate(bar.StartNode.Position, barDir * startCant);
Point endSupPt = BH.Engine.Geometry.Modify.Translate(bar.EndNode.Position, -barDir * endCant);
SCoordinate start = startSupPt.ToRAM();
SCoordinate end = endSupPt.ToRAM();
ramBeam = ramBeams.Add(bar.SectionProperty.Material.ToRAM(), start.dXLoc, start.dYLoc, 0, end.dXLoc, end.dYLoc, 0); // No Z offsets, beams flat on closest story
if (startSupPt.X < endSupPt.X || (startSupPt.X == endSupPt.X && startSupPt.Y > endSupPt.Y))
{
ramBeam.dStartCantilever = startCant.FromInch();
ramBeam.dEndCantilever = endCant.FromInch();
}
else
{
ramBeam.dStartCantilever = endCant.FromInch();
ramBeam.dEndCantilever = startCant.FromInch();
}
}
// Add warning to report distance of snapping to level as required for RAM
if (zStart != 0 || zEnd != 0)
{
Engine.Base.Compute.RecordWarning("Bar " + name + " snapped to level " + barStory.strLabel + ". Bar moved " + Math.Round(zStart, 2).ToString() + " inches at start and " + Math.Round(zEnd, 2).ToString() + " inches at end.");
}
IBeams beamsOnStory = barStory.GetBeams();
IBeam beam = beamsOnStory.Get(ramBeam.lUID);
beam.strSectionLabel = bar.SectionProperty.Name;
// beam.EAnalyzeFlag = EAnalyzeFlag.eAnalyze; deprecated in API
RAMId.Id = beam.lUID;
bar.SetAdapterId(RAMId);
}
catch
{
CreateElementError("bar", name);
}
}
//Create columns at each story with offset per actual height
foreach (Bar bar in barCols)
{
string name = bar.Name;
try
{
RAMId RAMId = new RAMId();
IStory barStory = bar.GetStory(StructuralUsage1D.Column, ramStories);
List <Node> colNodes = new List <Node>()
{
bar.StartNode, bar.EndNode
};
colNodes.Sort((x, y) => x.Position.Z.CompareTo(y.Position.Z));
double xBtm = colNodes[0].Position.X.ToInch();
double yBtm = colNodes[0].Position.Y.ToInch();
double zBtm = colNodes[0].Position.Z.ToInch() - barStory.dElevation;
double xTop = colNodes[1].Position.X.ToInch();
double yTop = colNodes[1].Position.Y.ToInch();
double zTop = colNodes[1].Position.Z.ToInch() - barStory.dElevation + barStory.dFlrHeight;
IFloorType ramFloorType = barStory.GetFloorType();
ILayoutColumns ramColumns = ramFloorType.GetLayoutColumns();
ILayoutColumn ramColumn;
// Get RAM column data
bool isHanging = false;
RAMFrameData ramFrameData = bar.FindFragment <RAMFrameData>(typeof(RAMFrameData));
if (ramFrameData != null)
{
isHanging = ramFrameData.IsHangingColumn;
}
if (isHanging.Equals("True") || isHanging.Equals("1")) //Check bool per RAM or GH preferred boolean context
{
ramColumn = ramColumns.Add3(bar.SectionProperty.Material.ToRAM(), xBtm, yBtm, xTop, yTop, 0, 0, 1); //No Z offsets, cols start and end at stories
}
else if (bar.IsVertical())
{
//Failing if no section property is provided
ramColumn = ramColumns.Add(bar.SectionProperty.Material.ToRAM(), xTop, yTop, 0, 0); //No Z offsets, cols start and end at stories
}
else
{
ramColumn = ramColumns.Add2(bar.SectionProperty.Material.ToRAM(), xTop, yTop, xBtm, yBtm, 0, 0); //No Z offsets, cols start and end at stories
}
//Set column properties
IColumns colsOnStory = barStory.GetColumns();
IColumn column = colsOnStory.Get(ramColumn.lUID);
column.strSectionLabel = bar.SectionProperty.Name;
column.EAnalyzeFlag = EAnalyzeFlag.eAnalyze;
RAMId.Id = column.lUID;
bar.SetAdapterId(RAMId);
}
catch
{
CreateElementError("bar", name);
}
}
//Save file
m_IDBIO.SaveDatabase();
return(true);
}
public ContinuousLoad(IBeam beam, double valueFromTextbox1)
{
_value = valueFromTextbox1 * beam.Lenght;
_center_of_gravity = beam.Lenght / 2;
}
public VerticalDeflectionResult(IBeam beam) : base(beam)
{
}
public NormalForceResult(IBeam beam) : base(beam)
{
}
public DesignVerification(IBeam beam, double l, double davail)
{
this.Beam = beam;
L = l;
Davail = davail;
}
public BendingMomentResult(IBeam beam) : base(beam)
{
}
private RotationResult(IBeam beam, bool adjustRotation) : this(beam)
{
_adjustRotation = adjustRotation;
}
public void FullBeamCalculationsTest_TimeoutPerformanceChecking_Success(
[Random(27.0, 37.0, 1)] double youngModulus,
[Random(150.0, 500.0, 1)] double width,
[Random(240.0, 1000.0, 1)] double height,
[Random(1.0, 10.0, 2)] double length1,
[Random(1.0, 10.0, 1)] double length2,
[Random(1.0, 10.0, 2)] double length3,
[Random(1.0, 10.0, 2)] double length4,
[Random(-1000.0, -1.0, 2)] double nodeForce,
[Random(-100.0, -1.0, 2)] double shearForce,
[Random(0.0, 1.0, 1)] double minPosition,
[Random(-300.0, -10.0, 2)] double pointLoad,
[Random(1.1, 3.0, 2)] double divider
)
{
var material = new Concrete(youngModulus: youngModulus);
var section = new RectangleSection(width: width, height: height);
var node1 = new FixedNode();
var node2 = new Hinge();
var node3 = new Hinge();
var node4 = new SupportedNode();
var node5 = new SupportedNode();
var nodes = new Node[] { node1, node2, node3, node4, node5 };
var span1 = new Span(
leftNode: node1,
length: length1,
rightNode: node2,
material: material,
section: section
);
var span2 = new Span(
leftNode: node2,
length: length2,
rightNode: node3,
material: material,
section: section
);
var span3 = new Span(
leftNode: node3,
length: length3,
rightNode: node4,
material: material,
section: section
);
var span4 = new Span(
leftNode: node4,
length: length4,
rightNode: node5,
material: material,
section: section
);
var spans = new Span[] { span1, span2, span3, span4 };
node3.ConcentratedForces.Add(new ShearLoad(value: nodeForce));
var startLoad1 = new LoadData(value: shearForce, position: minPosition);
var endLoad1 = new LoadData(value: shearForce, position: length1);
span1.ContinousLoads.Add(ContinousShearLoad.Create(startLoad1, endLoad1));
var pointLoad1 = new ShearLoad(value: pointLoad, position: length2 / divider);
span2.PointLoads.Add(pointLoad1);
_beam = new Beam(spans, nodes);
_beam.Calculate();
for (int i = 0; i < _beam.Length * 100; i++)
{
_beam.ShearResult.GetValue(i);
_beam.BendingMomentResult.GetValue(i);
_beam.VerticalDeflectionResult.GetValue(i);
_beam.RotationResult.GetValue(i);
}
Assert.That(_beam.Spans[0].LeftNode.NormalForce?.Value, Is.Not.Null);
Assert.That(_beam.Spans[0].LeftNode.ShearForce?.Value, Is.Not.Null);
Assert.That(_beam.Spans[0].LeftNode.BendingMoment?.Value, Is.Not.Null);
Assert.That(_beam.Spans[1].LeftNode.NormalForce, Is.Null);
Assert.That(_beam.Spans[1].LeftNode.ShearForce, Is.Null);
Assert.That(_beam.Spans[1].LeftNode.BendingMoment, Is.Null);
Assert.That(_beam.Spans[2].LeftNode.NormalForce, Is.Null);
Assert.That(_beam.Spans[2].LeftNode.ShearForce, Is.Null);
Assert.That(_beam.Spans[2].LeftNode.BendingMoment, Is.Null);
Assert.That(_beam.Spans[3].LeftNode.NormalForce?.Value, Is.Not.Null);
Assert.That(_beam.Spans[3].LeftNode.ShearForce?.Value, Is.Not.Null);
Assert.That(_beam.Spans[3].LeftNode.BendingMoment, Is.Null);
Assert.That(_beam.Spans[3].RightNode.NormalForce?.Value, Is.Not.Null);
Assert.That(_beam.Spans[3].RightNode.ShearForce?.Value, Is.Not.Null);
Assert.That(_beam.Spans[3].RightNode.BendingMoment, Is.Null);
}
public HorizontalDeflectionResult(IBeam beam) : base(beam)
{
}
// POST: api/Beam
public void Post(IBeam beam)
{
fullCatalogue.Add(beam);
}
public GlobalStiffnessMatrix(IBeam beam)
{
_beam = beam ?? throw new ArgumentNullException(nameof(beam));
}
public ShearResult(IBeam beam) : base(beam)
{
}
public RotationResult(IBeam beam) : base(beam)
{
}
