From 976b6b5f68e0d73687dc0143ff591966e1020973 Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Tue, 17 Jun 2025 21:55:52 +0500 Subject: [PATCH] Add check logics for beam shear --- .../CheckBeamShearActionLogic.cs | 52 ++++++++++ .../BeamShears/BeamShearCalculatorLogic.cs | 14 ++- .../CheckBeamShearCalculatorInputDataLogic.cs | 26 ++++- .../Logics/CheckBeamShearSectionLogic.cs | 94 +++++++++++++++++++ .../Logics/CheckDirectForceInputDataLogic.cs | 91 ++++++++++++++++++ .../Logics/CheckInclinedSectionLogic.cs | 64 +++++++++++++ .../Logics/DirectShearForceLogicInputData.cs | 13 +++ .../Logics/GetDirectShearForceLogic.cs | 70 ++++++-------- .../Logics/IDirectShearForceLogicInputData.cs | 14 +++ 9 files changed, 392 insertions(+), 46 deletions(-) create mode 100644 StructureHelperCommon/Models/Forces/BeamShearActions/CheckBeamShearActionLogic.cs create mode 100644 StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearSectionLogic.cs create mode 100644 StructureHelperLogics/Models/BeamShears/Logics/CheckDirectForceInputDataLogic.cs create mode 100644 StructureHelperLogics/Models/BeamShears/Logics/CheckInclinedSectionLogic.cs create mode 100644 StructureHelperLogics/Models/BeamShears/Logics/DirectShearForceLogicInputData.cs create mode 100644 StructureHelperLogics/Models/BeamShears/Logics/IDirectShearForceLogicInputData.cs diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/CheckBeamShearActionLogic.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/CheckBeamShearActionLogic.cs new file mode 100644 index 0000000..dc7b469 --- /dev/null +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/CheckBeamShearActionLogic.cs @@ -0,0 +1,52 @@ +using StructureHelperCommon.Infrastructures.Interfaces; + +namespace StructureHelperCommon.Models.Forces.BeamShearActions +{ + public class CheckBeamShearActionLogic : ICheckEntityLogic + { + private string checkResult; + private bool result; + + public string CheckResult => checkResult; + public IBeamShearAction Entity { get; set; } + + public IShiftTraceLogger? TraceLogger { get; set; } + public CheckBeamShearActionLogic(IBeamShearAction entity, IShiftTraceLogger? traceLogger) + { + Entity = entity; + TraceLogger = traceLogger; + } + + public bool Check() + { + checkResult = string.Empty; + result = true; + if (Entity is null) + { + result = false; + string errorString = "\nInclined section is not assigned"; + TraceMessage(errorString); + } + else + { + if (Entity.ExternalForce is null) + { + result = false; + TraceMessage($"\nExternal force is null"); + } + if (Entity.SupportAction is null) + { + result = false; + TraceMessage($"\nSupport action is null"); + } + } + return result; + } + + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs b/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs index 2b52676..04d95ca 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs @@ -129,7 +129,14 @@ namespace StructureHelperLogics.Models.BeamShears { inclinedSection.ConcreteCompressionStrength = strength.Compressive; inclinedSection.ConcreteTensionStrength = strength.Tensile; - IForceTuple forceTuple = GetForceTupleByShearAction(beamShearAction, inclinedSection, CollapseLimitState, calcTerm); + DirectShearForceLogicInputData inputData = new() + { + BeamShearAction = beamShearAction, + InclinedSection = inclinedSection, + LimitState = CollapseLimitState, + CalcTerm = calcTerm, + }; + IForceTuple forceTuple = GetForceTupleByShearAction(inputData); BeamShearSectionLogicInputData newInputData = new(Guid.NewGuid()) { InclinedSection = inclinedSection, @@ -166,10 +173,9 @@ namespace StructureHelperLogics.Models.BeamShears return getInclinedSectionListLogic.GetInclinedSections(); } - private IForceTuple GetForceTupleByShearAction(IBeamShearAction beamShearAction, IInclinedSection inclinedSection, LimitStates limitState, CalcTerms calcTerm) + private IForceTuple GetForceTupleByShearAction(IDirectShearForceLogicInputData inputData) { - //IGetDirectShearForceLogic getDirectShearForceLogic = new GetDirectShearForceLogic(beamShearAction, inclinedSection, limitState, calcTerm, TraceLogger); - IGetDirectShearForceLogic getDirectShearForceLogic = new GetDirectShearForceLogic(beamShearAction, inclinedSection, limitState, calcTerm, null); + IGetDirectShearForceLogic getDirectShearForceLogic = new GetDirectShearForceLogic(inputData, null); return getDirectShearForceLogic.CalculateShearForceTuple(); } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearCalculatorInputDataLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearCalculatorInputDataLogic.cs index 0fd489d..b9379a4 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearCalculatorInputDataLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearCalculatorInputDataLogic.cs @@ -1,6 +1,7 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; +using StructureHelperLogics.Models.BeamShears.Logics; using StructureHelperLogics.NdmCalculations.Cracking; using System; using System.Collections.Generic; @@ -14,6 +15,7 @@ namespace StructureHelperLogics.Models.BeamShears { private bool result; private string checkResult; + private ICheckEntityLogic checkSectionLogic; public string CheckResult => checkResult; public IBeamShearCalculatorInputData InputData { get; set; } @@ -34,19 +36,37 @@ namespace StructureHelperLogics.Models.BeamShears string errorString = ErrorStrings.ParameterIsNull + ": Input data"; throw new StructureHelperException(errorString); } - if (InputData.Actions is null || ! InputData.Actions.Any()) + if (InputData.Actions is null || !InputData.Actions.Any()) { result = false; string errorString = "Collection of actions does not contain any action"; TraceMessage(errorString); } - if (InputData.Sections is null || ! InputData.Sections.Any()) + CheckSections(); + return result; + } + + private void CheckSections() + { + if (InputData.Sections is null || !InputData.Sections.Any()) { result = false; string errorString = "Collection of sections does not contain any section"; TraceMessage(errorString); } - return result; + else + { + checkSectionLogic ??= new CheckBeamShearSectionLogic(TraceLogger); + foreach (var item in InputData.Sections) + { + checkSectionLogic.Entity = item; + if (checkSectionLogic.Check() == false) + { + result = false; + checkResult += checkSectionLogic.CheckResult; + } + } + } } private void TraceMessage(string errorString) diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearSectionLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearSectionLogic.cs new file mode 100644 index 0000000..2eb1ad5 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckBeamShearSectionLogic.cs @@ -0,0 +1,94 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Shapes; + +namespace StructureHelperLogics.Models.BeamShears.Logics +{ + public class CheckBeamShearSectionLogic : ICheckEntityLogic + { + private const double minValueOfCenterCover = 0.01; + private const double minValueOfCrossSectionWidth = 0.05; + private const double minValueOfCrossSectionHeight = 0.05; + private bool result; + private string checkResult; + + public CheckBeamShearSectionLogic(IShiftTraceLogger? traceLogger) + { + TraceLogger = traceLogger; + } + + public IBeamShearSection Entity { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public bool Check() + { + checkResult = string.Empty; + result = true; + if (Entity is null) + { + result = false; + string errorString = "\nSection is not assigned"; + TraceMessage(errorString); + } + else + { + if (Entity.Material is null) + { + result = false; + TraceMessage($"\nMaterial of cross-section is not assigned"); + } + if (Entity.CenterCover < minValueOfCenterCover) + { + result = false; + TraceMessage($"\nValue of center cover c = {Entity.CenterCover}(m) must not be less than cmin = {minValueOfCenterCover}(m)"); + } + CheckShape(); + } + return result; + } + + private void CheckShape() + { + if (Entity.Shape is null) + { + result = false; + TraceMessage($"\nShape of cross-section is null"); + } + else + { + if (Entity.Shape is IRectangleShape rectangle) + { + CheckRectangleShape(rectangle); + } + else + { + result = false; + TraceMessage($"\nType of shape of cross-section is unknown"); + } + } + } + + private void CheckRectangleShape(IRectangleShape rectangle) + { + if (rectangle.Width < minValueOfCrossSectionWidth) + { + result = false; + TraceMessage($"\nValue of cross-section width b = {rectangle.Width}(m) must not be less than bmin = {minValueOfCrossSectionWidth}(m)"); + } + if (rectangle.Height < minValueOfCrossSectionHeight) + { + result = false; + TraceMessage($"\nValue of cross-section height h = {rectangle.Height}(m) must not be less than hmin = {minValueOfCrossSectionHeight}(m)"); + } + } + + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckDirectForceInputDataLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckDirectForceInputDataLogic.cs new file mode 100644 index 0000000..f68c27e --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckDirectForceInputDataLogic.cs @@ -0,0 +1,91 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.BeamShearActions; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class CheckDirectForceInputDataLogic : ICheckInputDataLogic + { + private string checkResult; + private bool result; + private ICheckEntityLogic checkInclinedSectionLogic; + private ICheckEntityLogic checkBeamShearActionLogic; + + public string CheckResult => checkResult; + + public IDirectShearForceLogicInputData InputData { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + + public CheckDirectForceInputDataLogic(IDirectShearForceLogicInputData inputData, IShiftTraceLogger? traceLogger) + { + InputData = inputData; + TraceLogger = traceLogger; + } + + + public bool Check() + { + InitializeStrategies(); + result = true; + if (InputData is null) + { + result = false; + string errorString = "\nInput data is not assigned"; + TraceMessage(errorString); + } + else + { + CheckBeamShearAction(); + CheckInclinedSection(); + } + return result; + } + + private void InitializeStrategies() + { + checkInclinedSectionLogic ??= new CheckInclinedSectionLogic(InputData.InclinedSection, TraceLogger); + checkBeamShearActionLogic ??= new CheckBeamShearActionLogic(InputData.BeamShearAction, TraceLogger); + } + + private void CheckBeamShearAction() + { + if (InputData.BeamShearAction is null) + { + result = false; + TraceMessage($"\nBeam shear action is not assigned"); + } + else + { + if (checkBeamShearActionLogic.Check() == false) + { + result = false; + checkResult += checkBeamShearActionLogic.CheckResult; + } + } + } + + private void CheckInclinedSection() + { + if (InputData.InclinedSection is null) + { + result = false; + TraceMessage($"\nInclined section is not assigned"); + } + else + { + if (checkInclinedSectionLogic.Check() == false) + { + result = false; + checkResult += checkInclinedSectionLogic.CheckResult; + } + } + } + + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckInclinedSectionLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckInclinedSectionLogic.cs new file mode 100644 index 0000000..fe1125b --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckInclinedSectionLogic.cs @@ -0,0 +1,64 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class CheckInclinedSectionLogic : ICheckEntityLogic + { + private const double minValueOfEffectiveDepth = 0.05; + private const double minValueOfWebWidth = 0.05; + private string checkResult; + private bool result; + + public IInclinedSection Entity { get; set; } + public string CheckResult => checkResult; + public IShiftTraceLogger? TraceLogger { get; set; } + public CheckInclinedSectionLogic(IInclinedSection entity, IShiftTraceLogger? traceLogger) + { + Entity = entity; + TraceLogger = traceLogger; + } + + public bool Check() + { + checkResult = string.Empty; + result = true; + if (Entity is null) + { + result = false; + string errorString = "\nInclined section is not assigned"; + TraceMessage(errorString); + } + else + { + if (Entity.StartCoord < 0) + { + result = false; + TraceMessage($"\nCoordinate of start of inclined section Xstart = {Entity.StartCoord}(m) must not be less than zero"); + } + if (Entity.EndCoord < Entity.StartCoord) + { + result = false; + TraceMessage($"\nCoordinate of end of inclined section Xend = {Entity.EndCoord}(m) must not be less than Xstart = {Entity.StartCoord}(m)"); + } + if (Entity.EffectiveDepth < minValueOfEffectiveDepth) + { + result = false; + TraceMessage($"\nEffective depth of inclined section d = {Entity.EffectiveDepth}(m) must be grater than dmin = {minValueOfEffectiveDepth}(m)"); + } + if (Entity.WebWidth < minValueOfWebWidth) + { + result = false; + TraceMessage($"\nWidth of web of inclined section b = {Entity.WebWidth}(m) must be grater than bmin = {minValueOfWebWidth}(m)"); + } + } + return result; + } + + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/DirectShearForceLogicInputData.cs b/StructureHelperLogics/Models/BeamShears/Logics/DirectShearForceLogicInputData.cs new file mode 100644 index 0000000..4b9ba6d --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/DirectShearForceLogicInputData.cs @@ -0,0 +1,13 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperLogics.Models.BeamShears +{ + internal class DirectShearForceLogicInputData : IDirectShearForceLogicInputData + { + public IBeamShearAction BeamShearAction { get; set; } + public CalcTerms CalcTerm { get; set; } + public IInclinedSection InclinedSection { get; set; } + public LimitStates LimitState { get; set; } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs index b36472d..6c46cbb 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs @@ -1,4 +1,6 @@ using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Forces.BeamShearActions; @@ -15,48 +17,25 @@ namespace StructureHelperLogics.Models.BeamShears /// public class GetDirectShearForceLogic : IGetDirectShearForceLogic { + private IDirectShearForceLogicInputData inputData; private ISumForceByShearLoadLogic summaryForceLogic; + private ICheckInputDataLogic checkInputDataLogic; /// public IShiftTraceLogger? TraceLogger { get; set; } - public IBeamShearAction AxisAction { get; set; } - public IInclinedSection InclinedSection { get; set; } - public LimitStates LimitState { get; set; } - public CalcTerms CalcTerm { get; set; } - public GetDirectShearForceLogic( - IBeamShearAction axisAction, - IInclinedSection inclinedSection, - LimitStates limitState, - CalcTerms calcTerm, - IShiftTraceLogger? traceLogger) + public GetDirectShearForceLogic(IDirectShearForceLogicInputData inputData, IShiftTraceLogger? traceLogger) { - AxisAction = axisAction; - InclinedSection = inclinedSection; - LimitState = limitState; - CalcTerm = calcTerm; + this.inputData = inputData; TraceLogger = traceLogger; } - public GetDirectShearForceLogic( - IBeamShearAction axisAction, - IInclinedSection inclinedSection, - LimitStates limitState, - CalcTerms calcTerm, - IShiftTraceLogger? traceLogger, - ISumForceByShearLoadLogic summaryForceLogic) - { - this.summaryForceLogic = summaryForceLogic; - AxisAction = axisAction; - InclinedSection = inclinedSection; - LimitState = limitState; - CalcTerm = calcTerm; - TraceLogger = traceLogger; - } + /// public IForceTuple CalculateShearForceTuple() { + Check(); IForceTuple externalTuple = CalculateExternalForceTuple(); IForceTuple internalTuple = CalculateInternalForceTuple(); IForceTuple totalTuple = ForceTupleService.SumTuples(internalTuple, externalTuple); @@ -65,13 +44,22 @@ namespace StructureHelperLogics.Models.BeamShears return totalTuple; } + private void Check() + { + checkInputDataLogic = new CheckDirectForceInputDataLogic(inputData, TraceLogger); + if (checkInputDataLogic.Check() == false) + { + throw new StructureHelperException(checkInputDataLogic.CheckResult); + } + } + private IForceTuple CalculateExternalForceTuple() { var forceTupleLogic = new GetForceTupleByFactoredTupleLogic() { - FactoredForceTuple = AxisAction.ExternalForce, - LimitState = LimitState, - CalcTerm = CalcTerm + FactoredForceTuple = inputData.BeamShearAction.ExternalForce, + LimitState = inputData.LimitState, + CalcTerm = inputData.CalcTerm }; IForceTuple internalForceTuple = forceTupleLogic.GetForceTuple(); return internalForceTuple; @@ -81,18 +69,18 @@ namespace StructureHelperLogics.Models.BeamShears { TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service); InitializeStrategies(); - IBeamShearAxisAction beamShearAxisAction = AxisAction.SupportAction; + IBeamShearAxisAction beamShearAxisAction = inputData.BeamShearAction.SupportAction; var forceTupleLogic = new GetForceTupleByFactoredTupleLogic() { FactoredForceTuple = beamShearAxisAction.SupportForce, - LimitState = LimitState, - CalcTerm = CalcTerm + LimitState = inputData.LimitState, + CalcTerm = inputData.CalcTerm }; IForceTuple supportShearForce = forceTupleLogic.GetForceTuple(); TraceLogger?.AddMessage($"Shear force at support Qmax = {supportShearForce.Qy}(N)"); - TraceLogger?.AddMessage($"Start of inclined section a,start = {InclinedSection.StartCoord}(m)"); - TraceLogger?.AddMessage($"End of inclined section a,end = {InclinedSection.EndCoord}(m)"); + TraceLogger?.AddMessage($"Start of inclined section a,start = {inputData.InclinedSection.StartCoord}(m)"); + TraceLogger?.AddMessage($"End of inclined section a,end = {inputData.InclinedSection.EndCoord}(m)"); ForceTuple summarySpanShearForce = GetSummarySpanShearForce(beamShearAxisAction.ShearLoads); TraceLogger?.AddMessage($"Summary span shear force deltaQ = {summarySpanShearForce.Qy}(N)"); IForceTuple shearForce = ForceTupleService.SumTuples(supportShearForce, summarySpanShearForce); @@ -105,7 +93,7 @@ namespace StructureHelperLogics.Models.BeamShears ForceTuple summarySpanShearForce = new(Guid.NewGuid()); foreach (var spanLoad in spanLoads) { - IForceTuple summarySpanLoad = summaryForceLogic.GetSumShearForce(spanLoad, InclinedSection.StartCoord, InclinedSection.EndCoord); + IForceTuple summarySpanLoad = summaryForceLogic.GetSumShearForce(spanLoad, inputData.InclinedSection.StartCoord, inputData.InclinedSection.EndCoord); ForceTupleService.SumTupleToTarget(summarySpanLoad, summarySpanShearForce); } return summarySpanShearForce; @@ -113,7 +101,11 @@ namespace StructureHelperLogics.Models.BeamShears private void InitializeStrategies() { - summaryForceLogic ??= new SumForceByShearLoadLogic(TraceLogger) { LimitState = LimitState, CalcTerm = CalcTerm}; + summaryForceLogic ??= new SumForceByShearLoadLogic(TraceLogger) + { + LimitState = inputData.LimitState, + CalcTerm = inputData.CalcTerm + }; } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/IDirectShearForceLogicInputData.cs b/StructureHelperLogics/Models/BeamShears/Logics/IDirectShearForceLogicInputData.cs new file mode 100644 index 0000000..1731611 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/IDirectShearForceLogicInputData.cs @@ -0,0 +1,14 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperLogics.Models.BeamShears +{ + public interface IDirectShearForceLogicInputData : IInputData + { + IBeamShearAction BeamShearAction { get; set; } + CalcTerms CalcTerm { get; set; } + IInclinedSection InclinedSection { get; set; } + LimitStates LimitState { get; set; } + } +} \ No newline at end of file