diff --git a/StructureHelper/Windows/BeamShears/StirrupByInclinedRebarViewModel.cs b/StructureHelper/Windows/BeamShears/StirrupByInclinedRebarViewModel.cs index cded9fd..16fc41b 100644 --- a/StructureHelper/Windows/BeamShears/StirrupByInclinedRebarViewModel.cs +++ b/StructureHelper/Windows/BeamShears/StirrupByInclinedRebarViewModel.cs @@ -1,10 +1,6 @@ -using StructureHelper.Windows.ViewModels; +using StructureHelper.Windows.MainWindow.Materials; +using StructureHelper.Windows.ViewModels; using StructureHelperLogics.Models.BeamShears; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelper.Windows.BeamShears { @@ -63,9 +59,27 @@ namespace StructureHelper.Windows.BeamShears } } + public double LegCount + { + get => stirrupByInclinedRebar.LegCount; + set + { + if (value < 0.0) { value = 0.0; } + stirrupByInclinedRebar.LegCount = value; + OnPropertyChanged(nameof(LegCount)); + } + } + + public RebarSectionViewModel RebarSectionViewModel {get;} + public StirrupByInclinedRebarViewModel(IStirrupByInclinedRebar stirrupByInclinedRebar) { this.stirrupByInclinedRebar = stirrupByInclinedRebar; + RebarSectionViewModel = new(this.stirrupByInclinedRebar.RebarSection) + { + MinRebarDiameter = 0.003, + MaxRebarDiameter = 0.032 + }; } } } diff --git a/StructureHelper/Windows/BeamShears/StirrupByInclinedReebarView.xaml b/StructureHelper/Windows/BeamShears/StirrupByInclinedReebarView.xaml index cb4e5c7..6196c1a 100644 --- a/StructureHelper/Windows/BeamShears/StirrupByInclinedReebarView.xaml +++ b/StructureHelper/Windows/BeamShears/StirrupByInclinedReebarView.xaml @@ -9,35 +9,52 @@ d:DataContext="{d:DesignInstance local:StirrupByInclinedRebarViewModel}" mc:Ignorable="d" Title="Inclined rebar" Height="450" Width="400" MaxHeight="450" MaxWidth="400" MinHeight="450" MinWidth="400" WindowStartupLocation="CenterScreen"> + + + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/StructureHelper/Windows/MainWindow/Materials/RebarSectionViewModel.cs b/StructureHelper/Windows/MainWindow/Materials/RebarSectionViewModel.cs new file mode 100644 index 0000000..dc05e70 --- /dev/null +++ b/StructureHelper/Windows/MainWindow/Materials/RebarSectionViewModel.cs @@ -0,0 +1,43 @@ +using StructureHelper.Infrastructure; +using StructureHelper.Windows.ViewModels.Materials; +using StructureHelperLogics.Models.Materials; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelper.Windows.MainWindow.Materials +{ + public class RebarSectionViewModel : ViewModelBase + { + private readonly IRebarSection rebarSection; + + public double MinRebarDiameter { get; set; } = 0.003; + public double MaxRebarDiameter { get; set; } = 0.050; + public ReinforcementViewModel Material { get; private set; } + public double Diameter + { + get => rebarSection.Diameter; + set + { + try + { + if (value < MinRebarDiameter) { value = MinRebarDiameter; } + else if (value > MaxRebarDiameter) { value = MaxRebarDiameter; } + rebarSection.Diameter = value; + } + catch (Exception ex) + { + + } + } + } + + public RebarSectionViewModel(IRebarSection rebarSection) + { + this.rebarSection = rebarSection; + Material = new(this.rebarSection.Material) { MaterialLogicVisibility = false }; + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/IStirrupByInclinedRebar.cs b/StructureHelperLogics/Models/BeamShears/IStirrupByInclinedRebar.cs index 6756ba7..652b395 100644 --- a/StructureHelperLogics/Models/BeamShears/IStirrupByInclinedRebar.cs +++ b/StructureHelperLogics/Models/BeamShears/IStirrupByInclinedRebar.cs @@ -1,4 +1,5 @@ -using System; +using StructureHelperLogics.Models.Materials; +using System; using System.Collections.Generic; using System.Linq; using System.Text; @@ -23,5 +24,13 @@ namespace StructureHelperLogics.Models.BeamShears /// Angle of inclination of rebar in degrees /// double AngleOfInclination { get; set; } + /// + /// Number of legs of inclinated rebar + /// + double LegCount { get; set; } + /// + /// Cross-section of rebar + /// + IRebarSection RebarSection { get; set; } } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsLogic.cs index 234b07b..95aef71 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckStirrupsLogic.cs @@ -44,7 +44,7 @@ namespace StructureHelperLogics.Models.BeamShears checkResult += checkDensityLogic.CheckResult; } } - if (Entity is IStirrupByRebar rebar) + else if (Entity is IStirrupByRebar rebar) { checkRebarLogic ??= new CheckStirrupsByRebarLogic(TraceLogger); checkRebarLogic.Entity = rebar; @@ -53,6 +53,14 @@ namespace StructureHelperLogics.Models.BeamShears result = false; checkResult += checkRebarLogic.CheckResult; } + } + else if (Entity is IStirrupGroup stirrupGroup) + { + + } + else if (Entity is IStirrupByInclinedRebar inclinedRebar) + { + } else { diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByInclinedRebarStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByInclinedRebarStrengthLogic.cs new file mode 100644 index 0000000..ae78f0a --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByInclinedRebarStrengthLogic.cs @@ -0,0 +1,78 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models; +using StructureHelperLogics.Models.Materials; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class StirrupByInclinedRebarStrengthLogic : IBeamShearStrenghLogic + { + 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; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public StirrupByInclinedRebarStrengthLogic(IInclinedSection inclinedSection, IStirrupByInclinedRebar inclinedRebar, IShiftTraceLogger traceLogger) + { + this.inclinedSection = inclinedSection; + this.inclinedRebar = inclinedRebar; + TraceLogger = traceLogger; + } + + + public double GetShearStrength() + { + GetGeometry(); + if (inclinedSection.StartCoord > rebarTrueEndPoint) + { + TraceLogger?.AddMessage($"Inclined section start point coordinate X = {inclinedSection.StartCoord} is greater than inclined rebar true end point x = {rebarTrueEndPoint}, inclined rebar has been ignored"); + return 0.0; + } + if (inclinedSection.EndCoord < rebarTrueStartPoint) + { + TraceLogger?.AddMessage($"Inclined section end point coordinate X = {inclinedSection.EndCoord} is less than inclined rebar true end point x = {rebarTrueStartPoint}, inclined rebar has been ignored"); + return 0.0; + } + return GetInclinedRebarStrength(); + } + + private double GetInclinedRebarStrength() + { + rebarSectionStrengthLogic ??= new RebarSectionStrengthLogic() + { + RebarStrengthFactor = 0.8, + MaxRebarStrength = 3e8, + LimitState = LimitStates.ULS, + CalcTerm = CalcTerms.ShortTerm, + TraceLogger = TraceLogger, + }; + rebarSectionStrengthLogic.RebarSection = inclinedRebar.RebarSection; + double rebarStrength = rebarSectionStrengthLogic.GetRebarMaxTensileForce(); + double inclinedRebarStrength = rebarStrength * Math.Sin(angleInRad) * inclinedRebar.LegCount; + TraceLogger?.AddMessage($"Inclinated rebar {inclinedRebar.Name}, start point {rebarStartPoint}(m), end point {rebarEndPoint}(m), angle of inclination {inclinedRebar.AngleOfInclination}(deg), number of legs {inclinedRebar.LegCount}"); + TraceLogger?.AddMessage($"Force in inclined rebar = {rebarStrength}(N) * sin({inclinedRebar.AngleOfInclination}) * {inclinedRebar.LegCount} = {inclinedRebarStrength}(N)"); + return inclinedRebarStrength; + } + + private void GetGeometry() + { + angleInRad = inclinedRebar.AngleOfInclination / 180 * Math.PI; + rebarStartPoint = inclinedRebar.StartCoordinate; + rebarHeight = inclinedSection.EffectiveDepth - inclinedRebar.CompressedGap; + rebarEndPoint = rebarStartPoint + rebarHeight * Math.Cos(angleInRad); + rebarTrueStartPoint = rebarStartPoint + inclinedRebar.OffSet; + rebarTrueEndPoint = rebarEndPoint - inclinedRebar.OffSet; + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs index 723f6a2..812fec5 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs @@ -39,14 +39,9 @@ namespace StructureHelperLogics.Models.BeamShears { double area = Math.PI * source.Diameter * source.Diameter / 4d; TraceLogger?.AddMessage($"Area of rebar = {Math.PI} * ({source.Diameter})^2 / 4 = {area}(m^2)"); - double materialStrength = source.Material.GetStrength(LimitStates.ULS, CalcTerms.ShortTerm).Tensile; - TraceLogger?.AddMessage($"Stirrup material strength Rsw = {materialStrength}"); - double stirrupStrength = stirrupStrengthFactor * materialStrength; - TraceLogger?.AddMessage($"Strength of rebar Rsw = {stirrupStrengthFactor} * {materialStrength} = {stirrupStrength}(Pa)"); - double minimizedStrength = Math.Min(stirrupStrength, maxStirrupStrength); - TraceLogger?.AddMessage($"Strength of rebar Rsw = Min({stirrupStrength}, {maxStirrupStrength})= {minimizedStrength}(Pa)"); + double minimizedStrength = GetRebarStrength(source); double spiralEffectiveness = 1; - if (source.IsSpiral = true) + if (source.IsSpiral == true) { spiralEffectiveness = GetSpiralEffectiveness(source); } @@ -55,6 +50,17 @@ namespace StructureHelperLogics.Models.BeamShears return density; } + private double GetRebarStrength(IStirrupByRebar source) + { + double materialStrength = source.Material.GetStrength(LimitStates.ULS, CalcTerms.ShortTerm).Tensile; + TraceLogger?.AddMessage($"Stirrup material strength Rsw = {materialStrength}"); + double stirrupStrength = stirrupStrengthFactor * materialStrength; + TraceLogger?.AddMessage($"Strength of rebar Rsw = {stirrupStrengthFactor} * {materialStrength} = {stirrupStrength}(Pa)"); + double minimizedStrength = Math.Min(stirrupStrength, maxStirrupStrength); + TraceLogger?.AddMessage($"Strength of rebar Rsw = Min({stirrupStrength}, {maxStirrupStrength})= {minimizedStrength}(Pa)"); + return minimizedStrength; + } + private double GetSpiralEffectiveness(IStirrupByRebar source) { if (inclinedSection is null) diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupGroupStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupGroupStrengthLogic.cs new file mode 100644 index 0000000..04d2315 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupGroupStrengthLogic.cs @@ -0,0 +1,63 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +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 +{ + internal class StirrupGroupStrengthLogic : IBeamShearStrenghLogic + { + private readonly IBeamShearSectionLogicInputData sourceInputData; + private IBeamShearSectionLogicInputData localInputData; + private IStirrupGroup stirrupGroup; + private IUpdateStrategy inputDataUpdateStrategy; + + public StirrupGroupStrengthLogic(IBeamShearSectionLogicInputData inputData, IStirrupGroup stirrupGroup, IShiftTraceLogger? traceLogger) + { + this.sourceInputData = inputData; + this.stirrupGroup = stirrupGroup; + TraceLogger = traceLogger; + } + + public IShiftTraceLogger? TraceLogger { get; set; } + + public double GetShearStrength() + { + Check(); + if (!stirrupGroup.Stirrups.Any()) { return 0.0; } + GetLocalInputData(); + double shearStrength = 0; + foreach (var item in stirrupGroup.Stirrups) + { + localInputData.Stirrup = item; + var stirrupSrengthLogic = new StirrupStrengthLogic(localInputData, TraceLogger?.GetSimilarTraceLogger(50)); + shearStrength += stirrupSrengthLogic.GetShearStrength(); + } + TraceLogger?.AddMessage($"Total bearing capacity of group {stirrupGroup.Name} for shear Vtot = {shearStrength}(N)"); + return shearStrength; + } + + private void Check() + { + if (stirrupGroup is null) + { + throw new StructureHelperException(ErrorStrings.ParameterIsNull + ": Stirrup group"); + } + if (stirrupGroup.Stirrups is null) + { + throw new StructureHelperException(ErrorStrings.ParameterIsNull + ": Stirrups"); + } + } + + private void GetLocalInputData() + { + localInputData = new BeamShearSectionLogicInputData(Guid.Empty); + inputDataUpdateStrategy ??= new BeamShearSectionLogicInputDataUpdateStrategy(); + inputDataUpdateStrategy.Update(localInputData, sourceInputData); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupStrengthLogic.cs index 47b9028..198e51d 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupStrengthLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupStrengthLogic.cs @@ -8,7 +8,9 @@ namespace StructureHelperLogics.Models.BeamShears private readonly IBeamShearSectionLogicInputData inputData; private IStirrup stirrup => inputData.Stirrup; private IInclinedSection inclinedSection => inputData.InclinedSection; - private IBeamShearStrenghLogic stirrupDensityStrengthLogic; + private IBeamShearStrenghLogic stirrupByDensityStrengthLogic; + private IBeamShearStrenghLogic stirrupGroupStrengthLogic; + private IBeamShearStrenghLogic stirrupByInclinedRebarStrengthLogic; public StirrupStrengthLogic(IBeamShearSectionLogicInputData inputData, IShiftTraceLogger? traceLogger) { @@ -21,17 +23,29 @@ namespace StructureHelperLogics.Models.BeamShears public double GetShearStrength() { var stirrupEffectiveness = StirrupEffectivenessFactory.GetEffectiveness(BeamShearSectionType.Rectangle); - if (stirrup is IStirrupByDensity stirrupByDensity) + if (stirrup is IStirrupByRebar stirrupByRebar) { - TraceLogger?.AddMessage("Stirrups type is stirrup by density"); - stirrupDensityStrengthLogic = new StirrupByDensityStrengthLogic(stirrupEffectiveness, stirrupByDensity, inclinedSection,TraceLogger); - return stirrupDensityStrengthLogic.GetShearStrength(); + TraceLogger?.AddMessage($"Stirrups type is stirrup by rebar {stirrupByRebar.Name}"); + stirrupByDensityStrengthLogic = new StirrupByRebarStrengthLogic(stirrupEffectiveness, stirrupByRebar, inclinedSection, inputData.ForceTuple, TraceLogger); + return stirrupByDensityStrengthLogic.GetShearStrength(); } - else if (stirrup is IStirrupByRebar stirrupByRebar) + else if (stirrup is IStirrupGroup stirrupGroup) { - TraceLogger?.AddMessage("Stirrups type is stirrup by rebar"); - stirrupDensityStrengthLogic = new StirrupByRebarStrengthLogic(stirrupEffectiveness, stirrupByRebar, inclinedSection, inputData.ForceTuple, TraceLogger); - return stirrupDensityStrengthLogic.GetShearStrength(); + TraceLogger?.AddMessage($"Stirrups type is stirrupGroup {stirrupGroup.Name}"); + stirrupGroupStrengthLogic ??= new StirrupGroupStrengthLogic(inputData, stirrupGroup, TraceLogger); + return stirrupGroupStrengthLogic.GetShearStrength(); + } + else if (stirrup is IStirrupByDensity stirrupByDensity) + { + TraceLogger?.AddMessage($"Stirrups type is stirrup by density {stirrupByDensity.Name}"); + stirrupByDensityStrengthLogic = new StirrupByDensityStrengthLogic(stirrupEffectiveness, stirrupByDensity, inclinedSection,TraceLogger); + return stirrupByDensityStrengthLogic.GetShearStrength(); + } + else if (stirrup is IStirrupByInclinedRebar inclinedRebar) + { + TraceLogger?.AddMessage($"Stirrups type is inclined rebar {inclinedRebar.Name}"); + stirrupByInclinedRebarStrengthLogic ??= new StirrupByInclinedRebarStrengthLogic(inclinedSection, inclinedRebar, TraceLogger); + return stirrupByInclinedRebarStrengthLogic.GetShearStrength(); } else { diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs new file mode 100644 index 0000000..a3cffd1 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs @@ -0,0 +1,21 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class BeamShearSectionLogicInputDataUpdateStrategy : IUpdateStrategy + { + public void Update(IBeamShearSectionLogicInputData targetObject, IBeamShearSectionLogicInputData sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + targetObject.InclinedSection = sourceObject.InclinedSection; + targetObject.Stirrup = sourceObject.Stirrup; + targetObject.LimitState = sourceObject.LimitState; + targetObject.CalcTerm = sourceObject.CalcTerm; + targetObject.ForceTuple = sourceObject.ForceTuple; + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs index 90aa628..bd350e2 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs @@ -1,6 +1,7 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Services; +using StructureHelperLogics.Models.Materials; using StructureHelperLogics.NdmCalculations.Primitives; namespace StructureHelperLogics.Models.BeamShears @@ -18,6 +19,9 @@ namespace StructureHelperLogics.Models.BeamShears targetObject.StartCoordinate = sourceObject.StartCoordinate; targetObject.OffSet = sourceObject.OffSet; targetObject.AngleOfInclination = sourceObject.AngleOfInclination; + targetObject.LegCount = sourceObject.LegCount; + CheckObject.IsNull(sourceObject.RebarSection, "Rebar section"); + targetObject.RebarSection = sourceObject.RebarSection.Clone() as IRebarSection; } } } diff --git a/StructureHelperLogics/Models/BeamShears/StirrupByInclinedRebar.cs b/StructureHelperLogics/Models/BeamShears/StirrupByInclinedRebar.cs index 6985c9d..d9faf3a 100644 --- a/StructureHelperLogics/Models/BeamShears/StirrupByInclinedRebar.cs +++ b/StructureHelperLogics/Models/BeamShears/StirrupByInclinedRebar.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperLogics.Models.Materials; using System; using System.Collections.Generic; using System.Linq; @@ -59,6 +60,10 @@ namespace StructureHelperLogics.Models.BeamShears angleOfInclination = value; } } + /// + public IRebarSection RebarSection { get; set; } = new RebarSection(Guid.NewGuid()); + /// + public double LegCount { get; set; } = 2; public StirrupByInclinedRebar(Guid id) { diff --git a/StructureHelperLogics/Models/Materials/IRebarSection.cs b/StructureHelperLogics/Models/Materials/IRebarSection.cs new file mode 100644 index 0000000..164034c --- /dev/null +++ b/StructureHelperLogics/Models/Materials/IRebarSection.cs @@ -0,0 +1,24 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.Materials +{ + /// + /// Implements properies of cross-section of reinforcement bar + /// + public interface IRebarSection : ISaveable, ICloneable + { + /// + /// Material of rebar + /// + IReinforcementLibMaterial Material { get; set; } + /// + /// Diameter of rebar + /// + double Diameter { get; set; } + } +} diff --git a/StructureHelperLogics/Models/Materials/Logics/IRebarSectionStrengthLogic.cs b/StructureHelperLogics/Models/Materials/Logics/IRebarSectionStrengthLogic.cs new file mode 100644 index 0000000..9914f31 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/Logics/IRebarSectionStrengthLogic.cs @@ -0,0 +1,13 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; + +namespace StructureHelperLogics.Models.Materials +{ + public interface IRebarSectionStrengthLogic : ILogic + { + IRebarSection RebarSection { get; set; } + IShiftTraceLogger? TraceLogger { get; set; } + + double GetRebarMaxTensileForce(); + } +} \ No newline at end of file diff --git a/StructureHelperLogics/Models/Materials/Logics/RebarSectionStrengthLogic.cs b/StructureHelperLogics/Models/Materials/Logics/RebarSectionStrengthLogic.cs new file mode 100644 index 0000000..b53db39 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/Logics/RebarSectionStrengthLogic.cs @@ -0,0 +1,41 @@ +using StructureHelperCommon.Infrastructures.Enums; +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.Materials +{ + public class RebarSectionStrengthLogic : IRebarSectionStrengthLogic + { + public double RebarStrengthFactor { get; set; } = 1; + public double MaxRebarStrength { get; set; } = double.PositiveInfinity; + /// + /// Limit state, default - ULS + /// + public LimitStates LimitState { get; set; } = LimitStates.ULS; + /// + /// Calc term, default - short term + /// + public CalcTerms CalcTerm { get; set; } = CalcTerms.ShortTerm; + public IRebarSection RebarSection { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public double GetRebarMaxTensileForce() + { + double rebarArea = Math.PI * RebarSection.Diameter * RebarSection.Diameter / 4; + TraceLogger?.AddMessage($"Rebar area = {rebarArea}(m2)"); + double materialStrength = RebarSection.Material.GetStrength(LimitState, CalcTerm).Tensile; + TraceLogger?.AddMessage($"Stirrup material strength Rsw = {materialStrength}"); + double rebarStrength = RebarStrengthFactor * materialStrength; + TraceLogger?.AddMessage($"Strength of rebar Rs = {RebarStrengthFactor} * {materialStrength} = {rebarStrength}(Pa)"); + double minimizedStrength = Math.Min(rebarStrength, MaxRebarStrength); + TraceLogger?.AddMessage($"Strength of rebar Rs = Min({rebarStrength}, {MaxRebarStrength})= {minimizedStrength}(Pa)"); + double rebarForce = minimizedStrength * rebarArea; + TraceLogger?.AddMessage($"Force in rebar Ns = {minimizedStrength}(Pa) * {rebarArea}(m2) = {rebarForce}"); + return rebarForce; + } + } +} diff --git a/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs new file mode 100644 index 0000000..f9a3129 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs @@ -0,0 +1,18 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; + +namespace StructureHelperLogics.Models.Materials +{ + public class RebarSectionUpdateStrategy : IUpdateStrategy + { + public void Update(IRebarSection targetObject, IRebarSection sourceObject) + { + CheckObject.IsNull(sourceObject); + CheckObject.IsNull(targetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + CheckObject.IsNull(sourceObject.Material); + targetObject.Material = sourceObject.Material.Clone() as IReinforcementLibMaterial; + targetObject.Diameter = sourceObject.Diameter; + } + } +} diff --git a/StructureHelperLogics/Models/Materials/RebarSection.cs b/StructureHelperLogics/Models/Materials/RebarSection.cs new file mode 100644 index 0000000..b4300b9 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/RebarSection.cs @@ -0,0 +1,52 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.Materials +{ + /// + public class RebarSection : IRebarSection + { + private const double minRebarDiameter = 0.001; + private const double maxRebarDiameter = 0.050; + private double diameter; + + /// + public Guid Id { get;} + /// + public IReinforcementLibMaterial Material { get; set; } + /// + public double Diameter + { + get => diameter; set + { + if (value < minRebarDiameter) + { + throw new StructureHelperException($"Diameter of stirrup must not be less than {minRebarDiameter * 1000}mm, but was {value}"); + } + if (value > maxRebarDiameter) + { + throw new StructureHelperException($"Diameter of stirrup must be less or equal than {maxRebarDiameter * 1000}mm, but was {value}"); + } + diameter = value; + } + } + public RebarSection(Guid id) + { + Id = id; + Diameter = 0.008; + Material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Reinforcement400).HelperMaterial as IReinforcementLibMaterial; + } + + public object Clone() + { + var newItem = new RebarSection(Guid.NewGuid()); + var logic = new RebarSectionUpdateStrategy(); + logic.Update(newItem, this); + return newItem; + } + } +}