From c61069a394b5965ecf9f3d1ec08c6b43e4bd6dd1 Mon Sep 17 00:00:00 2001 From: RedikultsevEvg Date: Sun, 10 Aug 2025 18:24:46 +0500 Subject: [PATCH] Add test of rebar by density and rebar by inclined rebar --- .../BeamShearDesignRangePropertyDTO.cs | 4 - .../BeamShearSectionPrimitive.cs | 7 +- .../GraphicalPrimitives/IGraphicPrimitive.cs | 3 +- .../InclinedSectionPrimitive.cs | 10 +- .../StirrupByDensityPrimitive.cs | 7 +- .../StirrupByInclinedRebarPrimitive.cs | 8 +- .../StirrupByRebarPrimitive.cs | 7 +- .../UI/Resources/BeamShearTemplate.xaml | 23 ++- .../BeamShears/BeamShearResultView.xaml | 2 +- .../BeamShears/BeamShearResultViewModel.cs | 6 +- .../UserControls/PrimitiveVisualProperty.xaml | 4 +- .../PrimitiveVisualPropertyViewModel.cs | 5 + .../BeamShearDesignRangeProperty.cs | 28 ---- .../BeamShears/BeamShearSectionLogicResult.cs | 1 + .../IBeamShearDesignRangeProperty.cs | 8 -- .../IBeamShearSectionLogicResult.cs | 4 + .../Logics/BeamShearSectionLogic.cs | 42 +++--- .../Logics/GetInclinedSectionListLogic.cs | 6 +- .../StirrupByDensityStrengthLogic.cs | 1 - .../StirrupByInclinedRebarStrengthLogic.cs | 67 +++++---- .../StirrupByRebarStrengthLogic.cs | 0 .../StirrupGroupStrengthLogic.cs | 0 .../StirrupStrengthLogic.cs | 0 ...mShearDesignRangePropertyUpdateStrategy.cs | 2 - .../Logics/IRebarSectionStrengthLogic.cs | 7 +- .../BeamShearStrengthByStirrupDensityTests.cs | 104 ++++++++++++-- .../GetReducedAreaLogicSP63_2018_rev3Tests.cs | 2 + .../CheckPrimitiveCollectionLogicTests.cs | 5 +- ...tirrupByInclinedRebarStrengthLogicTests.cs | 135 ++++++++++++++++++ 29 files changed, 364 insertions(+), 134 deletions(-) rename StructureHelperLogics/Models/BeamShears/Logics/{ => StrengthLogics}/StirrupByDensityStrengthLogic.cs (98%) rename StructureHelperLogics/Models/BeamShears/Logics/{ => StrengthLogics}/StirrupByInclinedRebarStrengthLogic.cs (71%) rename StructureHelperLogics/Models/BeamShears/Logics/{ => StrengthLogics}/StirrupByRebarStrengthLogic.cs (100%) rename StructureHelperLogics/Models/BeamShears/Logics/{ => StrengthLogics}/StirrupGroupStrengthLogic.cs (100%) rename StructureHelperLogics/Models/BeamShears/Logics/{ => StrengthLogics}/StirrupStrengthLogic.cs (100%) create mode 100644 StructureHelperTests/UnitTests/StirrupByInclinedRebarStrengthLogicTests.cs diff --git a/DataAccess/DTOs/DTOEntities/BeamShears/BeamShearDesignRangePropertyDTO.cs b/DataAccess/DTOs/DTOEntities/BeamShears/BeamShearDesignRangePropertyDTO.cs index 02a000c..8275f86 100644 --- a/DataAccess/DTOs/DTOEntities/BeamShears/BeamShearDesignRangePropertyDTO.cs +++ b/DataAccess/DTOs/DTOEntities/BeamShears/BeamShearDesignRangePropertyDTO.cs @@ -13,10 +13,6 @@ namespace DataAccess.DTOs public double RelativeEffectiveDepthRangeValue { get; set; } = 3.3; [JsonProperty("StepCount")] public int StepCount { get; set; } = 55; - [JsonProperty("SectionLengthMaxValue")] - public double RelativeEffectiveDepthSectionLengthMaxValue { get; set; } = 3; - [JsonProperty("LengthMinValue")] - public double RelativeEffectiveDepthSectionLengthMinValue { get; set; } = 0; public BeamShearDesignRangePropertyDTO(Guid id) { diff --git a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/BeamShearSectionPrimitive.cs b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/BeamShearSectionPrimitive.cs index 4f75ada..feb2c8c 100644 --- a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/BeamShearSectionPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/BeamShearSectionPrimitive.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Models.VisualProperties; +using StructureHelper.Windows.UserControls; +using StructureHelperCommon.Models.VisualProperties; using StructureHelperLogics.Models.BeamShears; using System; using System.Collections.Generic; @@ -29,14 +30,16 @@ namespace StructureHelper.Infrastructure.UI.GraphicalPrimitives public double SupportStartY => -SupportHeight; public string SupportPathData => $"M 0 0 L {SupportWidth / 2} {-SupportHeight} L {-SupportWidth / 2} {-SupportHeight} Z"; - public IPrimitiveVisualProperty VisualProperty => beamShearSection.VisualProperty; public IBeamShearSection BeamShearSection => beamShearSection; + public PrimitiveVisualPropertyViewModel VisualProperty {get;} + public BeamShearSectionPrimitive(IBeamShearSection beamShearSection, IInclinedSection inclinedSection) { this.beamShearSection = beamShearSection; this.inclinedSection = inclinedSection; + VisualProperty = new(beamShearSection.VisualProperty); } } } diff --git a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/IGraphicPrimitive.cs b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/IGraphicPrimitive.cs index 87beba5..fe0ea33 100644 --- a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/IGraphicPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/IGraphicPrimitive.cs @@ -1,4 +1,5 @@ using FieldVisualizer.Entities.Values.Primitives; +using StructureHelper.Windows.UserControls; using StructureHelperCommon.Models.VisualProperties; using System; using System.Collections.Generic; @@ -10,6 +11,6 @@ namespace StructureHelper.Infrastructure.UI.GraphicalPrimitives { public interface IGraphicalPrimitive : ICenter { - IPrimitiveVisualProperty VisualProperty { get; } + PrimitiveVisualPropertyViewModel VisualProperty { get; } } } diff --git a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/InclinedSectionPrimitive.cs b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/InclinedSectionPrimitive.cs index 420f99b..92dea09 100644 --- a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/InclinedSectionPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/InclinedSectionPrimitive.cs @@ -1,15 +1,16 @@ -using StructureHelperCommon.Models.VisualProperties; +using StructureHelper.Windows.UserControls; using StructureHelperLogics.Models.BeamShears; using System; using System.Windows.Media; +using PrimitiveVisualProperty = StructureHelperCommon.Models.VisualProperties.PrimitiveVisualProperty; namespace StructureHelper.Infrastructure.UI.GraphicalPrimitives { public class InclinedSectionPrimitive : IGraphicalPrimitive { private IBeamShearSectionLogicResult source; - private IInclinedSection inclinedSection => source.InputData.InclinedSection; - private IInclinedSection inclinedCrack => source.InputData.InclinedCrack; + private IInclinedSection inclinedSection => source.ResultInputData.InclinedSection; + private IInclinedSection inclinedCrack => source.ResultInputData.InclinedCrack; public double SectionStartX => inclinedSection.StartCoord; public double SectionEndX => inclinedSection.EndCoord; @@ -27,7 +28,8 @@ namespace StructureHelper.Infrastructure.UI.GraphicalPrimitives public double CenterX => 0; public double CenterY => 0; - public IPrimitiveVisualProperty VisualProperty { get; private set; } = new PrimitiveVisualProperty(Guid.Empty); + + public PrimitiveVisualPropertyViewModel VisualProperty { get; } = new(new PrimitiveVisualProperty(Guid.Empty)); public InclinedSectionPrimitive(IBeamShearSectionLogicResult source) { diff --git a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByDensityPrimitive.cs b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByDensityPrimitive.cs index 6df83a6..3e62171 100644 --- a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByDensityPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByDensityPrimitive.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Models.VisualProperties; +using StructureHelper.Windows.UserControls; +using StructureHelperCommon.Models.VisualProperties; using StructureHelperLogics.Models.BeamShears; namespace StructureHelper.Infrastructure.UI.GraphicalPrimitives @@ -14,14 +15,16 @@ namespace StructureHelper.Infrastructure.UI.GraphicalPrimitives public double TopPointY => InclinedSection.FullDepth; public double Length => StirrupByDensity.EndCoordinate - StirrupByDensity.StartCoordinate; public double Depth => InclinedSection.EffectiveDepth; - public IPrimitiveVisualProperty VisualProperty => StirrupByDensity.VisualProperty; public IInclinedSection InclinedSection { get; set; } + public PrimitiveVisualPropertyViewModel VisualProperty { get; } + public StirrupByDensityPrimitive(IStirrupByDensity stirrupByDensity, IInclinedSection inclinedSection) { StirrupByDensity = stirrupByDensity; this.InclinedSection = inclinedSection; + VisualProperty = new(stirrupByDensity.VisualProperty); } } } diff --git a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByInclinedRebarPrimitive.cs b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByInclinedRebarPrimitive.cs index c8edf7e..48117bb 100644 --- a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByInclinedRebarPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByInclinedRebarPrimitive.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Models.VisualProperties; +using StructureHelper.Windows.UserControls; +using StructureHelperCommon.Models.VisualProperties; using StructureHelperLogics.Models.BeamShears; using System; using System.Collections.Generic; @@ -19,11 +20,14 @@ namespace StructureHelper.Infrastructure.UI.GraphicalPrimitives public double CenterX => 0; public double CenterY => 0; - public IPrimitiveVisualProperty VisualProperty => StirrupByInclinedRebar.VisualProperty; + + public PrimitiveVisualPropertyViewModel VisualProperty { get; } + public StirrupByInclinedRebarPrimitive(IStirrupByInclinedRebar stirrupByInclinedRebar, IInclinedSection inclinedSection) { StirrupByInclinedRebar = stirrupByInclinedRebar; this.inclinedSection = inclinedSection; + VisualProperty = new(stirrupByInclinedRebar.VisualProperty); } private double GetRebarLengthX() { diff --git a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByRebarPrimitive.cs b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByRebarPrimitive.cs index a943e16..212a838 100644 --- a/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByRebarPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/GraphicalPrimitives/StirrupByRebarPrimitive.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Models.VisualProperties; +using StructureHelper.Windows.UserControls; +using StructureHelperCommon.Models.VisualProperties; using StructureHelperLogics.Models.BeamShears; using System; @@ -18,17 +19,19 @@ namespace StructureHelper.Infrastructure.UI.GraphicalPrimitives public double Length => StirrupByRebar.EndCoordinate - StirrupByRebar.StartCoordinate; public double Depth => InclinedSection.EffectiveDepth; public double Density => Math.Round(stirrupByDensity.StirrupDensity); - public IPrimitiveVisualProperty VisualProperty => StirrupByRebar.VisualProperty; public IInclinedSection InclinedSection => inclinedSection; + public PrimitiveVisualPropertyViewModel VisualProperty { get; } + public StirrupByRebarPrimitive(IStirrupByRebar stirrupByRebar, IInclinedSection inclinedSection) { this.StirrupByRebar = stirrupByRebar; this.inclinedSection = inclinedSection; var logic = new StirrupByRebarToDensityConvertStrategy(null, inclinedSection); stirrupByDensity = logic.Convert(stirrupByRebar); + VisualProperty = new(stirrupByRebar.VisualProperty); } } } diff --git a/StructureHelper/Infrastructure/UI/Resources/BeamShearTemplate.xaml b/StructureHelper/Infrastructure/UI/Resources/BeamShearTemplate.xaml index e23077b..716bcf5 100644 --- a/StructureHelper/Infrastructure/UI/Resources/BeamShearTemplate.xaml +++ b/StructureHelper/Infrastructure/UI/Resources/BeamShearTemplate.xaml @@ -10,6 +10,7 @@ Width="{Binding PositiveLength}" Height="{Binding FullDepth}" StrokeThickness="0.01" + Visibility="{Binding VisualProperty.IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}" > @@ -47,6 +48,8 @@ Y2="{Binding BottomCover}" Stroke="Black" StrokeThickness="0.012" + StrokeDashArray="0.1 0.05" + Visibility="{Binding VisualProperty.IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}" > @@ -93,6 +96,7 @@ Y2="{Binding SectionEndY}" StrokeThickness="0.01" StrokeDashArray="0.05 0.02" + Visibility="{Binding VisualProperty.IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}" > @@ -131,17 +135,6 @@ - - - - - @@ -179,7 +173,7 @@ - + @@ -196,6 +190,7 @@ StrokeThickness="0.005" Canvas.Left="{Binding StartPoinX}" Canvas.Top="{Binding BottomPointY}" + Visibility="{Binding VisualProperty.IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}" > @@ -244,6 +239,7 @@ StrokeThickness="0.005" Canvas.Left="{Binding StartPoinX}" Canvas.Top="{Binding BottomPointY}" + Visibility="{Binding VisualProperty.IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}" > @@ -279,6 +275,7 @@ X2="{Binding EndPointX}" Y1="{Binding StartPointY}" Y2="{Binding EndPointY}" + Visibility="{Binding VisualProperty.IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}" StrokeThickness="{Binding StirrupByInclinedRebar.RebarSection.Diameter}" > @@ -319,6 +316,7 @@ Y1="{Binding StartPointY}" Y2="{Binding StartPointY}" StrokeThickness="{Binding StirrupByInclinedRebar.RebarSection.Diameter}" + Visibility="{Binding VisualProperty.IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}" > @@ -330,6 +328,7 @@ Y1="{Binding EndPointY}" Y2="{Binding EndPointY}" StrokeThickness="{Binding StirrupByInclinedRebar.RebarSection.Diameter}" + Visibility="{Binding VisualProperty.IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}" > diff --git a/StructureHelper/Windows/BeamShears/BeamShearResultView.xaml b/StructureHelper/Windows/BeamShears/BeamShearResultView.xaml index f867636..39ad871 100644 --- a/StructureHelper/Windows/BeamShears/BeamShearResultView.xaml +++ b/StructureHelper/Windows/BeamShears/BeamShearResultView.xaml @@ -25,7 +25,7 @@ + DescriptionText="Shows diagram for result for inclined section where factor of using is maximum"/> diff --git a/StructureHelper/Windows/BeamShears/BeamShearResultViewModel.cs b/StructureHelper/Windows/BeamShears/BeamShearResultViewModel.cs index ec2c943..a0b30e8 100644 --- a/StructureHelper/Windows/BeamShears/BeamShearResultViewModel.cs +++ b/StructureHelper/Windows/BeamShears/BeamShearResultViewModel.cs @@ -61,8 +61,12 @@ namespace StructureHelper.Windows.BeamShears private void Show2DDiagram(object obj) { if (SelectedResult is null) { return; } + if (SelectedResult.SectionResults is null) { return; } + var sectionResult = SelectedResult.SectionResults + .OrderByDescending(x => x.FactorOfUsing) + .FirstOrDefault(); var logic = new ShearDiagramLogic(SelectedResult); - logic.ShowWindow(0.0); + logic.ShowWindow(sectionResult.ResultInputData.InclinedSection.StartCoord); } private void ShowSectionResults(object commandParameter) diff --git a/StructureHelper/Windows/UserControls/PrimitiveVisualProperty.xaml b/StructureHelper/Windows/UserControls/PrimitiveVisualProperty.xaml index 3d29bf6..e5c04a6 100644 --- a/StructureHelper/Windows/UserControls/PrimitiveVisualProperty.xaml +++ b/StructureHelper/Windows/UserControls/PrimitiveVisualProperty.xaml @@ -41,8 +41,8 @@ - - + + diff --git a/StructureHelper/Windows/UserControls/PrimitiveVisualPropertyViewModel.cs b/StructureHelper/Windows/UserControls/PrimitiveVisualPropertyViewModel.cs index 1ab15e6..af5e430 100644 --- a/StructureHelper/Windows/UserControls/PrimitiveVisualPropertyViewModel.cs +++ b/StructureHelper/Windows/UserControls/PrimitiveVisualPropertyViewModel.cs @@ -32,6 +32,11 @@ namespace StructureHelper.Windows.UserControls } public double Opacity + { + get => visualProperty.Opacity; + } + + public double FactoredOpacity { get => visualProperty.Opacity * 100d; set diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearDesignRangeProperty.cs b/StructureHelperLogics/Models/BeamShears/BeamShearDesignRangeProperty.cs index f94c325..2c39342 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearDesignRangeProperty.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearDesignRangeProperty.cs @@ -10,8 +10,6 @@ namespace StructureHelperLogics.Models.BeamShears private double absoluteRangeValue = 0.0; private double relativeEffectiveDepthRangeValue = 3.3; private int stepCount = 55; - private double relativeEffectiveDepthSectionLengthMaxValue = 3; - private double relativeEffectiveDepthSectionLengthMinValue = 0; /// public Guid Id { get; } @@ -59,32 +57,6 @@ namespace StructureHelperLogics.Models.BeamShears } } - public double RelativeEffectiveDepthSectionLengthMaxValue - { - get => relativeEffectiveDepthSectionLengthMaxValue; - set - { - if (value <= 0) - { - throw new StructureHelperException($"Maximum inclined section factor must be greater than zero, but was {value}"); - } - relativeEffectiveDepthSectionLengthMaxValue = value; - } - } - - public double RelativeEffectiveDepthSectionLengthMinValue - { - get => relativeEffectiveDepthSectionLengthMinValue; - set - { - if (value < 0) - { - throw new StructureHelperException($"Maximum inclined section factor must be greater than zero, but was {value}"); - } - relativeEffectiveDepthSectionLengthMinValue = value; - } - } - public BeamShearDesignRangeProperty(Guid id) { Id = id; diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogicResult.cs b/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogicResult.cs index ecce7d1..505162e 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogicResult.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogicResult.cs @@ -12,6 +12,7 @@ namespace StructureHelperLogics.Models.BeamShears public bool IsValid { get; set; } public string? Description { get; set; } public IBeamShearSectionLogicInputData InputData { get; set; } + public IBeamShearSectionLogicInputData ResultInputData { get; set; } public double ConcreteStrength { get; set; } public double StirrupStrength { get; set; } public double TotalStrength { get; set; } diff --git a/StructureHelperLogics/Models/BeamShears/IBeamShearDesignRangeProperty.cs b/StructureHelperLogics/Models/BeamShears/IBeamShearDesignRangeProperty.cs index b68baa0..2dadcd7 100644 --- a/StructureHelperLogics/Models/BeamShears/IBeamShearDesignRangeProperty.cs +++ b/StructureHelperLogics/Models/BeamShears/IBeamShearDesignRangeProperty.cs @@ -21,14 +21,6 @@ namespace StructureHelperLogics.Models.BeamShears /// double RelativeEffectiveDepthRangeValue { get; set; } /// - /// Relative value of inclination length as factor of effective depth of cross-section - /// - double RelativeEffectiveDepthSectionLengthMaxValue { get; set; } - /// - /// Relative value of inclination length as factor of effective depth of cross-section - /// - double RelativeEffectiveDepthSectionLengthMinValue { get; set; } - /// /// Number of step of solvation /// int StepCount { get; set; } diff --git a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicResult.cs b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicResult.cs index 4953634..f116318 100644 --- a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicResult.cs +++ b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicResult.cs @@ -13,6 +13,10 @@ namespace StructureHelperLogics.Models.BeamShears /// IBeamShearSectionLogicInputData InputData { get; set; } /// + /// New Input data for calculating + /// + IBeamShearSectionLogicInputData ResultInputData { get; set; } + /// /// Ultimate shear force due to cocrete /// public double ConcreteStrength { get; set; } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionLogic.cs index 470e96e..966b79c 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionLogic.cs @@ -40,10 +40,10 @@ namespace StructureHelperLogics.Models.BeamShears PrepareNewResult(); if (Check() == false) { return; } localTraceLogger?.AddMessage(sectionMessage); - InitializeStrategies(); try { - AddInclinedCrackToInputData(); + PrepareResultData(); + InitializeStrategies(); CalculateResult(); } catch (Exception ex) @@ -53,18 +53,22 @@ namespace StructureHelperLogics.Models.BeamShears } } - private void AddInclinedCrackToInputData() + private void PrepareResultData() { - InclinedSection newSection = new(); + InclinedSection crackSection = new(); var updateStrategy = new InclinedSectionUpdateStrategy(); - updateStrategy.Update(newSection, InputData.InclinedSection); - double crackLength = newSection.EndCoord - newSection.StartCoord; - double maxCrackLength = 2 * newSection.EffectiveDepth; + updateStrategy.Update(crackSection, InputData.InclinedSection); + BeamShearSectionLogicInputData resultData = new(Guid.Empty); + var resultDataUpdateStrategy = new BeamShearSectionLogicInputDataUpdateStrategy(); + resultDataUpdateStrategy.Update(resultData, InputData); + double crackLength = crackSection.EndCoord - crackSection.StartCoord; + double maxCrackLength = 2 * crackSection.EffectiveDepth; if (crackLength > maxCrackLength) { - newSection.StartCoord = newSection.EndCoord - maxCrackLength; + crackSection.StartCoord = crackSection.EndCoord - maxCrackLength; } - InputData.InclinedCrack = newSection; + resultData.InclinedCrack = crackSection; + result.ResultInputData = resultData; } private bool Check() @@ -104,7 +108,7 @@ namespace StructureHelperLogics.Models.BeamShears double totalStrength = concreteStrength + stirrupStrength; localTraceLogger?.AddMessage($"Total strength = {concreteStrength} + {stirrupStrength} = {totalStrength}(N)"); result.TotalStrength = totalStrength; - double actualShearForce = InputData.ForceTuple.Qy; + double actualShearForce = result.ResultInputData.ForceTuple.Qy; if (actualShearForce > totalStrength) { result.IsValid = false; @@ -125,38 +129,38 @@ namespace StructureHelperLogics.Models.BeamShears { var logic = new StirrupBySearchLogic(localTraceLogger.GetSimilarTraceLogger(100)) { - InputData = InputData, + InputData = result.ResultInputData, SectionEffectiveness = sectionEffectiveness }; double stirrupStrength = logic.GetShearStrength(); localTraceLogger?.AddMessage($"Stirrup strength was restricted as Qsw,restricted = {stirrupStrength}(N)"); - InputData.InclinedCrack = logic.InclinedCrack; + result.ResultInputData.InclinedCrack = logic.InclinedCrack; return stirrupStrength; } private void InitializeStrategies() { - if (InputData.InclinedSection.BeamShearSection.Shape is IRectangleShape) + if (result.ResultInputData.InclinedSection.BeamShearSection.Shape is IRectangleShape) { sectionEffectiveness = SectionEffectivenessFactory.GetShearEffectiveness(BeamShearSectionType.Rectangle); } - else if (InputData.InclinedSection.BeamShearSection.Shape is ICircleShape) + else if (result.ResultInputData.InclinedSection.BeamShearSection.Shape is ICircleShape) { sectionEffectiveness = SectionEffectivenessFactory.GetShearEffectiveness(BeamShearSectionType.Circle); } else { - throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(InputData.InclinedSection.BeamShearSection.Shape)); + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(result.ResultInputData.InclinedSection.BeamShearSection.Shape)); } - concreteLogic = new(sectionEffectiveness, InputData.InclinedSection, localTraceLogger); - stirrupLogic = new(InputData, localTraceLogger); + concreteLogic = new(sectionEffectiveness, result.ResultInputData.InclinedSection, localTraceLogger); + stirrupLogic = new(result.ResultInputData, localTraceLogger); getLongitudinalForceFactorLogic = new GetLongitudinalForceFactorLogic(localTraceLogger?.GetSimilarTraceLogger(100)); } private void SetLongitudinalForce() { - getLongitudinalForceFactorLogic.LongitudinalForce = InputData.ForceTuple.Nz; - getLongitudinalForceFactorLogic.InclinedSection = InputData.InclinedSection; + getLongitudinalForceFactorLogic.LongitudinalForce = result.ResultInputData.ForceTuple.Nz; + getLongitudinalForceFactorLogic.InclinedSection = result.ResultInputData.InclinedSection; } private void PrepareNewResult() diff --git a/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs index 2d6c8fe..6699bdb 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs @@ -7,6 +7,8 @@ namespace StructureHelperLogics.Models.BeamShears { public class GetInclinedSectionListLogic : IGetInclinedSectionListLogic { + private const int minimumInclinedSectionLengthFactor = 0; + private const int maximumInclinedSectionLengthFactor = 3; private IGetInclinedSectionLogic inclinedSectionLogic; private double depth; private double effectiveDepth; @@ -28,8 +30,8 @@ namespace StructureHelperLogics.Models.BeamShears Check(); GetShapeParameters(); GetCoordinates(); - double minSectionLength = DesignRangeProperty.RelativeEffectiveDepthSectionLengthMinValue * effectiveDepth; - double maxSectionLength = DesignRangeProperty.RelativeEffectiveDepthSectionLengthMaxValue * effectiveDepth; + double minSectionLength = minimumInclinedSectionLengthFactor * effectiveDepth; + double maxSectionLength = maximumInclinedSectionLengthFactor * effectiveDepth; foreach (var startCoord in coordinates) { var endCoordinates = coordinates.Where(x => x >= startCoord); diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs similarity index 98% rename from StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityStrengthLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs index 9bed4d4..bc1c647 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityStrengthLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs @@ -11,7 +11,6 @@ namespace StructureHelperLogics.Models.BeamShears /// public class StirrupByDensityStrengthLogic : IBeamShearStrenghLogic { - //private const double minStirrupRatio = 0.25; private readonly IStirrupEffectiveness stirrupEffectiveness; private readonly IStirrupByDensity stirrupByDensity; private readonly IInclinedSection inclinedSection; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByInclinedRebarStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByInclinedRebarStrengthLogic.cs similarity index 71% rename from StructureHelperLogics/Models/BeamShears/Logics/StirrupByInclinedRebarStrengthLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByInclinedRebarStrengthLogic.cs index b233329..bafd918 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByInclinedRebarStrengthLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByInclinedRebarStrengthLogic.cs @@ -11,25 +11,42 @@ namespace StructureHelperLogics.Models.BeamShears const double stirrupEffectivenessFactor = 0.75; private readonly IStirrupByInclinedRebar inclinedRebar; private readonly IInclinedSection inclinedSection; - private IRebarSectionStrengthLogic rebarSectionStrengthLogic; private double angleInRad; private double rebarStartPoint; private double rebarHeight; private double rebarEndPoint; private double rebarTrueStartPoint; private double rebarTrueEndPoint; + private IRebarSectionStrengthLogic rebarSectionStrengthLogic; private IInterpolateValueLogic interpolationLogic; public IShiftTraceLogger? TraceLogger { get; set; } - public StirrupByInclinedRebarStrengthLogic(IInclinedSection inclinedSection, IStirrupByInclinedRebar inclinedRebar, IShiftTraceLogger traceLogger) + public StirrupByInclinedRebarStrengthLogic( + IInclinedSection inclinedSection, + IStirrupByInclinedRebar inclinedRebar, + IShiftTraceLogger traceLogger) : this( + inclinedSection, + inclinedRebar, + new RebarSectionStrengthLogic(), + new InterpolateValueLogic(), + traceLogger + ) { } + + public StirrupByInclinedRebarStrengthLogic( + IInclinedSection inclinedSection, + IStirrupByInclinedRebar inclinedRebar, + IRebarSectionStrengthLogic rebarSectionStrengthLogic, + IInterpolateValueLogic interpolationLogic, + IShiftTraceLogger? traceLogger) { this.inclinedSection = inclinedSection; this.inclinedRebar = inclinedRebar; + this.rebarSectionStrengthLogic = rebarSectionStrengthLogic; + this.interpolationLogic = interpolationLogic; TraceLogger = traceLogger; } - public double GetShearStrength() { GetGeometry(); @@ -48,7 +65,7 @@ namespace StructureHelperLogics.Models.BeamShears TraceLogger?.AddMessage($"Inclined section start point coordinate X = {inclinedSection.StartCoord} is in end transfer zone"); return GetEndTransferValue(); } - if (inclinedSection.EndCoord > rebarStartPoint & inclinedSection.EndCoord < rebarTrueStartPoint) + if (inclinedSection.EndCoord > rebarStartPoint && inclinedSection.EndCoord < rebarTrueStartPoint) { TraceLogger?.AddMessage($"Inclined section end point coordinate X = {inclinedSection.EndCoord} is in start transfer zone"); return GetStartTransferValue(); @@ -59,41 +76,33 @@ namespace StructureHelperLogics.Models.BeamShears private double GetStartTransferValue() { - interpolationLogic = new InterpolateValueLogic() - { - X1 = rebarStartPoint, - X2 = rebarTrueStartPoint, - Y1 = 0.0, - Y2 = GetInclinedRebarStrength(), - KnownValueX = inclinedSection.EndCoord - }; + interpolationLogic.X1 = rebarStartPoint; + interpolationLogic.X2 = rebarTrueStartPoint; + interpolationLogic.Y1 = 0.0; + interpolationLogic.Y2 = GetInclinedRebarStrength(); + interpolationLogic.KnownValueX = inclinedSection.EndCoord; return interpolationLogic.GetValueY(); } private double GetEndTransferValue() { - interpolationLogic = new InterpolateValueLogic() - { - X1 = rebarTrueEndPoint, - X2 = rebarEndPoint, - Y1 = GetInclinedRebarStrength(), - Y2 = 0.0, - KnownValueX = inclinedSection.StartCoord - }; + interpolationLogic.X1 = rebarTrueEndPoint; + interpolationLogic.X2 = rebarEndPoint; + interpolationLogic.Y1 = GetInclinedRebarStrength(); + interpolationLogic.Y2 = 0.0; + interpolationLogic.KnownValueX = inclinedSection.StartCoord; return interpolationLogic.GetValueY(); } private double GetInclinedRebarStrength() { - rebarSectionStrengthLogic ??= new RebarSectionStrengthLogic() - { - RebarStrengthFactor = 0.8, - MaxRebarStrength = 3e8, - LimitState = LimitStates.ULS, - CalcTerm = CalcTerms.ShortTerm, - TraceLogger = TraceLogger, - }; + rebarSectionStrengthLogic.RebarStrengthFactor = 0.8; + rebarSectionStrengthLogic.MaxRebarStrength = 3e8; + rebarSectionStrengthLogic.LimitState = LimitStates.ULS; + rebarSectionStrengthLogic.CalcTerm = CalcTerms.ShortTerm; + rebarSectionStrengthLogic.TraceLogger = TraceLogger; rebarSectionStrengthLogic.RebarSection = inclinedRebar.RebarSection; + double rebarStrength = rebarSectionStrengthLogic.GetRebarMaxTensileForce(); double inclinedRebarStrength = stirrupEffectivenessFactor * rebarStrength * Math.Sin(angleInRad) * inclinedRebar.LegCount; TraceLogger?.AddMessage($"Inclined rebar Name = {inclinedRebar.Name}, start point {rebarStartPoint}(m), end point {rebarEndPoint}(m), angle of inclination {inclinedRebar.AngleOfInclination}(deg), number of legs {inclinedRebar.LegCount}"); @@ -113,7 +122,7 @@ namespace StructureHelperLogics.Models.BeamShears rebarTrueEndPoint = rebarEndPoint - transferLength; if (rebarTrueStartPoint >= rebarTrueEndPoint) { - throw new StructureHelperException("Transfer aone in inclined rebar is too big"); + throw new StructureHelperException("Transfer zone in inclined rebar is too big"); } } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByRebarStrengthLogic.cs similarity index 100% rename from StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarStrengthLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByRebarStrengthLogic.cs diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupGroupStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupGroupStrengthLogic.cs similarity index 100% rename from StructureHelperLogics/Models/BeamShears/Logics/StirrupGroupStrengthLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupGroupStrengthLogic.cs diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupStrengthLogic.cs similarity index 100% rename from StructureHelperLogics/Models/BeamShears/Logics/StirrupStrengthLogic.cs rename to StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupStrengthLogic.cs diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs index 1b65e5b..1f7c31b 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs @@ -14,8 +14,6 @@ namespace StructureHelperLogics.Models.BeamShears targetObject.AbsoluteRangeValue = sourceObject.AbsoluteRangeValue; targetObject.RelativeEffectiveDepthRangeValue = sourceObject.RelativeEffectiveDepthRangeValue; targetObject.StepCount = sourceObject.StepCount; - targetObject.RelativeEffectiveDepthSectionLengthMaxValue = sourceObject.RelativeEffectiveDepthSectionLengthMaxValue; - targetObject.RelativeEffectiveDepthSectionLengthMinValue = sourceObject.RelativeEffectiveDepthSectionLengthMinValue; } } } diff --git a/StructureHelperLogics/Models/Materials/Logics/IRebarSectionStrengthLogic.cs b/StructureHelperLogics/Models/Materials/Logics/IRebarSectionStrengthLogic.cs index 9914f31..8f55da2 100644 --- a/StructureHelperLogics/Models/Materials/Logics/IRebarSectionStrengthLogic.cs +++ b/StructureHelperLogics/Models/Materials/Logics/IRebarSectionStrengthLogic.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; namespace StructureHelperLogics.Models.Materials @@ -7,6 +8,10 @@ namespace StructureHelperLogics.Models.Materials { IRebarSection RebarSection { get; set; } IShiftTraceLogger? TraceLogger { get; set; } + CalcTerms CalcTerm { get; set; } + LimitStates LimitState { get; set; } + double MaxRebarStrength { get; set; } + double RebarStrengthFactor { get; set; } double GetRebarMaxTensileForce(); } diff --git a/StructureHelperTests/UnitTests/BeamShearTests/BeamShearStrengthByStirrupDensityTests.cs b/StructureHelperTests/UnitTests/BeamShearTests/BeamShearStrengthByStirrupDensityTests.cs index 8d3432a..d4b0ab9 100644 --- a/StructureHelperTests/UnitTests/BeamShearTests/BeamShearStrengthByStirrupDensityTests.cs +++ b/StructureHelperTests/UnitTests/BeamShearTests/BeamShearStrengthByStirrupDensityTests.cs @@ -33,21 +33,107 @@ namespace StructureHelperTests.UnitTests.BeamShearTests ); } - [Test] - public void GetShearStrength_CalculatesCorrectly() + [TestCase(0.2, 0.48)] + [TestCase(0.5, 1.2)] + [TestCase(1.1, 2.64)] + [TestCase(2.2, 2.64)] + public void GetShearStrength_CalculatesCorrectly_differentStirrupEnd(double stirrupEnd, double expectedStrength) { // Arrange - _mockInclinedSection.Setup(s => s.StartCoord).Returns(1.0); - _mockInclinedSection.Setup(s => s.EndCoord).Returns(3.0); - _mockInclinedSection.Setup(s => s.EffectiveDepth).Returns(2.0); + _mockInclinedSection.Setup(s => s.StartCoord).Returns(0); + _mockInclinedSection.Setup(s => s.EndCoord).Returns(100); + _mockInclinedSection.Setup(s => s.EffectiveDepth).Returns(0.55); - _mockStirrupEffectiveness.Setup(s => s.MaxCrackLengthRatio).Returns(0.5); - _mockStirrupEffectiveness.Setup(s => s.StirrupShapeFactor).Returns(1.2); - _mockStirrupEffectiveness.Setup(s => s.StirrupPlacementFactor).Returns(1.1); + _mockStirrupEffectiveness.Setup(s => s.MaxCrackLengthRatio).Returns(2.0); + _mockStirrupEffectiveness.Setup(s => s.StirrupShapeFactor).Returns(0.8); + _mockStirrupEffectiveness.Setup(s => s.StirrupPlacementFactor).Returns(0.75); + _mockStirrupEffectiveness.Setup(s => s.MinimumStirrupRatio).Returns(0.25); _mockStirrupByDensity.Setup(s => s.StirrupDensity).Returns(4.0); + _mockStirrupByDensity.Setup(s => s.StartCoordinate).Returns(0); + _mockStirrupByDensity.Setup(s => s.EndCoordinate).Returns(stirrupEnd); - double expectedStrength = 1.2 * 1.1 * 1.0 * 4.0; // Min(2.0, 1.0) = 1.0 + // Act + double result = _beamShearStrength.GetShearStrength(); + + // Assert + Assert.That(result, Is.EqualTo(expectedStrength).Within(1e-6)); + _mockTraceLogger.Verify(t => t.AddMessage(It.IsAny(), It.IsAny()), Times.AtLeastOnce); + } + + [TestCase(0.20, 0.48)] + [TestCase(0.55, 1.32)] + [TestCase(1.1, 2.64)] + [TestCase(2.2, 2.64)] + public void GetShearStrength_CalculatesCorrectly_differentInclinedSectionEnd(double inclinedSectionEnd, double expectedStrength) + { + // Arrange + _mockInclinedSection.Setup(s => s.StartCoord).Returns(0); + _mockInclinedSection.Setup(s => s.EndCoord).Returns(inclinedSectionEnd); + _mockInclinedSection.Setup(s => s.EffectiveDepth).Returns(0.55); + + _mockStirrupEffectiveness.Setup(s => s.MaxCrackLengthRatio).Returns(2.0); + _mockStirrupEffectiveness.Setup(s => s.StirrupShapeFactor).Returns(0.8); + _mockStirrupEffectiveness.Setup(s => s.StirrupPlacementFactor).Returns(0.75); + _mockStirrupEffectiveness.Setup(s => s.MinimumStirrupRatio).Returns(0.25); + + _mockStirrupByDensity.Setup(s => s.StirrupDensity).Returns(4.0); + _mockStirrupByDensity.Setup(s => s.StartCoordinate).Returns(0); + _mockStirrupByDensity.Setup(s => s.EndCoordinate).Returns(100); + + // Act + double result = _beamShearStrength.GetShearStrength(); + + // Assert + Assert.That(result, Is.EqualTo(expectedStrength).Within(1e-6)); + _mockTraceLogger.Verify(t => t.AddMessage(It.IsAny(), It.IsAny()), Times.AtLeastOnce); + } + + [TestCase(0.2, 0.66)] + [TestCase(0.5, 1.65)] + [TestCase(0.8, 2.64)] + public void GetShearStrength_CalculatesCorrectly_differentShapeFactor(double shapeFactor, double expectedStrength) + { + // Arrange + _mockInclinedSection.Setup(s => s.StartCoord).Returns(0); + _mockInclinedSection.Setup(s => s.EndCoord).Returns(1.1); + _mockInclinedSection.Setup(s => s.EffectiveDepth).Returns(0.55); + + _mockStirrupEffectiveness.Setup(s => s.MaxCrackLengthRatio).Returns(2.0); + _mockStirrupEffectiveness.Setup(s => s.StirrupShapeFactor).Returns(shapeFactor); + _mockStirrupEffectiveness.Setup(s => s.StirrupPlacementFactor).Returns(0.75); + _mockStirrupEffectiveness.Setup(s => s.MinimumStirrupRatio).Returns(0.25); + + _mockStirrupByDensity.Setup(s => s.StirrupDensity).Returns(4.0); + _mockStirrupByDensity.Setup(s => s.StartCoordinate).Returns(0); + _mockStirrupByDensity.Setup(s => s.EndCoordinate).Returns(100); + + // Act + double result = _beamShearStrength.GetShearStrength(); + + // Assert + Assert.That(result, Is.EqualTo(expectedStrength).Within(1e-6)); + _mockTraceLogger.Verify(t => t.AddMessage(It.IsAny(), It.IsAny()), Times.AtLeastOnce); + } + + [TestCase(0.2, 0.704)] + [TestCase(0.5, 1.76)] + [TestCase(0.8, 2.816)] + public void GetShearStrength_CalculatesCorrectly_differentPlacementFactor(double placementFactor, double expectedStrength) + { + // Arrange + _mockInclinedSection.Setup(s => s.StartCoord).Returns(0); + _mockInclinedSection.Setup(s => s.EndCoord).Returns(1.1); + _mockInclinedSection.Setup(s => s.EffectiveDepth).Returns(0.55); + + _mockStirrupEffectiveness.Setup(s => s.MaxCrackLengthRatio).Returns(2.0); + _mockStirrupEffectiveness.Setup(s => s.StirrupShapeFactor).Returns(0.8); + _mockStirrupEffectiveness.Setup(s => s.StirrupPlacementFactor).Returns(placementFactor); + _mockStirrupEffectiveness.Setup(s => s.MinimumStirrupRatio).Returns(0.25); + + _mockStirrupByDensity.Setup(s => s.StirrupDensity).Returns(4.0); + _mockStirrupByDensity.Setup(s => s.StartCoordinate).Returns(0); + _mockStirrupByDensity.Setup(s => s.EndCoordinate).Returns(100); // Act double result = _beamShearStrength.GetShearStrength(); diff --git a/StructureHelperTests/UnitTests/BeamShearTests/GetReducedAreaLogicSP63_2018_rev3Tests.cs b/StructureHelperTests/UnitTests/BeamShearTests/GetReducedAreaLogicSP63_2018_rev3Tests.cs index 9baff4f..33ef16c 100644 --- a/StructureHelperTests/UnitTests/BeamShearTests/GetReducedAreaLogicSP63_2018_rev3Tests.cs +++ b/StructureHelperTests/UnitTests/BeamShearTests/GetReducedAreaLogicSP63_2018_rev3Tests.cs @@ -3,6 +3,7 @@ using Moq; using NUnit.Framework; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Models.Materials; +using StructureHelperCommon.Models.Shapes; using StructureHelperLogics.Models.BeamShears; using StructureHelperLogics.Models.Materials; using System; @@ -36,6 +37,7 @@ namespace StructureHelperTests.UnitTests.BeamShearTests mockSection.Setup(s => s.ConcreteMaterial).Returns(mockConcreteMaterial.Object); mockSection.Setup(s => s.ReinforcementMaterial).Returns(mockReinforcementMaterial.Object); mockSection.Setup(s => s.ReinforcementArea).Returns(reinforcementArea); + mockSection.Setup(s => s.Shape).Returns(new RectangleShape(){ Width = 1, Height =2 }); var mockInclSection = new Mock(); mockInclSection.Setup(s => s.WebWidth).Returns(width); diff --git a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs index 4f64ec1..b43ca6d 100644 --- a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs @@ -5,6 +5,7 @@ using StructureHelperCommon.Models; using StructureHelperLogics.Models.Primitives; using StructureHelperLogics.NdmCalculations.Primitives.Logics; using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperCommon.Infrastructures.Interfaces; namespace StructureHelperTests.UnitTests.Ndms @@ -13,7 +14,7 @@ namespace StructureHelperTests.UnitTests.Ndms public class CheckPrimitiveCollectionLogicTests { private Mock _mockTraceLogger; - private Mock _mockCheckRebarPrimitiveLogic; + private Mock> _mockCheckRebarPrimitiveLogic; private Mock _mockHasPrimitives; private Mock _mockCheckPrimitiveCollectionLogic; @@ -21,7 +22,7 @@ namespace StructureHelperTests.UnitTests.Ndms public void SetUp() { _mockTraceLogger = new Mock(); - _mockCheckRebarPrimitiveLogic = new Mock(); + _mockCheckRebarPrimitiveLogic = new Mock>(); _mockHasPrimitives = new Mock(); _mockCheckPrimitiveCollectionLogic = new Mock(_mockTraceLogger.Object, _mockCheckRebarPrimitiveLogic.Object) diff --git a/StructureHelperTests/UnitTests/StirrupByInclinedRebarStrengthLogicTests.cs b/StructureHelperTests/UnitTests/StirrupByInclinedRebarStrengthLogicTests.cs new file mode 100644 index 0000000..4a16a53 --- /dev/null +++ b/StructureHelperTests/UnitTests/StirrupByInclinedRebarStrengthLogicTests.cs @@ -0,0 +1,135 @@ +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Models; +using StructureHelperCommon.Services; +using StructureHelperLogics.Models.BeamShears; +using StructureHelperLogics.Models.Materials; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperTests.UnitTests +{ + + [TestFixture] + public class StirrupByInclinedRebarStrengthLogicTests + { + private Mock sectionMock; + private Mock rebarMock; + private Mock rebarStrengthMock; + private Mock interpolateMock; + private Mock loggerMock; + + [SetUp] + public void SetUp() + { + sectionMock = new Mock(); + rebarMock = new Mock(); + rebarStrengthMock = new Mock(); + interpolateMock = new Mock(); + loggerMock = new Mock(); + + // Default geometry + rebarMock.SetupGet(r => r.TransferLength).Returns(0.1); + rebarMock.SetupGet(r => r.StartCoordinate).Returns(0.0); + rebarMock.SetupGet(r => r.AngleOfInclination).Returns(45.0); + rebarMock.SetupGet(r => r.CompressedGap).Returns(0.0); + rebarMock.SetupGet(r => r.LegCount).Returns(2); + rebarMock.SetupGet(r => r.RebarSection).Returns(Mock.Of()); + + sectionMock.SetupGet(s => s.EffectiveDepth).Returns(1.0); + + rebarStrengthMock.Setup(m => m.GetRebarMaxTensileForce()).Returns(1000.0); + interpolateMock.Setup(m => m.GetValueY()).Returns(123.0); + } + + [Test] + public void GetShearStrength_RebarOutsideSectionStart_ReturnsZero() + { + sectionMock.SetupGet(s => s.StartCoord).Returns(10.0); // start is after rebar end + sectionMock.SetupGet(s => s.EndCoord).Returns(12.0); + + var logic = CreateLogic(); + var result = logic.GetShearStrength(); + + Assert.That(result, Is.EqualTo(0.0)); + loggerMock.Verify(l => l.AddMessage(It.Is(msg => msg.Contains("has been ignored")))); + } + + [Test] + public void GetShearStrength_RebarOutsideSectionEnd_ReturnsZero() + { + sectionMock.SetupGet(s => s.StartCoord).Returns(-5.0); + sectionMock.SetupGet(s => s.EndCoord).Returns(-1.0); + + var logic = CreateLogic(); + var result = logic.GetShearStrength(); + + Assert.That(result, Is.EqualTo(0.0)); + loggerMock.Verify(l => l.AddMessage(It.Is(msg => msg.Contains("has been ignored")))); + } + + [Test] + public void GetShearStrength_StartTransferZone_UsesInterpolation() + { + sectionMock.SetupGet(s => s.StartCoord).Returns(0.0); + sectionMock.SetupGet(s => s.EndCoord).Returns(0.05); // falls in start transfer zone + + var logic = CreateLogic(); + var result = logic.GetShearStrength(); + + Assert.That(result, Is.EqualTo(123.0)); // from interpolateMock + interpolateMock.Verify(m => m.GetValueY(), Times.Once); + } + + [Test] + public void GetShearStrength_EndTransferZone_UsesInterpolation() + { + sectionMock.SetupGet(s => s.StartCoord).Returns(0.95); // falls in end transfer zone + sectionMock.SetupGet(s => s.EndCoord).Returns(2.0); + + var logic = CreateLogic(); + var result = logic.GetShearStrength(); + + Assert.That(result, Is.EqualTo(123.0)); + interpolateMock.Verify(m => m.GetValueY(), Times.Once); + } + + [Test] + public void GetShearStrength_MainZone_ComputesStrength() + { + sectionMock.SetupGet(s => s.StartCoord).Returns(0.2); + sectionMock.SetupGet(s => s.EndCoord).Returns(1.0); + + var logic = CreateLogic(); + var result = logic.GetShearStrength(); + + // Strength = 0.75 * 1000 * sin(45°) * 2 + var expected = 0.75 * 1000.0 * Math.Sin(Math.PI / 4) * 2; + Assert.That(result, Is.EqualTo(expected).Within(1e-6)); + } + + [Test] + public void GetShearStrength_TransferZonesOverlap_ThrowsException() + { + rebarMock.SetupGet(r => r.TransferLength).Returns(5.0); // huge transfer length + + var logic = CreateLogic(); + Assert.Throws(() => logic.GetShearStrength()); + } + + private StirrupByInclinedRebarStrengthLogic CreateLogic() + { + return new StirrupByInclinedRebarStrengthLogic( + sectionMock.Object, + rebarMock.Object, + rebarStrengthMock.Object, + interpolateMock.Object, + loggerMock.Object + ); + } + } +}