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

Add BeamShearCalculator

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-02-16 17:24:16 +05:00
parent f60d031f91
commit e4a23f5139
39 changed files with 1023 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
StructureHelperLogics/Models/BeamShears/BeamShearCalculator.cs Normal file
View File

@@ -0,0 +1,86 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
internal class BeamShearCalculator : IBeamShearCalculator
{
private ICheckInputDataLogic<IBeamShearCalculatorInputData> checkInputDataLogic;
IGetResultByInputDataLogic<IBeamShearCalculatorInputData, IBeamShearCalculatorResult> calculationLogic;
private IBeamShearCalculatorResult result;
public Guid Id { get; }
public string Name { get; set; } = string.Empty;
public IBeamShearCalculatorInputData InputData { get; set; } = new BeamShearCalculatorInputData(Guid.NewGuid());
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public object Clone()
{
throw new NotImplementedException();
}
public void Run()
{
PrepareNewResult();
PrepareInputData();
try
{
InitializeStrategies();
if (CheckInputData() == false) { return;}
CalculateResult();
}
catch (Exception ex)
{
result.IsValid = false;
TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error);
}
}
private void PrepareInputData()
{
throw new NotImplementedException();
}
private bool CheckInputData()
{
var checkResult = checkInputDataLogic.Check();
if (checkResult == false)
{
result.IsValid = false;
result.Description += checkInputDataLogic.CheckResult;
TraceLogger?.AddMessage(checkInputDataLogic.CheckResult, TraceLogStatuses.Error);
}
return checkResult;
}
private void CalculateResult()
{
result = calculationLogic.GetResultByInputData(InputData);
}
private void InitializeStrategies()
{
checkInputDataLogic ??= new CheckBeamShearCalculatorInputDataLogic(InputData, TraceLogger);
calculationLogic ??= new BeamShearCalculatorLogic(TraceLogger);
}
private void PrepareNewResult()
{
result = new BeamShearCalculatorResult()
{
IsValid = true,
Description = string.Empty
};
}
}
}

30
StructureHelperLogics/Models/BeamShears/BeamShearCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,30 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
/// <inheritdoc/>
public class BeamShearCalculatorInputData : IBeamShearCalculatorInputData
{
/// <inheritdoc/>
public Guid Id { get; }
/// <inheritdoc/>
public List<IBeamShearAction> BeamShearActions { get; } = new();
/// <inheritdoc/>
public List<IBeamShearSection> ShearSections { get; } = new();
/// <inheritdoc/>
public List<IStirrup> Stirrups { get; } = new();
public BeamShearCalculatorInputData(Guid id)
{
Id = id;
}
}
}

88
StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs Normal file
View File

@@ -0,0 +1,88 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class BeamShearCalculatorLogic : IGetResultByInputDataLogic<IBeamShearCalculatorInputData, IBeamShearCalculatorResult>
{
private IBeamShearCalculatorResult result;
private IBeamShearSectionCalculator beamShearSectionCalculator;
private List<IBeamShearSectionCalculatorInputData> sectionInputDatas;
public BeamShearCalculatorLogic(IShiftTraceLogger? traceLogger)
{
TraceLogger = traceLogger;
}
public IShiftTraceLogger? TraceLogger { get; set; }
public IBeamShearCalculatorResult GetResultByInputData(IBeamShearCalculatorInputData inputData)
{
PrepareNewResult();
InitializeStrategies();
try
{
GetSectionInputDatas(inputData);
CalculateResult();
}
catch (Exception ex)
{
TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error);
result.IsValid = false;
}
return result;
}
private void CalculateResult()
{
foreach (var sectionInputData in sectionInputDatas)
{
beamShearSectionCalculator.InputData = sectionInputData;
beamShearSectionCalculator.Run();
var sectionResult = beamShearSectionCalculator.Result as IBeamShearSectionCalculatorResult;
result.SectionResults.Add(sectionResult);
}
}
private void InitializeStrategies()
{
beamShearSectionCalculator ??= new BeamShearSectionCalculator();
}
private void PrepareNewResult()
{
result = new BeamShearCalculatorResult()
{
IsValid = true,
Description = string.Empty
};
}
private void GetSectionInputDatas(IBeamShearCalculatorInputData inputData)
{
sectionInputDatas = new();
foreach (var beamShearSection in inputData.ShearSections)
{
foreach (var stirrup in inputData.Stirrups)
{
foreach (var beamShearAction in inputData.BeamShearActions)
{
BeamShearSectionCalculatorInputData newInputData = new(Guid.NewGuid())
{
BeamShearSection = beamShearSection,
Stirrup = stirrup,
BeamShearAction = beamShearAction
};
sectionInputDatas.Add(newInputData);
}
}
}
}
}
}

