avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add logic for converting beam shear calculator input data

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-03-30 17:34:00 +05:00
parent a0a25f183a
commit cefe30f103
41 changed files with 346 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,30 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.Models.BeamShears
{
internal class BeamShearCalculatorInputDataUpdateStrategy : IUpdateStrategy<IBeamShearCalculatorInputData>
{
private IUpdateStrategy<IHasBeamShearActions>? hasActionUpdateStrategy;
private IUpdateStrategy<IHasStirrups>? hasStirrupsUpdateStrategy;
private IUpdateStrategy<IHasBeamShearSections> hasSectionsUpdateStrategy;
public void Update(IBeamShearCalculatorInputData targetObject, IBeamShearCalculatorInputData sourceObject)
{
CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; };
InitializeStrategies();
hasActionUpdateStrategy?.Update(targetObject, sourceObject);
hasStirrupsUpdateStrategy?.Update(targetObject, sourceObject);
}
private void InitializeStrategies()
{
hasActionUpdateStrategy ??= new HasBeamShearActionUpdateStrategy();
hasStirrupsUpdateStrategy ??= new HasStirrupsUpdateStrategy();
hasSectionsUpdateStrategy ??= new HasBeamShearSectionUpdateStrategy();
}
}
}

65
StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorToLogicInputDataConvertStrategy.cs Normal file
View File

@@ -0,0 +1,65 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Services.Forces;
namespace StructureHelperLogics.Models.BeamShears
{
public class BeamShearCalculatorToLogicInputDataConvertStrategy
{
const LimitStates limitState = LimitStates.ULS;
private readonly IShiftTraceLogger? traceLogger;
private readonly List<CalcTerms> calcTerms = new() { CalcTerms.ShortTerm, CalcTerms.LongTerm };
public BeamShearCalculatorToLogicInputDataConvertStrategy(IShiftTraceLogger? traceLogger)
{
this.traceLogger = traceLogger;
}
public List<IBeamShearSectionLogicInputData> Convert(IBeamShearCalculatorInputData source)
{
List<IBeamShearSectionLogicInputData> result = new();
foreach (var section in source.Sections)
{
foreach (var action in source.Actions)
{
foreach (var stirrup in source.Stirrups)
{
foreach (var calcTerm in calcTerms)
{
IForceTuple forceTuple = GetForceTuple(action, limitState, calcTerm);
BeamShearSectionLogicInputData newItem = new()
{
BeamShearSection = section,
ForceTuple = forceTuple,
Stirrup = stirrup,
LimitState = limitState,
CalcTerm = calcTerm
};
result.Add(newItem);
}
}
}
}
return result;
}
private IForceTuple GetForceTuple(IBeamShearAction action, LimitStates limitState, CalcTerms calcTerm)
{
IForceTuple externalForceTuple = GetExternalForceTuple(action.ExternalForce, limitState, calcTerm);
IForceTuple internalForceTuple = GetInternalForceTuple(action.SupportAction, limitState, calcTerm);
IForceTuple sumForceTuple = ForceTupleService.SumTuples(externalForceTuple, internalForceTuple);
return sumForceTuple;
}
private IForceTuple GetInternalForceTuple(IBeamShearAxisAction supportAction, LimitStates limitState, CalcTerms calcTerm)
{
throw new NotImplementedException();
}
private IForceTuple GetExternalForceTuple(IFactoredForceTuple externalForce, LimitStates limitState, CalcTerms calcTerm)
{
throw new NotImplementedException();
}
}
}

26
StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,26 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.Models.BeamShears
{
public class BeamShearCalculatorUpdateStrategy : IUpdateStrategy<IBeamShearCalculator>
{
private IUpdateStrategy<IBeamShearCalculatorInputData>? inputDataUpdateStrategy;
public void Update(IBeamShearCalculator targetObject, IBeamShearCalculator sourceObject)
{
CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; };
targetObject.Name = sourceObject.Name;
targetObject.InputData ??= new BeamShearCalculatorInputData(Guid.NewGuid());
InitializeStrategies();
inputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData);
}
private void InitializeStrategies()
{
inputDataUpdateStrategy ??= new BeamShearCalculatorInputDataUpdateStrategy();
}
}
}

19
StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs
View File

