From b81b7a09292c8554067e3e013bcc27985ce64615 Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Sun, 10 Mar 2024 19:20:01 +0500 Subject: [PATCH 01/18] Logics of accidental eccentricity were separated and tested --- .../Libraries/LoaderCalculator.dll | Bin 86016 -> 86016 bytes .../PublishProfiles/FolderProfile.pubxml.user | 2 +- .../Models/Calculators/GenericResult.cs | 15 ++ .../Materials/ConcreteMaterialOptionLogic.cs | 6 +- .../Libraries/Factories/LibMaterialFactory.cs | 2 +- .../Materials/MaterialCommonOptionLogic.cs | 75 ++++++-- .../Materials/ReinforcementByBuilderLogic.cs | 5 +- .../Logics/AccidentalEccentricityLogic.cs | 90 ---------- .../Sections/Logics/ForceTupleCopier.cs | 23 +++ .../Logics/ForceTupleMoveToPointDecorator.cs | 32 ++++ .../Logics/IAccidentalEccentricityLogic.cs | 38 ---- .../Models/Sections/Logics/IHasInputForce.cs | 17 ++ .../Sections/Logics/IProcessorDecorator.cs | 14 ++ .../Models/Sections/Logics/IProcessorLogic.cs | 22 +++ .../Logics/IRcAccEccentricityLogic.cs | 12 ++ .../Logics/IRcEccentricityAxisLogic.cs | 8 + .../Sections/Logics/RcAccEccentricityLogic.cs | 54 ++++++ .../Logics/RcEccentricityAxisLogic.cs | 57 ++++++ .../Sections/Logics/RcEccentricityLogic.cs | 100 +++++++++++ .../Services/Forces/ForceTupleService.cs | 7 - .../Analyses/ByForces/ForceCalculator.cs | 164 +++++------------- .../Buckling/ConcreteBucklingCalculator.cs | 121 +++++++------ .../Buckling/ForceTupleBucklingLogic.cs | 136 +++++++++++++++ .../Buckling/IForceTupleBucklingLogic.cs | 13 ++ .../Buckling/ProcessEccentricity.cs | 57 ++++++ .../RcAccEccentricityAxisTest.cs | 39 +++++ .../Eccentricitis/RcAccEccentricityTest.cs | 43 +++++ .../Eccentricitis/RcEccentricityLogicTest.cs | 58 +++++++ .../MaterialTests/MaterialStrengthTest.cs | 4 +- .../ViewModelTests/GraphViewModelTest.cs | 2 +- 30 files changed, 885 insertions(+), 331 deletions(-) create mode 100644 StructureHelperCommon/Models/Calculators/GenericResult.cs delete mode 100644 StructureHelperCommon/Models/Sections/Logics/AccidentalEccentricityLogic.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/ForceTupleCopier.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/ForceTupleMoveToPointDecorator.cs delete mode 100644 StructureHelperCommon/Models/Sections/Logics/IAccidentalEccentricityLogic.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/IHasInputForce.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/IProcessorDecorator.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/IProcessorLogic.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/IRcAccEccentricityLogic.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/IRcEccentricityAxisLogic.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/RcAccEccentricityLogic.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/RcEccentricityAxisLogic.cs create mode 100644 StructureHelperCommon/Models/Sections/Logics/RcEccentricityLogic.cs create mode 100644 StructureHelperLogics/NdmCalculations/Buckling/ForceTupleBucklingLogic.cs create mode 100644 StructureHelperLogics/NdmCalculations/Buckling/IForceTupleBucklingLogic.cs create mode 100644 StructureHelperLogics/NdmCalculations/Buckling/ProcessEccentricity.cs create mode 100644 StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityAxisTest.cs create mode 100644 StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityTest.cs create mode 100644 StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcEccentricityLogicTest.cs diff --git a/StructureHelper/Libraries/LoaderCalculator.dll b/StructureHelper/Libraries/LoaderCalculator.dll index 7a3289fa0f054162f36e6b065bb2fb231ec10756..cdc1bd5ecae456967ae8d73def90b97860779a03 100644 GIT binary patch delta 29276 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 delta 29333 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 diff --git a/StructureHelper/Properties/PublishProfiles/FolderProfile.pubxml.user b/StructureHelper/Properties/PublishProfiles/FolderProfile.pubxml.user index 7cc792e..3948670 100644 --- a/StructureHelper/Properties/PublishProfiles/FolderProfile.pubxml.user +++ b/StructureHelper/Properties/PublishProfiles/FolderProfile.pubxml.user @@ -4,7 +4,7 @@ https://go.microsoft.com/fwlink/?LinkID=208121. --> - True|2024-02-02T07:22:50.1454015Z;True|2023-02-25T13:37:39.2738786+05:00;False|2023-02-25T13:37:24.0284261+05:00;True|2023-02-25T13:34:01.6858860+05:00;True|2023-02-25T13:31:18.8295711+05:00;False|2023-02-25T13:25:21.5807199+05:00;False|2023-02-25T13:24:41.7164398+05:00; + True|2024-03-10T14:11:27.6834663Z;True|2024-02-02T12:22:50.1454015+05:00;True|2023-02-25T13:37:39.2738786+05:00;False|2023-02-25T13:37:24.0284261+05:00;True|2023-02-25T13:34:01.6858860+05:00;True|2023-02-25T13:31:18.8295711+05:00;False|2023-02-25T13:25:21.5807199+05:00;False|2023-02-25T13:24:41.7164398+05:00; \ No newline at end of file diff --git a/StructureHelperCommon/Models/Calculators/GenericResult.cs b/StructureHelperCommon/Models/Calculators/GenericResult.cs new file mode 100644 index 0000000..c03c6d6 --- /dev/null +++ b/StructureHelperCommon/Models/Calculators/GenericResult.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Calculators +{ + public class GenericResult : IResult + { + public bool IsValid { get; set; } + public string? Description { get; set; } + public T? Value { get; set; } + } +} diff --git a/StructureHelperCommon/Models/Materials/ConcreteMaterialOptionLogic.cs b/StructureHelperCommon/Models/Materials/ConcreteMaterialOptionLogic.cs index 69016d0..d1786ea 100644 --- a/StructureHelperCommon/Models/Materials/ConcreteMaterialOptionLogic.cs +++ b/StructureHelperCommon/Models/Materials/ConcreteMaterialOptionLogic.cs @@ -16,7 +16,7 @@ namespace StructureHelperCommon.Models.Materials { private ConcreteLogicOptions options; private MaterialCommonOptionLogic optionLogic; - private FactorLogic factorLogic; + public ConcreteMaterialOptionLogic(ConcreteLogicOptions options) { @@ -32,10 +32,6 @@ namespace StructureHelperCommon.Models.Materials var concreteOptions = materialOptions as ConcreteOptions; optionLogic = new MaterialCommonOptionLogic(options); optionLogic.SetMaterialOptions(concreteOptions); - factorLogic = new FactorLogic(options.SafetyFactors); - var strength = factorLogic.GetTotalFactor(options.LimitState, options.CalcTerm); - concreteOptions.ExternalFactor.Compressive = strength.Compressive; - concreteOptions.ExternalFactor.Tensile = strength.Tensile; concreteOptions.WorkInTension = options.WorkInTension; concreteOptions.RelativeHumidity = options.RelativeHumidity; concreteOptions.Age = options.Age; diff --git a/StructureHelperCommon/Models/Materials/Libraries/Factories/LibMaterialFactory.cs b/StructureHelperCommon/Models/Materials/Libraries/Factories/LibMaterialFactory.cs index c85cb09..1f31608 100644 --- a/StructureHelperCommon/Models/Materials/Libraries/Factories/LibMaterialFactory.cs +++ b/StructureHelperCommon/Models/Materials/Libraries/Factories/LibMaterialFactory.cs @@ -240,7 +240,7 @@ namespace StructureHelperCommon.Models.Materials.Libraries Code = code, Name = "A400", InitModulus = 2e11d, - MainStrength = 400e6d + MainStrength = 390e6d }, new ReinforcementMaterialEntity(new Guid("045b54b1-0bbf-41fd-a27d-aeb20f600bb4")) { diff --git a/StructureHelperCommon/Models/Materials/MaterialCommonOptionLogic.cs b/StructureHelperCommon/Models/Materials/MaterialCommonOptionLogic.cs index 80097e1..f5b1f7d 100644 --- a/StructureHelperCommon/Models/Materials/MaterialCommonOptionLogic.cs +++ b/StructureHelperCommon/Models/Materials/MaterialCommonOptionLogic.cs @@ -1,12 +1,16 @@ -using StructureHelperCommon.Infrastructures.Enums; +using LoaderCalculator.Data.Materials.MaterialBuilders; +using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Models.Materials.Libraries; using LCMB = LoaderCalculator.Data.Materials.MaterialBuilders; +using SHEnums = StructureHelperCommon.Infrastructures.Enums; namespace StructureHelperCommon.Models.Materials { public class MaterialCommonOptionLogic : IMaterialOptionLogic { private IMaterialLogicOptions options; + private FactorLogic factorLogic; public MaterialCommonOptionLogic(IMaterialLogicOptions options) { @@ -17,6 +21,58 @@ namespace StructureHelperCommon.Models.Materials { materialOptions.InitModulus = options.MaterialEntity.InitModulus; materialOptions.Strength = options.MaterialEntity.MainStrength; + ProcessCodeType(materialOptions); + ProcessLimitState(materialOptions); + ProcessCalcTerm(materialOptions); + ProcessExternalFactors(materialOptions); + } + + private void ProcessExternalFactors(IMaterialOptions materialOptions) + { + factorLogic = new FactorLogic(options.SafetyFactors); + var strength = factorLogic.GetTotalFactor(options.LimitState, options.CalcTerm); + materialOptions.ExternalFactor.Compressive = strength.Compressive; + materialOptions.ExternalFactor.Tensile = strength.Tensile; + } + + private void ProcessCalcTerm(IMaterialOptions materialOptions) + { + if (options.CalcTerm == CalcTerms.ShortTerm) + { + materialOptions.IsShortTerm = true; + } + else if (options.CalcTerm == CalcTerms.LongTerm) + { + materialOptions.IsShortTerm = false; + } + else + { + throw new StructureHelperException(ErrorStrings.LoadTermIsNotValid); + } + } + + private void ProcessLimitState(IMaterialOptions materialOptions) + { + if (options.LimitState == SHEnums.LimitStates.ULS) + { + materialOptions.LimitState = LCMB.LimitStates.Collapse; + } + else if (options.LimitState == SHEnums.LimitStates.SLS) + { + materialOptions.LimitState = LCMB.LimitStates.ServiceAbility; + } + else if (options.LimitState == SHEnums.LimitStates.Special) + { + materialOptions.LimitState = LCMB.LimitStates.Special; + } + else + { + throw new StructureHelperException(ErrorStrings.LimitStatesIsNotValid); + } + } + + private void ProcessCodeType(IMaterialOptions materialOptions) + { if (options.MaterialEntity.CodeType == CodeTypes.EuroCode_2_1990) { materialOptions.CodesType = LCMB.CodesType.EC2_1990; @@ -25,23 +81,10 @@ namespace StructureHelperCommon.Models.Materials { materialOptions.CodesType = LCMB.CodesType.SP63_2018; } - else { throw new StructureHelperException($"{ErrorStrings.ObjectTypeIsUnknown} : {materialOptions.CodesType}"); } - if (options.LimitState == LimitStates.ULS) + else { - materialOptions.LimitState = LCMB.LimitStates.Collapse; + throw new StructureHelperException($"{ErrorStrings.ObjectTypeIsUnknown} : {materialOptions.CodesType}"); } - else if (options.LimitState == LimitStates.SLS) - { - materialOptions.LimitState = LCMB.LimitStates.ServiceAbility; - } - else if (options.LimitState == LimitStates.Special) - { - materialOptions.LimitState = LCMB.LimitStates.Special; - } - else { throw new StructureHelperException(ErrorStrings.LimitStatesIsNotValid); } - if (options.CalcTerm == CalcTerms.ShortTerm) { materialOptions.IsShortTerm = true; } - else if (options.CalcTerm == CalcTerms.LongTerm) { materialOptions.IsShortTerm = false; } - else { throw new StructureHelperException(ErrorStrings.LoadTermIsNotValid); } } } } diff --git a/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs b/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs index 6104cdd..f66f3aa 100644 --- a/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs +++ b/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs @@ -43,7 +43,10 @@ namespace StructureHelperCommon.Models.Materials private void GetLoaderOptions() { - materialOptions = new ReinforcementOptions() { DiagramType = DiagramType}; + materialOptions = new ReinforcementOptions() + { + DiagramType = DiagramType + }; optionLogic = new MaterialCommonOptionLogic(options); optionLogic.SetMaterialOptions(materialOptions); } diff --git a/StructureHelperCommon/Models/Sections/Logics/AccidentalEccentricityLogic.cs b/StructureHelperCommon/Models/Sections/Logics/AccidentalEccentricityLogic.cs deleted file mode 100644 index f90df30..0000000 --- a/StructureHelperCommon/Models/Sections/Logics/AccidentalEccentricityLogic.cs +++ /dev/null @@ -1,90 +0,0 @@ -using StructureHelperCommon.Models.Forces; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -//Copyright (c) 2023 Redikultsev Evgeny, Ekaterinburg, Russia -//All rights reserved. - -namespace StructureHelperCommon.Models.Sections -{ - public class AccidentalEccentricityLogic : IAccidentalEccentricityLogic - { - private double lengthFactor; - private double sizeFactor; - private double minEccentricity; - - public double Length { get; set; } - public double SizeX { get; set; } - public double SizeY { get; set; } - public IForceTuple InitialForceTuple { get; set; } - public IShiftTraceLogger? TraceLogger { get; set; } - public AccidentalEccentricityLogic() - { - lengthFactor = 600d; - sizeFactor = 30d; - minEccentricity = 0.01d; - } - public ForceTuple GetForceTuple() - { - var lengthEccetricity = Length / lengthFactor; - TraceLogger?.AddMessage(string.Format("Accidental eccentricity by length ea = {0} / {1} = {2}", Length, lengthFactor, lengthEccetricity)); - var sizeXEccetricity = SizeX / sizeFactor; - TraceLogger?.AddMessage(string.Format("Accidental eccentricity by SizeX ea ={0} / {1} = {2}", SizeX, sizeFactor, sizeXEccetricity)); - var sizeYEccetricity = SizeY / sizeFactor; - TraceLogger?.AddMessage(string.Format("Accidental eccentricity by SizeY ea ={0} / {1} = {2}", SizeY, sizeFactor, sizeYEccetricity)); - TraceLogger?.AddMessage(string.Format("Minimum accidental eccentricity ea = {0}", minEccentricity)); - var xEccentricity = Math.Abs(InitialForceTuple.My / InitialForceTuple.Nz); - TraceLogger?.AddMessage(string.Format("Actual eccentricity e0,x = {0}", xEccentricity)); - var yEccentricity = Math.Abs(InitialForceTuple.Mx / InitialForceTuple.Nz); - TraceLogger?.AddMessage(string.Format("Actual eccentricity e0,y = {0}", yEccentricity)); - - var xFullEccentricity = new List() - { - lengthEccetricity, - sizeXEccetricity, - minEccentricity, - xEccentricity - } - .Max(); - string mesEx = string.Format("Eccentricity e,x = max({0}; {1}; {2}; {3}) = {4}", - lengthEccetricity, sizeXEccetricity, - minEccentricity, xEccentricity, - xFullEccentricity); - TraceLogger?.AddMessage(mesEx); - var yFullEccentricity = new List() - { - lengthEccetricity, - sizeYEccetricity, - minEccentricity, - yEccentricity - } - .Max(); - string mesEy = string.Format("Eccentricity e,y = max({0}; {1}; {2}; {3}) = {4}", - lengthEccetricity, sizeYEccetricity, - minEccentricity, yEccentricity, - yFullEccentricity); - TraceLogger?.AddMessage(mesEy); - var xSign = InitialForceTuple.Mx == 0d ? -1d : Math.Sign(InitialForceTuple.Mx); - var ySign = InitialForceTuple.My == 0d ? -1d : Math.Sign(InitialForceTuple.My); - var mx = (-1d) * InitialForceTuple.Nz * yFullEccentricity * xSign; - var my = (-1d) * InitialForceTuple.Nz * xFullEccentricity * ySign; - TraceLogger?.AddMessage(string.Format("Bending moment arbitrary X-axis Mx = {0} * {1} = {2}", InitialForceTuple.Nz, yFullEccentricity, mx), TraceLogStatuses.Debug); - TraceLogger?.AddMessage(string.Format("Bending moment arbitrary Y-axis My = {0} * {1} = {2}", InitialForceTuple.Nz, xFullEccentricity, my), TraceLogStatuses.Debug); - - var newTuple = new ForceTuple() - { - Mx = mx, - My = my, - Nz = InitialForceTuple.Nz, - Qx = InitialForceTuple.Qx, - Qy = InitialForceTuple.Qy, - Mz = InitialForceTuple.Mz, - }; - TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(newTuple)); - return newTuple; - } - } -} diff --git a/StructureHelperCommon/Models/Sections/Logics/ForceTupleCopier.cs b/StructureHelperCommon/Models/Sections/Logics/ForceTupleCopier.cs new file mode 100644 index 0000000..d57fbdf --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/ForceTupleCopier.cs @@ -0,0 +1,23 @@ +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Sections.Logics +{ + public class ForceTupleCopier : IProcessorLogic + { + public IForceTuple InputForceTuple { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public ForceTupleCopier(IForceTuple forceTuple) + { + InputForceTuple = forceTuple; + } + public IForceTuple GetValue() + { + return InputForceTuple.Clone() as IForceTuple; + } + } +} diff --git a/StructureHelperCommon/Models/Sections/Logics/ForceTupleMoveToPointDecorator.cs b/StructureHelperCommon/Models/Sections/Logics/ForceTupleMoveToPointDecorator.cs new file mode 100644 index 0000000..eaf8c73 --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/ForceTupleMoveToPointDecorator.cs @@ -0,0 +1,32 @@ +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Shapes; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Sections.Logics +{ + public class ForceTupleMoveToPointDecorator : IProcessorDecorator + { + public IPoint2D Point2D { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + /// + /// Internal source of ForceTuple + /// + public IProcessorLogic ForceTupleLogics { get; } + public ForceTupleMoveToPointDecorator(IProcessorLogic procLogic) + { + ForceTupleLogics = procLogic; + } + public IForceTuple GetValue() + { + ForceTupleLogics.TraceLogger = TraceLogger; + var newTuple = ForceTupleLogics.GetValue(); + newTuple.Mx += newTuple.Nz * Point2D.Y; + newTuple.My -= newTuple.Nz * Point2D.X; + return newTuple; + } + } +} diff --git a/StructureHelperCommon/Models/Sections/Logics/IAccidentalEccentricityLogic.cs b/StructureHelperCommon/Models/Sections/Logics/IAccidentalEccentricityLogic.cs deleted file mode 100644 index 27c9d2c..0000000 --- a/StructureHelperCommon/Models/Sections/Logics/IAccidentalEccentricityLogic.cs +++ /dev/null @@ -1,38 +0,0 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Models.Forces; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelperCommon.Models.Sections -{ - /// - /// Logic for calculating of value of accidental eccentricity - /// - public interface IAccidentalEccentricityLogic : ILogic - { - /// - /// Properties of compressed member - /// - double Length { get;set;} - /// - /// Size of cross-section along X-axis, m - /// - double SizeX { get; set; } - /// - /// Size of cross-section along Y-axis, m - /// - double SizeY { get; set; } - /// - /// Initial tuple of force - /// - IForceTuple InitialForceTuple { get; set; } - /// - /// Returns new force tuple with accidental eccentricity - /// - /// - ForceTuple GetForceTuple(); - } -} diff --git a/StructureHelperCommon/Models/Sections/Logics/IHasInputForce.cs b/StructureHelperCommon/Models/Sections/Logics/IHasInputForce.cs new file mode 100644 index 0000000..03fc403 --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/IHasInputForce.cs @@ -0,0 +1,17 @@ +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Sections.Logics +{ + public interface IHasInputForce + { + /// + /// Initial tuple of force + /// + IForceTuple InputForceTuple { get; set; } + } +} diff --git a/StructureHelperCommon/Models/Sections/Logics/IProcessorDecorator.cs b/StructureHelperCommon/Models/Sections/Logics/IProcessorDecorator.cs new file mode 100644 index 0000000..517aa22 --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/IProcessorDecorator.cs @@ -0,0 +1,14 @@ +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Sections.Logics +{ + public interface IProcessorDecorator : IProcessorLogic + { + IProcessorLogic ForceTupleLogics { get; } + } +} diff --git a/StructureHelperCommon/Models/Sections/Logics/IProcessorLogic.cs b/StructureHelperCommon/Models/Sections/Logics/IProcessorLogic.cs new file mode 100644 index 0000000..cf90cc0 --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/IProcessorLogic.cs @@ -0,0 +1,22 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Sections +{ + /// + /// Logic for calculating of some value + /// + public interface IProcessorLogic : ILogic + { + /// + /// Returns new value + /// + /// + T GetValue(); + } +} diff --git a/StructureHelperCommon/Models/Sections/Logics/IRcAccEccentricityLogic.cs b/StructureHelperCommon/Models/Sections/Logics/IRcAccEccentricityLogic.cs new file mode 100644 index 0000000..4f929af --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/IRcAccEccentricityLogic.cs @@ -0,0 +1,12 @@ +namespace StructureHelperCommon.Models.Sections.Logics +{ + public interface IRcAccEccentricityLogic : IProcessorLogic<(double ex, double ey)> + { + double Length { get; set; } + double SizeX { get; set; } + double SizeY { get; set; } + IShiftTraceLogger? TraceLogger { get; set; } + + (double ex, double ey) GetValue(); + } +} \ No newline at end of file diff --git a/StructureHelperCommon/Models/Sections/Logics/IRcEccentricityAxisLogic.cs b/StructureHelperCommon/Models/Sections/Logics/IRcEccentricityAxisLogic.cs new file mode 100644 index 0000000..9c8695d --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/IRcEccentricityAxisLogic.cs @@ -0,0 +1,8 @@ +namespace StructureHelperCommon.Models.Sections.Logics +{ + public interface IRcEccentricityAxisLogic : IProcessorLogic + { + double Length { get; set; } + double Size { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperCommon/Models/Sections/Logics/RcAccEccentricityLogic.cs b/StructureHelperCommon/Models/Sections/Logics/RcAccEccentricityLogic.cs new file mode 100644 index 0000000..5db7f39 --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/RcAccEccentricityLogic.cs @@ -0,0 +1,54 @@ +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +//Copyright (c) 2023 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace StructureHelperCommon.Models.Sections.Logics +{ + public class RcAccEccentricityLogic : IRcAccEccentricityLogic + { + private const string accEccMessage = "Accidental eccentricity along {0}-axis"; + /// + /// Properties of compressed member + /// + public double Length { get; set; } + /// + /// Size of cross-section along X-axis, m + /// + public double SizeX { get; set; } + /// + /// Size of cross-section along Y-axis, m + /// + public double SizeY { get; set; } + /// + public IShiftTraceLogger? TraceLogger { get; set; } + private IRcEccentricityAxisLogic eccentricityLogic; + public RcAccEccentricityLogic(IRcEccentricityAxisLogic eccentricityLogic) + { + this.eccentricityLogic = eccentricityLogic; + } + public RcAccEccentricityLogic() : this(new RcEccentricityAxisLogic()) + { + + } + public (double ex, double ey) GetValue() + { + eccentricityLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50); + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); + TraceLogger?.AddMessage(string.Format(accEccMessage, "x")); + eccentricityLogic.Length = Length; + eccentricityLogic.Size = SizeX; + var xFullEccentricity = eccentricityLogic.GetValue(); + TraceLogger?.AddMessage(string.Format(accEccMessage, "y")); + eccentricityLogic.Size = SizeY; + var yFullEccentricity = eccentricityLogic.GetValue(); + return (xFullEccentricity, yFullEccentricity); + } + } +} diff --git a/StructureHelperCommon/Models/Sections/Logics/RcEccentricityAxisLogic.cs b/StructureHelperCommon/Models/Sections/Logics/RcEccentricityAxisLogic.cs new file mode 100644 index 0000000..30e581e --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/RcEccentricityAxisLogic.cs @@ -0,0 +1,57 @@ +using StructureHelperCommon.Models.Loggers; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Sections.Logics +{ + public class RcEccentricityAxisLogic : IRcEccentricityAxisLogic + { + private readonly double lengthFactor; + private readonly double sizeFactor; + private readonly double minEccentricity; + + /// + /// Properties of compressed member + /// + public double Length { get; set; } + /// + /// Size of cross-section along X-axis, m + /// + public double Size { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public RcEccentricityAxisLogic() + { + lengthFactor = 600d; + sizeFactor = 30d; + minEccentricity = 0.01d; + } + public double GetValue() + { + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); + var lengthEccetricity = Length / lengthFactor; + TraceLogger?.AddMessage(string.Format("Length of member = {0}(m)", Length)); + TraceLogger?.AddMessage(string.Format("Accidental eccentricity by length e,a = {0}(m) / {1} = {2}(m)", Length, lengthFactor, lengthEccetricity)); + TraceLogger?.AddMessage(string.Format("Size of cross-section of member = {0}(m)", Size)); + var sizeXEccetricity = Size / sizeFactor; + TraceLogger?.AddMessage(string.Format("Accidental eccentricity by size e,a ={0}(m) / {1} = {2}(m)", Size, sizeFactor, sizeXEccetricity)); ; + TraceLogger?.AddMessage(string.Format("In any case, minimum accidental eccentricity e,a = {0}(m)", minEccentricity)); + + var fullEccentricity = new List() + { + lengthEccetricity, + sizeXEccetricity, + minEccentricity, + } + .Max(); + string mesEcc = string.Format("Maximum accidental eccentricity e,a = max({0}(m); {1}(m); {2}(m)) = {3}(m)", + lengthEccetricity, sizeXEccetricity, + minEccentricity, + fullEccentricity); + TraceLogger?.AddMessage(mesEcc); + return fullEccentricity; + } + } +} diff --git a/StructureHelperCommon/Models/Sections/Logics/RcEccentricityLogic.cs b/StructureHelperCommon/Models/Sections/Logics/RcEccentricityLogic.cs new file mode 100644 index 0000000..1743674 --- /dev/null +++ b/StructureHelperCommon/Models/Sections/Logics/RcEccentricityLogic.cs @@ -0,0 +1,100 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Sections.Logics; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +//Copyright (c) 2023 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace StructureHelperCommon.Models.Sections +{ + public class RcEccentricityLogic : IProcessorLogic, IHasInputForce + { + private const string fstAxisName = "x"; + private const string sndAxisName = "y"; + private const string actualEccMessage = "Actual eccentricity e0,{0} = {1}(m)"; + private const string maxEccentricityMessage = "Eccentricity e,{0} = max({1}(m); {2}(m)) = {3}(m)"; + private const string OutPutBendingMomentMessage = "Bending moment arbitrary {0}-axis M{0} = Nz * e,{0} = {1}(N) * {2}(m) = {3}(N*m)"; + + /// + /// Properties of compressed member + /// + public double Length { get; set; } + /// + /// Size of cross-section along X-axis, m + /// + public double SizeX { get; set; } + /// + /// Size of cross-section along Y-axis, m + /// + public double SizeY { get; set; } + /// + public IForceTuple? InputForceTuple { get; set; } + /// + public IShiftTraceLogger? TraceLogger { get; set; } + public IRcAccEccentricityLogic EccentricityLogic { get; private set; } + + public RcEccentricityLogic(IRcAccEccentricityLogic eccentricityLogic) + { + EccentricityLogic = eccentricityLogic; + } + + public RcEccentricityLogic() : this(new RcAccEccentricityLogic()) + { + + } + + public IForceTuple GetValue() + { + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); + if (InputForceTuple is null) + { + string errorString = ErrorStrings.NullReference + $": {nameof(InputForceTuple)}"; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + + EccentricityLogic.Length = Length; + EccentricityLogic.SizeX = SizeX; + EccentricityLogic.SizeY = SizeY; + EccentricityLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50); + + var (ex, ey) = EccentricityLogic.GetValue(); + + var xEccentricity = Math.Abs(InputForceTuple.My / InputForceTuple.Nz); + TraceLogger?.AddMessage(string.Format(actualEccMessage, fstAxisName, xEccentricity)); + var yEccentricity = Math.Abs(InputForceTuple.Mx / InputForceTuple.Nz); + TraceLogger?.AddMessage(string.Format(actualEccMessage, sndAxisName, yEccentricity)); + + var xFullEccentricity = Math.Max(ex, xEccentricity); + var yFullEccentricity = Math.Max(ey, yEccentricity); + string mesEx = string.Format(maxEccentricityMessage, fstAxisName, ex, xEccentricity, xFullEccentricity); + TraceLogger?.AddMessage(mesEx); + string mesEy = string.Format(maxEccentricityMessage, sndAxisName, ey, yEccentricity, yFullEccentricity); + TraceLogger?.AddMessage(mesEy); + var xSign = InputForceTuple.Mx == 0d ? -1d : Math.Sign(InputForceTuple.Mx); + var ySign = InputForceTuple.My == 0d ? -1d : Math.Sign(InputForceTuple.My); + var mx = (-1d) * InputForceTuple.Nz * yFullEccentricity * xSign; + var my = (-1d) * InputForceTuple.Nz * xFullEccentricity * ySign; + TraceLogger?.AddMessage(string.Format(OutPutBendingMomentMessage, fstAxisName, InputForceTuple.Nz, yFullEccentricity, mx), TraceLogStatuses.Debug); + TraceLogger?.AddMessage(string.Format(OutPutBendingMomentMessage, sndAxisName, InputForceTuple.Nz, xFullEccentricity, my), TraceLogStatuses.Debug); + + var newTuple = new ForceTuple() + { + Mx = mx, + My = my, + Nz = InputForceTuple.Nz, + Qx = InputForceTuple.Qx, + Qy = InputForceTuple.Qy, + Mz = InputForceTuple.Mz, + }; + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(newTuple)); + return newTuple; + } + } +} diff --git a/StructureHelperCommon/Services/Forces/ForceTupleService.cs b/StructureHelperCommon/Services/Forces/ForceTupleService.cs index ab74200..2e51453 100644 --- a/StructureHelperCommon/Services/Forces/ForceTupleService.cs +++ b/StructureHelperCommon/Services/Forces/ForceTupleService.cs @@ -20,13 +20,6 @@ namespace StructureHelperCommon.Services.Forces target.Clear(); SumTupleToTarget(source, target, factor); } - public static IForceTuple MoveTupleIntoPoint(IForceTuple forceTuple, IPoint2D point2D) - { - var newTuple = forceTuple.Clone() as IForceTuple; - newTuple.Mx += newTuple.Nz * point2D.Y; - newTuple.My -= newTuple.Nz * point2D.X; - return newTuple; - } public static IForceTuple SumTuples(IForceTuple first, IForceTuple second, double factor = 1d) { CheckTuples(first, second); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs index 93e7fc2..55d40ac 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs @@ -4,13 +4,16 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; using StructureHelperCommon.Models.Sections; +using StructureHelperCommon.Models.Sections.Logics; using StructureHelperCommon.Models.Shapes; using StructureHelperCommon.Services.Forces; using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics; using StructureHelperLogics.NdmCalculations.Buckling; using StructureHelperLogics.NdmCalculations.Primitives; using StructureHelperLogics.Services.NdmPrimitives; +using System; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { @@ -19,6 +22,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces static readonly ForceCalculatorUpdateStrategy updateStrategy = new(); private readonly IForceTupleCalculator forceTupleCalculator; private ForcesResults result; + private IProcessorLogic eccentricityLogic; + private ForceTupleBucklingLogic bucklingLogic; public string Name { get; set; } public List LimitStatesList { get; private set; } @@ -34,6 +39,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public void Run() { + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); var checkResult = CheckInputData(); if (checkResult != "") { @@ -95,13 +101,14 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces CalcTerms calcTerm = tuple.CalcTerm; var ndms = NdmPrimitivesService.GetNdms(Primitives, limitState, calcTerm); IPoint2D point2D; + IProcessorLogic forcelogic = new ForceTupleCopier(tuple.ForceTuple); if (combination.SetInGravityCenter == true) { var (Cx, Cy) = LoaderCalculator.Logics.Geometry.GeometryOperations.GetGravityCenter(ndms); - point2D = new Point2D(){ X = Cx, Y = Cy }; + point2D = new Point2D() { X = Cx, Y = Cy }; + forcelogic = new ForceTupleMoveToPointDecorator(forcelogic) { Point2D = point2D}; } - else point2D = combination.ForcePoint; - var newTuple = ForceTupleService.MoveTupleIntoPoint(tuple.ForceTuple, point2D); + var newTuple = forcelogic.GetValue(); TraceLogger?.AddMessage($"Input force combination"); TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(newTuple)); if (CompressedMember.Buckling == true) @@ -109,27 +116,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces if (newTuple.Nz >= 0d) { TraceLogger?.AddMessage(string.Format("Second order effect is not considered as Nz={0} >= 0", newTuple.Nz)); + tupleResult = GetForceResult(limitState, calcTerm, ndms, newTuple); } else { - TraceLogger?.AddMessage("Get eccentricity for full load"); - newTuple = ProcessAccEccentricity(ndms, newTuple); - var buckResult = GetForceTupleByBuckling(combination, limitState, calcTerm, ndms, newTuple); - if (buckResult.isValid == true) - { - newTuple = buckResult.tuple; - } - else - { - return new ForcesTupleResult() - { - IsValid = false, - DesignForceTuple = tuple, - Description = buckResult.description, - }; - } - } - tupleResult = GetForceResult(limitState, calcTerm, ndms, newTuple); + tupleResult = ProcessCompressedMember(combination, tuple, ndms, newTuple); + } } else { @@ -143,10 +135,19 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces return tupleResult; } - private (bool isValid, IForceTuple tuple, string description) GetForceTupleByBuckling(IForceCombinationList combination, LimitStates limitState, CalcTerms calcTerm, List ndms, IForceTuple newTuple) + private IForcesTupleResult ProcessCompressedMember(IForceCombinationList combination, IDesignForceTuple tuple, List ndms, IForceTuple newTuple) { - var tuple = newTuple.Clone() as IForceTuple; - var inputData = new BucklingInputData() + IForcesTupleResult tupleResult; + LimitStates limitState = tuple.LimitState; + CalcTerms calcTerm = tuple.CalcTerm; + + TraceLogger?.AddMessage("Get eccentricity for full load"); + eccentricityLogic = new ProcessEccentricity(CompressedMember, ndms, newTuple) + { + TraceLogger = TraceLogger ?? null + }; + newTuple = eccentricityLogic.GetValue(); + var buclingInputData = new BucklingInputData() { Combination = combination, LimitState = limitState, @@ -154,117 +155,42 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces Ndms = ndms, ForceTuple = newTuple }; - var bucklingResult = ProcessBuckling(inputData); - - if (bucklingResult.IsValid != true) + bucklingLogic = new ForceTupleBucklingLogic(buclingInputData) { - TraceLogger?.AddMessage(bucklingResult.Description, TraceLogStatuses.Error); - return (false, tuple, $"Buckling result:\n{bucklingResult.Description}"); + CompressedMember = CompressedMember, + Accuracy = Accuracy, + Primitives = Primitives, + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + var buckResult = bucklingLogic.GetForceTupleByBuckling(); + if (buckResult.IsValid == true) + { + newTuple = buckResult.Value; } else { - tuple = CalculateBuckling(tuple, bucklingResult); - TraceLogger?.AddMessage(string.Intern("Force combination with considering of second order effects")); - TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tuple)); + return new ForcesTupleResult() + { + IsValid = false, + DesignForceTuple = tuple, + Description = buckResult.Description, + }; } - - return (true, tuple, string.Empty); + TraceLogger?.AddMessage(string.Intern("Result of second order was obtained succesfully, new force combination was obtained")); + tupleResult = GetForceResult(limitState, calcTerm, ndms, newTuple); + return tupleResult; } private IForcesTupleResult GetForceResult(LimitStates limitState, CalcTerms calcTerm, List ndms, IForceTuple newTuple) { + TraceLogger?.AddMessage("Calculation of cross-section is started"); var tupleResult = GetPrimitiveStrainMatrix(ndms, newTuple, Accuracy); tupleResult.DesignForceTuple.LimitState = limitState; tupleResult.DesignForceTuple.CalcTerm = calcTerm; tupleResult.DesignForceTuple.ForceTuple = newTuple; return tupleResult; - } - private IForceTuple ProcessAccEccentricity(List ndms, IForceTuple tuple) - { - var newTuple = tuple.Clone() as IForceTuple; - var accLogic = new AccidentalEccentricityLogic() - { - Length = CompressedMember.GeometryLength, - SizeX = ndms.Max(x => x.CenterX) - ndms.Min(x => x.CenterX), - SizeY = ndms.Max(x => x.CenterY) - ndms.Min(x => x.CenterY), - InitialForceTuple = newTuple, - }; - if (TraceLogger is not null) - { - accLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); - } - newTuple = accLogic.GetForceTuple(); - return newTuple; - } - - private IConcreteBucklingResult ProcessBuckling(BucklingInputData inputData) - { - IForceTuple resultTuple; - IForceTuple longTuple; - if (inputData.CalcTerm == CalcTerms.LongTerm) - { - longTuple = inputData.ForceTuple; - } - else - { - longTuple = GetLongTuple(inputData.Combination.DesignForces, inputData.LimitState); - } - TraceLogger?.AddMessage("Get eccentricity for long term load"); - longTuple = ProcessAccEccentricity(inputData.Ndms, longTuple); - var bucklingCalculator = GetBucklingCalculator(CompressedMember, inputData.LimitState, inputData.CalcTerm, inputData.ForceTuple, longTuple); - if (TraceLogger is not null) - { - bucklingCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); - } - bucklingCalculator.Run(); - var bucklingResult = bucklingCalculator.Result as IConcreteBucklingResult; - - return bucklingResult; - } - - private IForceTuple GetLongTuple(List designForces, LimitStates limitState) - { - IForceTuple longTuple; - try - { - longTuple = designForces - .Where(x => x.LimitState == limitState & x.CalcTerm == CalcTerms.LongTerm) - .Single() - .ForceTuple; - } - catch (Exception) - { - longTuple = new ForceTuple(); - } - return longTuple; - } - - private IConcreteBucklingCalculator GetBucklingCalculator(ICompressedMember compressedMember, LimitStates limitStates, CalcTerms calcTerms, IForceTuple calcTuple, IForceTuple longTuple) - { - var options = new ConcreteBucklingOptions() - { - CompressedMember = compressedMember, - LimitState = limitStates, - CalcTerm = calcTerms, - CalcForceTuple = calcTuple, - LongTermTuple = longTuple, - Primitives = Primitives - }; - var bucklingCalculator = new ConcreteBucklingCalculator(options, Accuracy); - return bucklingCalculator; - } - - private ForceTuple CalculateBuckling(IForceTuple calcTuple, IConcreteBucklingResult bucklingResult) - { - var newTuple = calcTuple.Clone() as ForceTuple; - newTuple.Mx *= bucklingResult.EtaFactorAlongY; - newTuple.My *= bucklingResult.EtaFactorAlongX; - return newTuple; - } - - private string CheckInputData() { string result = ""; diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs index a0b557a..e9e1cc5 100644 --- a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs @@ -57,6 +57,66 @@ namespace StructureHelperLogics.NdmCalculations.Buckling otherNdms = ndmCollection.Except(concreteNdms).ToList(); } + public void Run() + { + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); + TraceLogger?.AddMessage(LoggerStrings.MethodBasedOn + "SP63.13330.2018"); + var checkResult = CheckInputData(); + if (checkResult != "") + { + ProcessFalseResult(checkResult); + return; + } + else + { + ProcessValidResult(); + } + TraceLogger?.AddMessage(LoggerStrings.CalculationHasDone); + } + + private void ProcessValidResult() + { + var phiLLogic = GetPhiLogic(); + var (DeltaLogicAboutX, DeltaLogicAboutY) = GetDeltaLogics(); + stiffnessLogicX = new RCStiffnessLogicSP63(phiLLogic, DeltaLogicAboutX); + stiffnessLogicY = new RCStiffnessLogicSP63(phiLLogic, DeltaLogicAboutY); + if (TraceLogger is not null) + { + stiffnessLogicX.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + stiffnessLogicY.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + } + criticalForceLogic = new EilerCriticalForceLogic(); + if (TraceLogger is not null) + { + criticalForceLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + } + + var (EtaFactorX, EtaFactorY) = GetBucklingCoefficients(); + var messageString = "Eta factor orbitrary {0} axis, Eta{0} = {1} (dimensionless)"; + var messageStringX = string.Format(messageString, "X", EtaFactorX); + var messageStringY = string.Format(messageString, "Y", EtaFactorY); + TraceLogger?.AddMessage(messageStringX); + TraceLogger?.AddMessage(messageStringY); + Result = new ConcreteBucklingResult() + { + IsValid = true, + EtaFactorAlongX = EtaFactorX, + EtaFactorAlongY = EtaFactorY + }; + } + + private void ProcessFalseResult(string checkResult) + { + TraceLogger?.AddMessage(checkResult, TraceLogStatuses.Error); + Result = new ConcreteBucklingResult() + { + IsValid = false, + Description = checkResult, + EtaFactorAlongX = double.PositiveInfinity, + EtaFactorAlongY = double.PositiveInfinity + }; + } + private (IConcreteDeltaELogic DeltaLogicX, IConcreteDeltaELogic DeltaLogicY) GetDeltaLogics() { IForceTuple forceTuple = options.CalcForceTuple; @@ -66,6 +126,15 @@ namespace StructureHelperLogics.NdmCalculations.Buckling } var eccentricityAlongX = options.CalcForceTuple.My / forceTuple.Nz; var eccentricityAlongY = options.CalcForceTuple.Mx / forceTuple.Nz; + const string eccMesssage = "Eccentricity along {0}-axis e{0} = {1}(N * m) / {2}(N) = {3}(m)"; + TraceLogger?.AddMessage(string.Format(eccMesssage, + "x", + options.CalcForceTuple.My, forceTuple.Nz, + eccentricityAlongX)); + TraceLogger?.AddMessage(string.Format(eccMesssage, + "y", + options.CalcForceTuple.Mx, forceTuple.Nz, + eccentricityAlongY)); var sizeAlongX = ndmCollection.Max(x => x.CenterX) - ndmCollection.Min(x => x.CenterX); var sizeAlongY = ndmCollection.Max(x => x.CenterY) - ndmCollection.Min(x => x.CenterY); var DeltaElogicAboutX = new DeltaELogicSP63(eccentricityAlongY, sizeAlongY); @@ -82,7 +151,7 @@ namespace StructureHelperLogics.NdmCalculations.Buckling { const string sumStif = "Summary stiffness"; var gravityCenter = GeometryOperations.GetGravityCenter(ndmCollection); - string message = string.Format("Gravity center, x = {0}, y = {1}", gravityCenter.Cx, gravityCenter.Cy); + string message = string.Format("Gravity center, x = {0}(m), y = {1}(m)", gravityCenter.Cx, gravityCenter.Cy); TraceLogger?.AddMessage(message); if (TraceLogger is not null) { @@ -152,55 +221,7 @@ namespace StructureHelperLogics.NdmCalculations.Buckling return calculator; } - public void Run() - { - TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); - TraceLogger?.AddMessage(LoggerStrings.MethodBasedOn + "SP63.13330.2018"); - var checkResult = CheckInputData(); - if (checkResult != "") - { - TraceLogger?.AddMessage(checkResult, TraceLogStatuses.Error); - Result = new ConcreteBucklingResult() - { - IsValid = false, - Description = checkResult, - EtaFactorAlongX = double.PositiveInfinity, - EtaFactorAlongY = double.PositiveInfinity - }; - return; - } - else - { - var phiLLogic = GetPhiLogic(); - var (DeltaLogicAboutX, DeltaLogicAboutY) = GetDeltaLogics(); - stiffnessLogicX = new RCStiffnessLogicSP63(phiLLogic, DeltaLogicAboutX); - stiffnessLogicY = new RCStiffnessLogicSP63(phiLLogic, DeltaLogicAboutY); - if (TraceLogger is not null) - { - stiffnessLogicX.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); - stiffnessLogicY.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); - } - criticalForceLogic = new EilerCriticalForceLogic(); - if (TraceLogger is not null) - { - criticalForceLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); - } - - var (EtaFactorX, EtaFactorY) = GetBucklingCoefficients(); - var messageString = "Eta factor orbitrary {0} axis, Eta{0} = {1} (dimensionless)"; - var messageStringX = string.Format(messageString, "X", EtaFactorX); - var messageStringY = string.Format(messageString, "Y", EtaFactorY); - TraceLogger?.AddMessage(messageStringX); - TraceLogger?.AddMessage(messageStringY); - Result = new ConcreteBucklingResult() - { - IsValid = true, - EtaFactorAlongX = EtaFactorX, - EtaFactorAlongY = EtaFactorY - }; - } - TraceLogger?.AddMessage(LoggerStrings.CalculationHasDone); - } + private string CheckInputData() { diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ForceTupleBucklingLogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/ForceTupleBucklingLogic.cs new file mode 100644 index 0000000..e3e0d09 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/ForceTupleBucklingLogic.cs @@ -0,0 +1,136 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using StructureHelperCommon.Models.Sections; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperCommon.Models.Loggers; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public class ForceTupleBucklingLogic : IForceTupleBucklingLogic + { + private IProcessorLogic eccentricityLogic; + private BucklingInputData bucklingInputData; + + public ICompressedMember CompressedMember { get; set; } + public IAccuracy Accuracy { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public IEnumerable Primitives { get; set; } + + public ForceTupleBucklingLogic(BucklingInputData inputData) + { + bucklingInputData = inputData; + } + + public GenericResult GetForceTupleByBuckling() + { + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); + + var tuple = bucklingInputData.ForceTuple.Clone() as IForceTuple; + + var bucklingResult = ProcessBuckling(bucklingInputData); + + if (bucklingResult.IsValid != true) + { + TraceLogger?.AddMessage(bucklingResult.Description, TraceLogStatuses.Error); + var tupleResult = new GenericResult() + { + IsValid = false, + Description = $"Buckling result:\n{bucklingResult.Description}", + Value = tuple + }; + return tupleResult; + } + else + { + tuple = CalculateBuckling(tuple, bucklingResult); + TraceLogger?.AddMessage(string.Intern("Force combination with considering of second order effects")); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tuple)); + } + var trueTupleResult = new GenericResult() + { + IsValid = true, + Description = string.Empty, + Value = tuple + }; + return trueTupleResult; + } + + private IConcreteBucklingResult ProcessBuckling(BucklingInputData inputData) + { + IForceTuple resultTuple; + IForceTuple longTuple; + if (inputData.CalcTerm == CalcTerms.LongTerm) + { + longTuple = inputData.ForceTuple; + } + else + { + longTuple = GetLongTuple(inputData.Combination.DesignForces, inputData.LimitState); + } + TraceLogger?.AddMessage("Get eccentricity for long term load"); + eccentricityLogic = new ProcessEccentricity(CompressedMember, inputData.Ndms, longTuple) + { + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + longTuple = eccentricityLogic.GetValue(); + var bucklingCalculator = GetBucklingCalculator(inputData.LimitState, inputData.CalcTerm, inputData.ForceTuple, longTuple); + if (TraceLogger is not null) + { + bucklingCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + } + bucklingCalculator.Run(); + var bucklingResult = bucklingCalculator.Result as IConcreteBucklingResult; + + return bucklingResult; + } + + private IForceTuple GetLongTuple(List designForces, LimitStates limitState) + { + IForceTuple longTuple; + try + { + longTuple = designForces + .Where(x => x.LimitState == limitState & x.CalcTerm == CalcTerms.LongTerm) + .Single() + .ForceTuple; + } + catch (Exception) + { + longTuple = new ForceTuple(); + } + return longTuple; + } + + private IConcreteBucklingCalculator GetBucklingCalculator(LimitStates limitStates, CalcTerms calcTerms, IForceTuple calcTuple, IForceTuple longTuple) + { + var options = new ConcreteBucklingOptions() + { + CompressedMember = CompressedMember, + LimitState = limitStates, + CalcTerm = calcTerms, + CalcForceTuple = calcTuple, + LongTermTuple = longTuple, + Primitives = Primitives + }; + var bucklingCalculator = new ConcreteBucklingCalculator(options, Accuracy); + return bucklingCalculator; + } + + private ForceTuple CalculateBuckling(IForceTuple calcTuple, IConcreteBucklingResult bucklingResult) + { + var newTuple = calcTuple.Clone() as ForceTuple; + newTuple.Mx *= bucklingResult.EtaFactorAlongY; + newTuple.My *= bucklingResult.EtaFactorAlongX; + return newTuple; + } + + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IForceTupleBucklingLogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/IForceTupleBucklingLogic.cs new file mode 100644 index 0000000..2fcd9f8 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IForceTupleBucklingLogic.cs @@ -0,0 +1,13 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public interface IForceTupleBucklingLogic : ILogic + { + GenericResult GetForceTupleByBuckling(); + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ProcessEccentricity.cs b/StructureHelperLogics/NdmCalculations/Buckling/ProcessEccentricity.cs new file mode 100644 index 0000000..8932242 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/ProcessEccentricity.cs @@ -0,0 +1,57 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Sections; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using StructureHelperCommon.Models.Loggers; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public class ProcessEccentricity : IProcessorLogic + { + private IProcessorLogic eccentricityLogic; + + public ICompressedMember CompressedMember { get; private set; } + public IEnumerable Ndms { get; private set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public IForceTuple InputForceTuple { get; set; } + + private double sizeX; + private double sizeY; + + public ProcessEccentricity(IProcessorLogic eccentricityLogic) + { + this.eccentricityLogic = eccentricityLogic; + } + public ProcessEccentricity(ICompressedMember compressedMember, IEnumerable ndms, IForceTuple initialForceTuple) + { + CompressedMember = compressedMember; + Ndms = ndms; + InputForceTuple = initialForceTuple; + sizeX = ndms.Max(x => x.CenterX) - ndms.Min(x => x.CenterX); + sizeY = ndms.Max(x => x.CenterY) - ndms.Min(x => x.CenterY); + eccentricityLogic = new RcEccentricityLogic() + { + InputForceTuple = InputForceTuple, + Length = CompressedMember.GeometryLength, + SizeX = sizeX, + SizeY = sizeY, + }; + } + + public IForceTuple GetValue() + { + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); + TraceLogger?.AddMessage("Get eccentricity taking into account accidental eccentricity"); + TraceLogger?.AddMessage(string.Format("Cross-section size along x-axis dx = {0}, along y-axis dy = {1}", sizeX, sizeY)); + + eccentricityLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50); + var newTuple = eccentricityLogic.GetValue(); + return newTuple; + } + } +} diff --git a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityAxisTest.cs b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityAxisTest.cs new file mode 100644 index 0000000..1691ca2 --- /dev/null +++ b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityAxisTest.cs @@ -0,0 +1,39 @@ +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Models.Sections.Logics; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperTests.FunctionalTests.RCs.Eccentricitis +{ + public class RcEccentricityAxisLogicTests + { + [TestCase(12d, 0.2d, 0.02d)] + [TestCase(3d, 0.9d, 0.03d)] + [TestCase(2, 0.2d, 0.01d)] + public void GetValue_ShouldCalculateCorrectly(double length, double size, double expectedEccentricity) + { + // Arrange + var loggerMock = new Mock(); + + var rcEccentricityAxisLogic = new RcEccentricityAxisLogic + { + Length = length, + Size = size, + TraceLogger = loggerMock.Object, + }; + + // Act + var result = rcEccentricityAxisLogic.GetValue(); + + // Assert + //loggerMock.Verify(logger => logger.AddMessage(It.IsAny(), It.IsAny()), Times.Exactly(7)); // Adjust based on your actual calls + Assert.AreEqual(expectedEccentricity, result, 0.0001); // Adjust based on your expected result + // Add more assertions based on your expected behavior + } + } +} diff --git a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityTest.cs b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityTest.cs new file mode 100644 index 0000000..673a002 --- /dev/null +++ b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcAccEccentricityTest.cs @@ -0,0 +1,43 @@ +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Models.Sections.Logics; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperTests.FunctionalTests.RCs.Eccentricitis +{ + public class RcAccEccentricityLogicTests + { + [Test] + public void GetValue_ShouldCalculateCorrectly() + { + // Arrange + var eccentricityAxisLogicMock = new Mock(); + eccentricityAxisLogicMock.Setup(el => el.GetValue()).Returns(3.0); // Adjust based on your expected result + + var loggerMock = new Mock(); + + var rcAccEccentricityLogic = new RcAccEccentricityLogic(eccentricityAxisLogicMock.Object) + { + Length = 100.0, + SizeX = 5.0, + SizeY = 10.0, + TraceLogger = loggerMock.Object, + }; + + // Act + var result = rcAccEccentricityLogic.GetValue(); + + // Assert + eccentricityAxisLogicMock.Verify(el => el.GetValue(), Times.Exactly(2)); + //loggerMock.Verify(logger => logger.AddMessage(It.IsAny(), It.IsAny()), Times.Exactly(3)); // Adjust based on your actual calls + Assert.AreEqual(3.0, result.ex, 0.001); // Adjust based on your expected result + Assert.AreEqual(3.0, result.ey, 0.001); // Adjust based on your expected result + // Add more assertions based on your expected behavior + } + } +} diff --git a/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcEccentricityLogicTest.cs b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcEccentricityLogicTest.cs new file mode 100644 index 0000000..bef8dcd --- /dev/null +++ b/StructureHelperTests/FunctionalTests/RCs/Eccentricitis/RcEccentricityLogicTest.cs @@ -0,0 +1,58 @@ +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Sections.Logics; +using StructureHelperCommon.Models.Sections; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperTests.FunctionalTests.RCs.Eccentricitis +{ + public class RcEccentricityLogicTests + { + [TestCase(30, 1.0, 2.0, -60, -30)] + [TestCase(30, 2.0, 1.0, -30, -60)] + public void GetValue_ShouldCalculateCorrectly(double nz, double ex, double ey, double expectedMx, double expectedMy) + { + // Arrange + var inputForceTuple = new ForceTuple + { + Mx = 10, + My = 20, + Nz = nz, + Qx = 40.0, + Qy = 50.0, + Mz = 60.0, + }; + + var eccentricityLogicMock = new Mock(); + eccentricityLogicMock.Setup(el => el.GetValue()).Returns((ex, ey)); + + var loggerMock = new Mock(); + + var rcEccentricityLogic = new RcEccentricityLogic(eccentricityLogicMock.Object) + { + Length = 100.0, + SizeX = 5.0, + SizeY = 10.0, + InputForceTuple = inputForceTuple, + TraceLogger = loggerMock.Object, + }; + + // Act + var result = rcEccentricityLogic.GetValue(); + + // Assert + eccentricityLogicMock.Verify(el => el.GetValue(), Times.Once); + //loggerMock.Verify(logger => logger.AddMessage(It.IsAny(), It.IsAny()), Times.Exactly(6)); // Adjust based on your actual calls + //loggerMock.Verify(logger => logger.AddEntry(It.IsAny()), Times.Once); // Adjust based on your actual calls + Assert.AreEqual(expectedMx, result.Mx, 0.001); // Adjust based on your expected result + Assert.AreEqual(expectedMy, result.My, 0.001); // Adjust based on your expected result + // Add more assertions based on your expected behavior + } + } +} diff --git a/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs b/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs index 9f5078d..86b8db4 100644 --- a/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs +++ b/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs @@ -7,8 +7,8 @@ namespace StructureHelperTests.UnitTests.MaterialTests { public class MaterialStrengthTest { - [TestCase(HeadmaterialType.Reinforcement400, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.ShortTerm, 347826086.95652175d, 347826086.95652175d)] - [TestCase(HeadmaterialType.Reinforcement400, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 400000000d, 400000000d)] + [TestCase(HeadmaterialType.Reinforcement400, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.ShortTerm, 339130434.78260875d, 339130434.78260875d)] + [TestCase(HeadmaterialType.Reinforcement400, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 390000000d, 390000000d)] [TestCase(HeadmaterialType.Reinforecement500, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.ShortTerm, 400000000.0d, 434782608.69565225d)] [TestCase(HeadmaterialType.Reinforecement500, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.LongTerm, 434782608.69565225d, 434782608.69565225d)] [TestCase(HeadmaterialType.Reinforecement500, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 5e8d, 5e8d)] diff --git a/StructureHelperTests/ViewModelTests/GraphViewModelTest.cs b/StructureHelperTests/ViewModelTests/GraphViewModelTest.cs index c64a078..858a9c0 100644 --- a/StructureHelperTests/ViewModelTests/GraphViewModelTest.cs +++ b/StructureHelperTests/ViewModelTests/GraphViewModelTest.cs @@ -15,7 +15,7 @@ namespace StructureHelperTests.ViewModelTests var labels = new List(); for (int i = 0; i < columnCount; i++) { - labels[i] = $"Column{i}"; + labels.Add($"Column{i}"); } var array = new ArrayParameter(rowCount, columnCount, labels); for (int i = 0; i < columnCount; i++) From f2f6840ffb83ada626d4d675c2f6b71559fc195a Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Sat, 16 Mar 2024 21:46:24 +0500 Subject: [PATCH 02/18] Value point graph was added --- .../Services/ColorServices/ColorOperations.cs | 7 +- .../UI/Resources/ItemEditPanels.xaml | 11 +- .../Libraries/LoaderCalculator.dll | Bin 86016 -> 86016 bytes .../PublishProfiles/FolderProfile.pubxml.user | 2 +- .../Services/ResultViewers/IResultFunc.cs | 1 + .../Services/ResultViewers/ResultFunc.cs | 1 + .../ResultViewers/ResultFuncFactory.cs | 19 ++-- .../ForceResultLogic/DiagramFactory.cs | 60 +++++++++++ .../ForceResultLogic/ShowDiagramLogic.cs | 41 ++----- .../ForceResultLogic/ShowProgressLogic.cs | 4 +- .../ShowValuePointDiagramLogic.cs | 101 +++++++++++++++++- .../ForcesResultsViewModel.cs | 29 +++-- .../Windows/Forces/PrimitiveValuePoints.cs | 5 +- .../Windows/Forces/ValueDelegatesLogic.cs | 3 +- .../Forces/ValuePointsInterpolateView.xaml.cs | 17 +-- .../Forces/ValuePointsInterpolateViewModel.cs | 1 + .../Exceptions/StructureHelperException.cs | 4 + .../Models/Parameters/ArrayParameter.cs | 57 ++++++++++ .../Analyses/ByForces/ForceCalculator.cs | 2 +- .../CrackWidthLogicInputDataFactory.cs | 2 +- .../Cracking/TensileAreaLogicSP63.cs | 2 +- .../Primitives/CirclePrimitive.cs | 39 ++++++- .../Primitives/INamedAreaPoint.cs | 11 ++ .../Primitives/INdmPrimitive.cs | 2 +- .../Primitives/NamedAreaPoint.cs | 17 +++ .../Primitives/PointPrimitive.cs | 10 +- .../Primitives/RebarPrimitive.cs | 10 +- .../Primitives/RectanglePrimitive.cs | 32 ++++-- 28 files changed, 383 insertions(+), 107 deletions(-) create mode 100644 StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/DiagramFactory.cs create mode 100644 StructureHelperLogics/NdmCalculations/Primitives/INamedAreaPoint.cs create mode 100644 StructureHelperLogics/NdmCalculations/Primitives/NamedAreaPoint.cs diff --git a/FieldVisualizer/Services/ColorServices/ColorOperations.cs b/FieldVisualizer/Services/ColorServices/ColorOperations.cs index 9b3148d..d436432 100644 --- a/FieldVisualizer/Services/ColorServices/ColorOperations.cs +++ b/FieldVisualizer/Services/ColorServices/ColorOperations.cs @@ -85,11 +85,16 @@ namespace FieldVisualizer.Services.ColorServices return map.Colors[^1]; } double colorPerc = 1d / (map.Colors.Count - 1d); // % of each block of color. the last is the "100% Color" - double blockOfColor = valPerc / colorPerc;// the integer part repersents how many block to skip + double blockOfColor = valPerc / colorPerc;// the integer part represents how many block to skip int blockIdx = (int)Math.Truncate(blockOfColor);// Idx of double valPercResidual = valPerc - (blockIdx * colorPerc);//remove the part represented of block double percOfColor = valPercResidual / colorPerc;// % of color of this block that will be filled + //in some cases due to accuracy of double type percent of color may be less than zero + if (percOfColor <= 0d) + { + return map.Colors[blockIdx]; + } Color c = GetColorByColorMap(map, blockIdx, percOfColor); return c; } diff --git a/StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml b/StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml index 7c7acb2..502aeed 100644 --- a/StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml +++ b/StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml @@ -23,7 +23,8 @@ + ItemTemplate="{Binding ItemDataDemplate}" + > @@ -41,8 +42,9 @@ - - + @@ -341,7 +352,16 @@ - + + + + + + + + + + diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs index d639e36..5664f16 100644 --- a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs +++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs @@ -44,12 +44,21 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections { AddLimitCurveCalculator(); } + else if (parameterType == CalculatorTypes.CrackCalculator) + { + AddCrackCalculator(); + } else { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(parameterType)); } } + private void AddCrackCalculator() + { + throw new NotImplementedException(); + } + private void AddLimitCurveCalculator() { var inputData = new LimitCurveInputData(repository.Primitives); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs index 7d1e22e..88c702c 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs @@ -1,4 +1,5 @@ using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; @@ -12,8 +13,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class CrackWidthCalculator : ICalculator { - static readonly ILengthBetweenCracksLogic lengthLogic = new LengthBetweenCracksLogicSP63(); - CrackWidthCalculatorResult result; + private static readonly ILengthBetweenCracksLogic lengthLogic = new LengthBetweenCracksLogicSP63(); + private CrackWidthCalculatorResult result; private IEnumerable ndmPrimitives; private List? rebarPrimitives; private IEnumerable ndmCollection; @@ -24,7 +25,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public CrackWidthCalculatorInputData InputData { get; set; } public IResult Result => result; - public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } + public IShiftTraceLogger? TraceLogger { get; set; } public void Run() { @@ -54,17 +55,17 @@ namespace StructureHelperLogics.NdmCalculations.Cracking crackInputData.RebarPrimitive = item; calculator.Run(); var rebarResult = calculator.Result as CrackWidthSimpleCalculatorResult; - if (crackForceResult.IsSectionCracked == false) - { - rebarResult.CrackWidth = 0d; - } + //if (crackForceResult.IsSectionCracked == false) + //{ + // rebarResult.CrackWidth = 0d; + //} result.RebarResults.Add(rebarResult); } } private void CalcStrainMatrix() { - IForceTupleInputData inputData = new ForceTupleInputData() { NdmCollection = ndmCollection, Tuple = InputData.ForceTuple}; + IForceTupleInputData inputData = new ForceTupleInputData() { NdmCollection = ndmCollection, Tuple = InputData.LongTermTuple}; IForceTupleCalculator calculator = new ForceTupleCalculator() { InputData = inputData }; calculator.Run(); var forceResult = calculator.Result as IForcesTupleResult; @@ -80,7 +81,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { PsiSFactor = crackForceResult.PsiS, Length = length, - LimitState = InputData.LimitState, StrainTuple = strainTuple }; return crackInputData; @@ -97,13 +97,13 @@ namespace StructureHelperLogics.NdmCalculations.Cracking rebarPrimitives.Add(item as RebarPrimitive); } } - ndmCollection = NdmPrimitivesService.GetNdms(ndmPrimitives, InputData.LimitState, InputData.CalcTerm); + ndmCollection = NdmPrimitivesService.GetNdms(ndmPrimitives, LimitStates.SLS, CalcTerms.ShortTerm); } private void CalcCrackForce() { var calculator = new CrackForceCalculator(); - calculator.EndTuple = InputData.ForceTuple; + calculator.EndTuple = InputData.LongTermTuple; calculator.NdmCollection = ndmCollection; calculator.Run(); crackForceResult = calculator.Result as CrackForceResult; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorInputData.cs index 607ad35..bf0b0a9 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorInputData.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using StructureHelperLogics.NdmCalculations.Primitives; using System; @@ -9,11 +10,10 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public class CrackWidthCalculatorInputData + public class CrackWidthCalculatorInputData : IInputData { - public LimitStates LimitState { get; set; } - public CalcTerms CalcTerm { get; set; } - public IForceTuple ForceTuple { get; set; } + public IForceTuple LongTermTuple { get; set; } + public IForceTuple ShortTermTuple { get; set; } public List NdmPrimitives {get;set;} } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorResult.cs index 0afdafe..b1503a0 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorResult.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; using System; using System.Collections.Generic; using System.Linq; @@ -11,7 +12,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public bool IsValid { get; set; } public string Description { get; set; } + public IForceTuple LongTermTuple { get; set; } + public IForceTuple ShortTermTuple { get; set; } + public bool IsCracked { get; set; } public List RebarResults { get; set; } + public double MaxLongTermCrackWidth => IsCracked? RebarResults.Select(x => x.LongTermResult.CrackWidth).Max() : 0d; + public double MaxShortTermCrackWidth => IsCracked? RebarResults.Select(x => x.ShortTermResult.CrackWidth).Max() : 0d; public CrackWidthCalculatorResult() { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs index 03b423c..e0bebd2 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs @@ -11,8 +11,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public ICrackWidthSimpleCalculatorInputData InputData { get; set; } public IResult Result => result; - public Action ActionToOutputResults { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } - public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } + public Action ActionToOutputResults { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } public void Run() { @@ -31,9 +31,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking result.Description += "\n" + ex; } result.RebarPrimitive = InputData.RebarPrimitive; - result.CrackWidth = crackWidth; - result.RebarStrain = logicInputData.RebarStrain; - result.ConcreteStrain = logicInputData.ConcreteStrain; + //result.CrackWidth = crackWidth; + //result.RebarStrain = logicInputData.RebarStrain; + //result.ConcreteStrain = logicInputData.ConcreteStrain; } public object Clone() { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorInputData.cs index 73980a6..b759327 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorInputData.cs @@ -11,7 +11,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class CrackWidthSimpleCalculatorInputData : ICrackWidthSimpleCalculatorInputData { - public LimitStates LimitState { get; set; } public CalcTerms CalcTerm { get; set; } public StrainTuple StrainTuple { get; set; } public double PsiSFactor { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorResult.cs index c0e0461..32e287c 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorResult.cs @@ -13,8 +13,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public bool IsValid { get; set; } public string Description { get; set; } public RebarPrimitive RebarPrimitive { get; set; } - public double CrackWidth { get; set; } - public double RebarStrain { get; set; } - public double ConcreteStrain { get; set; } + public CrackWidthTupleResult LongTermResult { get; set; } + public CrackWidthTupleResult ShortTermResult { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthTupleResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthTupleResult.cs new file mode 100644 index 0000000..7928c9f --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthTupleResult.cs @@ -0,0 +1,17 @@ +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public class CrackWidthTupleResult + { + public IForceTuple? ForceTuple { get; set; } + public double CrackWidth { get; set; } + public double RebarStrain { get; set; } + public double ConcreteStrain { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs index 7fb69ea..6511928 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs @@ -41,7 +41,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private static void ProcessBaseProps(ICrackWidthSimpleCalculatorInputData inputData, ICrackWidthLogicInputData data) { var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(inputData.StrainTuple); - var triangulationOptions = new TriangulationOptions { LimiteState = inputData.LimitState, CalcTerm = inputData.CalcTerm }; + var triangulationOptions = new TriangulationOptions { LimiteState = LimitStates.SLS, CalcTerm = inputData.CalcTerm }; var ndms = inputData.RebarPrimitive.GetNdms(triangulationOptions).ToArray(); var concreteNdm = ndms[0]; var rebarNdm = ndms[1]; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthSimpleCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthSimpleCalculatorInputData.cs index 739e4a4..fdea856 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthSimpleCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthSimpleCalculatorInputData.cs @@ -11,7 +11,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public interface ICrackWidthSimpleCalculatorInputData { - LimitStates LimitState { get; set; } CalcTerms CalcTerm { get; set; } StrainTuple StrainTuple { get; set; } double PsiSFactor { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ILengthBetweenCracksLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ILengthBetweenCracksLogic.cs index 5226e07..4c92067 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ILengthBetweenCracksLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ILengthBetweenCracksLogic.cs @@ -1,5 +1,6 @@ using LoaderCalculator.Data.Matrix; using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Interfaces; using System; using System.Collections.Generic; using System.Linq; @@ -8,7 +9,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public interface ILengthBetweenCracksLogic + public interface ILengthBetweenCracksLogic : ILogic { IEnumerable NdmCollection { get; set; } IStrainMatrix StrainMatrix { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs index 8e2811c..59376ef 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs @@ -1,5 +1,6 @@ using LoaderCalculator.Data.Matrix; using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models; using System; using System.Collections.Generic; using System.Linq; @@ -19,6 +20,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking readonly ITensileAreaLogic tensileAreaLogic; public IEnumerable NdmCollection { get; set; } public IStrainMatrix StrainMatrix { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public LengthBetweenCracksLogicSP63(IAverageDiameterLogic diameterLogic, ITensileAreaLogic tensileAreaLogic) { this.diameterLogic = diameterLogic; From e75521dc20dc2dff821ea9b33d092fb3578650e9 Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Sun, 5 May 2024 16:39:02 +0500 Subject: [PATCH 05/18] CrackedCalculator and TriangulationLogic were changed --- .../CalculatorsViews/CrackDiagramLogic.cs | 11 +- .../ForceResultLogic/ShowCrackResultLogic.cs | 9 +- .../ForceResultLogic/ShowCrackWidthLogic.cs | 4 +- .../Windows/MainWindow/CrossSectionModel.cs | 12 +- .../Windows/MainWindow/CrossSectionView.xaml | 4 +- .../MainWindow/CrossSectionViewModel.cs | 10 +- .../AnalysisViewModelLogic.cs | 42 ++++--- .../Interfaces/IHasForceCombinations.cs | 3 + .../Models/Loggers/LoggerStrings.cs | 1 + .../CrossSections/CalculatorLogic.cs | 18 ++- .../CrossSections/RCs/SectionTemplate.cs | 9 ++ .../Analyses/ByForces/ForceCalculator.cs | 20 +++- .../LimitCurve/LimitCurvesCalculator.cs | 11 +- .../Buckling/ConcreteBucklingCalculator.cs | 10 +- .../Cracking/CrackCalculator.cs | 93 ++++++++++++++++ .../Cracking/CrackCalculatorUpdateStrategy.cs | 24 ++++ .../Cracking/CrackInputData.cs | 25 +++++ .../Cracking/CrackInputDataUpdateStrategy.cs | 23 ++++ .../NdmCalculations/Cracking/CrackResult.cs | 20 ++++ .../Cracking/GetTupleInputDatasLogic.cs | 101 +++++++++++++++++ .../Cracking/IGetTupleInputDatasLogic.cs | 15 +++ ...eCalculator.cs => RebarCrackCalculator.cs} | 4 +- ...torInputData.cs => RebarCrackInputData.cs} | 2 +- ...alculatorResult.cs => RebarCrackResult.cs} | 2 +- ...hCalculator.cs => TupleCrackCalculator.cs} | 55 ++++++--- ...torInputData.cs => TupleCrackInputData.cs} | 9 +- ...alculatorResult.cs => TupleCrackResult.cs} | 8 +- .../Primitives/IHasPrimitives.cs | 3 + .../NdmCalculations/CalculationService.cs | 9 +- .../ITriangulatePrimitiveLogic.cs | 16 +++ .../NdmPrimitives/NdmPrimitivesService.cs | 56 ---------- .../TriangulatePrimitiveLogic.cs | 105 ++++++++++++++++++ .../CrackCalculatorTest.cs | 10 +- .../RectangleTriangulationTest.cs | 26 ++++- 34 files changed, 645 insertions(+), 125 deletions(-) create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CrackInputData.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CrackResult.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/IGetTupleInputDatasLogic.cs rename StructureHelperLogics/NdmCalculations/Cracking/{CrackWidthSimpleCalculator.cs => RebarCrackCalculator.cs} (93%) rename StructureHelperLogics/NdmCalculations/Cracking/{CrackWidthSimpleCalculatorInputData.cs => RebarCrackInputData.cs} (87%) rename StructureHelperLogics/NdmCalculations/Cracking/{CrackWidthSimpleCalculatorResult.cs => RebarCrackResult.cs} (90%) rename StructureHelperLogics/NdmCalculations/Cracking/{CrackWidthCalculator.cs => TupleCrackCalculator.cs} (68%) rename StructureHelperLogics/NdmCalculations/Cracking/{CrackWidthCalculatorInputData.cs => TupleCrackInputData.cs} (59%) rename StructureHelperLogics/NdmCalculations/Cracking/{CrackWidthCalculatorResult.cs => TupleCrackResult.cs} (75%) create mode 100644 StructureHelperLogics/Services/NdmPrimitives/ITriangulatePrimitiveLogic.cs delete mode 100644 StructureHelperLogics/Services/NdmPrimitives/NdmPrimitivesService.cs create mode 100644 StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs index b514987..ea03e2b 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs @@ -22,6 +22,8 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews internal class CrackDiagramLogic : ILongProcessLogic { static readonly CrackForceCalculator calculator = new(); + private ITriangulatePrimitiveLogic triangulateLogic; + private List ValidTupleList { get; set; } ArrayParameter arrayParameter; private IEnumerable TupleList { get; set; } @@ -102,7 +104,14 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews calculator.EndTuple = validTupleList[i].DesignForceTuple.ForceTuple; var limitState = validTupleList[i].DesignForceTuple.LimitState; var calcTerm = validTupleList[i].DesignForceTuple.CalcTerm; - var ndms = NdmPrimitivesService.GetNdms(ndmPrimitives, limitState, calcTerm); + triangulateLogic = new TriangulatePrimitiveLogic() + { + Primitives = ndmPrimitives, + LimitState = limitState, + CalcTerm = calcTerm, + TraceLogger = TraceLogger + }; + var ndms = triangulateLogic.GetNdms(); calculator.NdmCollection = ndms; calculator.Run(); var result = (CrackForceResult)calculator.Result; diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs index 04445c5..f03902b 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs @@ -18,6 +18,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu internal class ShowCrackResultLogic { private CrackForceCalculator calculator; + private ITriangulatePrimitiveLogic triangulateLogic; public static GeometryNames GeometryNames => ProgramSetting.GeometryNames; public LimitStates LimitState { get; set; } @@ -42,7 +43,13 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu calculator.TraceLogger = new ShiftTraceLogger(); calculator.StartTuple = startDesignTuple; calculator.EndTuple = finishDesignTuple; - calculator.NdmCollection = NdmPrimitivesService.GetNdms(ndmPrimitives, LimitState, CalcTerm); + triangulateLogic = new TriangulatePrimitiveLogic() + { + Primitives = ndmPrimitives, + LimitState = LimitState, + CalcTerm = CalcTerm + }; + calculator.NdmCollection = triangulateLogic.GetNdms(); calculator.Run(); var result = (CrackForceResult)calculator.Result; if (result.IsValid) diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs index 0a69aed..19c324a 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs @@ -19,14 +19,14 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu internal void Show() { - var inputData = new CrackWidthCalculatorInputData() + var inputData = new TupleCrackInputData() { //LimitState = LimitState, //CalcTerm = CalcTerm, LongTermTuple = ForceTuple, NdmPrimitives = ndmPrimitives }; - var calculator = new CrackWidthCalculator() { InputData = inputData }; + var calculator = new TupleCrackCalculator() { InputData = inputData }; calculator.Run(); var result = calculator.Result; diff --git a/StructureHelper/Windows/MainWindow/CrossSectionModel.cs b/StructureHelper/Windows/MainWindow/CrossSectionModel.cs index 95488a7..874a705 100644 --- a/StructureHelper/Windows/MainWindow/CrossSectionModel.cs +++ b/StructureHelper/Windows/MainWindow/CrossSectionModel.cs @@ -1,4 +1,5 @@ using LoaderCalculator; +using LoaderCalculator.Data.Materials.MaterialBuilders; using LoaderCalculator.Data.Matrix; using LoaderCalculator.Data.Ndms; using LoaderCalculator.Data.ResultData; @@ -9,6 +10,7 @@ using StructureHelper.Services.Primitives; using StructureHelper.UnitSystem; using StructureHelper.UnitSystem.Systems; using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models; using StructureHelperCommon.Services.Units; using StructureHelperLogics.Models.Calculations.CalculationProperties; using StructureHelperLogics.Models.CrossSections; @@ -26,6 +28,8 @@ namespace StructureHelper.Windows.MainWindow { public class CrossSectionModel { + private ITriangulatePrimitiveLogic triangulateLogic; + public ICrossSection Section { get; private set; } private IPrimitiveRepository primitiveRepository; public IHeadMaterialRepository HeadMaterialRepository { get; } @@ -52,7 +56,13 @@ namespace StructureHelper.Windows.MainWindow public IEnumerable GetNdms(ICalculationProperty calculationProperty) { var ndmPrimitives = Section.SectionRepository.Primitives; - return NdmPrimitivesService.GetNdms(ndmPrimitives, calculationProperty.LimitState, calculationProperty.CalcTerm); + triangulateLogic = new TriangulatePrimitiveLogic() + { + Primitives = ndmPrimitives, + LimitState = calculationProperty.LimitState, + CalcTerm = calculationProperty.CalcTerm + }; + return triangulateLogic.GetNdms(); ////Настройки триангуляции, пока опции могут быть только такие //ITriangulationOptions options = new TriangulationOptions { LimiteState = calculationProperty.LimitState, CalcTerm = calculationProperty.CalcTerm }; diff --git a/StructureHelper/Windows/MainWindow/CrossSectionView.xaml b/StructureHelper/Windows/MainWindow/CrossSectionView.xaml index 4d78355..ac8b107 100644 --- a/StructureHelper/Windows/MainWindow/CrossSectionView.xaml +++ b/StructureHelper/Windows/MainWindow/CrossSectionView.xaml @@ -201,7 +201,7 @@ - - + @@ -59,7 +63,6 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml.cs index d3d78a9..042665c 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml.cs @@ -1,4 +1,5 @@ -using System; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; using System.Collections.Generic; using System.Linq; using System.Text; @@ -19,9 +20,16 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews /// public partial class TupleCrackResultView : Window { - public TupleCrackResultView() + TupleCrackResultViewModel viewModel; + public TupleCrackResultView(TupleCrackResultViewModel viewModel) { InitializeComponent(); + this.viewModel = viewModel; + DataContext = this.viewModel; + } + public TupleCrackResultView(TupleCrackResult crackResult) : this(new TupleCrackResultViewModel(crackResult)) + { + } } } diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs index 8d6bef2..cbb3f51 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs @@ -1,12 +1,45 @@ -using System; +using LoaderCalculator.Data.Matrix; +using LoaderCalculator.Data.Ndms; +using StructureHelper.Infrastructure; +using StructureHelper.Services.Reports.CalculationReports; +using StructureHelper.Services.ResultViewers; +using StructureHelper.Windows.Errors; +using StructureHelper.Windows.ViewModels.Errors; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; using System.Collections.Generic; +using System.ComponentModel; using System.Linq; +using System.Runtime.CompilerServices; using System.Text; using System.Threading.Tasks; +using System.Windows.Input; namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews { - public class TupleCrackResultViewModel + public class TupleCrackResultViewModel : ViewModelBase { + IShowCrackIsoFieldsLogic showCrackIsoFieldsLogic => new ShowCrackIsoFieldsLogic(); + private TupleCrackResult crackResult; + private RelayCommand showIsoFieldCommand; + private IsoFieldReport isoFieldReport; + + public TupleCrackResult CrackResult => crackResult; + public List RebarResults => crackResult.RebarResults; + public RebarCrackResult SelectedResult { get; set; } + public ICommand ShowIsoFieldCommand + { + get + { + return showIsoFieldCommand ??= new RelayCommand(o => + { + showCrackIsoFieldsLogic.ShowIsoField(crackResult.RebarResults); + }); + } + } + public TupleCrackResultViewModel(TupleCrackResult crackResult) + { + this.crackResult = crackResult; + } } } diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs index 19c324a..54eccf4 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs @@ -24,7 +24,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu //LimitState = LimitState, //CalcTerm = CalcTerm, LongTermTuple = ForceTuple, - NdmPrimitives = ndmPrimitives + Primitives = ndmPrimitives }; var calculator = new TupleCrackCalculator() { InputData = inputData }; calculator.Run(); diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs index 950c5b5..b08bb5c 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs @@ -22,7 +22,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu private List<(INamedAreaPoint areaPoint, INdmPrimitive ndmPrimitive)> pointCollection; private List validTuplesList; private ArrayParameter arrayOfValuesByPoint; - private IEnumerable selectedDelegates; + private IEnumerable selectedDelegates; private string exceptionMessage; public IEnumerable TupleList { get; set; } @@ -154,7 +154,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu + userPrestrain.Nz + autoPrestrain.Nz; return ndm; } - private List GetValueLabels(IEnumerable selectedDelegates) + private List GetValueLabels(IEnumerable selectedDelegates) { List strings = new(); foreach (var valuePoint in pointCollection) diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs index 1264d96..1191a0a 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs @@ -416,7 +416,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu try { IStrainMatrix strainMatrix = SelectedResult.LoaderResults.ForceStrainPair.StrainMatrix; - var primitiveSets = ShowIsoFieldResult.GetPrimitiveSets(strainMatrix, ndms, ResultFuncFactory.GetResultFuncs()); + var primitiveSets = ShowIsoFieldResult.GetPrimitiveSets(strainMatrix, ndms, ForceResultFuncFactory.GetResultFuncs()); isoFieldReport = new IsoFieldReport(primitiveSets); isoFieldReport.Show(); } @@ -429,7 +429,6 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu }; new ErrorMessage(vm).ShowDialog(); } - } private void GetNdms() { diff --git a/StructureHelper/Windows/Forces/ValueDelegatesLogic.cs b/StructureHelper/Windows/Forces/ValueDelegatesLogic.cs index 0307821..d85b6f0 100644 --- a/StructureHelper/Windows/Forces/ValueDelegatesLogic.cs +++ b/StructureHelper/Windows/Forces/ValueDelegatesLogic.cs @@ -11,13 +11,13 @@ namespace StructureHelper.Windows.Forces { public class ValueDelegatesLogic : ViewModelBase { - private readonly List resultFuncs; - public SelectItemsVM ResultFuncs { get; } + private readonly List resultFuncs; + public SelectItemsVM ResultFuncs { get; } public ValueDelegatesLogic() { - resultFuncs = new List(); - resultFuncs.AddRange(ResultFuncFactory.GetResultFuncs(FuncsTypes.Full)); - ResultFuncs = new SelectItemsVM(resultFuncs) + resultFuncs = new List(); + resultFuncs.AddRange(ForceResultFuncFactory.GetResultFuncs(FuncsTypes.Full)); + ResultFuncs = new SelectItemsVM(resultFuncs) { ShowButtons = true }; diff --git a/StructureHelper/Windows/ViewModels/Calculations/CalculationResult/CalculationResultViewModel.cs b/StructureHelper/Windows/ViewModels/Calculations/CalculationResult/CalculationResultViewModel.cs index 1145ff7..5bafcf7 100644 --- a/StructureHelper/Windows/ViewModels/Calculations/CalculationResult/CalculationResultViewModel.cs +++ b/StructureHelper/Windows/ViewModels/Calculations/CalculationResult/CalculationResultViewModel.cs @@ -55,7 +55,7 @@ namespace StructureHelper.Windows.ViewModels.Calculations.CalculationResult private void ShowIsoField() { IStrainMatrix strainMatrix = SelectedResult.LoaderResults.ForceStrainPair.StrainMatrix; - var primitiveSets = ShowIsoFieldResult.GetPrimitiveSets(strainMatrix, ndms, ResultFuncFactory.GetResultFuncs()); + var primitiveSets = ShowIsoFieldResult.GetPrimitiveSets(strainMatrix, ndms, ForceResultFuncFactory.GetResultFuncs()); isoFieldReport = new IsoFieldReport(primitiveSets); isoFieldReport.Show(); } diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs index cb8e637..b4c206f 100644 --- a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs +++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs @@ -184,7 +184,6 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections } if (SelectedItem is LimitCurvesCalculator calculator) { - var inputData = calculator.InputData; ShowInteractionDiagramByInputData(calculator); } else @@ -193,7 +192,13 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections var result = SelectedItem.Result; if (result.IsValid == false) { - MessageBox.Show(result.Description, "Check data for analisys", MessageBoxButtons.OK, MessageBoxIcon.Warning); + var vm = new ErrorProcessor() + { + ShortText = "Errors apearred during calculations, see detailed information", + DetailText = SelectedItem.Result.Description + }; + new ErrorMessage(vm).ShowDialog(); + return; } else { diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ICheckInputDataLogic.cs b/StructureHelperCommon/Infrastructures/Interfaces/ICheckInputDataLogic.cs new file mode 100644 index 0000000..5cf6ab5 --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/ICheckInputDataLogic.cs @@ -0,0 +1,14 @@ +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public interface ICheckInputDataLogic : ICheckLogic + { + IInputData InputData { get; set; } + } +} diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs b/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs new file mode 100644 index 0000000..dbefc5f --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public interface ICheckLogic : ILogic + { + string CheckResult { get; } + bool Check(); + } +} diff --git a/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs b/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs index fc07e65..8031064 100644 --- a/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs +++ b/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs @@ -33,8 +33,16 @@ namespace StructureHelperCommon.Models.Materials { GetLoaderOptions(); IBuilderDirector director = GetMaterialDirector(); - var material = director.BuildMaterial(); - return material; + try + { + var material = director.BuildMaterial(); + return material; + } + catch (System.Exception) + { + + throw; + } } private IBuilderDirector GetMaterialDirector() diff --git a/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs b/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs index f66f3aa..ac246ee 100644 --- a/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs +++ b/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs @@ -30,8 +30,17 @@ namespace StructureHelperCommon.Models.Materials { GetLoaderOptions(); IBuilderDirector director = GetMaterialDirector(); - var material = director.BuildMaterial(); - return material; + try + { + var material = director.BuildMaterial(); + return material; + } + catch (System.Exception) + { + + throw; + } + } private IBuilderDirector GetMaterialDirector() @@ -45,7 +54,7 @@ namespace StructureHelperCommon.Models.Materials { materialOptions = new ReinforcementOptions() { - DiagramType = DiagramType + DiagramType = DiagramType, }; optionLogic = new MaterialCommonOptionLogic(options); optionLogic.SetMaterialOptions(materialOptions); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs index e160803..b463e6d 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs @@ -60,14 +60,16 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private void MultiThreadProc(IEnumerable points) { Task[] tasks = new Task[points.Count()]; - for (int i = 0; i < points.Count(); i++) + int pointCount = points.Count(); + List PointList = points.ToList(); + for (int i = 0; i < pointCount; i++) { - var point = points.ToList()[i]; + var point = PointList[i]; tasks[i] = new Task(() => FindResultPoint(point)); tasks[i].Start(); } Task.WaitAll(tasks); - for (int j = 0; j < points.Count(); j++) + for (int j = 0; j < pointCount; j++) { var taskResult = tasks[j].Result; resultList.Add(taskResult); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleTraceResultLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleTraceResultLogic.cs index 0a412a5..63295aa 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleTraceResultLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleTraceResultLogic.cs @@ -50,7 +50,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces Point2D minPoint = new(), maxPoint = new(); foreach (var item in ndmCollection) { - var strain = stressLogic.GetTotalStrain(strainMatrix, item); + var strain = stressLogic.GetSectionStrain(strainMatrix, item); if (strain < minStrain) { minStrain = strain; diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs index 8f0a361..88884c6 100644 --- a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs @@ -205,7 +205,7 @@ namespace StructureHelperLogics.NdmCalculations.Buckling var stressLogic = new StressLogic(); foreach (var item in ndmCollection) { - var strain = stressLogic.GetTotalStrain(strains, item); + var strain = stressLogic.GetSectionStrain(strains, item); if (strain > maxStrain) { maxStrain = strain; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs new file mode 100644 index 0000000..676ed3e --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs @@ -0,0 +1,119 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Materials; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + /// + /// Logic of checking of input data for crack calcultor + /// + public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic + { + private string checkResult; + private CrackInputData inputData; + private bool result; + + public IInputData InputData + { + get => inputData; + set + { + if (value is CrackInputData data) + { + inputData = data; + } + else + { + throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(CrackInputData), value)); + } + } + } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + public CheckCrackCalculatorInputDataLogic(CrackInputData inputData) + { + this.inputData = inputData; + } + public bool Check() + { + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Debug); + result = true; + checkResult = string.Empty; + CheckPrimitives(); + CheckActions(); + return result; + } + + private void CheckActions() + { + if (inputData.ForceActions is null || (!inputData.ForceActions.Any())) + { + result = false; + string message = "Calculator does not contain any actions\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + }; + } + + private void CheckPrimitives() + { + if (inputData.Primitives is null || (!inputData.Primitives.Any())) + { + result = false; + string message = "Calculator does not contain any primitives\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + else + { + foreach (var primitive in inputData.Primitives) + { + if (primitive is RebarPrimitive rebar) + { + CheckRebar(rebar); + } + } + } + } + + private void CheckRebar(RebarPrimitive rebar) + { + if (rebar.HostPrimitive is null) + { + result = false; + string message = $"Primitive {rebar.Name} does not have a host\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + else + { + bool isPrimitivesContainRebarHost = inputData.Primitives.Contains(rebar.HostPrimitive); + if (isPrimitivesContainRebarHost == false) + { + result = false; + string message = $"Host {rebar.Name}({rebar.HostPrimitive.Name}) is not included in primitives\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + } + if (rebar.HostPrimitive.HeadMaterial.HelperMaterial is not ICrackedMaterial) + { + result = false; + string message = $"Material of host of {rebar.Name} does not support cracking\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs index a024b92..b1d416f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs @@ -23,6 +23,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private CrackResult result; private IGetTupleInputDatasLogic datasLogic; private CrackCalculatorUpdateStrategy updateStrategy = new(); + private ICheckInputDataLogic checkInputDataLogic; public string Name { get; set; } public CrackInputData InputData { get; set; } @@ -44,6 +45,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public void Run() { PrepareNewResult(); + CheckInputData(); TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); try { @@ -58,6 +60,19 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } } + private void CheckInputData() + { + checkInputDataLogic = new CheckCrackCalculatorInputDataLogic(InputData) + { + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + if (checkInputDataLogic.Check() == false) + { + result.IsValid = false; + result.Description += checkInputDataLogic.CheckResult; + } + } + private void ProcessCalculations() { datasLogic = new GetTupleInputDatasLogic(InputData.Primitives, InputData.ForceActions, InputData.UserCrackInputData) diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs index 5052ce0..3e00cb6 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs @@ -35,7 +35,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage($"Rebar elongation Epsilon = {inputData.RebarStrain} - {inputData.ConcreteStrain} = {rebarElongation}(dimensionless)"); double width = rebarElongation * inputData.Length; width *= inputData.TermFactor * inputData.BondFactor * inputData.StressStateFactor * inputData.PsiSFactor; - TraceLogger?.AddMessage($"Width of crack a,crc = {width}(m)"); + TraceLogger?.AddMessage($"Width of crack a,crc = {inputData.TermFactor} * {inputData.BondFactor} * {inputData.StressStateFactor} * {inputData.PsiSFactor} * {rebarElongation} * {inputData.Length}(m) = {width}(m)"); return width; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs index 097ad9b..82c15a2 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs @@ -52,9 +52,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking resultList.Add(new TupleCrackInputData() { IsValid = true, + TupleName = action.Name, LongTermTuple = tuple.LongTuple, ShortTermTuple = tuple.ShortTuple, - NdmPrimitives = Primitives, + Primitives = Primitives, UserCrackInputData = UserCrackInputData }); } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs index 7404778..19cdf81 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs @@ -2,6 +2,9 @@ { public interface ICrackWidthTupleResult { + /// + /// Calculated crack width + /// double CrackWidth { get; set; } bool IsCrackLessThanUltimate { get; } double UltimateCrackWidth { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs index 34c5bf5..99d185f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs @@ -106,7 +106,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private double GetAverageDiameter(IEnumerable rebars) { var tesileRebars = rebars - .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d); + .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d); diameterLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50); diameterLogic.Rebars = tesileRebars; var rebarDiameter = diameterLogic.GetAverageDiameter(); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs index c3eb9bc..74a6548 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs @@ -8,12 +8,26 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { + /// + /// Result of calculation of crack for specific result + /// public class RebarCrackResult : IResult { + /// public bool IsValid { get; set; } + /// public string Description { get; set; } + /// + /// Specific rebar primitive + /// public RebarPrimitive RebarPrimitive { get; set; } + /// + /// Result of calculation of crack for long term + /// public CrackWidthRebarTupleResult LongTermResult { get; set; } + /// + /// Result of calculation of crack for short term + /// public CrackWidthRebarTupleResult ShortTermResult { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs index 86dc758..aca6206 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs @@ -62,7 +62,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public void Run() { - GetNdms(); + GetNdmCollectionFromPrimitives(); result = new RebarStressResult() { IsValid = true, @@ -71,13 +71,13 @@ namespace StructureHelperLogics.NdmCalculations.Cracking var strainTuple = GetStrainTuple(); result.StrainTuple = strainTuple; var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple); - result.RebarStrain = stressLogic.GetTotalStrain(strainMatrix, rebarNdm); + result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm); result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm); result.ConcreteStrain = concreteNdm.Prestrain; } - private void GetNdms() + private void GetNdmCollectionFromPrimitives() { var options = new TriangulationOptions() { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs index a6aaf44..c24bac3 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs @@ -10,7 +10,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class RebarStressResult : IResult { + /// public bool IsValid { get; set; } + /// public string? Description { get; set; } public StrainTuple StrainTuple { get; set; } public double RebarStress { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs index 8436f83..f5a6533 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs @@ -29,7 +29,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); var rebarCollection = NdmCollection - .Where(x => x is RebarNdm & stressLogic.GetTotalStrain(StrainMatrix, x) > 0d); + .Where(x => x is RebarNdm & stressLogic.GetSectionStrain(StrainMatrix, x) > 0d); var rebarArea = rebarCollection. Sum(x => x.Area * x.StressScale); TraceLogger?.AddMessage($"Summary rebar area As = {rebarArea}"); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs index 134c75d..8303141 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs @@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); TraceLogger?.AddMessage("Method of obtaining of summary area of rebars in tension based on areas which are proportional by maximum strain"); var rebars = Rebars - .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d); + .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d); if (!rebars.Any()) { string errorString = ErrorStrings.DataIsInCorrect + ": Collection of rebars does not contain any tensile rebars"; @@ -40,7 +40,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking throw new StructureHelperException(errorString); } var maxStrain = rebars - .Select(x => stressLogic.GetTotalStrain(StrainMatrix, x)) + .Select(x => stressLogic.GetSectionStrain(StrainMatrix, x)) .Max(); TraceLogger?.AddMessage($"Maximum strain maxStrain = {maxStrain}"); if (TraceLogger is not null) @@ -51,7 +51,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking foreach (var rebar in rebars) { double area = rebar.Area * rebar.StressScale; - double strain = stressLogic.GetTotalStrain(StrainMatrix, rebar); + double strain = stressLogic.GetSectionStrain(StrainMatrix, rebar); TraceLogger?.AddMessage($"Rebar area = {area}(m^2)"); TraceLogger?.AddMessage($"Rebar strain = {strain}"); var reducedArea = area * strain / maxStrain; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs index a9abe5b..d446c3a 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs @@ -11,6 +11,9 @@ using System.Linq; using System.Text; using System.Threading.Tasks; +//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + namespace StructureHelperLogics.NdmCalculations.Cracking { public class TensionRebarAreaSimpleSumLogic : ITensionRebarAreaLogic @@ -32,7 +35,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); TraceLogger?.AddMessage("Method of obtaining of summary area of rebars in tension based on ordinary summarizing of areas"); var rebars = Rebars - .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d); + .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d); if (!rebars.Any()) { string errorString = ErrorStrings.DataIsInCorrect + ": Collection of rebars does not contain any tensile rebars"; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs index 81d44b3..2563d2a 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs @@ -1,4 +1,5 @@ using LoaderCalculator.Data.Ndms; +using StructureHelper.Models.Materials; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Models; @@ -26,6 +27,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private StrainTuple shortDefaultStrainTuple; private double longLength; private double shortLength; + private object locker = new(); public string Name { get; set; } public TupleCrackInputData InputData { get; set; } @@ -68,6 +70,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { CheckInputData(); Triangulate(); + longDefaultStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, crackableNdms); shortDefaultStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, crackableNdms); var longElasticStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, elasticNdms); @@ -85,17 +88,28 @@ namespace StructureHelperLogics.NdmCalculations.Cracking shortLength = GetLengthBetweenCracks(shortElasticStrainTuple); } CalcCrackForce(); - foreach (var rebar in rebarPrimitives) - { - RebarCrackCalculatorInputData rebarCalculatorData = GetRebarCalculatorInputData(rebar); - var calculator = new RebarCrackCalculator + //for (int j = 0; j < 100000; j++) + //{ + result.RebarResults.Clear(); + int rebarCount = rebarPrimitives.Count; + Task[] tasks = new Task[rebarCount]; + for (int i = 0; i < rebarCount; i++) { - InputData = rebarCalculatorData, - TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) - }; - calculator.Run(); - var rebarResult = calculator.Result as RebarCrackResult; - result.RebarResults.Add(rebarResult); + var rebar = rebarPrimitives[i]; + tasks[i] = new Task(() => ProcessRebar(rebar)); + tasks[i].Start(); + } + Task.WaitAll(tasks); + for (int i = 0; i < rebarCount; i++) + { + result.RebarResults.Add(tasks[i].Result); + } + //} + + if (result.RebarResults.Any(x => x.IsValid == false)) + { + result.IsValid = false; + return; } result.LongTermResult = new() { @@ -109,25 +123,50 @@ namespace StructureHelperLogics.NdmCalculations.Cracking }; } + private RebarCrackResult ProcessRebar(RebarPrimitive rebar) + { + RebarCrackCalculatorInputData rebarCalculatorData = GetRebarCalculatorInputData(rebar); + var calculator = new RebarCrackCalculator + { + InputData = rebarCalculatorData, + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + calculator.Run(); + var rebarResult = calculator.Result as RebarCrackResult; + return rebarResult; + } + private RebarCrackCalculatorInputData GetRebarCalculatorInputData(RebarPrimitive rebar) { + IEnumerable crackableNdmsLoc = null; + IEnumerable crackedNdmsLoc = null; + RebarPrimitive rebarCopy = null; + lock (locker) + { + rebarCopy = rebar.Clone() as RebarPrimitive; + rebarCopy.HeadMaterial = rebarCopy.HeadMaterial.Clone() as IHeadMaterial; + var triangulationLogicLoc = new CrackedSectionTriangulationLogic(InputData.Primitives); + crackableNdmsLoc = triangulationLogicLoc.GetNdmCollection(); + crackedNdmsLoc = triangulationLogicLoc.GetCrackedNdmCollection(); + } + var longRebarData = new RebarCrackInputData() { - CrackableNdmCollection = crackableNdms, - CrackedNdmCollection = crackedNdms, - ForceTuple = InputData.LongTermTuple as ForceTuple, + CrackableNdmCollection = crackableNdmsLoc, + CrackedNdmCollection = crackedNdmsLoc, + ForceTuple = InputData.LongTermTuple.Clone() as ForceTuple, Length = longLength }; var shortRebarData = new RebarCrackInputData() { CrackableNdmCollection = crackableNdms, CrackedNdmCollection = crackedNdms, - ForceTuple = InputData.ShortTermTuple as ForceTuple, + ForceTuple = InputData.ShortTermTuple.Clone() as ForceTuple, Length = shortLength }; var rebarCalculatorData = new RebarCrackCalculatorInputData() { - RebarPrimitive = rebar, + RebarPrimitive = rebarCopy, LongRebarData = longRebarData, ShortRebarData = shortRebarData, UserCrackInputData = InputData.UserCrackInputData @@ -153,6 +192,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { result.IsValid = false; result.Description += forceResult.Description; + TraceLogger?.AddMessage("Bearing capacity of cross-section is not enough for action", TraceLogStatuses.Error); + return null; } var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix); return strain; @@ -171,7 +212,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private void Triangulate() { - triangulationLogic = new CrackedSectionTriangulationLogic(InputData.NdmPrimitives) + triangulationLogic = new CrackedSectionTriangulationLogic(InputData.Primitives) { //TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) }; @@ -192,7 +233,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private void CheckInputData() { - if (InputData.NdmPrimitives is null || InputData.NdmPrimitives.Count == 0) + if (InputData.Primitives is null || InputData.Primitives.Count == 0) { throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": input data doesn't have any primitives"); } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs index 9e26612..851987f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs @@ -8,14 +8,32 @@ using System.Linq; using System.Text; using System.Threading.Tasks; +//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + namespace StructureHelperLogics.NdmCalculations.Cracking { - public class TupleCrackInputData : IInputData + /// + /// Input data for calculation of crack for specific force tuple + /// + public class TupleCrackInputData : IInputData, IHasPrimitives { + /// public bool IsValid { get; set; } + public string TupleName { get; set; } + /// + /// Force tuple for long term calculations + /// public IForceTuple? LongTermTuple { get; set; } + /// + /// Force tuple for short term calculations + /// public IForceTuple? ShortTermTuple { get; set; } - public List? NdmPrimitives {get;set;} + /// + public List? Primitives { get; set;} + /// + /// Settings ajusted by user + /// public UserCrackInputData UserCrackInputData { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs index 89e3b0b..6e3ca8b 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs @@ -6,21 +6,25 @@ using System.Linq; using System.Text; using System.Threading.Tasks; +//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + namespace StructureHelperLogics.NdmCalculations.Cracking { + /// + /// Result of crack calculation for specific force tuple + /// public class TupleCrackResult : IResult { + /// public bool IsValid { get; set; } + /// public string Description { get; set; } public TupleCrackInputData InputData { get; set; } public bool IsCracked { get; set; } public List RebarResults { get; private set; } public CrackWidthRebarTupleResult LongTermResult { get; set; } public CrackWidthRebarTupleResult ShortTermResult { get; set; } - //public double MaxLongTermCrackWidth => RebarResults.Select(x => x.LongTermResult.CrackWidth).Max(); - //public double MaxShortTermCrackWidth => RebarResults.Select(x => x.ShortTermResult.CrackWidth).Max(); - //public bool IsLongCrackLessThanUltimate => MaxLongTermCrackWidth <= InputData.UserCrackInputData.UltimateLongCrackWidth; - //public bool IsShortCrackLessThanUltimate => MaxShortTermCrackWidth <= InputData.UserCrackInputData.UltimateShortCrackWidth; public TupleCrackResult() { diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs index 1ecb6ed..8b41179 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs @@ -26,11 +26,11 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks }; // Setup the mock to return positive strains - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 1.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 1.0))) .Returns(0.5); - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 2.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 2.0))) .Returns(1.0); - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 3.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 3.0))) .Returns(1.5); var logic = new TensionRebarAreaSimpleSumLogic(mockStressLogic.Object) @@ -64,7 +64,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks }; // Setup the mock to return non-positive strain - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.IsAny())) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.IsAny())) .Returns(0.0); var logic = new TensionRebarAreaSimpleSumLogic(mockStressLogic.Object) diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs index 736ebf8..ea12e1d 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs @@ -29,11 +29,11 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks }; // Setup the mock to return positive strains - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 1.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 1.0))) .Returns(0.5); - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 2.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 2.0))) .Returns(1.0); - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 3.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 3.0))) .Returns(1.5); var logic = new TensionRebarAreaByStrainLogic(mockStressLogic.Object) @@ -69,7 +69,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks }; // Setup the mock to return non-positive strain - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.IsAny())) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.IsAny())) .Returns(0.0); var logic = new TensionRebarAreaByStrainLogic(mockStressLogic.Object) From 0913ca85b797d0c444cfca6bcd087ff78fe7fc09 Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Sun, 26 May 2024 14:05:02 +0500 Subject: [PATCH 15/18] View of tuple crack result was changed --- .../Libraries/LoaderCalculator.dll | Bin 88576 -> 88576 bytes .../ResultViewers/CrackResultFuncFactory.cs | 14 +++++++ .../ResultViewers/ForceResultFuncFactory.cs | 2 +- .../Cracks/TupleCrackResultView.xaml | 16 +++++++- .../Cracks/TupleCrackResultViewModel.cs | 1 + .../AnalysisViewModelLogic.cs | 2 +- .../CrossSections/CalculatorLogic.cs | 4 +- .../Cracking/CrackCalculator.cs | 12 +++--- .../Cracking/CrackWidthLogicSP63.cs | 18 ++++----- .../Cracking/RebarCrackCalculator.cs | 6 ++- .../Cracking/TensileConcreteAreaLogicSP63.cs | 2 +- ...ogicTest.cs => CrackWidthLogicSP63Test.cs} | 2 +- .../Cracks/EquivalentDiameterLogicTest.cs | 36 ++++++++++++++++++ 13 files changed, 92 insertions(+), 23 deletions(-) rename StructureHelperTests/UnitTests/Ndms/Cracks/{CrackWidthLogicTest.cs => CrackWidthLogicSP63Test.cs} (96%) create mode 100644 StructureHelperTests/UnitTests/Ndms/Cracks/EquivalentDiameterLogicTest.cs diff --git a/StructureHelper/Libraries/LoaderCalculator.dll b/StructureHelper/Libraries/LoaderCalculator.dll index 09353ee4d75505194a175b31bba85d68f24d0c9d..fd7ba77b6e79046c913cff9b4f40c6eee696c556 100644 GIT binary patch delta 13486 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 diff --git a/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs b/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs index 9b3fbab..47b4799 100644 --- a/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs +++ b/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs @@ -34,6 +34,20 @@ namespace StructureHelper.Services.ResultViewers UnitName = unitLength.Name }, new() + { + Name = "Long softening factor", + ResultFunction = (RebarCrackResult rebar) => rebar.LongTermResult.SofteningFactor, + UnitFactor = unitLength.Multiplyer, + UnitName = unitLength.Name + }, + new() + { + Name = "Short softening factor", + ResultFunction = (RebarCrackResult rebar) => rebar.ShortTermResult.SofteningFactor, + UnitFactor = unitLength.Multiplyer, + UnitName = unitLength.Name + }, + new() { Name = "Long rebar stress", ResultFunction = (RebarCrackResult rebar) => rebar.LongTermResult.RebarStressResult.RebarStress, diff --git a/StructureHelper/Services/ResultViewers/ForceResultFuncFactory.cs b/StructureHelper/Services/ResultViewers/ForceResultFuncFactory.cs index 3935460..b39eec5 100644 --- a/StructureHelper/Services/ResultViewers/ForceResultFuncFactory.cs +++ b/StructureHelper/Services/ResultViewers/ForceResultFuncFactory.cs @@ -57,7 +57,7 @@ namespace StructureHelper.Services.ResultViewers { List resultFuncs = new (); resultFuncs.Add(new ForceResultFunc() { Name = "Section Strain", ResultFunction = stressLogic.GetSectionStrain }); - resultFuncs.Add(new ForceResultFunc() { Name = "Total Strain", ResultFunction = stressLogic.GetTotalStrainWithPrestrain }); + resultFuncs.Add(new ForceResultFunc() { Name = "Total Strain", ResultFunction = stressLogic.GetTotalStrain }); resultFuncs.Add(new ForceResultFunc() { Name = "Prestrain", ResultFunction = stressLogic.GetPrestrain }); resultFuncs.Add(new ForceResultFunc() { Name = "Elastic Strain", ResultFunction = stressLogic.GetElasticStrain }); resultFuncs.Add(new ForceResultFunc() { Name = "Plastic Strain", ResultFunction = stressLogic.GetPlasticStrain }); diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml index bdcb244..529033a 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml @@ -6,7 +6,7 @@ xmlns:local="clr-namespace:StructureHelper.Windows.CalculationWindows.CalculatorsViews" d:DataContext="{d:DesignInstance local:TupleCrackResultViewModel}" mc:Ignorable="d" - Title="TupleCrackResultView" Height="450" Width="800" MinHeight="300" MinWidth="500" MaxHeight="1000" MaxWidth="1200" WindowStartupLocation="CenterScreen"> + Title="{Binding WindowName}" Height="450" Width="1000" MinHeight="300" MinWidth="500" MaxHeight="1000" MaxWidth="1200" WindowStartupLocation="CenterScreen"> @@ -51,6 +51,20 @@ + + + + + + + + + + + + + + diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs index cbb3f51..e2dbf3c 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs @@ -27,6 +27,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews public TupleCrackResult CrackResult => crackResult; public List RebarResults => crackResult.RebarResults; public RebarCrackResult SelectedResult { get; set; } + public string WindowName => "Result of calculation of cracks for action " + crackResult.InputData.TupleName; public ICommand ShowIsoFieldCommand { get diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs index b4c206f..41e100a 100644 --- a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs +++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs @@ -60,7 +60,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections private void AddCrackCalculator() { var inputData = new CrackInputData(); - var calculator = new CrackCalculator(inputData) + var calculator = new CrackCalculator(inputData, new CheckCrackCalculatorInputDataLogic(inputData)) { Name = "New crack calculator", TraceLogger = new ShiftTraceLogger(), diff --git a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs index 01e25bb..7f5d3d6 100644 --- a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs +++ b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs @@ -16,7 +16,9 @@ namespace StructureHelperLogics.Models.Templates.CrossSections TraceLogger = new ShiftTraceLogger() }; calculators.Add(forceCalculator); - var crackCalculator = new CrackCalculator(new CrackInputData()) + CrackInputData newInputData = new CrackInputData(); + var checkLogic = new CheckCrackCalculatorInputDataLogic(newInputData); + var crackCalculator = new CrackCalculator(newInputData, checkLogic) { Name = "New Crack Calculator", TraceLogger = new ShiftTraceLogger() diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs index b1d416f..3ff8f64 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs @@ -30,14 +30,17 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public IResult Result => result; public IShiftTraceLogger? TraceLogger { get; set; } - public CrackCalculator(CrackInputData inputData) + public CrackCalculator(CrackInputData inputData, ICheckInputDataLogic checkInputDataLogic) { InputData = inputData; + this.checkInputDataLogic = checkInputDataLogic; } public object Clone() { - var newItem = new CrackCalculator(new CrackInputData()); + CrackInputData crackInputData = new CrackInputData(); + var checkDataLogic = new CheckCrackCalculatorInputDataLogic(InputData); + var newItem = new CrackCalculator(crackInputData, checkDataLogic); updateStrategy.Update(newItem, this); return newItem; } @@ -62,10 +65,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private void CheckInputData() { - checkInputDataLogic = new CheckCrackCalculatorInputDataLogic(InputData) - { - TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) - }; + checkInputDataLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50); if (checkInputDataLogic.Check() == false) { result.IsValid = false; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs index 3e00cb6..8cf70a9 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs @@ -20,10 +20,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); TraceLogger?.AddMessage("Method of crack width calculation based on SP 63.13330.2018"); CheckOptions(); - TraceLogger?.AddMessage($"Term factor fi1= {inputData.TermFactor}", TraceLogStatuses.Service); - TraceLogger?.AddMessage($"Bond factor fi2= {inputData.BondFactor}", TraceLogStatuses.Service); - TraceLogger?.AddMessage($"Stress state factor fi3= {inputData.StressStateFactor}", TraceLogStatuses.Service); - TraceLogger?.AddMessage($"PsiS factor PsiS= {inputData.PsiSFactor}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"Term factor fi1 = {inputData.TermFactor}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"Bond factor fi2 = {inputData.BondFactor}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"Stress state factor fi3 = {inputData.StressStateFactor}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"PsiS factor PsiS = {inputData.PsiSFactor}", TraceLogStatuses.Service); TraceLogger?.AddMessage($"Length between cracks Ls = {inputData.Length}", TraceLogStatuses.Service); //check if strain of concrete greater than strain of rebar double rebarElongation = inputData.RebarStrain - inputData.ConcreteStrain; @@ -49,26 +49,26 @@ namespace StructureHelperLogics.NdmCalculations.Cracking inputData = InputData as CrackWidthLogicInputDataSP63; if (inputData.Length <=0d) { - errorString = ErrorStrings.DataIsInCorrect + $": length between cracks Ls={inputData.Length} must be greate than zero"; + errorString = ErrorStrings.DataIsInCorrect + $": length between cracks Lcrc={inputData.Length} must be greater than zero"; } if (inputData.TermFactor <= 0d) { - errorString = ErrorStrings.DataIsInCorrect + $": Term factor fi1 {inputData.TermFactor} must be greate than zero"; + errorString = ErrorStrings.DataIsInCorrect + $": Term factor fi1 {inputData.TermFactor} must be greater than zero"; } if (inputData.BondFactor <= 0d) { - errorString = ErrorStrings.DataIsInCorrect + $": Bond factor fi2 {inputData.BondFactor} must be greate than zero"; + errorString = ErrorStrings.DataIsInCorrect + $": Bond factor fi2 {inputData.BondFactor} must be greater than zero"; } if (inputData.StressStateFactor <= 0d) { - errorString = ErrorStrings.DataIsInCorrect + $": Stress factor fi3 factor {inputData.StressStateFactor} must be greate than zero"; + errorString = ErrorStrings.DataIsInCorrect + $": Stress factor fi3 factor {inputData.StressStateFactor} must be greater than zero"; } if (inputData.PsiSFactor <= 0d) { - errorString = ErrorStrings.DataIsInCorrect + $": PsiS factor {inputData.PsiSFactor} must be greate than zero"; + errorString = ErrorStrings.DataIsInCorrect + $": PsiS factor {inputData.PsiSFactor} must be greater than zero"; } if (errorString != string.Empty) { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs index b69dc5f..b23aacc 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs @@ -47,7 +47,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { CrackWidth = acrc1, UltimateCrackWidth = InputData.UserCrackInputData.UltimateLongCrackWidth, - RebarStressResult = rebarStressResult + RebarStressResult = rebarStressResult, + SofteningFactor = crackSofteningLogic.GetSofteningFactor() }; TraceLogger?.AddMessage($"Long crack width acrc = acrc,1 = {acrc1}(m)"); TraceLogger?.AddMessage($"Ultimate long crack width acrc,ult = {longRebarResult.UltimateCrackWidth}(m)"); @@ -69,7 +70,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { CrackWidth = acrcShort, UltimateCrackWidth = InputData.UserCrackInputData.UltimateShortCrackWidth, - RebarStressResult = rebarStressResult + RebarStressResult = rebarStressResult, + SofteningFactor = crackSofteningLogic.GetSofteningFactor() }; TraceCrackResult(shortRebarResult); result.LongTermResult = longRebarResult; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs index f5a6533..72996f3 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs @@ -39,7 +39,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking .Sum(x => x.Area * x.StressScale); TraceLogger?.AddMessage($"Concrete area Ac = {concreteArea}"); var concreteTensileArea = concreteCollection - .Where(x => stressLogic.GetTotalStrainWithPrestrain(StrainMatrix, x) > 0d) + .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d) .Sum(x => x.Area * x.StressScale); TraceLogger?.AddMessage($"Concrete tensile area Ac,t = {concreteTensileArea}"); diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs similarity index 96% rename from StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicTest.cs rename to StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs index 8aaec8c..4a52d15 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicTest.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs @@ -8,7 +8,7 @@ using StructureHelperLogics.NdmCalculations.Cracking; namespace StructureHelperTests.UnitTests.Ndms.Cracks { - public class CrackWidthLogicTest + public class CrackWidthLogicSP63Test { [TestCase(1.4d, 0.001d, 0d, 0.3d, 0.00020999999999999998d)] [TestCase(1.4d, 0.001d, 0.001d, 0.3d, 0d)] diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/EquivalentDiameterLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/EquivalentDiameterLogicTest.cs new file mode 100644 index 0000000..f710f8b --- /dev/null +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/EquivalentDiameterLogicTest.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using LoaderCalculator.Data.Ndms; +using NUnit.Framework; +using StructureHelperLogics.NdmCalculations.Cracking; + +namespace StructureHelperTests.UnitTests.Ndms.Cracks +{ + public class EquivalentDiameterLogicTest + { + [TestCase(0.025d, 2, 0.025d, 2, 0.025d)] + [TestCase(0.032d, 2, 0.025d, 1, 0.029842055910607741d)] + [TestCase(0.032d, 1, 0.025d, 2, 0.027524820186583671d)] + public void Run_ShouldPass(double fstDiameter, int fstCount, double sndDiameter, int sndCount, double expectedDiameter) + { + //Arrange + List rebar = new(); + for (int i = 0; i < fstCount; i++) + { + rebar.Add(new RebarNdm() { Area = 0.785d * fstDiameter * fstDiameter }); + } + for (int i = 0; i < sndCount; i++) + { + rebar.Add(new RebarNdm() { Area = 0.785d * sndDiameter * sndDiameter }); + } + var logic = new EquivalentDiameterLogic() { Rebars = rebar }; + //Act + var eqDiametr = logic.GetAverageDiameter(); + //Assert + Assert.AreEqual(expectedDiameter, eqDiametr, 0.0001d); + } + } +} From 63463662feb842569ed95f8c29ff66a5891ac082 Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Sun, 26 May 2024 17:17:32 +0500 Subject: [PATCH 16/18] Crack func factori has been changed --- .../ResultViewers/CrackResultFuncFactory.cs | 8 ++-- .../Cracking/CheckTupleCalculatorInputData.cs | 44 +++++++++++++++++++ .../Cracking/RebarCrackCalculator.cs | 2 +- .../Cracking/TupleCrackCalculator.cs | 3 ++ .../Cracking/TupleCrackInputData.cs | 2 +- 5 files changed, 53 insertions(+), 6 deletions(-) create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CheckTupleCalculatorInputData.cs diff --git a/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs b/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs index 47b4799..0406d96 100644 --- a/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs +++ b/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs @@ -37,15 +37,15 @@ namespace StructureHelper.Services.ResultViewers { Name = "Long softening factor", ResultFunction = (RebarCrackResult rebar) => rebar.LongTermResult.SofteningFactor, - UnitFactor = unitLength.Multiplyer, - UnitName = unitLength.Name + UnitFactor = 1, + UnitName = "Dimensionless" }, new() { Name = "Short softening factor", ResultFunction = (RebarCrackResult rebar) => rebar.ShortTermResult.SofteningFactor, - UnitFactor = unitLength.Multiplyer, - UnitName = unitLength.Name + UnitFactor = 1, + UnitName = "Dimensionless" }, new() { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckTupleCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckTupleCalculatorInputData.cs new file mode 100644 index 0000000..a22968b --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckTupleCalculatorInputData.cs @@ -0,0 +1,44 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +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.NdmCalculations.Cracking +{ + public class CheckTupleCalculatorInputData : ICheckInputDataLogic + { + private string checkResult; + private TupleCrackInputData inputData; + private bool result; + + public IInputData InputData + { + get => inputData; set + { + if (value is TupleCrackInputData data) + { + inputData = data; + } + else + { + throw new StructureHelperException(ErrorStrings.DataIsInCorrect); + } + } + } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public bool Check() + { + result = true; + return result; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs index b23aacc..8affe0d 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs @@ -24,7 +24,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public void Run() { - TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Debug); result = new() { IsValid = true diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs index 2563d2a..2536626 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs @@ -11,6 +11,9 @@ using StructureHelperLogics.NdmCalculations.Analyses.ByForces; using StructureHelperLogics.NdmCalculations.Primitives; using StructureHelperLogics.Services.NdmPrimitives; +//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + namespace StructureHelperLogics.NdmCalculations.Cracking { public class TupleCrackCalculator : ICalculator diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs index 851987f..69aa841 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs @@ -20,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { /// public bool IsValid { get; set; } - public string TupleName { get; set; } + public string TupleName { get; set; } = string.Empty; /// /// Force tuple for long term calculations /// From 99d5aa360831420f27dadb1de9392dec4fd45941 Mon Sep 17 00:00:00 2001 From: ear Date: Wed, 29 May 2024 18:00:28 +0500 Subject: [PATCH 17/18] RebarStressCalculator was changed --- .../NdmCalculations/Cracking/RebarStressCalculator.cs | 2 +- .../NdmCalculations/Cracking/TupleCrackCalculator.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs index aca6206..52f0c5f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs @@ -73,7 +73,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple); result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm); result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm); - result.ConcreteStrain = concreteNdm.Prestrain; + result.ConcreteStrain = - concreteNdm.Prestrain; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs index 2536626..c388607 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs @@ -90,7 +90,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking longLength = GetLengthBetweenCracks(longElasticStrainTuple); shortLength = GetLengthBetweenCracks(shortElasticStrainTuple); } - CalcCrackForce(); + //CalcCrackForce(); //for (int j = 0; j < 100000; j++) //{ result.RebarResults.Clear(); From 31d668b996cbff7fc5572043eb1b427fbd0c2d6b Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Sun, 2 Jun 2024 16:56:44 +0500 Subject: [PATCH 18/18] Smart rounding was ajusted --- .../Entities/ColorMaps/IValueColorArray.cs | 13 ++ .../Entities/ColorMaps/IValueColorRange.cs | 23 +--- .../Entities/ColorMaps/ValueColorArray.cs | 33 +++++ .../Entities/ColorMaps/ValueColorRange.cs | 15 +-- .../Services/ColorServices/ColorOperations.cs | 17 ++- .../FieldViewerViewModel.cs | 36 ++++-- .../Windows/UserControls/VerticalLegend.xaml | 14 +-- FieldVisualizer/Windows/WndFieldViewer.xaml | 2 +- .../UI/Converters/Units/Area.cs | 2 +- .../UI/Converters/Units/CrackWidth.cs | 28 +++++ .../UI/Converters/Units/Curvature.cs | 2 +- .../UI/Converters/Units/Force.cs | 2 +- .../UI/Converters/Units/Length.cs | 3 +- .../UI/Converters/Units/Moment.cs | 2 +- .../UI/Converters/Units/PlainDouble.cs | 4 +- .../UI/Converters/Units/Stress.cs | 14 ++- .../UI/Converters/Units/UnitBase.cs | 51 +++++++- .../UI/Resources/Converters.xaml | 1 + .../Infrastructure/UI/Resources/Cracks.xaml | 2 +- .../ResultViewers/CrackResultFuncFactory.cs | 7 +- .../ResultViewers/ForceResultFuncFactory.cs | 9 +- .../ResultViewers/ShowIsoFieldResult.cs | 10 +- .../CalculatorsViews/CrackDiagramLogic.cs | 10 +- .../Cracks/CrackCalculatorInputDataView.xaml | 18 ++- .../CrackCalculatorInputDataViewModel.cs | 16 ++- .../Cracks/CrackResultView.xaml | 20 +-- .../CalculatorsViews/Cracks/Cracks.xaml | 2 +- .../Cracks/TupleCrackResultView.xaml | 26 ++-- .../Cracks/TupleCrackResultViewModel.cs | 2 +- .../ForceResultLogic/DiagramFactory.cs | 8 +- .../InteractionDiagramLogic.cs | 12 +- .../ForceResultLogic/LabelsFactory.cs | 8 +- .../ForcesResultsView.xaml | 2 +- .../UserControls/SurroundDataViewModel.cs | 7 +- .../ProgressViews/TraceDocumentView.xaml | 2 +- .../UserControls/MultiplyDouble.xaml.cs | 3 +- .../Parameters/IProcessValuePairLogic.cs | 7 ++ .../Models/Parameters/IValuePair.cs | 12 ++ .../Models/Parameters/IValueParameter.cs | 4 +- .../Parameters/ProcessDoublePairLogic.cs | 65 ++++++++++ .../Parameters/ValuePair.cs} | 7 +- .../Models/Parameters/ValueParameter.cs | 2 +- .../Services/DirectRoundLogic.cs | 16 +++ .../Services/FixedRoundLogic.cs | 25 ++++ .../Services/IDigitRoundLogic.cs | 7 ++ .../Services/IMathRoundLogic.cs | 7 ++ .../Services/SmartRoundLogic.cs | 30 +++++ .../Services/Units/CommonOperation.cs | 116 ------------------ .../Services/Units/ConvertUnitLogic.cs | 85 +++++++++++++ .../Services/Units/GetUnitLogic.cs | 50 ++++++++ .../Services/Units/IConvertUnitLogic.cs | 13 ++ .../Services/Units/IGetUnitLogic.cs | 9 ++ .../Services/Units/IStringDoublePair.cs | 14 --- .../Services/Units/ProcessString.cs | 25 ++++ .../Services/Units/UnitsFactory.cs | 8 +- .../ExportGeometryResultToCSVLogic.cs | 2 +- .../NdmPrimitives/TextParametersLogic.cs | 33 ++--- .../ParamTests/ProcessDoublePairTest.cs | 27 ++++ 58 files changed, 716 insertions(+), 274 deletions(-) create mode 100644 FieldVisualizer/Entities/ColorMaps/IValueColorArray.cs create mode 100644 FieldVisualizer/Entities/ColorMaps/ValueColorArray.cs create mode 100644 StructureHelper/Infrastructure/UI/Converters/Units/CrackWidth.cs create mode 100644 StructureHelperCommon/Models/Parameters/IProcessValuePairLogic.cs create mode 100644 StructureHelperCommon/Models/Parameters/IValuePair.cs create mode 100644 StructureHelperCommon/Models/Parameters/ProcessDoublePairLogic.cs rename StructureHelperCommon/{Services/Units/StringDoublePair.cs => Models/Parameters/ValuePair.cs} (53%) create mode 100644 StructureHelperCommon/Services/DirectRoundLogic.cs create mode 100644 StructureHelperCommon/Services/FixedRoundLogic.cs create mode 100644 StructureHelperCommon/Services/IDigitRoundLogic.cs create mode 100644 StructureHelperCommon/Services/IMathRoundLogic.cs create mode 100644 StructureHelperCommon/Services/SmartRoundLogic.cs delete mode 100644 StructureHelperCommon/Services/Units/CommonOperation.cs create mode 100644 StructureHelperCommon/Services/Units/ConvertUnitLogic.cs create mode 100644 StructureHelperCommon/Services/Units/GetUnitLogic.cs create mode 100644 StructureHelperCommon/Services/Units/IConvertUnitLogic.cs create mode 100644 StructureHelperCommon/Services/Units/IGetUnitLogic.cs delete mode 100644 StructureHelperCommon/Services/Units/IStringDoublePair.cs create mode 100644 StructureHelperCommon/Services/Units/ProcessString.cs create mode 100644 StructureHelperTests/UnitTests/ParamTests/ProcessDoublePairTest.cs diff --git a/FieldVisualizer/Entities/ColorMaps/IValueColorArray.cs b/FieldVisualizer/Entities/ColorMaps/IValueColorArray.cs new file mode 100644 index 0000000..1bed0b5 --- /dev/null +++ b/FieldVisualizer/Entities/ColorMaps/IValueColorArray.cs @@ -0,0 +1,13 @@ +using System.Windows.Media; + +namespace FieldVisualizer.Entities.ColorMaps +{ + public interface IValueColorArray + { + double AverageValue { get; set; } + Color BottomColor { get; set; } + double BottomValue { get; set; } + Color TopColor { get; set; } + double TopValue { get; set; } + } +} \ No newline at end of file diff --git a/FieldVisualizer/Entities/ColorMaps/IValueColorRange.cs b/FieldVisualizer/Entities/ColorMaps/IValueColorRange.cs index 395993c..85063a2 100644 --- a/FieldVisualizer/Entities/ColorMaps/IValueColorRange.cs +++ b/FieldVisualizer/Entities/ColorMaps/IValueColorRange.cs @@ -11,25 +11,8 @@ namespace FieldVisualizer.Entities.ColorMaps /// Flag of activity /// bool IsActive { get; set; } - /// - /// Minimum value of range - /// - double BottomValue { get; set; } - /// - /// Average value of range - /// - double AverageValue { get; set; } - /// - /// Maximum value of range - /// - double TopValue {get;set;} - /// - /// Color correspondent to minimum value - /// - Color BottomColor { get; set; } - /// - /// Color correspondent to maximum value - /// - Color TopColor { get; set; } + IValueColorArray ExactValues { get; } + IValueColorArray RoundedValues { get; } + } } diff --git a/FieldVisualizer/Entities/ColorMaps/ValueColorArray.cs b/FieldVisualizer/Entities/ColorMaps/ValueColorArray.cs new file mode 100644 index 0000000..66cd001 --- /dev/null +++ b/FieldVisualizer/Entities/ColorMaps/ValueColorArray.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Media; + +namespace FieldVisualizer.Entities.ColorMaps +{ + public class ValueColorArray : IValueColorArray + { + /// + /// Minimum value of range + /// + public double BottomValue { get; set; } + /// + /// Average value of range + /// + public double AverageValue { get; set; } + /// + /// Maximum value of range + /// + public double TopValue { get; set; } + /// + /// Color correspondent to minimum value + /// + public Color BottomColor { get; set; } + /// + /// Color correspondent to maximum value + /// + public Color TopColor { get; set; } + } +} diff --git a/FieldVisualizer/Entities/ColorMaps/ValueColorRange.cs b/FieldVisualizer/Entities/ColorMaps/ValueColorRange.cs index 695cca3..6813268 100644 --- a/FieldVisualizer/Entities/ColorMaps/ValueColorRange.cs +++ b/FieldVisualizer/Entities/ColorMaps/ValueColorRange.cs @@ -7,15 +7,10 @@ namespace FieldVisualizer.Entities.ColorMaps { /// public bool IsActive { get; set; } - /// - public double BottomValue { get; set; } - /// - public double AverageValue { get; set; } - /// - public double TopValue { get; set; } - /// - public Color BottomColor { get; set; } - /// - public Color TopColor { get; set; } + + public IValueColorArray ExactValues { get; private set; } = new ValueColorArray(); + + public IValueColorArray RoundedValues { get; private set; } = new ValueColorArray(); + } } diff --git a/FieldVisualizer/Services/ColorServices/ColorOperations.cs b/FieldVisualizer/Services/ColorServices/ColorOperations.cs index d436432..412f247 100644 --- a/FieldVisualizer/Services/ColorServices/ColorOperations.cs +++ b/FieldVisualizer/Services/ColorServices/ColorOperations.cs @@ -1,6 +1,7 @@ using FieldVisualizer.Entities.ColorMaps; using FieldVisualizer.Entities.Values; using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Services; using System; using System.Collections.Generic; using System.Text; @@ -11,6 +12,7 @@ namespace FieldVisualizer.Services.ColorServices public static class ColorOperations { const byte Alpha = 0xff; + static IMathRoundLogic roundLogic = new SmartRoundLogic(); /// /// /// @@ -23,15 +25,18 @@ namespace FieldVisualizer.Services.ColorServices var colorRanges = new List(); foreach (var valueRange in valueRanges) { - IValueColorRange valueColorRange = new ValueColorRange + var valueColorRange = new ValueColorRange { IsActive = true, - BottomValue = valueRange.BottomValue, - AverageValue = (valueRange.BottomValue + valueRange.TopValue) / 2, - TopValue = valueRange.TopValue }; - valueColorRange.BottomColor = GetColorByValue(fullRange, colorMap, valueColorRange.BottomValue); - valueColorRange.TopColor = GetColorByValue(fullRange, colorMap, valueColorRange.TopValue); + valueColorRange.ExactValues.BottomValue = valueRange.BottomValue; + valueColorRange.ExactValues.AverageValue = (valueRange.BottomValue + valueRange.TopValue) / 2; + valueColorRange.ExactValues.TopValue = valueRange.TopValue; + valueColorRange.ExactValues.BottomColor = GetColorByValue(fullRange, colorMap, valueColorRange.ExactValues.BottomValue); + valueColorRange.ExactValues.TopColor = GetColorByValue(fullRange, colorMap, valueColorRange.ExactValues.TopValue); + valueColorRange.RoundedValues.BottomValue = roundLogic.RoundValue(valueColorRange.ExactValues.BottomValue); + valueColorRange.RoundedValues.AverageValue = roundLogic.RoundValue(valueColorRange.ExactValues.AverageValue); + valueColorRange.RoundedValues.TopValue = roundLogic.RoundValue(valueColorRange.ExactValues.TopValue); colorRanges.Add(valueColorRange); } return colorRanges; diff --git a/FieldVisualizer/ViewModels/FieldViewerViewModels/FieldViewerViewModel.cs b/FieldVisualizer/ViewModels/FieldViewerViewModels/FieldViewerViewModel.cs index 540abf1..ca3b3a0 100644 --- a/FieldVisualizer/ViewModels/FieldViewerViewModels/FieldViewerViewModel.cs +++ b/FieldVisualizer/ViewModels/FieldViewerViewModels/FieldViewerViewModel.cs @@ -9,6 +9,7 @@ using FieldVisualizer.Services.ColorServices; using FieldVisualizer.Services.PrimitiveServices; using FieldVisualizer.Services.ValueRanges; using FieldVisualizer.Windows.UserControls; +using StructureHelperCommon.Services; using System; using System.Collections.Generic; using System.ComponentModel; @@ -22,6 +23,7 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels { public class FieldViewerViewModel : ViewModelBase, IDataErrorInfo { + private IMathRoundLogic roundLogic = new SmartRoundLogic() { DigitQuant = 3 }; public ICommand RebuildCommand { get; } public ICommand ZoomInCommand { get; } public ICommand ZoomOutCommand { get; } @@ -159,8 +161,8 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels private ColorMapsTypes _ColorMapType; private IColorMap _ColorMap; private IValueRange valueRange; - private IEnumerable _ValueRanges; - private IEnumerable _ValueColorRanges; + private IEnumerable valueRanges; + private IEnumerable valueColorRanges; private bool setMinValue; private bool setMaxValue; private double crossLineX; @@ -190,7 +192,7 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels if ((PrimitiveSet is null) == false) { ProcessPrimitives(); - Legend.ValueColorRanges = _ValueColorRanges; + Legend.ValueColorRanges = valueColorRanges; Legend.Refresh(); } } @@ -257,14 +259,14 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels { SolidColorBrush brush = new SolidColorBrush(); brush.Color = ColorOperations.GetColorByValue(valueRange, _ColorMap, valuePrimitive.Value); - foreach (var valueRange in _ValueColorRanges) + foreach (var valueRange in valueColorRanges) { - if (valuePrimitive.Value >= valueRange.BottomValue & valuePrimitive.Value <= valueRange.TopValue & (!valueRange.IsActive)) + if (valuePrimitive.Value >= valueRange.ExactValues.BottomValue & valuePrimitive.Value <= valueRange.ExactValues.TopValue & (!valueRange.IsActive)) { brush.Color = Colors.Gray; } } - shape.ToolTip = valuePrimitive.Value; + shape.ToolTip = roundLogic.RoundValue(valuePrimitive.Value); shape.Tag = valuePrimitive; shape.Fill = brush; Canvas.SetLeft(shape, valuePrimitive.CenterX - addX - dX); @@ -301,10 +303,24 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels { UserValueRange.TopValue = UserValueRange.BottomValue; } - if (SetMinValue) { valueRange.BottomValue = UserValueRange.BottomValue; } else { UserValueRange.BottomValue = valueRange.BottomValue; } - if (SetMaxValue) { valueRange.TopValue = UserValueRange.TopValue; } else { UserValueRange.TopValue = valueRange.TopValue; } - _ValueRanges = ValueRangeOperations.DivideValueRange(valueRange, RangeNumber); - _ValueColorRanges = ColorOperations.GetValueColorRanges(valueRange, _ValueRanges, _ColorMap); + if (SetMinValue == true) + { + valueRange.BottomValue = UserValueRange.BottomValue; + } + else + { + UserValueRange.BottomValue = valueRange.BottomValue; + } + if (SetMaxValue == true) + { + valueRange.TopValue = UserValueRange.TopValue; + } + else + { + UserValueRange.TopValue = valueRange.TopValue; + } + valueRanges = ValueRangeOperations.DivideValueRange(valueRange, RangeNumber); + valueColorRanges = ColorOperations.GetValueColorRanges(valueRange, valueRanges, _ColorMap); } private void SetCrossLine(object commandParameter) { diff --git a/FieldVisualizer/Windows/UserControls/VerticalLegend.xaml b/FieldVisualizer/Windows/UserControls/VerticalLegend.xaml index 5116791..58c8315 100644 --- a/FieldVisualizer/Windows/UserControls/VerticalLegend.xaml +++ b/FieldVisualizer/Windows/UserControls/VerticalLegend.xaml @@ -20,23 +20,23 @@ - + - + - - + + - - + + - + diff --git a/FieldVisualizer/Windows/WndFieldViewer.xaml b/FieldVisualizer/Windows/WndFieldViewer.xaml index 7362c15..7a290d6 100644 --- a/FieldVisualizer/Windows/WndFieldViewer.xaml +++ b/FieldVisualizer/Windows/WndFieldViewer.xaml @@ -6,7 +6,7 @@ xmlns:FieldViewerControl="clr-namespace:FieldVisualizer.Windows.UserControls" xmlns:local="clr-namespace:FieldVisualizer.Windows" mc:Ignorable="d" - Title="FieldViewer" Height="800" Width="1200" WindowStartupLocation="CenterOwner"> + Title="FieldViewer" Height="800" Width="1200" MinHeight="400" MinWidth="800" MaxHeight="1000" MaxWidth="1500" WindowStartupLocation="CenterScreen" ShowInTaskbar="False"> diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/Area.cs b/StructureHelper/Infrastructure/UI/Converters/Units/Area.cs index 383fb7f..74a112d 100644 --- a/StructureHelper/Infrastructure/UI/Converters/Units/Area.cs +++ b/StructureHelper/Infrastructure/UI/Converters/Units/Area.cs @@ -14,7 +14,7 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units internal class Area : UnitBase { public override UnitTypes UnitType { get => UnitTypes.Area; } - public override IUnit CurrentUnit { get => CommonOperation.GetUnit(UnitType, "mm2"); } + public override IUnit CurrentUnit { get => UnitLogic.GetUnit(UnitType, "mm2"); } public override string UnitName { get => "Area"; } } } diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/CrackWidth.cs b/StructureHelper/Infrastructure/UI/Converters/Units/CrackWidth.cs new file mode 100644 index 0000000..e520311 --- /dev/null +++ b/StructureHelper/Infrastructure/UI/Converters/Units/CrackWidth.cs @@ -0,0 +1,28 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Services; +using StructureHelperCommon.Services.Units; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelper.Infrastructure.UI.Converters.Units +{ + internal class CrackWidth : UnitBase + { + public CrackWidth() + { + OperationLogic = new ConvertUnitLogic() + { + MathRoundLogic = new FixedRoundLogic() + { + DigitQuant = 3 + } + }; + } + public override UnitTypes UnitType { get => UnitTypes.Length; } + public override IUnit CurrentUnit { get => UnitLogic.GetUnit(UnitType, "mm"); } + public override string UnitName { get => "Length"; } + } +} diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/Curvature.cs b/StructureHelper/Infrastructure/UI/Converters/Units/Curvature.cs index ec5a34b..1a34053 100644 --- a/StructureHelper/Infrastructure/UI/Converters/Units/Curvature.cs +++ b/StructureHelper/Infrastructure/UI/Converters/Units/Curvature.cs @@ -11,7 +11,7 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units internal class Curvature : UnitBase { public override UnitTypes UnitType { get => UnitTypes.Curvature; } - public override IUnit CurrentUnit { get => CommonOperation.GetUnit(UnitType, "1/mm"); } + public override IUnit CurrentUnit { get => UnitLogic.GetUnit(UnitType, "1/mm"); } public override string UnitName { get => "Curvature"; } } } diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/Force.cs b/StructureHelper/Infrastructure/UI/Converters/Units/Force.cs index 408660d..941f47d 100644 --- a/StructureHelper/Infrastructure/UI/Converters/Units/Force.cs +++ b/StructureHelper/Infrastructure/UI/Converters/Units/Force.cs @@ -13,7 +13,7 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units internal class Force : UnitBase { public override UnitTypes UnitType { get => UnitTypes.Force; } - public override IUnit CurrentUnit { get => CommonOperation.GetUnit(UnitType, "kN"); } + public override IUnit CurrentUnit { get => UnitLogic.GetUnit(UnitType, "kN"); } public override string UnitName { get => "Force"; } } } diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/Length.cs b/StructureHelper/Infrastructure/UI/Converters/Units/Length.cs index 5cac7d1..e4a01e1 100644 --- a/StructureHelper/Infrastructure/UI/Converters/Units/Length.cs +++ b/StructureHelper/Infrastructure/UI/Converters/Units/Length.cs @@ -5,8 +5,9 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units { internal class Length : UnitBase { + public override UnitTypes UnitType { get => UnitTypes.Length; } - public override IUnit CurrentUnit { get => CommonOperation.GetUnit(UnitType, "mm"); } + public override IUnit CurrentUnit { get => UnitLogic.GetUnit(UnitType, "mm"); } public override string UnitName { get => "Length"; } } } diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/Moment.cs b/StructureHelper/Infrastructure/UI/Converters/Units/Moment.cs index 76f8d6d..f260d7a 100644 --- a/StructureHelper/Infrastructure/UI/Converters/Units/Moment.cs +++ b/StructureHelper/Infrastructure/UI/Converters/Units/Moment.cs @@ -11,7 +11,7 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units internal class Moment : UnitBase { public override UnitTypes UnitType { get => UnitTypes.Moment; } - public override IUnit CurrentUnit { get => CommonOperation.GetUnit(UnitType, "kNm"); } + public override IUnit CurrentUnit { get => UnitLogic.GetUnit(UnitType, "kNm"); } public override string UnitName { get => "Moment"; } } } diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/PlainDouble.cs b/StructureHelper/Infrastructure/UI/Converters/Units/PlainDouble.cs index e4958d1..48cd0ac 100644 --- a/StructureHelper/Infrastructure/UI/Converters/Units/PlainDouble.cs +++ b/StructureHelper/Infrastructure/UI/Converters/Units/PlainDouble.cs @@ -12,6 +12,8 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units { internal class PlainDouble : IValueConverter { + IConvertUnitLogic operationLogic = new ConvertUnitLogic(); + public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { try @@ -28,7 +30,7 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units { try { - return CommonOperation.ConvertToDoubleChangeComma((string)value); + return ProcessString.ConvertCommaToCultureSettings((string)value); } catch (Exception) { diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/Stress.cs b/StructureHelper/Infrastructure/UI/Converters/Units/Stress.cs index eec20ab..f07de25 100644 --- a/StructureHelper/Infrastructure/UI/Converters/Units/Stress.cs +++ b/StructureHelper/Infrastructure/UI/Converters/Units/Stress.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Services; using StructureHelperCommon.Services.Units; using System; using System.Collections.Generic; @@ -12,8 +13,19 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units { internal class Stress : UnitBase { + public override UnitTypes UnitType { get => UnitTypes.Stress; } - public override IUnit CurrentUnit { get => CommonOperation.GetUnit(UnitType, "MPa"); } + public override IUnit CurrentUnit { get => UnitLogic.GetUnit(UnitType, "MPa"); } public override string UnitName { get => "Stress"; } + public Stress() + { + OperationLogic = new ConvertUnitLogic() + { + MathRoundLogic = new SmartRoundLogic() + { + DigitQuant = 3 + } + }; + } } } diff --git a/StructureHelper/Infrastructure/UI/Converters/Units/UnitBase.cs b/StructureHelper/Infrastructure/UI/Converters/Units/UnitBase.cs index ef778b0..4955cf1 100644 --- a/StructureHelper/Infrastructure/UI/Converters/Units/UnitBase.cs +++ b/StructureHelper/Infrastructure/UI/Converters/Units/UnitBase.cs @@ -1,4 +1,7 @@ using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Parameters; +using StructureHelperCommon.Services; using StructureHelperCommon.Services.Units; using System; using System.Collections.Generic; @@ -14,19 +17,61 @@ namespace StructureHelper.Infrastructure.UI.Converters.Units { internal abstract class UnitBase : IValueConverter { + IMathRoundLogic roundLogic = new DirectRoundLogic(); + public IConvertUnitLogic OperationLogic { get; set; } = new ConvertUnitLogic(); + public IGetUnitLogic UnitLogic { get; set; } = new GetUnitLogic(); public abstract UnitTypes UnitType { get; } public abstract IUnit CurrentUnit { get; } public abstract string UnitName { get;} + /// + /// From variable to user + /// + /// + /// + /// + /// + /// public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { - return CommonOperation.Convert(CurrentUnit, UnitName, value); + var pair = OperationLogic.Convert(CurrentUnit, UnitName, value); + var result = pair.Value; + if (parameter is not null) + { + if (parameter is string paramString) + { + var logic = new ProcessDoublePairLogic() { DigitPlace = DigitPlace.Any }; + var paramPair = logic.GetValuePairByString(paramString); + string paramTextPart = paramPair.Text.ToLower(); + int paramValuePart = (int)paramPair.Value; + if (paramTextPart == "smart") + { + roundLogic = new SmartRoundLogic() { DigitQuant = paramValuePart }; + } + else if (paramTextPart == "fixed") + { + roundLogic = new FixedRoundLogic() { DigitQuant = paramValuePart }; + } + result = roundLogic.RoundValue(result); + } + } + string strValue = $"{result} {pair.Text}"; + return strValue; } - + /// + /// From user to variable + /// + /// + /// + /// + /// + /// public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { try { - return CommonOperation.ConvertBack(UnitType, CurrentUnit, value); + double result = OperationLogic.ConvertBack(UnitType, CurrentUnit, value); + + return result; } catch (Exception) { diff --git a/StructureHelper/Infrastructure/UI/Resources/Converters.xaml b/StructureHelper/Infrastructure/UI/Resources/Converters.xaml index cfda1fd..f02301e 100644 --- a/StructureHelper/Infrastructure/UI/Resources/Converters.xaml +++ b/StructureHelper/Infrastructure/UI/Resources/Converters.xaml @@ -12,5 +12,6 @@ + \ No newline at end of file diff --git a/StructureHelper/Infrastructure/UI/Resources/Cracks.xaml b/StructureHelper/Infrastructure/UI/Resources/Cracks.xaml index 0e11fa7..12f6a73 100644 --- a/StructureHelper/Infrastructure/UI/Resources/Cracks.xaml +++ b/StructureHelper/Infrastructure/UI/Resources/Cracks.xaml @@ -1,7 +1,7 @@  - +