15
StructureHelperLogics/Models/BeamShears/BeamShearCalculatorResult.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class BeamShearCalculatorResult : IBeamShearCalculatorResult
{
public bool IsValid { get; set; } = true;
public string? Description { get; set; } = string.Empty;
public List<IBeamShearSectionCalculatorResult> SectionResults { get; set; } = new();
}
}

22
StructureHelperLogics/Models/BeamShears/BeamShearRepository.cs
View File

@@ -13,15 +13,33 @@ namespace StructureHelperLogics.Models.BeamShears
public Guid Id { get; }
public List<IBeamShearAction> BeamShearActions { get; }
public List<IBeamShearAction> BeamShearActions {get;}
public List<ICalculator> Calculators { get; } = new();
public List<IBeamShearSection> ShearSections { get; } = new();
public List<IStirrup> Stirrups { get; } = new();
public List<ICalculator> Calculators { get; }
public BeamShearRepository(Guid id)
{
Id = id;
}
public void DeleteBeamShearAction(IBeamShearAction beamShearAction)
{
foreach (var calculator in Calculators)
{
if (calculator is IBeamShearCalculator beamShearCalculator)
{
var inputData = beamShearCalculator.InputData;
inputData.BeamShearActions.Remove(beamShearAction);
}
}
BeamShearActions.Remove(beamShearAction);
}
public object Clone()
{
throw new NotImplementedException();

34
StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculator.cs Normal file
View File

@@ -0,0 +1,34 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class BeamShearSectionCalculator : IBeamShearSectionCalculator
{
private IBeamShearSectionCalculatorResult result;
public Guid Id { get; }
public string Name { get; set; }
public IBeamShearSectionCalculatorInputData InputData { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public object Clone()
{
throw new NotImplementedException();
}
public void Run()
{
throw new NotImplementedException();
}
}
}

27
StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,27 @@
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
/// <inheritdoc/>
public class BeamShearSectionCalculatorInputData : IBeamShearSectionCalculatorInputData
{
/// <inheritdoc/>
public Guid Id { get; }
/// <inheritdoc/>
public IBeamShearSection? BeamShearSection { get; set; }
/// <inheritdoc/>
public IBeamShearAction? BeamShearAction { get; set; }
/// <inheritdoc/>
public IStirrup? Stirrup { get; set; }
public BeamShearSectionCalculatorInputData(Guid id)
{
Id = id;
}
}
}

14
StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorResult.cs Normal file
View File

@@ -0,0 +1,14 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class BeamShearSectionCalculatorResult : IBeamShearSectionCalculatorResult
{
public bool IsValid { get; set; }
public string? Description { get; set; }
}
}

14
StructureHelperLogics/Models/BeamShears/IBeamShearCalculator.cs Normal file
View File

@@ -0,0 +1,14 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IBeamShearCalculator : ICalculator
{
IBeamShearCalculatorInputData InputData { get; set; }
}
}

15
StructureHelperLogics/Models/BeamShears/IBeamShearCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,15 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IBeamShearCalculatorInputData : ISaveable, IInputData, IHasBeamShearActions, IHasBeamShearSections, IHasStirrups
{
}
}

14
StructureHelperLogics/Models/BeamShears/IBeamShearCalculatorResult.cs Normal file
View File

@@ -0,0 +1,14 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IBeamShearCalculatorResult : IResult
{
List<IBeamShearSectionCalculatorResult> SectionResults { get; set; }
}
}

2
StructureHelperLogics/Models/BeamShears/IBeamShearRepository.cs
View File