@@ -1,6 +1,7 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Services.Forces;
//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia
//All rights reserved.
@@ -40,19 +41,23 @@ namespace StructureHelperLogics.Models.BeamShears
}
/// <inheritdoc/>
public double CalculateShearForce()
public IForceTuple CalculateShearForce()
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service);
InitializeStrategies();
double supportShearForce = AxisAction.SupportForce.ForceTuple.Qx;
IForceTuple supportShearForce = AxisAction.SupportForce.ForceTuple;
TraceLogger?.AddMessage($"Shear force at support Qmax = {supportShearForce}(N)");
TraceLogger?.AddMessage($"Start of inclined section a,start = {InclinedSection.StartCoord}(m)");
TraceLogger?.AddMessage($"End of inclined section a,end = {InclinedSection.EndCoord}(m)");
double summarySpanShearForce = AxisAction.ShearLoads
.Sum(load => summaryForceLogic.GetSumShearForce(load, InclinedSection.StartCoord, InclinedSection.EndCoord));
TraceLogger?.AddMessage($"Summary span force deltaQ = {summarySpanShearForce}(N)");
double shearForce = supportShearForce + summarySpanShearForce;
TraceLogger?.AddMessage($"Summary shear force at the end of inclined section Q = {shearForce}(N)");
ForceTuple summarySpanShearForce = new (Guid.NewGuid());
foreach (var item in AxisAction.ShearLoads)
{
IForceTuple summarySpanLoad = summaryForceLogic.GetSumShearForce(item, InclinedSection.StartCoord, InclinedSection.EndCoord);
ForceTupleService.SumTupleToTarget(summarySpanLoad, summarySpanShearForce);
}
TraceLogger?.AddMessage($"Summary span force deltaQ = {summarySpanShearForce.Qy}(N)");
IForceTuple shearForce = ForceTupleService.SumTuples(supportShearForce,summarySpanShearForce);
TraceLogger?.AddMessage($"Summary shear force at the end of inclined section Q = {shearForce.Qy}(N)");
return shearForce;
}

21
StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,21 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.Models.BeamShears
{
public class HasBeamShearActionUpdateStrategy : IUpdateStrategy<IHasBeamShearActions>
{
public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
{
CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; };
CheckObject.IsNull(sourceObject.Actions);
CheckObject.IsNull(targetObject.Actions);
targetObject.Actions.Clear();
targetObject.Actions.AddRange(sourceObject.Actions);
}
}
}

25
StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,25 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class HasBeamShearSectionUpdateStrategy : IUpdateStrategy<IHasBeamShearSections>
{
public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject)
{
CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; };
CheckObject.IsNull(sourceObject.Sections);
CheckObject.IsNull(targetObject.Sections);
targetObject.Sections.Clear();
targetObject.Sections.AddRange(sourceObject.Sections);
}
}
}

20
StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,20 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.Models.BeamShears
{
public class HasStirrupsUpdateStrategy : IUpdateStrategy<IHasStirrups>
{
public void Update(IHasStirrups targetObject, IHasStirrups sourceObject)
{
CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; };
CheckObject.IsNull(sourceObject.Stirrups);
CheckObject.IsNull(targetObject.Stirrups);
targetObject.Stirrups.Clear();
targetObject.Stirrups.AddRange(sourceObject.Stirrups);
}
}
}

2
StructureHelperLogics/Models/BeamShears/Logics/IGetDirectShearForceLogic.cs
View File

@@ -12,6 +12,6 @@ namespace StructureHelperLogics.Models.BeamShears
/// Returns value of shear force at the end of inclined section
/// </summary>
/// <returns>Value of shear force at the end of inclined section</returns>
double CalculateShearForce();
IForceTuple CalculateShearForce();
}
}

3
StructureHelperLogics/Models/BeamShears/Logics/IShearForceLogic.cs
View File

@@ -1,4 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia
//All rights reserved.
@@ -7,7 +8,7 @@ namespace StructureHelperLogics.Models.BeamShears
{
internal interface IShearForceLogic : ILogic
{
double GetShearForce();
IForceTuple GetShearForce();
}
}

2
StructureHelperLogics/Models/BeamShears/Logics/ISumForceByShearLoadLogic.cs
View File

@@ -20,6 +20,6 @@ namespace StructureHelperLogics.Models.BeamShears
/// <param name="startCoord">Coordinate of start point, m</param>
/// <param name="endCoord">Coordinate of end point, m</param>
/// <returns>Summary force, N</returns>
double GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord);
IForceTuple GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord);
}
}

7
StructureHelperLogics/Models/BeamShears/Logics/ShearForceLogic.cs
View File

