diff --git a/DataAccess/DTOs/Converters/NdmCrossSections/NdmPrimitiveFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/NdmCrossSections/NdmPrimitiveFromDTOConvertStrategy.cs index b7c6fc2..7fc126f 100644 --- a/DataAccess/DTOs/Converters/NdmCrossSections/NdmPrimitiveFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/NdmCrossSections/NdmPrimitiveFromDTOConvertStrategy.cs @@ -92,7 +92,10 @@ namespace DataAccess.DTOs rebarConvertStrategy.TraceLogger = TraceLogger; RebarNdmPrimitive newItem = rebarConvertStrategy.Convert(rebar); TraceLogger?.AddMessage($"Primtive has been obtained successfully, Name = {newItem.Name}"); - newItem.HostPrimitive = GetHostPrimitive(rebar); + if (rebar.HostPrimitive != null) + { + newItem.HostPrimitive = GetHostPrimitive(rebar); + } return newItem; } diff --git a/DataAccess/DTOs/DTOEntities/BeamShears/StirrupByRebarDTO.cs b/DataAccess/DTOs/DTOEntities/BeamShears/StirrupByRebarDTO.cs index 0d7b372..cd80a0c 100644 --- a/DataAccess/DTOs/DTOEntities/BeamShears/StirrupByRebarDTO.cs +++ b/DataAccess/DTOs/DTOEntities/BeamShears/StirrupByRebarDTO.cs @@ -20,6 +20,8 @@ namespace DataAccess.DTOs public double Spacing { get; set; } [JsonProperty("CompressedGap")] public double CompressedGap { get; set; } + [JsonProperty("IsSpiral")] + public bool IsSpiral { get; set; } = false; public StirrupByRebarDTO(Guid id) { diff --git a/StructureHelper/Infrastructure/Enums/StirrupTypes.cs b/StructureHelper/Infrastructure/Enums/StirrupTypes.cs index 14fa497..364099f 100644 --- a/StructureHelper/Infrastructure/Enums/StirrupTypes.cs +++ b/StructureHelper/Infrastructure/Enums/StirrupTypes.cs @@ -9,6 +9,8 @@ namespace StructureHelper.Infrastructure.Enums public enum StirrupTypes { Density, - UniformRebar + UniformRebar, + GroupOfStirrups, + InclinedRebar } } diff --git a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml b/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml index 730396a..c0ad10a 100644 --- a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml +++ b/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml @@ -693,6 +693,15 @@ + + + + + + + + + @@ -724,6 +733,20 @@ + + + + + + + + + + + + + + diff --git a/StructureHelper/StructureHelper.csproj.user b/StructureHelper/StructureHelper.csproj.user index 25f4bbb..32ecc72 100644 --- a/StructureHelper/StructureHelper.csproj.user +++ b/StructureHelper/StructureHelper.csproj.user @@ -39,9 +39,15 @@ Code + + Code + Code + + Code + Code diff --git a/StructureHelper/Windows/BeamShears/BeamShearView.xaml b/StructureHelper/Windows/BeamShears/BeamShearView.xaml index b9959c7..20748ea 100644 --- a/StructureHelper/Windows/BeamShears/BeamShearView.xaml +++ b/StructureHelper/Windows/BeamShears/BeamShearView.xaml @@ -3,8 +3,8 @@ xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" - xmlns:uc="clr-namespace:StructureHelper.Windows.UserControls" xmlns:local="clr-namespace:StructureHelper.Windows.BeamShears" + xmlns:uc="clr-namespace:StructureHelper.Windows.UserControls" xmlns:enums="clr-namespace:StructureHelper.Infrastructure.Enums" d:DataContext="{d:DesignInstance local:BeamShearViewModel}" mc:Ignorable="d" @@ -40,6 +40,18 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/StructureHelper/Windows/BeamShears/StirrupGroupView.xaml.cs b/StructureHelper/Windows/BeamShears/StirrupGroupView.xaml.cs new file mode 100644 index 0000000..71420ff --- /dev/null +++ b/StructureHelper/Windows/BeamShears/StirrupGroupView.xaml.cs @@ -0,0 +1,36 @@ +using StructureHelperLogics.Models.BeamShears; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Shapes; + +namespace StructureHelper.Windows.BeamShears +{ + /// + /// Логика взаимодействия для StirrupGroupView.xaml + /// + public partial class StirrupGroupView : Window + { + StirrupGroupViewModel viewModel; + public StirrupGroupView(StirrupGroupViewModel viewModel) + { + InitializeComponent(); + this.viewModel = viewModel; + this.viewModel.ParentWindow = this; + this.DataContext = this.viewModel; + } + public StirrupGroupView(IStirrupGroup stirrupGroup) : this(new StirrupGroupViewModel(stirrupGroup)) + { + + } + } +} diff --git a/StructureHelper/Windows/BeamShears/StirrupGroupViewModel.cs b/StructureHelper/Windows/BeamShears/StirrupGroupViewModel.cs new file mode 100644 index 0000000..0257564 --- /dev/null +++ b/StructureHelper/Windows/BeamShears/StirrupGroupViewModel.cs @@ -0,0 +1,28 @@ +using StructureHelper.Windows.ViewModels; +using StructureHelperLogics.Models.BeamShears; +using System.Collections.Generic; + +namespace StructureHelper.Windows.BeamShears +{ + public class StirrupGroupViewModel : OkCancelViewModelBase + { + private IStirrupGroup _stirrupGroup; + + public string Name + { + get => _stirrupGroup.Name; + set + { + _stirrupGroup.Name = value; + OnPropertyChanged(nameof(Name)); + } + } + public BeamStirrupsViewModel Stirrups { get; } + + public StirrupGroupViewModel(IStirrupGroup stirrupGroup) + { + _stirrupGroup = stirrupGroup; + Stirrups = new(_stirrupGroup); + } + } +} diff --git a/StructureHelperCommon/Infrastructures/Settings/ProgramSetting.cs b/StructureHelperCommon/Infrastructures/Settings/ProgramSetting.cs index 7f4ce6d..9dc18fe 100644 --- a/StructureHelperCommon/Infrastructures/Settings/ProgramSetting.cs +++ b/StructureHelperCommon/Infrastructures/Settings/ProgramSetting.cs @@ -91,7 +91,8 @@ namespace StructureHelperCommon.Infrastructures.Settings return new FileVersion() { VersionNumber = 1, - SubVersionNumber = 2 //Add Beam shear analysis + //SubVersionNumber = 2 //Add Beam shear analysis + SubVersionNumber = 3 //Add stirrup group and inclined rebar }; } } diff --git a/StructureHelperLogics/Models/BeamShears/IStirrupByInclinedRebar.cs b/StructureHelperLogics/Models/BeamShears/IStirrupByInclinedRebar.cs new file mode 100644 index 0000000..6756ba7 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/IStirrupByInclinedRebar.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.BeamShears +{ + /// + /// Implements properies of stirrup by inclined rebar + /// + public interface IStirrupByInclinedRebar : IStirrup + { + /// + /// Coordinate of start point of inclination, m + /// + double StartCoordinate { get; set; } + /// + /// Distance beetwen start/end point and point where rebar work is started + /// + double OffSet { get; set; } + /// + /// Angle of inclination of rebar in degrees + /// + double AngleOfInclination { get; set; } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/IStirrupByRebar.cs b/StructureHelperLogics/Models/BeamShears/IStirrupByRebar.cs index 0343c6e..06ce4da 100644 --- a/StructureHelperLogics/Models/BeamShears/IStirrupByRebar.cs +++ b/StructureHelperLogics/Models/BeamShears/IStirrupByRebar.cs @@ -17,6 +17,10 @@ namespace StructureHelperLogics.Models.BeamShears /// IReinforcementLibMaterial Material { get; set; } /// + /// True if hoop is spiral one + /// + bool IsSpiral { get; set; } + /// /// Count of legs of stirrup in specific cross-section /// double LegCount { get; set; } diff --git a/StructureHelperLogics/Models/BeamShears/IStirrupGroup.cs b/StructureHelperLogics/Models/BeamShears/IStirrupGroup.cs index 8510954..793f63e 100644 --- a/StructureHelperLogics/Models/BeamShears/IStirrupGroup.cs +++ b/StructureHelperLogics/Models/BeamShears/IStirrupGroup.cs @@ -6,8 +6,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears { - public interface IStirrupGroup : IStirrup + public interface IStirrupGroup : IStirrup, IHasStirrups { - List Stirrups { get; } } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarStrengthLogic.cs index 0b7af27..3a67683 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarStrengthLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarStrengthLogic.cs @@ -72,7 +72,7 @@ namespace StructureHelperLogics.Models.BeamShears private void InitializeStrategies() { - convertStrategy ??= new StirrupByRebarToDensityConvertStrategy(TraceLogger); + convertStrategy ??= new StirrupByRebarToDensityConvertStrategy(TraceLogger, inclinedSection); IStirrupByDensity stirrupByDensity = convertStrategy.Convert(stirrupByRebar); stirrupDensityStrengthLogic ??= new(stirrupEffectiveness, stirrupByDensity, inclinedSection, TraceLogger); } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs index 2953d35..723f6a2 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; @@ -8,13 +9,15 @@ namespace StructureHelperLogics.Models.BeamShears { private const double stirrupStrengthFactor = 0.8d; private const double maxStirrupStrength = 3e8; + private IInclinedSection inclinedSection; private IUpdateStrategy updateStrategy; public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } public IShiftTraceLogger TraceLogger { get; set; } - public StirrupByRebarToDensityConvertStrategy(IShiftTraceLogger traceLogger) + public StirrupByRebarToDensityConvertStrategy(IShiftTraceLogger traceLogger, IInclinedSection inclinedSection) { TraceLogger = traceLogger; + this.inclinedSection = inclinedSection; } public StirrupByRebarToDensityConvertStrategy(IUpdateStrategy updateStrategy, IShiftTraceLogger traceLogger) @@ -42,9 +45,33 @@ namespace StructureHelperLogics.Models.BeamShears 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 density = minimizedStrength * area * source.LegCount / source.Spacing; - TraceLogger?.AddMessage($"Density of stirrups = {minimizedStrength} * {area} * {source.LegCount} / {source.Spacing} = {density}(N/m)"); + double spiralEffectiveness = 1; + if (source.IsSpiral = true) + { + spiralEffectiveness = GetSpiralEffectiveness(source); + } + double density = minimizedStrength * area * source.LegCount / source.Spacing * spiralEffectiveness; + TraceLogger?.AddMessage($"Density of stirrups = {minimizedStrength} * {area} * {source.LegCount} / {source.Spacing} * {spiralEffectiveness} = {density}(N/m)"); return density; } + + private double GetSpiralEffectiveness(IStirrupByRebar source) + { + if (inclinedSection is null) + { + string errorString = ErrorStrings.ParameterIsNull + ": Inclined Section"; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + double spiralHeight = inclinedSection.EffectiveDepth - (inclinedSection.FullDepth - inclinedSection.EffectiveDepth); + TraceLogger?.AddMessage($"Spiral height = {spiralHeight}(m)"); + double spiralSpacing = source.Spacing; + TraceLogger?.AddMessage($"Spiral spacing = {spiralSpacing}(m)"); + double spiralAng = Math.Atan2(spiralHeight, spiralSpacing); + double spriralEffectiveness = Math.Sin(spiralAng); + double spiralAngInDegrees = 180 / (Math.PI) * spiralAng; + TraceLogger?.AddMessage($"Spiral effectiveness factor = sin({spiralAngInDegrees}(deg)) = {spriralEffectiveness}"); + return spriralEffectiveness; + } } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs index eacf3e9..65f7a0b 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs @@ -24,6 +24,7 @@ namespace StructureHelperLogics.Models.BeamShears targetObject.Diameter = sourceObject.Diameter; targetObject.LegCount = sourceObject.LegCount; targetObject.Spacing = sourceObject.Spacing; + targetObject.IsSpiral = sourceObject.IsSpiral; } } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs index fb24b28..6e7fba7 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs @@ -13,49 +13,74 @@ namespace StructureHelperLogics.Models.BeamShears.Logics { private IUpdateStrategy densityUpdateStrategy; private IUpdateStrategy uniformUpdateStrategy; + private IUpdateStrategy groupUpdateStrategy; + private IUpdateStrategy inclinedUpdateStrategy; + public void Update(IStirrup targetObject, IStirrup sourceObject) { CheckObject.IsNull(targetObject); CheckObject.IsNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - if (sourceObject is IStirrupByDensity density) + if (sourceObject is IStirrupGroup group) { - UpdateByDensity(targetObject, density); + UpdateGroup(targetObject, group); } else if (sourceObject is IStirrupByRebar stirrupByUniformRebar) { UpdateByUniformRebar(targetObject, stirrupByUniformRebar); } + else if (sourceObject is IStirrupByDensity density) + { + UpdateByDensity(targetObject, density); + } + else if (sourceObject is IStirrupByInclinedRebar inclinedRebar) + { + UpdateByInclinedRebar(targetObject, inclinedRebar); + } else { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(sourceObject)); } } - private void UpdateByUniformRebar(IStirrup targetObject, IStirrupByRebar stirrupByUniformRebar) + private void UpdateByInclinedRebar(IStirrup targetObject, IStirrupByInclinedRebar surceInclinedRebar) { - uniformUpdateStrategy ??= new StirrupByRebarUpdateStrategy(); - if (targetObject is IStirrupByRebar targetUniformRebar) - { - uniformUpdateStrategy.Update(targetUniformRebar, stirrupByUniformRebar); - } - else + if (targetObject is not IStirrupByInclinedRebar targetInclinedRebar) { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject)); } + inclinedUpdateStrategy ??= new StirrupByInclinedRebarUpdateStrategy(); + inclinedUpdateStrategy.Update(targetInclinedRebar, surceInclinedRebar); + } + + private void UpdateGroup(IStirrup targetObject, IStirrupGroup sourceGroup) + { + if (targetObject is not IStirrupGroup targetGroup) + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject)); + } + groupUpdateStrategy ??= new StirrupGroupUpdateStrategy(); + groupUpdateStrategy.Update(targetGroup, sourceGroup); + } + + private void UpdateByUniformRebar(IStirrup targetObject, IStirrupByRebar stirrupByUniformRebar) + { + if (targetObject is not IStirrupByRebar targetUniformRebar) + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject)); + } + uniformUpdateStrategy ??= new StirrupByRebarUpdateStrategy(); + uniformUpdateStrategy.Update(targetUniformRebar, stirrupByUniformRebar); } private void UpdateByDensity(IStirrup targetObject, IStirrupByDensity density) { - densityUpdateStrategy ??= new StirrupByDensityUpdateStrategy(); - if (targetObject is IStirrupByDensity targetDensity) - { - densityUpdateStrategy.Update(targetDensity, density); - } - else + if (targetObject is not IStirrupByDensity targetDensity) { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject)); } + densityUpdateStrategy ??= new StirrupByDensityUpdateStrategy(); + densityUpdateStrategy.Update(targetDensity, density); } } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs new file mode 100644 index 0000000..90aa628 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs @@ -0,0 +1,23 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class StirrupByInclinedRebarUpdateStrategy : IUpdateStrategy + { + private IUpdateStrategy? baseUpdateStrategy; + public void Update(IStirrupByInclinedRebar targetObject, IStirrupByInclinedRebar sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + baseUpdateStrategy ??= new StirrupBaseUpdateStrategy(); + baseUpdateStrategy.Update(targetObject, sourceObject); + targetObject.StartCoordinate = sourceObject.StartCoordinate; + targetObject.OffSet = sourceObject.OffSet; + targetObject.AngleOfInclination = sourceObject.AngleOfInclination; + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs new file mode 100644 index 0000000..020027c --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs @@ -0,0 +1,29 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class StirrupGroupUpdateStrategy : IUpdateStrategy + { + private StirrupBaseUpdateStrategy baseUpdateStrategy; + + public void Update(IStirrupGroup targetObject, IStirrupGroup sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + baseUpdateStrategy ??= new StirrupBaseUpdateStrategy(); + baseUpdateStrategy.Update(targetObject, sourceObject); + CheckObject.IsNull(sourceObject.Stirrups); + CheckObject.IsNull(targetObject.Stirrups); + targetObject.Stirrups.Clear(); + foreach (var item in sourceObject.Stirrups) + { + IStirrup? newItem = item.Clone() as IStirrup; + targetObject.Stirrups.Add(newItem); + } + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/StirrupByInclinedRebar.cs b/StructureHelperLogics/Models/BeamShears/StirrupByInclinedRebar.cs new file mode 100644 index 0000000..6985c9d --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/StirrupByInclinedRebar.cs @@ -0,0 +1,76 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class StirrupByInclinedRebar : IStirrupByInclinedRebar + { + private const int minInclinationAngle = 10; + private const int maxInclinationAngle = 80; + private double angleOfInclination = 45; + private double startCoordinate = 0.05; + private double compressedGap = 0.05; + + /// + public Guid Id { get; } + public string? Name { get; set; } = string.Empty; + /// + public double CompressedGap + { + get => compressedGap; + set + { + if (value < 0) + { + throw new StructureHelperException(ErrorStrings.IncorrectValue + $": distance from compressed edge must be positive"); + } + compressedGap = value; + } + } + /// + public double StartCoordinate + { + get => startCoordinate; + set + { + if (value < 0) + { + throw new StructureHelperException(ErrorStrings.IncorrectValue + $": start coordinate must be positive"); + } + startCoordinate = value; + } + } + /// + public double OffSet { get; set; } = 0.05; + /// + public double AngleOfInclination + { + get => angleOfInclination; + set + { + if (value < minInclinationAngle || value > maxInclinationAngle) + { + throw new StructureHelperException(ErrorStrings.IncorrectValue + $": angle of inclination of rebar must be beetwen {minInclinationAngle} and {maxInclinationAngle} degrees"); + } + angleOfInclination = value; + } + } + + public StirrupByInclinedRebar(Guid id) + { + Id = id; + } + + public object Clone() + { + var logic = new StirrupByInclinedRebarUpdateStrategy(); + StirrupByInclinedRebar newItem = new(Guid.NewGuid()); + logic.Update(newItem, this); + return newItem; + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/StirrupByRebar.cs b/StructureHelperLogics/Models/BeamShears/StirrupByRebar.cs index 221adc0..1949012 100644 --- a/StructureHelperLogics/Models/BeamShears/StirrupByRebar.cs +++ b/StructureHelperLogics/Models/BeamShears/StirrupByRebar.cs @@ -29,7 +29,8 @@ namespace StructureHelperLogics.Models.BeamShears } legCount = value; } - } /// + } + /// public double Diameter { get => diameter; set @@ -44,7 +45,8 @@ namespace StructureHelperLogics.Models.BeamShears } diameter = value; } - } /// + } + /// public double Spacing { get => step; set @@ -55,8 +57,11 @@ namespace StructureHelperLogics.Models.BeamShears } step = value; } - } /// + } + /// public double CompressedGap { get; set; } = 0; + /// + public bool IsSpiral { get; set; } = false; public StirrupByRebar(Guid id) { diff --git a/StructureHelperLogics/Models/BeamShears/StirrupGroup.cs b/StructureHelperLogics/Models/BeamShears/StirrupGroup.cs index 4b4a353..7dc8e5e 100644 --- a/StructureHelperLogics/Models/BeamShears/StirrupGroup.cs +++ b/StructureHelperLogics/Models/BeamShears/StirrupGroup.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; using System.Linq; using System.Text; using System.Threading.Tasks; @@ -9,18 +10,21 @@ namespace StructureHelperLogics.Models.BeamShears public class StirrupGroup : IStirrupGroup { public Guid Id { get; } - public string Name { get; set; } + public string Name { get; set; } = string.Empty; public List Stirrups { get; } = new(); public double CompressedGap { get; set; } - public double GetShearBearingCapacity(IInclinedSection inclinedSection) + public StirrupGroup(Guid id) { - throw new NotImplementedException(); + Id = id; } public object Clone() { - throw new NotImplementedException(); + var updateStrategy = new StirrupGroupUpdateStrategy(); + StirrupGroup newItem = new(Guid.NewGuid()); + updateStrategy.Update(newItem, this); + return newItem; } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs index 5e64b55..68a8671 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs @@ -1,16 +1,10 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Infrastructures.Settings; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; -using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Forces.Logics; -using StructureHelperLogics.NdmCalculations.Cracking; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperLogics.NdmCalculations.Primitives.Logics; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { @@ -19,6 +13,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private bool result; private string checkResult; private ICheckEntityLogic checkAccuracyLogic; + private ICheckEntityLogic checkPrimitiveCollectionLogic; public IForceCalculatorInputData InputData { get; set; } @@ -66,11 +61,32 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces TraceMessage("Calculator does not contain any calc term"); result = false; } + CheckPrimitives(); CheckAccuracy(); CheckActions(); return result; } + private void CheckPrimitives() + { + checkPrimitiveCollectionLogic ??= new CheckPrimitiveCollectionLogic( + TraceLogger, + new CheckRebarPrimitiveLogic() + { + CheckRebarHostMaterial = false, + CheckRebarPlacement = false + }) + { + Entity = InputData, + }; + if (checkPrimitiveCollectionLogic.Check() == false) + { + result = false; + } + TraceMessage(checkPrimitiveCollectionLogic.CheckResult); + + } + private void CheckActions() { var checkLogic = new CheckForceActionsLogic() diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs index 78fb59c..df89277 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs @@ -1,18 +1,10 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; -using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces.Logics; using StructureHelperCommon.Models.Loggers; -using StructureHelperCommon.Models.Materials; using StructureHelperLogics.NdmCalculations.Primitives; using StructureHelperLogics.NdmCalculations.Primitives.Logics; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using System.Windows.Media.Animation; namespace StructureHelperLogics.NdmCalculations.Cracking { @@ -22,7 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic { private bool result; - private ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic; + private ICheckEntityLogic checkPrimitiveCollectionLogic; public ICrackCalculatorInputData InputData { get; set; } @@ -31,7 +23,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public IShiftTraceLogger? TraceLogger { get; set; } - public CheckCrackCalculatorInputDataLogic(ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic) + public CheckCrackCalculatorInputDataLogic(ICheckEntityLogic checkPrimitiveCollectionLogic) { this.checkPrimitiveCollectionLogic = checkPrimitiveCollectionLogic; } @@ -57,7 +49,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { throw new StructureHelperException(ErrorStrings.ParameterIsNull + ": check primitive logic"); } - checkPrimitiveCollectionLogic.HasPrimitives = InputData; + checkPrimitiveCollectionLogic.Entity = InputData; checkPrimitiveCollectionLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(); if (checkPrimitiveCollectionLogic.Check() == false) { diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs index 228a65a..97b3e30 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs @@ -11,22 +11,24 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives.Logics { - public class CheckPrimitiveCollectionLogic : ICheckPrimitiveCollectionLogic + public class CheckPrimitiveCollectionLogic : ICheckEntityLogic { private const string collectionDoesntHaveAnyPrimitives = "Calculator does not contain any primitives\n"; private const string checkRebarLogic = ": check rebar logic"; private string checkResult; private bool result; - private ICheckRebarPrimitiveLogic checkRebarPrimitiveLogic; + private ICheckEntityLogic checkRebarPrimitiveLogic; - public IHasPrimitives HasPrimitives { get; set; } + public IHasPrimitives Entity { get; set; } public string CheckResult => checkResult; public IShiftTraceLogger? TraceLogger { get; set; } - public CheckPrimitiveCollectionLogic(IShiftTraceLogger shiftTraceLogger, ICheckRebarPrimitiveLogic checkRebarPrimitiveLogic) + public CheckPrimitiveCollectionLogic( + IShiftTraceLogger shiftTraceLogger, + ICheckEntityLogic checkRebarPrimitiveLogic) { TraceLogger = shiftTraceLogger; this.checkRebarPrimitiveLogic = checkRebarPrimitiveLogic; @@ -47,7 +49,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics private void CheckPrimitives() { - if (HasPrimitives.Primitives is null || (!HasPrimitives.Primitives.Any())) + if (Entity.Primitives is null || (!Entity.Primitives.Any())) { result = false; checkResult += collectionDoesntHaveAnyPrimitives; @@ -55,7 +57,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics } else { - foreach (var primitive in HasPrimitives.Primitives) + foreach (var primitive in Entity.Primitives) { if (primitive is IRebarNdmPrimitive rebar) { @@ -71,7 +73,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics { throw new StructureHelperException(ErrorStrings.ParameterIsNull + checkRebarLogic); } - checkRebarPrimitiveLogic.RebarPrimitive = rebar; + checkRebarPrimitiveLogic.Entity = rebar; checkRebarPrimitiveLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(); if (checkRebarPrimitiveLogic.Check() == false) { @@ -79,7 +81,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics checkResult += checkRebarPrimitiveLogic.CheckResult; return; } - bool isPrimitivesContainRebarHost = HasPrimitives.Primitives.Contains(rebar.HostPrimitive); + bool isPrimitivesContainRebarHost = Entity.Primitives.Contains(rebar.HostPrimitive); if (isPrimitivesContainRebarHost == false) { result = false; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs index 66a53b3..aca5130 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Models; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Materials; using System; @@ -9,12 +10,14 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives.Logics { - public class CheckRebarPrimitiveLogic : ICheckRebarPrimitiveLogic + public class CheckRebarPrimitiveLogic : ICheckEntityLogic { private string checkResult; private bool result; - public IRebarNdmPrimitive RebarPrimitive { get; set; } + public bool CheckRebarPlacement { get; set; } = true; + public bool CheckRebarHostMaterial { get; set; } = true; + public IRebarNdmPrimitive Entity { get; set; } public string CheckResult => checkResult; @@ -40,33 +43,47 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics private void CheckRebar() { - if (RebarPrimitive.HostPrimitive is null) + if (Entity.HostPrimitive is null) { result = false; - string message = $"Primitive {RebarPrimitive.Name} does not have a host\n"; + string message = $"Primitive {Entity.Name} does not have a host\n"; checkResult += message; TraceLogger?.AddMessage(message, TraceLogStatuses.Error); return; } - - if (RebarPrimitive.HostPrimitive is IHasDivisionSize division) + if (CheckRebarPlacement == true) { - if (!division.IsPointInside(RebarPrimitive.Center)) - { - result = false; - string message = $"Primitive of rebar {RebarPrimitive.Name} is out of its host {RebarPrimitive.HostPrimitive.Name}"; - checkResult += message; - TraceLogger?.AddMessage(message, TraceLogStatuses.Error); - } + CheckIfRebarInsideHostPrimitive(); } + if (CheckRebarHostMaterial == true) + { + CheckIfRemarMaterialIsCrackedMaterial(); + } + } - if (RebarPrimitive.HostPrimitive.NdmElement.HeadMaterial.HelperMaterial is not ICrackedMaterial) + private void CheckIfRemarMaterialIsCrackedMaterial() + { + if (Entity.HostPrimitive.NdmElement.HeadMaterial.HelperMaterial is not ICrackedMaterial) { result = false; - string message = $"Material of host of {RebarPrimitive.Name} ({RebarPrimitive.HostPrimitive.NdmElement.HeadMaterial.Name}) does not support cracking\n"; + string message = $"Material of host of {Entity.Name} ({Entity.HostPrimitive.NdmElement.HeadMaterial.Name}) does not support cracking\n"; checkResult += message; TraceLogger?.AddMessage(message, TraceLogStatuses.Error); } } + + private void CheckIfRebarInsideHostPrimitive() + { + if (Entity.HostPrimitive is IHasDivisionSize division) + { + if (!division.IsPointInside(Entity.Center)) + { + result = false; + string message = $"Primitive of rebar {Entity.Name} is out of its host {Entity.HostPrimitive.Name}"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + } + } } } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckPrimitiveCollectionLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckPrimitiveCollectionLogic.cs deleted file mode 100644 index f30ec13..0000000 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckPrimitiveCollectionLogic.cs +++ /dev/null @@ -1,14 +0,0 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelperLogics.NdmCalculations.Primitives.Logics -{ - public interface ICheckPrimitiveCollectionLogic : ICheckLogic - { - IHasPrimitives HasPrimitives { get; set; } - } -} diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckRebarPrimitiveLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckRebarPrimitiveLogic.cs deleted file mode 100644 index 7389b20..0000000 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckRebarPrimitiveLogic.cs +++ /dev/null @@ -1,14 +0,0 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelperLogics.NdmCalculations.Primitives.Logics -{ - public interface ICheckRebarPrimitiveLogic : ICheckLogic - { - IRebarNdmPrimitive RebarPrimitive { get; set; } - } -} diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs index 2ca659b..4ad29ba 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs @@ -53,6 +53,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations public Ndm GetConcreteNdm() { +//#error //fix check rebar for host null var hostPrimitive = options.HostPrimitive; var material = hostPrimitive .NdmElement diff --git a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs index 7ad0681..4f64ec1 100644 --- a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs @@ -29,7 +29,7 @@ namespace StructureHelperTests.UnitTests.Ndms CallBase = true }; - _mockCheckPrimitiveCollectionLogic.Object.HasPrimitives = _mockHasPrimitives.Object; + _mockCheckPrimitiveCollectionLogic.Object.Entity = _mockHasPrimitives.Object; } [Test] diff --git a/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs index 99c7983..06c1890 100644 --- a/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs @@ -31,7 +31,7 @@ namespace StructureHelperTests.UnitTests.Ndms _checkRebarPrimitiveLogic = new CheckRebarPrimitiveLogic(_mockTraceLogger.Object) { - RebarPrimitive = _mockRebarPrimitive.Object + Entity = _mockRebarPrimitive.Object }; }