@@ -9,7 +9,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IBeamShearRepository : ISaveable, IHasBeamShearActions, IHasCalculators, ICloneable
public interface IBeamShearRepository : ISaveable, IHasBeamShearActions, IHasCalculators, IHasBeamShearSections, IHasStirrups, ICloneable
{
}

14
StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculator.cs Normal file
View File

@@ -0,0 +1,14 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IBeamShearSectionCalculator : ICalculator
{
IBeamShearSectionCalculatorInputData InputData { get; set; }
}
}

18
StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,18 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IBeamShearSectionCalculatorInputData : IInputData, ISaveable
{
IBeamShearSection? BeamShearSection { get; set; }
IBeamShearAction? BeamShearAction { get; set; }
IStirrup? Stirrup { get; set; }
}
}

13
StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculatorResult.cs Normal file
View File

@@ -0,0 +1,13 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IBeamShearSectionCalculatorResult : IResult
{
}
}

13
StructureHelperLogics/Models/BeamShears/IHasBeamShearSections.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IHasBeamShearSections
{
List<IBeamShearSection> ShearSections { get; }
}
}

13
StructureHelperLogics/Models/BeamShears/IHasStirrups.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IHasStirrups
{
List<IStirrup> Stirrups { get; }
}
}

13
StructureHelperLogics/Models/BeamShears/IInclinedSection.cs
View File

@@ -7,10 +7,23 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
/// <summary>
/// Implement parameers of inclined cross-section for beam shear calculating
/// </summary>
public interface IInclinedSection : IEffectiveDepth
{
/// <summary>
/// Width of cross-section
/// </summary>
double WebWidth { get; set; }
/// <summary>
/// Coordinate of start of inclined cross-section
/// </summary>
double StartCoord { get; set; }
/// <summary>
/// Coordinate of end of inclined cross-section
/// </summary>
double EndCoord { get; set; }
}
}

7
StructureHelperLogics/Models/BeamShears/InclinedSection.cs
View File

@@ -6,11 +6,18 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
/// <inheritdoc/>
public class InclinedSection : IInclinedSection
{
/// <inheritdoc/>
public double FullDepth { get; set; }
/// <inheritdoc/>
public double EffectiveDepth { get; set; }
/// <inheritdoc/>
public double WebWidth { get; set; }
/// <inheritdoc/>
public double StartCoord { get; set; }
/// <inheritdoc/>
public double EndCoord { get; set; }
}
}

58
StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearCalculatorInputDataLogic.cs Normal file
View File

@@ -0,0 +1,58 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperLogics.NdmCalculations.Cracking;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class CheckBeamShearCalculatorInputDataLogic : ICheckInputDataLogic<IBeamShearCalculatorInputData>
{
private bool result;
private string checkResult;
public string CheckResult => checkResult;
public IBeamShearCalculatorInputData InputData { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public CheckBeamShearCalculatorInputDataLogic(IBeamShearCalculatorInputData inputData, IShiftTraceLogger? traceLogger)
{
InputData = inputData;
TraceLogger = traceLogger;
}
public bool Check()
{
result = true;
checkResult = string.Empty;
if (InputData is null)
{
result = false;
string errorString = ErrorStrings.ParameterIsNull + ": Input data";
throw new StructureHelperException(errorString);
}
if (InputData.BeamShearActions is null || ! InputData.BeamShearActions.Any())
{
result = false;
string errorString = "Collection of actions does not contain any action";
TraceMessage(errorString);
}
if (InputData.ShearSections is null || ! InputData.ShearSections.Any())
{
result = false;
string errorString = "Collection of sections does not contain any section";
TraceMessage(errorString);
}
return result;
}
private void TraceMessage(string errorString)
{
checkResult += errorString;
TraceLogger?.AddMessage(errorString);
}
}
}

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

@@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class GetInclinedSectionListInputData : IGetInclinedSectionListInputData
{
public int StepCount { get; set; } = 50;
public double MaxInclinedSectionLegthFactor { get; set; } = 3d;
public IGetInclinedSectionLogic? GetInclinedSectionLogic { get; set; }
public IBeamShearSection BeamShearSection { get; set; }
public GetInclinedSectionListInputData(IBeamShearSection beamShearSection)
{
BeamShearSection = beamShearSection;
}
}
}

87
StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs Normal file
View File