@@ -2,6 +2,7 @@
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Forces.Logics;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Services.Forces;
namespace StructureHelperLogics.Models.BeamShears
{
@@ -31,13 +32,13 @@ namespace StructureHelperLogics.Models.BeamShears
this.getDirectShearForceLogic = getDirectShearForceLogic;
}
public double GetShearForce()
public IForceTuple GetShearForce()
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service);
InitializeStrategies();
double factor = getFactorLogic.GetFactor();
double directShearForce = getDirectShearForceLogic.CalculateShearForce();
double shearForce = directShearForce * factor;
IForceTuple directShearForce = getDirectShearForceLogic.CalculateShearForce();
IForceTuple shearForce = ForceTupleService.MultiplyTupleByFactor(directShearForce,factor);
return shearForce;
}

19
StructureHelperLogics/Models/BeamShears/Logics/SumConcentratedForceLogic.cs
View File

@@ -2,6 +2,7 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Services.Forces;
namespace StructureHelperLogics.Models.BeamShears
{
@@ -22,13 +23,13 @@ namespace StructureHelperLogics.Models.BeamShears
TraceLogger = traceLogger;
}
public double GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord)
public IForceTuple GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord)
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service);
if (beamShearLoad is IConcentratedForce concentratedForce)
{
InitializeStrategies();
double sumForce = GetConcentratedForceSum(concentratedForce, startCoord, endCoord);
IForceTuple sumForce = GetConcentratedForceSum(concentratedForce, startCoord, endCoord);
return sumForce;
}
else
@@ -42,20 +43,20 @@ namespace StructureHelperLogics.Models.BeamShears
coordinateByLevelLogic ??= new CoordinateByLevelLogic(TraceLogger);
}
private double GetConcentratedForceSum(IConcentratedForce concentratedForce, double startCoord, double endCoord)
private IForceTuple GetConcentratedForceSum(IConcentratedForce concentratedForce, double startCoord, double endCoord)
{
TraceLogger?.AddMessage($"Concentrated force Name = {concentratedForce.Name}, Value = {concentratedForce.ForceValue}(N/m) ");
TraceLogger?.AddMessage($"Concentrated force Name = {concentratedForce.Name}, Value = {concentratedForce.ForceValue.Qy}(N/m) ");
if (concentratedForce.ForceCoordinate > endCoord)
{
TraceLogger?.AddMessage($"Force coordinate {concentratedForce.ForceCoordinate}(m) is bigger than section end {endCoord}(m), so total load is zero");
return 0;
return new ForceTuple(Guid.NewGuid());
}
return GetConcentratedForce(concentratedForce, startCoord, endCoord);
}
private double GetConcentratedForce(IConcentratedForce concentratedForce, double startCoord, double endCoord)
private IForceTuple GetConcentratedForce(IConcentratedForce concentratedForce, double startCoord, double endCoord)
{
double totalLoad;
IForceTuple totalLoad;
double limitCoordinate = startCoord;
if (concentratedForce.ForceCoordinate >= startCoord)
{
@@ -63,13 +64,13 @@ namespace StructureHelperLogics.Models.BeamShears
}
if (concentratedForce.ForceCoordinate < limitCoordinate)
{
totalLoad = concentratedForce.ForceValue * concentratedForce.LoadRatio;
totalLoad = ForceTupleService.MultiplyTupleByFactor(concentratedForce.ForceValue, concentratedForce.LoadRatio);
TraceLogger?.AddMessage($"Total load Q,tot = {concentratedForce.ForceValue}(N) * {concentratedForce.LoadRatio} = {totalLoad}(N)");
}
else
{
TraceLogger?.AddMessage($"Force coordinate {concentratedForce.ForceCoordinate}(m) is bigger than limit coordinate {limitCoordinate}(m), so total load is zero");
totalLoad = 0d;
totalLoad = new ForceTuple(Guid.NewGuid());
}
return totalLoad;
}

16
StructureHelperLogics/Models/BeamShears/Logics/SumDistributedLoadLogic.cs
View File

