diff --git a/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml b/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml index 30a00d7..b86d6b3 100644 --- a/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml +++ b/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml @@ -53,7 +53,7 @@ - + diff --git a/StructureHelper/Windows/BeamShears/BeamShearCalculatorsViewModel.cs b/StructureHelper/Windows/BeamShears/BeamShearCalculatorsViewModel.cs index 677ceef..1900b10 100644 --- a/StructureHelper/Windows/BeamShears/BeamShearCalculatorsViewModel.cs +++ b/StructureHelper/Windows/BeamShears/BeamShearCalculatorsViewModel.cs @@ -8,12 +8,7 @@ using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; 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.Forms; using System.Windows.Input; namespace StructureHelper.Windows.BeamShears @@ -28,13 +23,11 @@ namespace StructureHelper.Windows.BeamShears { get { - return runCommand ?? - ( - runCommand = new RelayCommand(param => + return runCommand ??= new RelayCommand(param => { RunMethod(param); }, o => SelectedItem != null - )); + ); } } diff --git a/StructureHelper/Windows/BeamShears/ConcentratedForceViewModel.cs b/StructureHelper/Windows/BeamShears/ConcentratedForceViewModel.cs index c1edfbd..2edebb0 100644 --- a/StructureHelper/Windows/BeamShears/ConcentratedForceViewModel.cs +++ b/StructureHelper/Windows/BeamShears/ConcentratedForceViewModel.cs @@ -24,10 +24,10 @@ namespace StructureHelper.Windows.BeamShears } public double ForceValue { - get => concenratedForce.ForceValue; + get => concenratedForce.ForceValue.Qy; set { - concenratedForce.ForceValue = value; + concenratedForce.ForceValue.Qy = value; } } public double LoadRatio diff --git a/StructureHelper/Windows/BeamShears/DistributedLoadViewModel.cs b/StructureHelper/Windows/BeamShears/DistributedLoadViewModel.cs index 6646d28..7c5b8ef 100644 --- a/StructureHelper/Windows/BeamShears/DistributedLoadViewModel.cs +++ b/StructureHelper/Windows/BeamShears/DistributedLoadViewModel.cs @@ -30,10 +30,10 @@ namespace StructureHelper.Windows.BeamShears } public double LoadValue { - get => distributedLoad.LoadValue; + get => distributedLoad.LoadValue.Qy; set { - distributedLoad.LoadValue = value; + distributedLoad.LoadValue.Qy = value; } } public double RelativeLevel diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/Factories/BeamShearLoadFactory.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/Factories/BeamShearLoadFactory.cs index c9bb620..bfbb952 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/Factories/BeamShearLoadFactory.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/Factories/BeamShearLoadFactory.cs @@ -34,11 +34,11 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions ConcentratedForce concentratedForce = new(Guid.NewGuid()) { Name = "Concentrated force", - ForceValue = -5e4, LoadRatio = 1, RelativeLoadLevel = 0.5, ForceCoordinate = 1 }; + concentratedForce.ForceValue.Qy = -5e4; return concentratedForce; } @@ -47,12 +47,12 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions DistributedLoad distributedLoad = new(Guid.NewGuid()) { Name = "Distributed load", - LoadValue = -5e3, LoadRatio = 1, RelativeLoadLevel = 0.5, StartCoordinate = 0, EndCoordinate = 100 }; + distributedLoad.LoadValue.Qy = -5e3; return distributedLoad; } } diff --git a/StructureHelperCommon/Models/Forces/ConcentratedForce.cs b/StructureHelperCommon/Models/Forces/ConcentratedForce.cs index eb9f057..a0640cd 100644 --- a/StructureHelperCommon/Models/Forces/ConcentratedForce.cs +++ b/StructureHelperCommon/Models/Forces/ConcentratedForce.cs @@ -24,7 +24,7 @@ namespace StructureHelperCommon.Models.Forces /// public double ForceCoordinate { get; set; } /// - public double ForceValue { get; set; } + public IForceTuple ForceValue { get; set; } = new ForceTuple(Guid.NewGuid()); /// public double RelativeLoadLevel { diff --git a/StructureHelperCommon/Models/Forces/DistributedLoad.cs b/StructureHelperCommon/Models/Forces/DistributedLoad.cs index 081b2a1..ab4b834 100644 --- a/StructureHelperCommon/Models/Forces/DistributedLoad.cs +++ b/StructureHelperCommon/Models/Forces/DistributedLoad.cs @@ -16,7 +16,7 @@ namespace StructureHelperCommon.Models.Forces public Guid Id { get; } public string Name { get; set; } = string.Empty; - public double LoadValue { get; set; } = 0d; + public IForceTuple LoadValue { get; set; } = new ForceTuple(Guid.NewGuid()); public double RelativeLoadLevel { get => relativeLoadLevel; diff --git a/StructureHelperCommon/Models/Forces/IConcentratedForce.cs b/StructureHelperCommon/Models/Forces/IConcentratedForce.cs index d5b1269..1803f36 100644 --- a/StructureHelperCommon/Models/Forces/IConcentratedForce.cs +++ b/StructureHelperCommon/Models/Forces/IConcentratedForce.cs @@ -18,6 +18,6 @@ namespace StructureHelperCommon.Models.Forces /// /// Value of force, N /// - double ForceValue { get; set; } + IForceTuple ForceValue { get; set; } } } diff --git a/StructureHelperCommon/Models/Forces/IDistributedLoad.cs b/StructureHelperCommon/Models/Forces/IDistributedLoad.cs index 543fa4b..080e179 100644 --- a/StructureHelperCommon/Models/Forces/IDistributedLoad.cs +++ b/StructureHelperCommon/Models/Forces/IDistributedLoad.cs @@ -8,7 +8,7 @@ /// /// Value of uniformly distributed load, N/m /// - double LoadValue { get; set; } + IForceTuple LoadValue { get; set; } /// /// Coordinate of start of load, m /// diff --git a/StructureHelperCommon/Services/Forces/ForceTupleService.cs b/StructureHelperCommon/Services/Forces/ForceTupleService.cs index 26683ff..905b0e3 100644 --- a/StructureHelperCommon/Services/Forces/ForceTupleService.cs +++ b/StructureHelperCommon/Services/Forces/ForceTupleService.cs @@ -71,6 +71,12 @@ namespace StructureHelperCommon.Services.Forces } return tuples; } + /// + /// Renew target force tuple with adding source tuple + /// + /// Source tuple + /// Target tuple + /// Factor which source tuple will be multiplied by (1d is default value) public static void SumTupleToTarget(IForceTuple source, IForceTuple target, double factor = 1d) { target.Mx += source.Mx * factor; diff --git a/StructureHelperLogics/Models/BeamShears/BeamSectionShearStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/BeamSectionShearStrengthLogic.cs index d54472e..2a766b3 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamSectionShearStrengthLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamSectionShearStrengthLogic.cs @@ -1,9 +1,4 @@ using StructureHelperCommon.Models; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears { diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearCalculator.cs b/StructureHelperLogics/Models/BeamShears/BeamShearCalculator.cs index 663b773..fb6566b 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearCalculator.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearCalculator.cs @@ -1,16 +1,12 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears { public class BeamShearCalculator : IBeamShearCalculator { + private IUpdateStrategy updateStrategy; private ICheckInputDataLogic checkInputDataLogic; private IGetResultByInputDataLogic calculationLogic; private IBeamShearCalculatorResult result; @@ -30,7 +26,10 @@ namespace StructureHelperLogics.Models.BeamShears public object Clone() { - throw new NotImplementedException(); + BeamShearCalculator newItem = new(Guid.NewGuid()); + updateStrategy ??= new BeamShearCalculatorUpdateStrategy(); + updateStrategy.Update(newItem, this); + return newItem; } public void Run() diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs b/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs index 077174d..0376425 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs @@ -11,15 +11,15 @@ namespace StructureHelperLogics.Models.BeamShears public class BeamShearCalculatorLogic : IGetResultByInputDataLogic { private IBeamShearCalculatorResult result; - private IBeamShearSectionCalculator beamShearSectionCalculator; - private List sectionInputDatas; + private IBeamShearSectionLogic beamShearSectionLogic; + private List sectionInputDatas; + public IShiftTraceLogger? TraceLogger { get; set; } public BeamShearCalculatorLogic(IShiftTraceLogger? traceLogger) { TraceLogger = traceLogger; } - public IShiftTraceLogger? TraceLogger { get; set; } public IBeamShearCalculatorResult GetResultByInputData(IBeamShearCalculatorInputData inputData) { @@ -43,16 +43,16 @@ namespace StructureHelperLogics.Models.BeamShears { foreach (var sectionInputData in sectionInputDatas) { - beamShearSectionCalculator.InputData = sectionInputData; - beamShearSectionCalculator.Run(); - var sectionResult = beamShearSectionCalculator.Result as IBeamShearSectionCalculatorResult; + beamShearSectionLogic.InputData = sectionInputData; + beamShearSectionLogic.Run(); + var sectionResult = beamShearSectionLogic.Result as IBeamShearSectionLogicResult; result.SectionResults.Add(sectionResult); } } private void InitializeStrategies() { - beamShearSectionCalculator ??= new BeamShearSectionCalculator(); + beamShearSectionLogic ??= new BeamShearSectionLogic(); } private void PrepareNewResult() @@ -66,23 +66,23 @@ namespace StructureHelperLogics.Models.BeamShears private void GetSectionInputDatas(IBeamShearCalculatorInputData inputData) { - sectionInputDatas = new(); - foreach (var beamShearSection in inputData.Sections) - { - foreach (var stirrup in inputData.Stirrups) - { - foreach (var beamShearAction in inputData.Actions) - { - BeamShearSectionCalculatorInputData newInputData = new(Guid.NewGuid()) - { - BeamShearSection = beamShearSection, - Stirrup = stirrup, - BeamShearAction = beamShearAction - }; - sectionInputDatas.Add(newInputData); - } - } - } + //sectionInputDatas = new(); + //foreach (var beamShearSection in inputData.Sections) + //{ + // foreach (var stirrup in inputData.Stirrups) + // { + // foreach (var beamShearAction in inputData.Actions) + // { + // BeamShearSectionLogicInputData newInputData = new(Guid.NewGuid()) + // { + // BeamShearSection = beamShearSection, + // Stirrup = stirrup, + // BeamShearAction = beamShearAction + // }; + // sectionInputDatas.Add(newInputData); + // } + // } + //} } } } diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorResult.cs b/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorResult.cs index c53cf50..2116485 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorResult.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorResult.cs @@ -10,6 +10,6 @@ namespace StructureHelperLogics.Models.BeamShears { public bool IsValid { get; set; } = true; public string? Description { get; set; } = string.Empty; - public List SectionResults { get; set; } = new(); + public List SectionResults { get; set; } = new(); } } diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorInputData.cs b/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorInputData.cs deleted file mode 100644 index 65e8f3d..0000000 --- a/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorInputData.cs +++ /dev/null @@ -1,27 +0,0 @@ -using StructureHelperCommon.Models.Forces; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelperLogics.Models.BeamShears -{ - /// - public class BeamShearSectionCalculatorInputData : IBeamShearSectionCalculatorInputData - { - /// - public Guid Id { get; } - /// - public IBeamShearSection? BeamShearSection { get; set; } - /// - public IBeamShearAction? BeamShearAction { get; set; } - /// - public IStirrup? Stirrup { get; set; } - public BeamShearSectionCalculatorInputData(Guid id) - { - Id = id; - } - - } -} diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorResult.cs b/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorResult.cs index 15f0c90..3b3507b 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorResult.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculatorResult.cs @@ -6,7 +6,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears { - public class BeamShearSectionCalculatorResult : IBeamShearSectionCalculatorResult + public class BeamShearSectionCalculatorResult : IBeamShearSectionLogicResult { public bool IsValid { get; set; } public string? Description { get; set; } diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculator.cs b/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogic.cs similarity index 55% rename from StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculator.cs rename to StructureHelperLogics/Models/BeamShears/BeamShearSectionLogic.cs index c883901..f89f54e 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearSectionCalculator.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogic.cs @@ -8,23 +8,15 @@ using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears { - public class BeamShearSectionCalculator : IBeamShearSectionCalculator + public class BeamShearSectionLogic : IBeamShearSectionLogic { - private IBeamShearSectionCalculatorResult result; + private IBeamShearSectionLogicResult result; - public Guid Id { get; } - public string Name { get; set; } - public IBeamShearSectionCalculatorInputData InputData { get; set; } + public IBeamShearSectionLogicInputData InputData { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } public IResult Result => result; - public IShiftTraceLogger? TraceLogger { get; set; } - - - public object Clone() - { - throw new NotImplementedException(); - } public void Run() { diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogicInputData.cs b/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogicInputData.cs new file mode 100644 index 0000000..35738ee --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/BeamShearSectionLogicInputData.cs @@ -0,0 +1,24 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Forces; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace StructureHelperLogics.Models.BeamShears +{ + /// + public class BeamShearSectionLogicInputData : IBeamShearSectionLogicInputData + { + /// + public IBeamShearSection BeamShearSection { get; set; } + /// + public IStirrup Stirrup { get; set; } + /// + public LimitStates LimitState { get; set; } + /// + public CalcTerms CalcTerm { get; set; } + /// + public IForceTuple ForceTuple { get; set; } + + } +} diff --git a/StructureHelperLogics/Models/BeamShears/IBeamShearCalculatorResult.cs b/StructureHelperLogics/Models/BeamShears/IBeamShearCalculatorResult.cs index 96a85b7..b902006 100644 --- a/StructureHelperLogics/Models/BeamShears/IBeamShearCalculatorResult.cs +++ b/StructureHelperLogics/Models/BeamShears/IBeamShearCalculatorResult.cs @@ -9,6 +9,6 @@ namespace StructureHelperLogics.Models.BeamShears { public interface IBeamShearCalculatorResult : IResult { - List SectionResults { get; set; } + List SectionResults { get; set; } } } diff --git a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculator.cs b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculator.cs deleted file mode 100644 index e6dc96a..0000000 --- a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculator.cs +++ /dev/null @@ -1,14 +0,0 @@ -using StructureHelperCommon.Models.Calculators; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelperLogics.Models.BeamShears -{ - public interface IBeamShearSectionCalculator : ICalculator - { - IBeamShearSectionCalculatorInputData InputData { get; set; } - } -} diff --git a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculatorInputData.cs b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogic.cs similarity index 50% rename from StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculatorInputData.cs rename to StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogic.cs index b9195b8..0826ff1 100644 --- a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculatorInputData.cs +++ b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogic.cs @@ -1,6 +1,5 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Calculators; -using StructureHelperCommon.Models.Forces; using System; using System.Collections.Generic; using System.Linq; @@ -9,10 +8,11 @@ using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears { - public interface IBeamShearSectionCalculatorInputData : IInputData, ISaveable + public interface IBeamShearSectionLogic : ILogic { - IBeamShearSection? BeamShearSection { get; set; } - IBeamShearAction? BeamShearAction { get; set; } - IStirrup? Stirrup { get; set; } + IBeamShearSectionLogicInputData InputData { get; set; } + IResult Result { get; } + + void Run(); } } diff --git a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicInputData.cs b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicInputData.cs new file mode 100644 index 0000000..a073ca1 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicInputData.cs @@ -0,0 +1,19 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; + +//Copyright (c) 2023 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace StructureHelperLogics.Models.BeamShears +{ + public interface IBeamShearSectionLogicInputData : IInputData + { + IBeamShearSection BeamShearSection { get; set; } + IStirrup Stirrup { get; set; } + LimitStates LimitState { get; set; } + CalcTerms CalcTerm { get; set; } + IForceTuple ForceTuple { get; set; } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculatorResult.cs b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicResult.cs similarity index 78% rename from StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculatorResult.cs rename to StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicResult.cs index 96fcca1..62460b2 100644 --- a/StructureHelperLogics/Models/BeamShears/IBeamShearSectionCalculatorResult.cs +++ b/StructureHelperLogics/Models/BeamShears/IBeamShearSectionLogicResult.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.Models.BeamShears { - public interface IBeamShearSectionCalculatorResult : IResult + public interface IBeamShearSectionLogicResult : IResult { } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs new file mode 100644 index 0000000..b058d24 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs @@ -0,0 +1,30 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; + +namespace StructureHelperLogics.Models.BeamShears +{ + internal class BeamShearCalculatorInputDataUpdateStrategy : IUpdateStrategy + { + private IUpdateStrategy? hasActionUpdateStrategy; + private IUpdateStrategy? hasStirrupsUpdateStrategy; + private IUpdateStrategy hasSectionsUpdateStrategy; + public void Update(IBeamShearCalculatorInputData targetObject, IBeamShearCalculatorInputData sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + InitializeStrategies(); + hasActionUpdateStrategy?.Update(targetObject, sourceObject); + hasStirrupsUpdateStrategy?.Update(targetObject, sourceObject); + + } + + private void InitializeStrategies() + { + hasActionUpdateStrategy ??= new HasBeamShearActionUpdateStrategy(); + hasStirrupsUpdateStrategy ??= new HasStirrupsUpdateStrategy(); + hasSectionsUpdateStrategy ??= new HasBeamShearSectionUpdateStrategy(); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorToLogicInputDataConvertStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorToLogicInputDataConvertStrategy.cs new file mode 100644 index 0000000..db23855 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorToLogicInputDataConvertStrategy.cs @@ -0,0 +1,65 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Services.Forces; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class BeamShearCalculatorToLogicInputDataConvertStrategy + { + const LimitStates limitState = LimitStates.ULS; + private readonly IShiftTraceLogger? traceLogger; + private readonly List calcTerms = new() { CalcTerms.ShortTerm, CalcTerms.LongTerm }; + + public BeamShearCalculatorToLogicInputDataConvertStrategy(IShiftTraceLogger? traceLogger) + { + this.traceLogger = traceLogger; + } + + public List Convert(IBeamShearCalculatorInputData source) + { + List result = new(); + foreach (var section in source.Sections) + { + foreach (var action in source.Actions) + { + foreach (var stirrup in source.Stirrups) + { + foreach (var calcTerm in calcTerms) + { + IForceTuple forceTuple = GetForceTuple(action, limitState, calcTerm); + BeamShearSectionLogicInputData newItem = new() + { + BeamShearSection = section, + ForceTuple = forceTuple, + Stirrup = stirrup, + LimitState = limitState, + CalcTerm = calcTerm + }; + result.Add(newItem); + } + } + } + } + return result; + } + + private IForceTuple GetForceTuple(IBeamShearAction action, LimitStates limitState, CalcTerms calcTerm) + { + IForceTuple externalForceTuple = GetExternalForceTuple(action.ExternalForce, limitState, calcTerm); + IForceTuple internalForceTuple = GetInternalForceTuple(action.SupportAction, limitState, calcTerm); + IForceTuple sumForceTuple = ForceTupleService.SumTuples(externalForceTuple, internalForceTuple); + return sumForceTuple; + } + + private IForceTuple GetInternalForceTuple(IBeamShearAxisAction supportAction, LimitStates limitState, CalcTerms calcTerm) + { + throw new NotImplementedException(); + } + + private IForceTuple GetExternalForceTuple(IFactoredForceTuple externalForce, LimitStates limitState, CalcTerms calcTerm) + { + throw new NotImplementedException(); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorUpdateStrategy.cs new file mode 100644 index 0000000..6023d26 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorUpdateStrategy.cs @@ -0,0 +1,26 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class BeamShearCalculatorUpdateStrategy : IUpdateStrategy + { + private IUpdateStrategy? inputDataUpdateStrategy; + public void Update(IBeamShearCalculator targetObject, IBeamShearCalculator sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + targetObject.Name = sourceObject.Name; + targetObject.InputData ??= new BeamShearCalculatorInputData(Guid.NewGuid()); + InitializeStrategies(); + inputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData); + } + + private void InitializeStrategies() + { + inputDataUpdateStrategy ??= new BeamShearCalculatorInputDataUpdateStrategy(); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs index b63ee02..9f7b2d4 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs @@ -1,6 +1,7 @@ using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Services.Forces; //Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia //All rights reserved. @@ -40,19 +41,23 @@ namespace StructureHelperLogics.Models.BeamShears } /// - public double CalculateShearForce() + public IForceTuple CalculateShearForce() { TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service); InitializeStrategies(); - double supportShearForce = AxisAction.SupportForce.ForceTuple.Qx; + IForceTuple supportShearForce = AxisAction.SupportForce.ForceTuple; TraceLogger?.AddMessage($"Shear force at support Qmax = {supportShearForce}(N)"); TraceLogger?.AddMessage($"Start of inclined section a,start = {InclinedSection.StartCoord}(m)"); TraceLogger?.AddMessage($"End of inclined section a,end = {InclinedSection.EndCoord}(m)"); - double summarySpanShearForce = AxisAction.ShearLoads - .Sum(load => summaryForceLogic.GetSumShearForce(load, InclinedSection.StartCoord, InclinedSection.EndCoord)); - TraceLogger?.AddMessage($"Summary span force deltaQ = {summarySpanShearForce}(N)"); - double shearForce = supportShearForce + summarySpanShearForce; - TraceLogger?.AddMessage($"Summary shear force at the end of inclined section Q = {shearForce}(N)"); + ForceTuple summarySpanShearForce = new (Guid.NewGuid()); + foreach (var item in AxisAction.ShearLoads) + { + IForceTuple summarySpanLoad = summaryForceLogic.GetSumShearForce(item, InclinedSection.StartCoord, InclinedSection.EndCoord); + ForceTupleService.SumTupleToTarget(summarySpanLoad, summarySpanShearForce); + } + TraceLogger?.AddMessage($"Summary span force deltaQ = {summarySpanShearForce.Qy}(N)"); + IForceTuple shearForce = ForceTupleService.SumTuples(supportShearForce,summarySpanShearForce); + TraceLogger?.AddMessage($"Summary shear force at the end of inclined section Q = {shearForce.Qy}(N)"); return shearForce; } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs new file mode 100644 index 0000000..75de505 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs @@ -0,0 +1,21 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Services; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class HasBeamShearActionUpdateStrategy : IUpdateStrategy + { + public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + CheckObject.IsNull(sourceObject.Actions); + CheckObject.IsNull(targetObject.Actions); + targetObject.Actions.Clear(); + targetObject.Actions.AddRange(sourceObject.Actions); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs new file mode 100644 index 0000000..d43b605 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs @@ -0,0 +1,25 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class HasBeamShearSectionUpdateStrategy : IUpdateStrategy + { + public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + CheckObject.IsNull(sourceObject.Sections); + CheckObject.IsNull(targetObject.Sections); + targetObject.Sections.Clear(); + targetObject.Sections.AddRange(sourceObject.Sections); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs new file mode 100644 index 0000000..1bae188 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs @@ -0,0 +1,20 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; + +namespace StructureHelperLogics.Models.BeamShears +{ + public class HasStirrupsUpdateStrategy : IUpdateStrategy + { + public void Update(IHasStirrups targetObject, IHasStirrups sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + CheckObject.IsNull(sourceObject.Stirrups); + CheckObject.IsNull(targetObject.Stirrups); + targetObject.Stirrups.Clear(); + targetObject.Stirrups.AddRange(sourceObject.Stirrups); + } + } +} diff --git a/StructureHelperLogics/Models/BeamShears/Logics/IGetDirectShearForceLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/IGetDirectShearForceLogic.cs index aa12f03..23e8e3e 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/IGetDirectShearForceLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/IGetDirectShearForceLogic.cs @@ -12,6 +12,6 @@ namespace StructureHelperLogics.Models.BeamShears /// Returns value of shear force at the end of inclined section /// /// Value of shear force at the end of inclined section - double CalculateShearForce(); + IForceTuple CalculateShearForce(); } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/IShearForceLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/IShearForceLogic.cs index 73ffe30..869e0cb 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/IShearForceLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/IShearForceLogic.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; //Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia //All rights reserved. @@ -7,7 +8,7 @@ namespace StructureHelperLogics.Models.BeamShears { internal interface IShearForceLogic : ILogic { - double GetShearForce(); + IForceTuple GetShearForce(); } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/ISumForceByShearLoadLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/ISumForceByShearLoadLogic.cs index ad91d20..e4852cf 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/ISumForceByShearLoadLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/ISumForceByShearLoadLogic.cs @@ -20,6 +20,6 @@ namespace StructureHelperLogics.Models.BeamShears /// Coordinate of start point, m /// Coordinate of end point, m /// Summary force, N - double GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord); + IForceTuple GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord); } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/ShearForceLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/ShearForceLogic.cs index 5a0b65c..515ec67 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/ShearForceLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/ShearForceLogic.cs @@ -2,6 +2,7 @@ using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Forces.Logics; using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Services.Forces; namespace StructureHelperLogics.Models.BeamShears { @@ -31,13 +32,13 @@ namespace StructureHelperLogics.Models.BeamShears this.getDirectShearForceLogic = getDirectShearForceLogic; } - public double GetShearForce() + public IForceTuple GetShearForce() { TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service); InitializeStrategies(); double factor = getFactorLogic.GetFactor(); - double directShearForce = getDirectShearForceLogic.CalculateShearForce(); - double shearForce = directShearForce * factor; + IForceTuple directShearForce = getDirectShearForceLogic.CalculateShearForce(); + IForceTuple shearForce = ForceTupleService.MultiplyTupleByFactor(directShearForce,factor); return shearForce; } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/SumConcentratedForceLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/SumConcentratedForceLogic.cs index eaf5016..79c8b43 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/SumConcentratedForceLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/SumConcentratedForceLogic.cs @@ -2,6 +2,7 @@ using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Services.Forces; namespace StructureHelperLogics.Models.BeamShears { @@ -22,13 +23,13 @@ namespace StructureHelperLogics.Models.BeamShears TraceLogger = traceLogger; } - public double GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord) + public IForceTuple GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord) { TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service); if (beamShearLoad is IConcentratedForce concentratedForce) { InitializeStrategies(); - double sumForce = GetConcentratedForceSum(concentratedForce, startCoord, endCoord); + IForceTuple sumForce = GetConcentratedForceSum(concentratedForce, startCoord, endCoord); return sumForce; } else @@ -42,20 +43,20 @@ namespace StructureHelperLogics.Models.BeamShears coordinateByLevelLogic ??= new CoordinateByLevelLogic(TraceLogger); } - private double GetConcentratedForceSum(IConcentratedForce concentratedForce, double startCoord, double endCoord) + private IForceTuple GetConcentratedForceSum(IConcentratedForce concentratedForce, double startCoord, double endCoord) { - TraceLogger?.AddMessage($"Concentrated force Name = {concentratedForce.Name}, Value = {concentratedForce.ForceValue}(N/m) "); + TraceLogger?.AddMessage($"Concentrated force Name = {concentratedForce.Name}, Value = {concentratedForce.ForceValue.Qy}(N/m) "); if (concentratedForce.ForceCoordinate > endCoord) { TraceLogger?.AddMessage($"Force coordinate {concentratedForce.ForceCoordinate}(m) is bigger than section end {endCoord}(m), so total load is zero"); - return 0; + return new ForceTuple(Guid.NewGuid()); } return GetConcentratedForce(concentratedForce, startCoord, endCoord); } - private double GetConcentratedForce(IConcentratedForce concentratedForce, double startCoord, double endCoord) + private IForceTuple GetConcentratedForce(IConcentratedForce concentratedForce, double startCoord, double endCoord) { - double totalLoad; + IForceTuple totalLoad; double limitCoordinate = startCoord; if (concentratedForce.ForceCoordinate >= startCoord) { @@ -63,13 +64,13 @@ namespace StructureHelperLogics.Models.BeamShears } if (concentratedForce.ForceCoordinate < limitCoordinate) { - totalLoad = concentratedForce.ForceValue * concentratedForce.LoadRatio; + totalLoad = ForceTupleService.MultiplyTupleByFactor(concentratedForce.ForceValue, concentratedForce.LoadRatio); TraceLogger?.AddMessage($"Total load Q,tot = {concentratedForce.ForceValue}(N) * {concentratedForce.LoadRatio} = {totalLoad}(N)"); } else { TraceLogger?.AddMessage($"Force coordinate {concentratedForce.ForceCoordinate}(m) is bigger than limit coordinate {limitCoordinate}(m), so total load is zero"); - totalLoad = 0d; + totalLoad = new ForceTuple(Guid.NewGuid()); } return totalLoad; } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/SumDistributedLoadLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/SumDistributedLoadLogic.cs index bcf0a19..1dda1a0 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/SumDistributedLoadLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/SumDistributedLoadLogic.cs @@ -2,6 +2,7 @@ using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Services.Forces; namespace StructureHelperLogics.Models.BeamShears { @@ -21,13 +22,13 @@ namespace StructureHelperLogics.Models.BeamShears TraceLogger = traceLogger; } - public double GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord) + public IForceTuple GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord) { TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service); if (beamShearLoad is IDistributedLoad distributedLoad) { InitializeStrategies(); - double sumForce = GetDistributedLoadSum(distributedLoad, startCoord, endCoord); + IForceTuple sumForce = GetDistributedLoadSum(distributedLoad, startCoord, endCoord); return sumForce; } else @@ -41,21 +42,22 @@ namespace StructureHelperLogics.Models.BeamShears coordinateByLevelLogic ??= new CoordinateByLevelLogic(TraceLogger); } - private double GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord) + private IForceTuple GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord) { - TraceLogger?.AddMessage($"Uniformly distributed load Name = {distributedLoad.Name}, Value = {distributedLoad.LoadValue}(N/m) "); + TraceLogger?.AddMessage($"Uniformly distributed load Name = {distributedLoad.Name}, Value = {distributedLoad.LoadValue.Qy}(N/m) "); double loadStartCoord = Math.Max(distributedLoad.StartCoordinate, 0d); if (loadStartCoord > endCoord) { TraceLogger?.AddMessage($"Load start coordinate {loadStartCoord}(m) is bigger than section end {endCoord}(m), so total load is zero"); - return 0d; + return new ForceTuple(Guid.NewGuid()); } double endCoordByLevel = coordinateByLevelLogic.GetCoordinate(startCoord, endCoord, distributedLoad.RelativeLoadLevel); double loadEndCoord = Math.Min(distributedLoad.EndCoordinate, endCoordByLevel); double loadLength = loadEndCoord - loadStartCoord; TraceLogger?.AddMessage($"Total length L,tot = {loadEndCoord}(m) - {loadStartCoord}(m) = {loadLength}(m)"); - double totalLoad = distributedLoad.LoadValue * distributedLoad.LoadRatio * loadLength; - TraceLogger?.AddMessage($"Total load Q,tot = {distributedLoad.LoadValue}(N/m) * {distributedLoad.LoadRatio} * {loadLength}(m) = {totalLoad}(N)"); + double sumFactor = distributedLoad.LoadRatio * loadLength; + IForceTuple totalLoad = ForceTupleService.MultiplyTupleByFactor(distributedLoad.LoadValue, sumFactor); + TraceLogger?.AddMessage($"Total load Q,tot = {distributedLoad.LoadValue.Qy}(N/m) * {distributedLoad.LoadRatio} * {loadLength}(m) = {totalLoad}(N)"); return totalLoad; } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/SumForceByShearLoadLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/SumForceByShearLoadLogic.cs index 7f167b3..ebe3c38 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/SumForceByShearLoadLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/SumForceByShearLoadLogic.cs @@ -26,13 +26,13 @@ namespace StructureHelperLogics.Models.BeamShears TraceLogger = traceLogger; } - public double GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord) + public IForceTuple GetSumShearForce(IBeamSpanLoad beamShearLoad, double startCoord, double endCoord) { TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Service); if (beamShearLoad is IDistributedLoad distributedLoad) { TraceLogger?.AddMessage($"Load is uniformly distributed load"); - double sumDistributed = GetDistributedLoadSum(distributedLoad, startCoord, endCoord); + IForceTuple sumDistributed = GetDistributedLoadSum(distributedLoad, startCoord, endCoord); return sumDistributed; } else if (beamShearLoad is IConcentratedForce concenratedForce) @@ -46,18 +46,18 @@ namespace StructureHelperLogics.Models.BeamShears } } - private double GetConcentratedForceSum(IConcentratedForce concenratedForce, double startCoord, double endCoord) + private IForceTuple GetConcentratedForceSum(IConcentratedForce concenratedForce, double startCoord, double endCoord) { sumConcentratedForceLogic ??= new SumConcentratedForceLogic(TraceLogger); - double sumForce = sumConcentratedForceLogic.GetSumShearForce(concenratedForce, startCoord, endCoord); + IForceTuple sumForce = sumConcentratedForceLogic.GetSumShearForce(concenratedForce, startCoord, endCoord); TraceLogger?.AddMessage($"Sum of uniformly distributed load Qud = {sumForce}(N)"); return sumForce; } - private double GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord) + private IForceTuple GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord) { sumDistributedLoadLogic ??= new SumDistributedLoadLogic(TraceLogger); - double sumForce = sumDistributedLoadLogic.GetSumShearForce(distributedLoad, startCoord, endCoord); + IForceTuple sumForce = sumDistributedLoadLogic.GetSumShearForce(distributedLoad, startCoord, endCoord); TraceLogger?.AddMessage($"Sum of concentrated force Qcf = {sumForce}(N)"); return sumForce; } diff --git a/StructureHelperTests/UnitTests/BeamShearTests/GetDirectShearForceLogicTests.cs b/StructureHelperTests/UnitTests/BeamShearTests/GetDirectShearForceLogicTests.cs index 1e3e176..2ae2c26 100644 --- a/StructureHelperTests/UnitTests/BeamShearTests/GetDirectShearForceLogicTests.cs +++ b/StructureHelperTests/UnitTests/BeamShearTests/GetDirectShearForceLogicTests.cs @@ -33,7 +33,7 @@ namespace StructureHelperTests.UnitTests.BeamShearTests mockInclinedSection.Setup(i => i.StartCoord).Returns(2.0); mockInclinedSection.Setup(i => i.EndCoord).Returns(5.0); - _mockSummaryForceLogic.Setup(s => s.GetSumShearForce(mockShearLoad.Object, 2.0, 5.0)).Returns(50.0); + _mockSummaryForceLogic.Setup(s => s.GetSumShearForce(mockShearLoad.Object, 2.0, 5.0)).Returns(new ForceTuple() { Qy = 50.0}); _logic = new GetDirectShearForceLogic(mockAxisAction.Object, mockInclinedSection.Object, _mockLogger.Object, _mockSummaryForceLogic.Object); } @@ -43,7 +43,7 @@ namespace StructureHelperTests.UnitTests.BeamShearTests // Arrange // Act - double result = _logic.CalculateShearForce(); + double result = _logic.CalculateShearForce().Qy; // Assert Assert.That(result, Is.EqualTo(150.0)); diff --git a/StructureHelperTests/UnitTests/BeamShearTests/GetShearForceLogicTests.cs b/StructureHelperTests/UnitTests/BeamShearTests/GetShearForceLogicTests.cs index 941b901..6bc2a36 100644 --- a/StructureHelperTests/UnitTests/BeamShearTests/GetShearForceLogicTests.cs +++ b/StructureHelperTests/UnitTests/BeamShearTests/GetShearForceLogicTests.cs @@ -35,10 +35,10 @@ namespace StructureHelperTests.UnitTests.BeamShearTests { // Arrange _mockGetFactorLogic.Setup(f => f.GetFactor()).Returns(1.5); - _mockGetDirectShearForceLogic.Setup(d => d.CalculateShearForce()).Returns(100.0); + _mockGetDirectShearForceLogic.Setup(d => d.CalculateShearForce()).Returns(new ForceTuple() { Qy = 100.0 }); // Act - double result = _logic.GetShearForce(); + double result = _logic.GetShearForce().Qy; // Assert Assert.That(result, Is.EqualTo(150.0)); diff --git a/StructureHelperTests/UnitTests/BeamShearTests/SumConcentratedForceLogicTests.cs b/StructureHelperTests/UnitTests/BeamShearTests/SumConcentratedForceLogicTests.cs index 2ddff52..89cd4b9 100644 --- a/StructureHelperTests/UnitTests/BeamShearTests/SumConcentratedForceLogicTests.cs +++ b/StructureHelperTests/UnitTests/BeamShearTests/SumConcentratedForceLogicTests.cs @@ -28,14 +28,14 @@ namespace StructureHelperTests.UnitTests.BeamShearTests // Arrange var mockConcentratedForce = new Mock(); mockConcentratedForce.Setup(f => f.ForceCoordinate).Returns(3.0); - mockConcentratedForce.Setup(f => f.ForceValue).Returns(100.0); + mockConcentratedForce.Setup(f => f.ForceValue).Returns(new ForceTuple() { Qy = 100.0 }); mockConcentratedForce.Setup(f => f.LoadRatio).Returns(0.8); mockConcentratedForce.Setup(f => f.RelativeLoadLevel).Returns(0.5); _mockCoordinateByLevelLogic.Setup(c => c.GetCoordinate(2.0, 5.0, 0.5)).Returns(3.5); // Act - double result = _logic.GetSumShearForce(mockConcentratedForce.Object, 2.0, 5.0); + double result = _logic.GetSumShearForce(mockConcentratedForce.Object, 2.0, 5.0).Qy; // Assert Assert.That(result, Is.EqualTo(80.0)); @@ -50,7 +50,7 @@ namespace StructureHelperTests.UnitTests.BeamShearTests mockConcentratedForce.Setup(f => f.ForceCoordinate).Returns(6.0); // Act - double result = _logic.GetSumShearForce(mockConcentratedForce.Object, 2.0, 5.0); + double result = _logic.GetSumShearForce(mockConcentratedForce.Object, 2.0, 5.0).Qy; // Assert Assert.That(result, Is.EqualTo(0.0)); diff --git a/StructureHelperTests/UnitTests/BeamShearTests/SumDistributedLoadLogicTests.cs b/StructureHelperTests/UnitTests/BeamShearTests/SumDistributedLoadLogicTests.cs index 846b162..86d37b1 100644 --- a/StructureHelperTests/UnitTests/BeamShearTests/SumDistributedLoadLogicTests.cs +++ b/StructureHelperTests/UnitTests/BeamShearTests/SumDistributedLoadLogicTests.cs @@ -29,14 +29,14 @@ namespace StructureHelperTests.UnitTests.BeamShearTests var mockDistributedLoad = new Mock(); mockDistributedLoad.Setup(d => d.StartCoordinate).Returns(1.0); mockDistributedLoad.Setup(d => d.EndCoordinate).Returns(4.0); - mockDistributedLoad.Setup(d => d.LoadValue).Returns(50.0); + mockDistributedLoad.Setup(d => d.LoadValue).Returns(new ForceTuple() { Qy = 50.0 }); mockDistributedLoad.Setup(d => d.LoadRatio).Returns(0.9); mockDistributedLoad.Setup(d => d.RelativeLoadLevel).Returns(0.5); _mockCoordinateByLevelLogic.Setup(c => c.GetCoordinate(2.0, 5.0, 0.5)).Returns(4.5); // Act - double result = _logic.GetSumShearForce(mockDistributedLoad.Object, 2.0, 5.0); + double result = _logic.GetSumShearForce(mockDistributedLoad.Object, 2.0, 5.0).Qy; // Assert Assert.That(result, Is.EqualTo(135.0)); @@ -51,7 +51,7 @@ namespace StructureHelperTests.UnitTests.BeamShearTests mockDistributedLoad.Setup(d => d.StartCoordinate).Returns(6.0); // Act - double result = _logic.GetSumShearForce(mockDistributedLoad.Object, 2.0, 5.0); + double result = _logic.GetSumShearForce(mockDistributedLoad.Object, 2.0, 5.0).Qy; // Assert Assert.That(result, Is.EqualTo(0.0));