@@ -0,0 +1,87 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.Models.BeamShears
{
public class GetInclinedSectionListLogic : IGetInclinedSectionListLogic
{
private readonly GetInclinedSectionListInputData inputData;
private IGetInclinedSectionLogic inclinedSectionLogic;
private double depth;
private double effectiveDepth;
private List<IInclinedSection> inclinedSections;
private List<double> coordinates;
public IShiftTraceLogger? TraceLogger { get; set; }
public GetInclinedSectionListLogic(
GetInclinedSectionListInputData inputData,
IShiftTraceLogger? traceLogger)
{
this.inputData = inputData;
TraceLogger = traceLogger;
}
public List<IInclinedSection> GetInclinedSections()
{
Check();
GetShapeParameters();
GetCoordinates();
foreach (var startCoord in coordinates)
{
var endCoordinates = coordinates.Where(x => x >= startCoord);
foreach (var endCoord in endCoordinates)
{
inclinedSectionLogic = InitializeInclinedSectionLogic(startCoord, endCoord);
IInclinedSection inclinedSection = inclinedSectionLogic.GetInclinedSection();
inclinedSections.Add(inclinedSection);
}
}
return inclinedSections;
}
private void GetCoordinates()
{
double maxSectionLength = inputData.MaxInclinedSectionLegthFactor * effectiveDepth;
double step = maxSectionLength / inputData.StepCount;
inclinedSections = new();
coordinates = new();
for (int i = 0; i < inputData.StepCount + 1; i++)
{
double endCoord = step * i;
coordinates.Add(endCoord);
}
}
private void Check()
{
CheckObject.IsNull(inputData);
CheckObject.IsNull(inputData.BeamShearSection);
}
private IGetInclinedSectionLogic InitializeInclinedSectionLogic(double startCoord, double endCoord)
{
if (inputData.GetInclinedSectionLogic is not null)
{
return inputData.GetInclinedSectionLogic;
}
return new GetInclinedSectionLogic(inputData.BeamShearSection, startCoord, endCoord, TraceLogger);
}
private void GetShapeParameters()
{
if (inputData.BeamShearSection.Shape is IRectangleShape rectangle)
{
depth = rectangle.Height;
}
else if (inputData.BeamShearSection.Shape is ICircleShape circle)
{
depth = circle.Diameter;
}
else
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(inputData.BeamShearSection.Shape));
}
effectiveDepth = depth - inputData.BeamShearSection.CenterCover;
}
}
}

39
StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionLogic.cs
View File