@@ -2,6 +2,7 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Services.Forces;
namespace StructureHelperLogics.Models.BeamShears
{
@@ -21,13 +22,13 @@ namespace StructureHelperLogics.Models.BeamShears
TraceLogger = traceLogger;
}
public double GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord)
public IForceTuple GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord)
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service);
if (beamShearLoad is IDistributedLoad distributedLoad)
{
InitializeStrategies();
double sumForce = GetDistributedLoadSum(distributedLoad, startCoord, endCoord);
IForceTuple sumForce = GetDistributedLoadSum(distributedLoad, startCoord, endCoord);
return sumForce;
}
else
@@ -41,21 +42,22 @@ namespace StructureHelperLogics.Models.BeamShears
coordinateByLevelLogic ??= new CoordinateByLevelLogic(TraceLogger);
}
private double GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord)
private IForceTuple GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord)
{
TraceLogger?.AddMessage($"Uniformly distributed load Name = {distributedLoad.Name}, Value = {distributedLoad.LoadValue}(N/m) ");
TraceLogger?.AddMessage($"Uniformly distributed load Name = {distributedLoad.Name}, Value = {distributedLoad.LoadValue.Qy}(N/m) ");
double loadStartCoord = Math.Max(distributedLoad.StartCoordinate, 0d);
if (loadStartCoord > endCoord)
{
TraceLogger?.AddMessage($"Load start coordinate {loadStartCoord}(m) is bigger than section end {endCoord}(m), so total load is zero");
return 0d;
return new ForceTuple(Guid.NewGuid());
}
double endCoordByLevel = coordinateByLevelLogic.GetCoordinate(startCoord, endCoord, distributedLoad.RelativeLoadLevel);
double loadEndCoord = Math.Min(distributedLoad.EndCoordinate, endCoordByLevel);
double loadLength = loadEndCoord - loadStartCoord;
TraceLogger?.AddMessage($"Total length L,tot = {loadEndCoord}(m) - {loadStartCoord}(m) = {loadLength}(m)");
double totalLoad = distributedLoad.LoadValue * distributedLoad.LoadRatio * loadLength;
TraceLogger?.AddMessage($"Total load Q,tot = {distributedLoad.LoadValue}(N/m) * {distributedLoad.LoadRatio} * {loadLength}(m) = {totalLoad}(N)");
double sumFactor = distributedLoad.LoadRatio * loadLength;
IForceTuple totalLoad = ForceTupleService.MultiplyTupleByFactor(distributedLoad.LoadValue, sumFactor);
TraceLogger?.AddMessage($"Total load Q,tot = {distributedLoad.LoadValue.Qy}(N/m) * {distributedLoad.LoadRatio} * {loadLength}(m) = {totalLoad}(N)");
return totalLoad;
}
}

12
StructureHelperLogics/Models/BeamShears/Logics/SumForceByShearLoadLogic.cs
View File

@@ -26,13 +26,13 @@ namespace StructureHelperLogics.Models.BeamShears
TraceLogger = traceLogger;
}
public double GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord)
public IForceTuple GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord)
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service);
if (beamShearLoad is IDistributedLoad distributedLoad)
{
TraceLogger?.AddMessage($"Load is uniformly distributed load");
double sumDistributed = GetDistributedLoadSum(distributedLoad, startCoord, endCoord);
IForceTuple sumDistributed = GetDistributedLoadSum(distributedLoad, startCoord, endCoord);
return sumDistributed;
}
else if (beamShearLoad is IConcentratedForce concenratedForce)
@@ -46,18 +46,18 @@ namespace StructureHelperLogics.Models.BeamShears
}
}
private double GetConcentratedForceSum(IConcentratedForce concenratedForce, double startCoord, double endCoord)
private IForceTuple GetConcentratedForceSum(IConcentratedForce concenratedForce, double startCoord, double endCoord)
{
sumConcentratedForceLogic ??= new SumConcentratedForceLogic(TraceLogger);
double sumForce = sumConcentratedForceLogic.GetSumShearForce(concenratedForce, startCoord, endCoord);
IForceTuple sumForce = sumConcentratedForceLogic.GetSumShearForce(concenratedForce, startCoord, endCoord);
TraceLogger?.AddMessage($"Sum of uniformly distributed load Qud = {sumForce}(N)");
return sumForce;
}
private double GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord)
private IForceTuple GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord)
{
sumDistributedLoadLogic ??= new SumDistributedLoadLogic(TraceLogger);
double sumForce = sumDistributedLoadLogic.GetSumShearForce(distributedLoad, startCoord, endCoord);
IForceTuple sumForce = sumDistributedLoadLogic.GetSumShearForce(distributedLoad, startCoord, endCoord);
TraceLogger?.AddMessage($"Sum of concentrated force Qcf = {sumForce}(N)");
return sumForce;
}