@@ -1,11 +1,6 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Shapes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
@@ -17,6 +12,8 @@ namespace StructureHelperLogics.Models.BeamShears
private double width;
private double depth;
private double effectiveDepth;
private InclinedSection? inclinedSection;
public IShiftTraceLogger? TraceLogger { get; set; }
public GetInclinedSectionLogic(
IBeamShearSection beamShearSection,
@@ -31,14 +28,26 @@ namespace StructureHelperLogics.Models.BeamShears
Check();
}
public GetInclinedSectionLogic(IShiftTraceLogger? traceLogger)
public IInclinedSection GetInclinedSection()
{
TraceLogger = traceLogger;
GetShapeParameters();
GetSection();
return inclinedSection;
}
public IShiftTraceLogger? TraceLogger { get; set; }
public IInclinedSection GetInclinedSection()
private void GetSection()
{
effectiveDepth = depth - beamShearSection.CenterCover;
inclinedSection = new()
{
FullDepth = depth,
EffectiveDepth = effectiveDepth,
StartCoord = startCoord,
EndCoord = endCoord,
WebWidth = width
};
}
private void GetShapeParameters()
{
if (beamShearSection.Shape is IRectangleShape rectangle)
{
@@ -54,17 +63,7 @@ namespace StructureHelperLogics.Models.BeamShears
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(beamShearSection.Shape));
}
effectiveDepth = depth - beamShearSection.CenterCover;
InclinedSection inclinedSection = new()
{
EffectiveDepth = effectiveDepth,
StartCoord = startCoord,
EndCoord = endCoord,
WebWidth = width
};
return inclinedSection;
}
private void Check()
{
if (beamShearSection is null)

106
StructureHelperLogics/Models/BeamShears/Logics/GetSumForceByShearActionLogic.cs Normal file
View File

@@ -0,0 +1,106 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class GetSumForceByShearActionLogic : IGetSumForceByShearActionLogic
{
public IShiftTraceLogger? TraceLogger { get; set; }
public GetSumForceByShearActionLogic(IShiftTraceLogger? traceLogger)
{
TraceLogger = traceLogger;
}
public double GetSumShearForce(IBeamShearLoad beamShearAction, double startCoord, double endCoord)
{
if (beamShearAction is IUniformlyDistributedLoad distributedLoad)
{
return GetDistributedLoadSum(distributedLoad, startCoord, endCoord);
}
else if (beamShearAction is IConcenratedForce concenratedForce)
{
return GetConcentratedForceSum(concenratedForce, startCoord, endCoord);
}
else
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(beamShearAction));
}
}
private double GetConcentratedForceSum(IConcenratedForce concentratedForce, double startCoord, double endCoord)
{
TraceLogger?.AddMessage($"Concentrated force Name = {concentratedForce.Name}, Value = {concentratedForce.ForceValue}(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;
}
double totalLoad;
double limitCoordinate = startCoord;
if (concentratedForce.ForceCoordinate >= startCoord)
{
limitCoordinate = GetCoordinateByLevel(startCoord, endCoord, concentratedForce.RelativeLoadLevel);
}
if (concentratedForce.ForceCoordinate < limitCoordinate)
{
totalLoad = 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;
}
return totalLoad;
}
private double GetDistributedLoadSum(IUniformlyDistributedLoad distributedLoad, double startCoord, double endCoord)
{
TraceLogger?.AddMessage($"Uniformly distributed load Name = {distributedLoad.Name}, Value = {distributedLoad.LoadValue}(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;
}
double endCoordByLevel = GetCoordinateByLevel(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)");
return totalLoad;
}
private double GetCoordinateByLevel(double startCoord, double endCoord, double relativeLevel)
{
CheckRelativeLevel(relativeLevel);
double delta = endCoord - startCoord;
double coordinate = startCoord + delta * (relativeLevel + 0.5d);
return coordinate;
}
private void CheckRelativeLevel(double relativeLevel)
{
if (relativeLevel > 0.5d)
{
string errorString = ErrorStrings.IncorrectValue + ": relative level must not be greater than 0.5";
TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
if (relativeLevel < -0.5d)
{
string errorString = ErrorStrings.IncorrectValue + ": relative level must not be less than -0.5";
TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
}
}
}

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

@@ -7,8 +7,15 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
/// <summary>
/// Implement logic for obtaining of inclined section
/// </summary>
public interface IGetInclinedSectionLogic : ILogic
{
/// <summary>
/// Returns inclined section
/// </summary>
/// <returns>Inclined section</returns>
IInclinedSection GetInclinedSection();
}
}

16
StructureHelperLogics/Models/BeamShears/Logics/IGetInclinedSectionListInputData.cs Normal file
View File

@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IGetInclinedSectionListInputData
{
int StepCount { get; set; }
double MaxInclinedSectionLegthFactor { get; set; }
IGetInclinedSectionLogic? GetInclinedSectionLogic { get; set; }
IBeamShearSection BeamShearSection { get; set; }
}
}

12
StructureHelperLogics/Models/BeamShears/Logics/IGetInclinedSectionListLogic.cs Normal file
View File

@@ -0,0 +1,12 @@
using StructureHelperCommon.Infrastructures.Interfaces;
namespace StructureHelperLogics.Models.BeamShears
{
/// <summary>
/// Returns collection of inclined section for beam shear calculating
/// </summary>
public interface IGetInclinedSectionListLogic : ILogic
{
List<IInclinedSection> GetInclinedSections();
}
}

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

@@ -0,0 +1,25 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
/// <summary>
/// Implement logic for obtaining of summary force of action from start to end
/// </summary>
public interface IGetSumForceByShearActionLogic : ILogic
{
/// <summary>
/// Returns summary force of action from start to end
/// </summary>
/// <param name="beamShearAction">Source action</param>
/// <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(IBeamShearLoad beamShearAction, double startCoord, double endCoord);
}
}