From 3eb5aa2b96ea39bf58b3dfc0568a6e580fb0452f Mon Sep 17 00:00:00 2001 From: RedikultsevEvg Date: Sun, 4 Aug 2024 23:01:10 +0500 Subject: [PATCH] Force crack calculator was fixed --- .../CalculatorsViews/CrackDiagramLogic.cs | 6 +- .../CrackCalculatorInputDataViewModel.cs | 2 +- .../ForceResultLogic/ShowCrackResultLogic.cs | 11 +- .../AnalysisViewModelLogic.cs | 2 +- .../Interfaces/ICheckEntityLogic.cs | 13 ++ .../Infrastructures/Interfaces/ICheckLogic.cs | 10 ++ .../Models/Calculators/CheckAccuracyLogic.cs | 62 +++++++ .../Calculators/FindParameterCalculator.cs | 21 +-- .../FindParameterCalculatorInputData.cs | 24 +++ .../Calculators/IFindParameterCalculator.cs | 8 + .../IFindParameterCalculatorInputData.cs | 23 +++ .../Models/Loggers/ITraceLogger.cs | 3 +- .../Models/Loggers/ShiftTraceLogger.cs | 7 +- .../Models/Loggers/TraceLogger.cs | 7 +- .../CrossSections/CalculatorLogic.cs | 2 +- .../ByForces/CheckForceCalculatorInputData.cs | 70 ++++++-- .../Analyses/ByForces/ForceCalculator.cs | 52 +++--- .../Analyses/ByForces/ForceCalculatorLogic.cs | 7 +- .../Analyses/ByForces/ForceInputData.cs | 2 +- .../Analyses/ByForces/ForceTupleCalculator.cs | 141 ++++++---------- .../ByForces/IForceCalculatorLogic.cs | 2 +- .../Analyses/ByForces/IForceInputData.cs | 18 ++ .../ByForces/IForceTupleCalculator.cs | 2 +- .../Analyses/ByForces/IForceTupleInputData.cs | 2 +- .../LimitCurve/Factories/PredicateFactory.cs | 2 +- .../LimitCurve/LimitCurveParameterLogic.cs | 6 +- .../Logics/CheckForceTupleInputDataLogic.cs | 84 ++++++++++ .../ByForces/Logics/ForceTupleCalcLogic.cs | 155 ++++++++++++++++++ .../ByForces/Logics/IForceTupleCalcLogic.cs | 17 ++ .../CheckCrackCalculatorInputDataLogic.cs | 4 +- .../CheckCrackForceCalculatorInputData.cs | 63 +++++++ .../Cracking/CrackCalculator.cs | 10 +- ...putData.cs => CrackCalculatorInputData.cs} | 4 +- .../Cracking/CrackCalculatorUpdateStrategy.cs | 4 +- ...cs => CrackForceBynarySearchCalculator.cs} | 104 +++++++----- .../Cracking/CrackForceCalculatorInputData.cs | 24 +++ .../CrackForceSteppedSearchCalculator.cs | 30 ++++ .../Cracking/CrackInputDataUpdateStrategy.cs | 4 +- .../Cracking/CrackedConcreteNdmLogic.cs | 2 +- .../CrackWidthLogicInputDataFactory.cs | 2 +- .../Cracking/ICrackForceCalculator.cs | 10 ++ ...c.cs => ICrackForceCalculatorInputData.cs} | 9 +- .../Cracking/ICrackWidthTupleResult.cs | 15 +- .../IIsSectionCrackedByFactorLogic.cs | 34 ++++ ...ic.cs => IIsSectionCrackedByForceLogic.cs} | 4 +- ...ic.cs => IsSectionCrackedByFactorLogic.cs} | 21 ++- ...gic.cs => IsSectionCrackedByForceLogic.cs} | 15 +- .../Cracking/RebarCrackInputData.cs | 14 +- .../Cracking/RebarCrackInputDataFactory.cs | 4 +- .../RebarStressSofteningLogic.cs | 20 +-- .../Triangulations/RebarTriangulationLogic.cs | 6 +- .../CrackCalculatorTest.cs | 6 +- .../CheckForceTupleInputDataLogicTests.cs | 136 +++++++++++++++ .../UnitTests/Calcuators/FindParameterTest.cs | 25 ++- 54 files changed, 1031 insertions(+), 300 deletions(-) create mode 100644 StructureHelperCommon/Infrastructures/Interfaces/ICheckEntityLogic.cs create mode 100644 StructureHelperCommon/Models/Calculators/CheckAccuracyLogic.cs create mode 100644 StructureHelperCommon/Models/Calculators/FindParameterCalculatorInputData.cs create mode 100644 StructureHelperCommon/Models/Calculators/IFindParameterCalculator.cs create mode 100644 StructureHelperCommon/Models/Calculators/IFindParameterCalculatorInputData.cs create mode 100644 StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceInputData.cs create mode 100644 StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs create mode 100644 StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs create mode 100644 StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/IForceTupleCalcLogic.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs rename StructureHelperLogics/NdmCalculations/Cracking/{CrackInputData.cs => CrackCalculatorInputData.cs} (88%) rename StructureHelperLogics/NdmCalculations/Cracking/{CrackForceCalculator.cs => CrackForceBynarySearchCalculator.cs} (70%) create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculatorInputData.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculator.cs rename StructureHelperLogics/NdmCalculations/Cracking/{ICrackedLogic.cs => ICrackForceCalculatorInputData.cs} (59%) create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByFactorLogic.cs rename StructureHelperLogics/NdmCalculations/Cracking/{ISectionCrackedLogic.cs => IIsSectionCrackedByForceLogic.cs} (89%) rename StructureHelperLogics/NdmCalculations/Cracking/{CrackedLogic.cs => IsSectionCrackedByFactorLogic.cs} (54%) rename StructureHelperLogics/NdmCalculations/Cracking/{SectionCrackedLogic.cs => IsSectionCrackedByForceLogic.cs} (88%) create mode 100644 StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs index 0a41407..d16f1db 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs @@ -23,7 +23,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews { static IConvertUnitLogic operationLogic = new ConvertUnitLogic(); static IGetUnitLogic unitLogic = new GetUnitLogic(); - static readonly CrackForceCalculator calculator = new(); + static readonly CrackForceBynarySearchCalculator calculator = new(); private ITriangulatePrimitiveLogic triangulateLogic; private List ValidTupleList { get; set; } @@ -103,7 +103,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews validTupleList[i].DesignForceTuple.ForceTuple.My * unitMoment.Multiplyer, validTupleList[i].DesignForceTuple.ForceTuple.Nz * unitForce.Multiplyer }; - calculator.EndTuple = validTupleList[i].DesignForceTuple.ForceTuple; + calculator.InputData.EndTuple = validTupleList[i].DesignForceTuple.ForceTuple; var limitState = validTupleList[i].DesignForceTuple.LimitState; var calcTerm = validTupleList[i].DesignForceTuple.CalcTerm; triangulateLogic = new TriangulatePrimitiveLogic() @@ -114,7 +114,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews TraceLogger = TraceLogger }; var ndms = triangulateLogic.GetNdms(); - calculator.NdmCollection = ndms; + calculator.InputData.CheckedNdmCollection = calculator.InputData.SectionNdmCollection = ndms; calculator.Run(); var result = (CrackForceResult)calculator.Result; if (result.IsValid == false) diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs index 0cd6bb9..1d6b331 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs @@ -15,7 +15,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews public class CrackCalculatorInputDataViewModel : OkCancelViewModelBase { private CrackCalculator calculator; - CrackInputData crackInputData; + CrackCalculatorInputData crackInputData; private bool setUserValueSofteningFactor; private double softeningFactor; private string name; diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs index f03902b..b1ef3ef 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs @@ -17,7 +17,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu { internal class ShowCrackResultLogic { - private CrackForceCalculator calculator; + private CrackForceBynarySearchCalculator calculator; private ITriangulatePrimitiveLogic triangulateLogic; public static GeometryNames GeometryNames => ProgramSetting.GeometryNames; @@ -39,17 +39,18 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu private void FindCrackFactor(IForceTuple finishDesignTuple, IForceTuple startDesignTuple) { - calculator = new CrackForceCalculator(); + calculator = new CrackForceBynarySearchCalculator(); calculator.TraceLogger = new ShiftTraceLogger(); - calculator.StartTuple = startDesignTuple; - calculator.EndTuple = finishDesignTuple; + calculator.InputData.StartTuple = startDesignTuple; + calculator.InputData.EndTuple = finishDesignTuple; triangulateLogic = new TriangulatePrimitiveLogic() { Primitives = ndmPrimitives, LimitState = LimitState, CalcTerm = CalcTerm }; - calculator.NdmCollection = triangulateLogic.GetNdms(); + var ndms = triangulateLogic.GetNdms(); + calculator.InputData.CheckedNdmCollection = calculator.InputData.SectionNdmCollection = ndms; calculator.Run(); var result = (CrackForceResult)calculator.Result; if (result.IsValid) diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs index b4c206f..bce1479 100644 --- a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs +++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs @@ -59,7 +59,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections private void AddCrackCalculator() { - var inputData = new CrackInputData(); + var inputData = new CrackCalculatorInputData(); var calculator = new CrackCalculator(inputData) { Name = "New crack calculator", diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ICheckEntityLogic.cs b/StructureHelperCommon/Infrastructures/Interfaces/ICheckEntityLogic.cs new file mode 100644 index 0000000..eaa3c68 --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/ICheckEntityLogic.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public interface ICheckEntityLogic : ICheckLogic + { + TEntity Entity { get; set; } + } +} diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs b/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs index dbefc5f..cc04d86 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs @@ -6,9 +6,19 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Infrastructures.Interfaces { + /// + /// Logic for checking entities + /// public interface ICheckLogic : ILogic { + /// + /// Text result of checking + /// string CheckResult { get; } + /// + /// Start checking process + /// + /// bool Check(); } } diff --git a/StructureHelperCommon/Models/Calculators/CheckAccuracyLogic.cs b/StructureHelperCommon/Models/Calculators/CheckAccuracyLogic.cs new file mode 100644 index 0000000..e117132 --- /dev/null +++ b/StructureHelperCommon/Models/Calculators/CheckAccuracyLogic.cs @@ -0,0 +1,62 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Calculators +{ + public class CheckAccuracyLogic : ICheckEntityLogic + { + private string checkResult; + private bool result; + + public IAccuracy Entity { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public CheckAccuracyLogic(IShiftTraceLogger traceLogger) + { + TraceLogger = traceLogger; + } + + public CheckAccuracyLogic() : this (null) + { + + } + + public bool Check() + { + result = true; + if (Entity is null) + { + result = false; + string errorString = "\nAccuracy requirements is not assigned"; + TraceMessage(errorString); + } + else + { + if (Entity.IterationAccuracy <= 0) + { + result = false; + TraceMessage($"\nValue of accuracy {Entity.IterationAccuracy} must be grater than zero"); + } + if (Entity.MaxIterationCount <= 0) + { + result = false; + TraceMessage($"\nMax number of iteration {Entity.MaxIterationCount} must be grater than zero"); + } + } + return result; + } + + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs b/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs index fbfa38d..bc83347 100644 --- a/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs +++ b/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs @@ -10,14 +10,12 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Calculators { - public class FindParameterCalculator : ICalculator, IHasActionByResult + public class FindParameterCalculator : IFindParameterCalculator { FindParameterResult result; public string Name { get; set; } - public double StartValue { get; set; } - public double EndValue { get; set; } - public Predicate Predicate { get; set; } - public IAccuracy Accuracy {get;set;} + public IFindParameterCalculatorInputData InputData { get; set; } + public IAccuracy Accuracy { get; set; } public IResult Result => result; public Action ActionToOutputResults { get; set; } @@ -25,18 +23,21 @@ namespace StructureHelperCommon.Models.Calculators public FindParameterCalculator() { - StartValue = 0d; - EndValue = 1d; - Accuracy = new Accuracy() { IterationAccuracy = 0.001d, MaxIterationCount = 1000 }; + InputData = new FindParameterCalculatorInputData(); + Accuracy = new Accuracy() + { + IterationAccuracy = 0.001d, + MaxIterationCount = 1000 + }; } public void Run() { result = new(); try { - FindMinimumValue(StartValue, EndValue, Predicate); + FindMinimumValue(InputData.StartValue, InputData.EndValue, InputData.Predicate); } - catch(Exception ex) + catch (Exception ex) { result.IsValid = false; result.Description += ex; diff --git a/StructureHelperCommon/Models/Calculators/FindParameterCalculatorInputData.cs b/StructureHelperCommon/Models/Calculators/FindParameterCalculatorInputData.cs new file mode 100644 index 0000000..8db3793 --- /dev/null +++ b/StructureHelperCommon/Models/Calculators/FindParameterCalculatorInputData.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Calculators +{ + /// + public class FindParameterCalculatorInputData : IFindParameterCalculatorInputData + { + /// + public double StartValue { get; set; } + /// + public double EndValue { get; set; } + /// + public Predicate Predicate { get; set; } + public FindParameterCalculatorInputData() + { + StartValue = 0d; + EndValue = 1d; + } + } +} diff --git a/StructureHelperCommon/Models/Calculators/IFindParameterCalculator.cs b/StructureHelperCommon/Models/Calculators/IFindParameterCalculator.cs new file mode 100644 index 0000000..f4d09e1 --- /dev/null +++ b/StructureHelperCommon/Models/Calculators/IFindParameterCalculator.cs @@ -0,0 +1,8 @@ +namespace StructureHelperCommon.Models.Calculators +{ + public interface IFindParameterCalculator : ICalculator, IHasActionByResult + { + IAccuracy Accuracy { get; set; } + IFindParameterCalculatorInputData InputData { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperCommon/Models/Calculators/IFindParameterCalculatorInputData.cs b/StructureHelperCommon/Models/Calculators/IFindParameterCalculatorInputData.cs new file mode 100644 index 0000000..986ca1c --- /dev/null +++ b/StructureHelperCommon/Models/Calculators/IFindParameterCalculatorInputData.cs @@ -0,0 +1,23 @@ +using System; + +namespace StructureHelperCommon.Models.Calculators +{ + /// + /// Input data for calculators of finding parameters + /// + public interface IFindParameterCalculatorInputData : IInputData + { + /// + /// Start value of range where parameter looking for + /// + double StartValue { get; set; } + /// + /// End value of range where parameter looking for + /// + double EndValue { get; set; } + /// + /// Predicate for checking parameter for true; + /// + Predicate Predicate { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperCommon/Models/Loggers/ITraceLogger.cs b/StructureHelperCommon/Models/Loggers/ITraceLogger.cs index e22701e..d6a4689 100644 --- a/StructureHelperCommon/Models/Loggers/ITraceLogger.cs +++ b/StructureHelperCommon/Models/Loggers/ITraceLogger.cs @@ -9,7 +9,8 @@ namespace StructureHelperCommon.Models public interface ITraceLogger { List TraceLoggerEntries { get; } - void AddMessage(string message, TraceLogStatuses status = TraceLogStatuses.Info, int shiftPriority = 0); + void AddMessage(string message, TraceLogStatuses status, int shiftPriority = 0); + void AddMessage(string message); void AddMessage(string message, int priority); bool KeepErrorStatus { get; set; } } diff --git a/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs b/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs index 54c80ee..7f6d282 100644 --- a/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs +++ b/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs @@ -20,7 +20,7 @@ namespace StructureHelperCommon.Models KeepErrorStatus = true; } public ShiftTraceLogger() : this(new TraceLogger()) { } - public void AddMessage(string message, TraceLogStatuses status = TraceLogStatuses.Info, int shiftPrioriry = 0) + public void AddMessage(string message, TraceLogStatuses status, int shiftPrioriry = 0) { // if status in (fatal, error, warning) they must be kept as they are if (status <= TraceLogStatuses.Warning & KeepErrorStatus == true) @@ -57,5 +57,10 @@ namespace StructureHelperCommon.Models } Logger.TraceLoggerEntries.Add(loggerEntry); } + + public void AddMessage(string message) + { + AddMessage(message, TraceLogStatuses.Info,0); + } } } diff --git a/StructureHelperCommon/Models/Loggers/TraceLogger.cs b/StructureHelperCommon/Models/Loggers/TraceLogger.cs index 9477de3..6a5b9e3 100644 --- a/StructureHelperCommon/Models/Loggers/TraceLogger.cs +++ b/StructureHelperCommon/Models/Loggers/TraceLogger.cs @@ -19,7 +19,7 @@ namespace StructureHelperCommon.Models KeepErrorStatus = true; } - public void AddMessage(string message, TraceLogStatuses status = TraceLogStatuses.Info, int shiftPrioriry = 0) + public void AddMessage(string message, TraceLogStatuses status, int shiftPrioriry = 0) { if (status == TraceLogStatuses.Fatal) { message = $"Fatal error! {message}"; } if (status == TraceLogStatuses.Error) { message = $"Error! {message}"; } @@ -38,5 +38,10 @@ namespace StructureHelperCommon.Models Priority = priority }); } + + public void AddMessage(string message) + { + AddMessage(message, TraceLogStatuses.Info,0); + } } } diff --git a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs index df3e619..55828a3 100644 --- a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs +++ b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs @@ -16,7 +16,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections TraceLogger = new ShiftTraceLogger() }; calculators.Add(forceCalculator); - CrackInputData newInputData = new CrackInputData(); + CrackCalculatorInputData newInputData = new CrackCalculatorInputData(); var checkLogic = new CheckCrackCalculatorInputDataLogic { InputData = newInputData diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs index 6efa2d3..e2ec72a 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs @@ -1,7 +1,10 @@ -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Infrastructures.Settings; using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Cracking; using System; using System.Collections.Generic; using System.Linq; @@ -10,46 +13,77 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - internal class CheckForceCalculatorInputData : ICheckInputDataLogic + internal class CheckForceCalculatorInputData : ICheckInputDataLogic { - - public ForceInputData InputData { get; set; } + private bool result; + private string checkResult; + private ICheckEntityLogic checkAccuracyLogic; - public string CheckResult { get; private set; } + public IForceInputData InputData { get; set; } + + public string CheckResult => checkResult; public IShiftTraceLogger? TraceLogger { get; set; } - public CheckForceCalculatorInputData(ForceInputData inputData) + public CheckForceCalculatorInputData(ICheckEntityLogic checkAccuracyLogic) { - InputData = inputData; - CheckResult = string.Empty; + this.checkAccuracyLogic = checkAccuracyLogic; + } + + public CheckForceCalculatorInputData() : this(new CheckAccuracyLogic()) + { + } public bool Check() { - bool result = true; - CheckResult = string.Empty; - if (!InputData.Primitives.Any()) + result = true; + checkResult = string.Empty; + if (InputData is null) { - CheckResult += "Calculator does not contain any primitives \n"; + string errorString = ErrorStrings.ParameterIsNull + ": input data"; + TraceMessage(errorString); + throw new StructureHelperException(errorString); + } + if (InputData.Primitives is null || !InputData.Primitives.Any()) + { + TraceMessage("Calculator does not contain any primitives"); result = false; } - if (!InputData.ForceActions.Any()) + if (InputData.ForceActions is null || !InputData.ForceActions.Any()) { - CheckResult += "Calculator does not contain any forces \n"; + TraceMessage("Calculator does not contain any forces"); result = false; } - if (!InputData.LimitStatesList.Any()) + if (InputData.LimitStatesList is null || !InputData.LimitStatesList.Any()) { - CheckResult += "Calculator does not contain any limit states \n"; + TraceMessage("Calculator does not contain any limit states"); result = false; } - if (!InputData.CalcTermsList.Any()) + if (InputData.CalcTermsList is null || !InputData.CalcTermsList.Any()) { - CheckResult += "Calculator does not contain any calc term \n"; + TraceMessage("Calculator does not contain any calc term"); result = false; } + CheckAccuracy(); return result; } + + private void CheckAccuracy() + { + checkAccuracyLogic.Entity = InputData.Accuracy; + checkAccuracyLogic.TraceLogger = TraceLogger; + if (checkAccuracyLogic.Check() == false) + { + result = false; + } + TraceMessage(checkAccuracyLogic.CheckResult); + } + + private void TraceMessage(string errorString) + { + checkResult += errorString + "\n"; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs index 0f32865..f971989 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs @@ -8,8 +8,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { public class ForceCalculator : ICalculator, IHasActionByResult { - private IUpdateStrategy updateStrategy = new ForceCalculatorUpdateStrategy(); - private ICheckInputDataLogic checkInputDataLogic; + private IUpdateStrategy updateStrategy; + private ICheckInputDataLogic checkInputDataLogic; private IForceCalculatorLogic forceCalculatorLogic; @@ -19,11 +19,30 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public IShiftTraceLogger? TraceLogger { get; set; } public IResult Result { get; private set; } + public ForceCalculator(ICheckInputDataLogic checkInputDataLogic, + IForceCalculatorLogic forceCalculatorLogic, + IUpdateStrategy updateStrategy + ) + { + this.checkInputDataLogic = checkInputDataLogic; + this.forceCalculatorLogic = forceCalculatorLogic; + this.updateStrategy = updateStrategy; + + InputData = new ForceInputData(); + } + + public ForceCalculator() : + this(new CheckForceCalculatorInputData(), + new ForceCalculatorLogic(), + new ForceCalculatorUpdateStrategy()) + { + } + public void Run() { TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); - checkInputDataLogic = new CheckForceCalculatorInputData(InputData); - checkInputDataLogic.TraceLogger?.GetSimilarTraceLogger(50); + checkInputDataLogic.InputData = InputData; + checkInputDataLogic.TraceLogger = TraceLogger; if (checkInputDataLogic.Check() != true) { Result = new ForcesResults() @@ -33,6 +52,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces }; return; } + forceCalculatorLogic.InputData = InputData; if (ActionToOutputResults is not null) { forceCalculatorLogic.ActionToOutputResults = ActionToOutputResults; @@ -46,31 +66,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces throw new NotImplementedException(); } - public ForceCalculator(ForceInputData inputData, - ICheckInputDataLogic checkInputDataLogic, - IForceCalculatorLogic forceCalculatorLogic, - IUpdateStrategy updateStrategy - ) - { - this.InputData = inputData; - this.checkInputDataLogic = checkInputDataLogic; - this.forceCalculatorLogic = forceCalculatorLogic; - this.updateStrategy = updateStrategy; - } - - public ForceCalculator(ForceInputData inputData) : - this(inputData, - new CheckForceCalculatorInputData(inputData), - new ForceCalculatorLogic(inputData), - new ForceCalculatorUpdateStrategy()) - { - } - - public ForceCalculator() : this(new ForceInputData()) { } - public object Clone() { - var newCalculator = new ForceCalculator(new ForceInputData()); + var newCalculator = new ForceCalculator(); updateStrategy.Update(newCalculator, this); return newCalculator; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs index 5fdd779..f8ef86b 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs @@ -18,14 +18,11 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private IProcessorLogic eccentricityLogic; private ForceTupleBucklingLogic bucklingLogic; private ITriangulatePrimitiveLogic triangulateLogic; - public ForceInputData InputData { get; set; } + public IForceInputData InputData { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } public Action ActionToOutputResults { get; set; } - public ForceCalculatorLogic(ForceInputData inputData) - { - InputData = inputData; - } + public ForcesResults GetForcesResults() { TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceInputData.cs index 136a291..30472b5 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceInputData.cs @@ -13,7 +13,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - public class ForceInputData : IInputData, IHasPrimitives, IHasForceCombinations + public class ForceInputData : IForceInputData { public List LimitStatesList { get; private set; } public List CalcTermsList { get; private set; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs index db90dcc..3d3dfc8 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs @@ -4,6 +4,7 @@ using LoaderCalculator.Data.Ndms; using LoaderCalculator.Data.ResultData; using LoaderCalculator.Data.SourceData; using LoaderCalculator.Logics; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; @@ -13,122 +14,78 @@ using StructureHelperLogics.Services; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - public class ForceTupleCalculator : IForceTupleCalculator, IHasActionByResult + public class ForceTupleCalculator : IForceTupleCalculator { IForceTupleTraceResultLogic forceTupleTraceResultLogic; + IForcesTupleResult result; + private ICheckInputDataLogic checkInputDataLogic; + private IForceTupleCalcLogic calcLogic; + public IForceTupleInputData InputData { get; set; } public string Name { get; set; } - public IResult Result { get; private set; } + public IResult Result => result; public Action ActionToOutputResults { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } - public ForceTupleCalculator() + public ForceTupleCalculator(ICheckInputDataLogic checkInputDataLogic, IForceTupleCalcLogic calcLogic) + { + this.checkInputDataLogic = checkInputDataLogic; + this.calcLogic = calcLogic; + } + + public ForceTupleCalculator() : this(new CheckForceTupleInputDataLogic(), new ForceTupleCalcLogic()) { } + public void Run() { - Result = CalculateResult(); + PrepareNewResult(); + if (CheckInputData() == false) + { + return; + } + CalculateResult(); } - - private IForcesTupleResult CalculateResult() - { - TraceLogger?.AddMessage(string.Intern($"Calculator type: {GetType()}"), TraceLogStatuses.Service); - TraceLogger?.AddMessage(string.Intern("Calculator logic based on calculating strain in plain section by elementary parts of finished size")); - var ndmCollection = InputData.NdmCollection; - if (TraceLogger is not null) - { - TraceService.TraceNdmCollection(TraceLogger, ndmCollection); - } - var tuple = InputData.Tuple; - var accuracy = InputData.Accuracy; - TraceLogger?.AddMessage(string.Intern("Input force combination")); - TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tuple)); - var mx = tuple.Mx; - var my = tuple.My; - var nz = tuple.Nz; - TraceLogger?.AddMessage($"Required accuracy rate {accuracy.IterationAccuracy}"); - TraceLogger?.AddMessage($"Maximum iteration count {accuracy.MaxIterationCount}"); - try - { - var loaderData = new LoaderOptions - { - Preconditions = new Preconditions - { - ConditionRate = accuracy.IterationAccuracy, - MaxIterationCount = accuracy.MaxIterationCount, - StartForceMatrix = new ForceMatrix { Mx = mx, My = my, Nz = nz } - }, - ActionToOutputResults = ShowResultToTrace, - NdmCollection = ndmCollection - }; - var calculator = new Calculator(); - TraceLogger?.AddMessage(string.Intern("Calculation is started"), TraceLogStatuses.Debug); - calculator.Run(loaderData, new CancellationToken()); - TraceLogger?.AddMessage(string.Intern("Calculation result is obtained"), TraceLogStatuses.Debug); - var calcResult = calculator.Result; - if (calcResult.AccuracyRate <= accuracy.IterationAccuracy) - { - var result = new ForcesTupleResult() - { - IsValid = true, - Description = LoggerStrings.CalculationHasDone, - LoaderResults = calcResult - }; - forceTupleTraceResultLogic = new ForceTupleTraceResultLogic(ndmCollection) { TraceLogger = TraceLogger }; - forceTupleTraceResultLogic.TraceResult(result); - return result; - } - else - { - TraceLogger?.AddMessage(string.Intern("Required accuracy rate has not achieved"), TraceLogStatuses.Error); - TraceLogger?.AddMessage($"Current accuracy {calcResult.AccuracyRate}, {calcResult.IterationCounter} iteration has done", TraceLogStatuses.Warning); - return new ForcesTupleResult() - { - IsValid = false, - Description = string.Intern("Required accuracy rate has not achieved"), - LoaderResults = calcResult - }; - } - - } - catch (Exception ex) - { - TraceLogger?.AddMessage($"Critical error ocured during calculation\n{ex}", TraceLogStatuses.Error); - var result = new ForcesTupleResult() - { - IsValid = false - }; - if (ex.Message == "Calculation result is not valid: stiffness matrix is equal to zero") - { - TraceLogger?.AddMessage(string.Intern("Stiffness matrix is equal to zero\nProbably section was collapsed"), TraceLogStatuses.Error); - result.Description = string.Intern("Stiffness matrix is equal to zero\nProbably section was collapsed"); - } - else - { - result.Description = $"Error is appeared due to analysis. Error: {ex}"; - } - return result; - } - } - public object Clone() { var newItem = new ForceTupleCalculator(); return newItem; } - private static void ShowResultToConsole(ILoaderResults result) + private void CalculateResult() { - var strain = result.StrainMatrix; - //MessageBox.Show($" Текущие результаты в {result.IterationCounter} итерации:"); + calcLogic.InputData = InputData; + calcLogic.ActionToOutputResults = ActionToOutputResults; + calcLogic.TraceLogger = TraceLogger; + calcLogic.Calculate(); + result = calcLogic.Result; } - private void ShowResultToTrace(ILoaderResults result) + private void PrepareNewResult() { - var strain = result.StrainMatrix; - TraceLogger?.AddMessage($"Iteration {result.IterationCounter}, current accuracy rate {result.AccuracyRate}", TraceLogStatuses.Debug,100); + result = new ForcesTupleResult() + { + IsValid = true, + Description = string.Empty, + }; } + + private bool CheckInputData() + { + checkInputDataLogic.InputData = InputData; + checkInputDataLogic.TraceLogger = TraceLogger; + if (checkInputDataLogic.Check() == false) + { + result.IsValid = false; + result.Description += checkInputDataLogic.CheckResult; + return false; + } + return true; + } + + + } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs index 52e31a5..72fae4f 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs @@ -10,7 +10,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { public interface IForceCalculatorLogic : ILogic, IHasActionByResult { - ForceInputData InputData { get; set; } + IForceInputData InputData { get; set; } ForcesResults GetForcesResults(); } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceInputData.cs new file mode 100644 index 0000000..f77c3ea --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceInputData.cs @@ -0,0 +1,18 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Sections; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public interface IForceInputData : IInputData, IHasPrimitives, IHasForceCombinations + { + IAccuracy Accuracy { get; set; } + List CalcTermsList { get; } + ICompressedMember CompressedMember { get; set; } + List ForceCombinationLists { get; set; } + List LimitStatesList { get; } + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs index f18dc2b..90f7565 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - public interface IForceTupleCalculator : ICalculator + public interface IForceTupleCalculator : ICalculator, IHasActionByResult { IForceTupleInputData InputData {get;set;} } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs index c151d6f..857047d 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs @@ -9,7 +9,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - public interface IForceTupleInputData + public interface IForceTupleInputData : IInputData { IEnumerable NdmCollection { get; set; } IForceTuple Tuple { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs index a6976d0..be5405b 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs @@ -83,7 +83,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private bool IsSectionCracked(IPoint2D point2D) { logger?.TraceLoggerEntries.Clear(); - var logic = new SectionCrackedLogic(); + var logic = new IsSectionCrackedByForceLogic(); var point3D = ConvertLogic.GetPoint3D(point2D); tuple = new() { diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs index 57ebf48..bdbdeb5 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs @@ -20,10 +20,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public double GetParameter() { - var parameterCalculator = new FindParameterCalculator() - { - Predicate = GetFactorPredicate, - }; + var parameterCalculator = new FindParameterCalculator(); + parameterCalculator.InputData.Predicate = GetFactorPredicate; if (TraceLogger is not null) { parameterCalculator.TraceLogger = TraceLogger; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs new file mode 100644 index 0000000..41886d7 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs @@ -0,0 +1,84 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public class CheckForceTupleInputDataLogic : ICheckInputDataLogic + { + private bool result; + private string checkResult; + + public IForceTupleInputData InputData { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public CheckForceTupleInputDataLogic(IForceTupleInputData inputData, IShiftTraceLogger traceLogger) + { + InputData = inputData; + TraceLogger = traceLogger; + } + + public CheckForceTupleInputDataLogic() + { + + } + + public bool Check() + { + result = true; + checkResult = string.Empty; + if (InputData is null) + { + string errorString = ErrorStrings.ParameterIsNull + ": Input data"; + TraceLogger?.AddMessage(errorString); + throw new StructureHelperException(errorString); + } + if (InputData.NdmCollection is null || ! InputData.NdmCollection.Any()) + { + result = false; + string errorString = "\nNdm collection is null or empty"; + TraceMessage(errorString); + } + if (InputData.Tuple is null) + { + result = false; + string errorString = "\nForce tuple is null"; + TraceMessage(errorString); + } + if (InputData.Accuracy is null) + { + result = false; + string errorString = "\nAccuracy requirements is not assigned"; + TraceMessage(errorString); + } + else + { + if (InputData.Accuracy.IterationAccuracy <= 0) + { + result = false; + TraceMessage($"\nValue of accuracy {InputData.Accuracy.IterationAccuracy} must be grater than zero"); + } + if (InputData.Accuracy.MaxIterationCount <= 0) + { + result = false; + TraceMessage($"\nMax number of iteration {InputData.Accuracy.MaxIterationCount} must be grater than zero"); + } + } + return result; + } + + private void TraceMessage(string errorString) + { + checkResult += errorString; + TraceLogger?.AddMessage(errorString); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs new file mode 100644 index 0000000..0a05ed3 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs @@ -0,0 +1,155 @@ +using LoaderCalculator.Data.Matrix; +using LoaderCalculator; +using LoaderCalculator.Data.ResultData; +using LoaderCalculator.Data.SourceData; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Loggers; +using StructureHelperLogics.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public class ForceTupleCalcLogic : IForceTupleCalcLogic + { + private IForcesTupleResult result; + private ForceTupleTraceResultLogic forceTupleTraceResultLogic; + private LoaderOptions loaderData; + private Calculator calculator; + private ILoaderResults calcResult; + + public IForceTupleInputData InputData { get; set; } + + public IForcesTupleResult Result => result; + + public IShiftTraceLogger? TraceLogger { get; set; } + public Action ActionToOutputResults { get; set; } + + public void Calculate() + { + PrepareNewResult(); + CalculateResult(); + } + + private void PrepareNewResult() + { + result = new ForcesTupleResult() + { + IsValid = true, + Description = string.Empty, + }; + } + + private void CalculateResult() + { + TraceStartOfCalculation(); + try + { + GetLoaderResult(); + ProcessLoaderResult(); + + } + catch (Exception ex) + { + ProcessCalculationException(ex); + } + } + + private void TraceStartOfCalculation() + { + TraceLogger?.AddMessage(string.Intern($"Calculator type: {GetType()}"), TraceLogStatuses.Service); + TraceLogger?.AddMessage(string.Intern("Calculator logic based on calculating strain in plain section by elementary parts of finished size")); + if (TraceLogger is not null) + { + TraceService.TraceNdmCollection(TraceLogger, InputData.NdmCollection); + } + TraceLogger?.AddMessage(string.Intern("Input force combination")); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.Tuple)); + TraceLogger?.AddMessage($"Required accuracy rate {InputData.Accuracy.IterationAccuracy}"); + TraceLogger?.AddMessage($"Maximum iteration count {InputData.Accuracy.MaxIterationCount}"); + } + + private void ProcessCalculationException(Exception ex) + { + TraceLogger?.AddMessage($"Critical error ocured during calculation\n{ex}", TraceLogStatuses.Error); + result.IsValid = false; + if (ex.Message == "Calculation result is not valid: stiffness matrix is equal to zero") + { + TraceLogger?.AddMessage(string.Intern("Stiffness matrix is equal to zero\nProbably section was collapsed"), TraceLogStatuses.Error); + result.Description = string.Intern("Stiffness matrix is equal to zero\nProbably section was collapsed"); + } + else + { + result.Description = $"Error is appeared due to analysis. Error: {ex}"; + } + } + + private void ProcessLoaderResult() + { + if (calcResult.AccuracyRate <= InputData.Accuracy.IterationAccuracy) + { + ProcessCorrectLoaderResult(); + } + else + { + ProcessInCorrectLoaderResult(); + } + } + + private void ProcessInCorrectLoaderResult() + { + TraceLogger?.AddMessage(string.Intern("Required accuracy rate has not achieved"), TraceLogStatuses.Error); + TraceLogger?.AddMessage($"Current accuracy {calcResult.AccuracyRate}, {calcResult.IterationCounter} iteration has done", TraceLogStatuses.Warning); + result.IsValid = false; + result.Description = string.Intern("Required accuracy rate has not achieved"); + result.LoaderResults = calcResult; + } + + private void ProcessCorrectLoaderResult() + { + result.IsValid = true; + result.Description = LoggerStrings.CalculationHasDone; + result.LoaderResults = calcResult; + forceTupleTraceResultLogic = new ForceTupleTraceResultLogic(InputData.NdmCollection) + { + TraceLogger = TraceLogger + }; + forceTupleTraceResultLogic.TraceResult(result); + } + + private void GetLoaderResult() + { + loaderData = new LoaderOptions + { + Preconditions = new Preconditions + { + ConditionRate = InputData.Accuracy.IterationAccuracy, + MaxIterationCount = InputData.Accuracy.MaxIterationCount, + StartForceMatrix = new ForceMatrix + { + Mx = InputData.Tuple.Mx, + My = InputData.Tuple.My, + Nz = InputData.Tuple.Nz + } + }, + ActionToOutputResults = ShowResultToTrace, + NdmCollection = InputData.NdmCollection + }; + calculator = new Calculator(); + TraceLogger?.AddMessage(string.Intern("Calculation is started"), TraceLogStatuses.Debug); + calculator.Run(loaderData, new CancellationToken()); + TraceLogger?.AddMessage(string.Intern("Calculation result is obtained"), TraceLogStatuses.Debug); + calcResult = calculator.Result; + } + + private void ShowResultToTrace(ILoaderResults result) + { + var strain = result.StrainMatrix; + TraceLogger?.AddMessage($"Iteration {result.IterationCounter}, current accuracy rate {result.AccuracyRate}", TraceLogStatuses.Debug, 100); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/IForceTupleCalcLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/IForceTupleCalcLogic.cs new file mode 100644 index 0000000..e709e04 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/IForceTupleCalcLogic.cs @@ -0,0 +1,17 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public interface IForceTupleCalcLogic: ILogic, IHasActionByResult + { + IForceTupleInputData InputData { get; set; } + IForcesTupleResult Result { get; } + void Calculate(); + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs index a7d958e..b032503 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs @@ -18,12 +18,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Logic of checking of input data for crack calcultor /// - public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic + public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic { private bool result; private ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic; - public CrackInputData InputData { get; set; } + public CrackCalculatorInputData InputData { get; set; } public string CheckResult { get; private set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs new file mode 100644 index 0000000..e6e2ad0 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs @@ -0,0 +1,63 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public class CheckCrackForceCalculatorInputData : ICheckInputDataLogic + { + private string checkResult; + private bool result; + public ICrackForceCalculatorInputData InputData { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public bool Check() + { + result = true; + if (InputData is null) + { + TraceMessage("InputData is null"); + return false; + } + if (InputData.CheckedNdmCollection is null || ! InputData.CheckedNdmCollection.Any()) + { + result = false; + TraceMessage("Checked ndm collection is null or empty"); + } + if (InputData.SectionNdmCollection is null || !InputData.SectionNdmCollection.Any()) + { + result = false; + TraceMessage("Section ndm collection is null or empty"); + } + if (InputData.StartTuple is null) + { + result = false; + TraceMessage("Start force tuple is null"); + } + if (InputData.EndTuple is null) + { + result = false; + TraceMessage("End force tuple is null"); + } + if (InputData.StartTuple == InputData.EndTuple) + { + result = false; + TraceMessage("Start tuple is equal to end tuple"); + } + return result; + } + + private void TraceMessage(string errorString) + { + checkResult += errorString + "\n"; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs index ba7f11c..ea7c63b 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs @@ -23,21 +23,21 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private CrackResult result; private IGetTupleInputDatasLogic datasLogic; private CrackCalculatorUpdateStrategy updateStrategy = new(); - private ICheckInputDataLogic checkInputDataLogic; + private ICheckInputDataLogic checkInputDataLogic; public string Name { get; set; } - public CrackInputData InputData { get; set; } + public CrackCalculatorInputData InputData { get; set; } public IResult Result => result; public IShiftTraceLogger? TraceLogger { get; set; } - public CrackCalculator(CrackInputData inputData, ICheckInputDataLogic checkInputDataLogic) + public CrackCalculator(CrackCalculatorInputData inputData, ICheckInputDataLogic checkInputDataLogic) { InputData = inputData; this.checkInputDataLogic = checkInputDataLogic; Name = string.Empty; } - public CrackCalculator(CrackInputData inputData) + public CrackCalculator(CrackCalculatorInputData inputData) : this(inputData, new CheckCrackCalculatorInputDataLogic() { InputData = inputData} @@ -45,7 +45,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public object Clone() { - CrackInputData crackInputData = new CrackInputData(); + CrackCalculatorInputData crackInputData = new CrackCalculatorInputData(); var checkDataLogic = new CheckCrackCalculatorInputDataLogic() { InputData = InputData diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs similarity index 88% rename from StructureHelperLogics/NdmCalculations/Cracking/CrackInputData.cs rename to StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs index 2109c3e..00e5dad 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs @@ -10,14 +10,14 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public class CrackInputData : IInputData, IHasPrimitives, IHasForceCombinations + public class CrackCalculatorInputData : IInputData, IHasPrimitives, IHasForceCombinations { /// public List Primitives { get; private set; } /// public List ForceActions { get; private set; } public UserCrackInputData UserCrackInputData { get; set; } - public CrackInputData() + public CrackCalculatorInputData() { Primitives = new(); ForceActions = new(); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs index 2ceb464..c1735aa 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs @@ -10,9 +10,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class CrackCalculatorUpdateStrategy : IUpdateStrategy { - private IUpdateStrategy inputDataUpdateStrategy; + private IUpdateStrategy inputDataUpdateStrategy; - public CrackCalculatorUpdateStrategy(IUpdateStrategy inputDataUpdateStrategy) + public CrackCalculatorUpdateStrategy(IUpdateStrategy inputDataUpdateStrategy) { this.inputDataUpdateStrategy = inputDataUpdateStrategy; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs similarity index 70% rename from StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs rename to StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs index 3f09923..23046b6 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs @@ -1,5 +1,6 @@ using LoaderCalculator.Data.Ndms; using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Infrastructures.Settings; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; @@ -11,9 +12,10 @@ using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics; namespace StructureHelperLogics.NdmCalculations.Cracking { - public class CrackForceCalculator : ICalculator + public class CrackForceBynarySearchCalculator : ICrackForceCalculator { - private CrackedLogic crackedLogic; + private IIsSectionCrackedByFactorLogic crackedByFactorLogic; + private ICheckInputDataLogic checkInputDataLogic; ExpSofteningLogic softeningLogic = new(); static readonly CrackStrainLogic crackStrainLogic = new(); static readonly SofteningFactorLogic softeningFactorLogic = new(); @@ -22,64 +24,72 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private FindParameterCalculator parameterCalculator; public string Name { get; set; } - public IForceTuple StartTuple { get; set; } - public IForceTuple EndTuple { get; set; } - public IEnumerable NdmCollection { get; set; } - public Accuracy Accuracy {get;set; } + public ICrackForceCalculatorInputData InputData { get; set; } + public Accuracy Accuracy { get; set; } public IResult Result => result; public IShiftTraceLogger? TraceLogger { get; set; } - public CrackForceCalculator(CrackedLogic crackedLogic) + public CrackForceBynarySearchCalculator( + IIsSectionCrackedByFactorLogic crackedByFactorLogic, + ICheckInputDataLogic checkInputDataLogic + ) { - StartTuple ??= new ForceTuple(); - Accuracy ??= new Accuracy() { IterationAccuracy = 0.0001d, MaxIterationCount = 10000 }; + this.crackedByFactorLogic = crackedByFactorLogic; + this.checkInputDataLogic = checkInputDataLogic; + Accuracy ??= new Accuracy() + { + IterationAccuracy = 0.0001d, + MaxIterationCount = 10000 + }; forceTupleCalculator = new ForceTupleCalculator(); - this.crackedLogic = crackedLogic; + InputData = new CrackForceCalculatorInputData(); } - public CrackForceCalculator() : this(new CrackedLogic()) + public CrackForceBynarySearchCalculator() : this(new IsSectionCrackedByFactorLogic(), new CheckCrackForceCalculatorInputData()) { - + } public void Run() { - parameterCalculator = new FindParameterCalculator() - { - Accuracy = Accuracy, - Predicate = crackedLogic.IsSectionCracked - }; + PrepareNewResult(); + if (CheckInputData() == false) { return; } + parameterCalculator = new FindParameterCalculator(); + parameterCalculator.InputData.Predicate = crackedByFactorLogic.IsSectionCracked; if (TraceLogger is not null) { forceTupleCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(100); parameterCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); - crackedLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(150); + crackedByFactorLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(150); } TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service); - result = new CrackForceResult(); TraceLogger?.AddMessage($"Start force combination"); - TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(StartTuple)); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.StartTuple)); TraceLogger?.AddMessage($"Actual (end) force combination"); - TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(EndTuple)); - crackedLogic.StartTuple = StartTuple; - crackedLogic.EndTuple = EndTuple; - crackedLogic.NdmCollection = NdmCollection; + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.EndTuple)); + crackedByFactorLogic.IsSectionCrackedByForceLogic = new IsSectionCrackedByForceLogic() + { + CheckedNdmCollection = InputData.CheckedNdmCollection, + SectionNdmCollection = InputData.SectionNdmCollection, + }; + crackedByFactorLogic.StartTuple = InputData.StartTuple; + crackedByFactorLogic.EndTuple = InputData.EndTuple; try { - Check(); + CheckInputData(); } - catch(Exception ex) + catch (Exception ex) { result.IsValid = false; result.Description += ex; return; } - if (crackedLogic.IsSectionCracked(0d) == true) + if (crackedByFactorLogic.IsSectionCracked(0d) == true) { - TraceLogger?.AddMessage($"Crack is appeared in start corce combination", TraceLogStatuses.Warning); + TraceLogger?.AddMessage($"Crack is appeared in start force combination", TraceLogStatuses.Warning); SectionCrackedAtStart(); return; } - if (crackedLogic.IsSectionCracked(1d) == false) + if (crackedByFactorLogic.IsSectionCracked(1d) == false) { TraceLogger?.AddMessage($"Crack is not appeared from actual (end) force combination", TraceLogStatuses.Warning); SectionIsNotCracked(); @@ -100,6 +110,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } } + private void PrepareNewResult() + { + result = new CrackForceResult(); + } + private void SectionIsCrackedBetween(FindParameterResult? paramResult) { var factorOfCrackAppearance = paramResult.Parameter; @@ -111,11 +126,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } softeningLogic.ForceRatio = factorOfCrackAppearance; var psiS = softeningLogic.GetSofteningFactor(); - var tupleOfCrackApeearence = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance); + var tupleOfCrackApeearence = ForceTupleService.InterpolateTuples(InputData.EndTuple, InputData.StartTuple, factorOfCrackAppearance); TraceLogger?.AddMessage($"Crack is appeared in force combination"); TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tupleOfCrackApeearence)); var reducedStrainTuple = GetReducedStrainTuple(factorOfCrackAppearance, psiS); - var crackedStrainTuple = GetStrainTuple(EndTuple); + var crackedStrainTuple = GetStrainTuple(InputData.EndTuple); TraceLogger?.AddMessage($"Strains in cracked section from actual (end) force"); TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(crackedStrainTuple)); TraceLogger?.AddMessage($"Average strains of cracked part of element"); @@ -129,14 +144,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking result.TupleOfCrackAppearance = tupleOfCrackApeearence; result.CrackedStrainTuple = crackedStrainTuple; result.ReducedStrainTuple = reducedStrainTuple; - result.SofteningFactors= softeningFactors; + result.SofteningFactors = softeningFactors; result.PsiS = psiS; TraceLogger?.AddMessage($"Valid result was obtained", TraceLogStatuses.Debug); } private StrainTuple GetSofteningFactors(StrainTuple reducedStrainTuple) { - softeningFactorLogic.NdmCollection = NdmCollection; + softeningFactorLogic.NdmCollection = InputData.SectionNdmCollection; softeningFactorLogic.StrainTuple = reducedStrainTuple; return softeningFactorLogic.GetSofteningFactors(); } @@ -144,9 +159,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private StrainTuple GetReducedStrainTuple(double factorOfCrackAppearance, double softeningFactor) { const double notCrackedForceFactor = 0.99d; - var notCrackedForceTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple; + var notCrackedForceTuple = ForceTupleService.InterpolateTuples(InputData.EndTuple, InputData.StartTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple; var crackAppearanceStrainTuple = GetStrainTuple(notCrackedForceTuple); - var actualStrainTuple = GetStrainTuple(EndTuple); + var actualStrainTuple = GetStrainTuple(InputData.EndTuple); crackStrainLogic.BeforeCrackingTuple = crackAppearanceStrainTuple; crackStrainLogic.AfterCrackingTuple = actualStrainTuple; crackStrainLogic.SofteningFactor = softeningFactor; @@ -160,10 +175,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { result.IsValid = true; result.FactorOfCrackAppearance = 0d; - result.TupleOfCrackAppearance = (IForceTuple)StartTuple.Clone(); + result.TupleOfCrackAppearance = (IForceTuple)InputData.StartTuple.Clone(); softeningLogic.ForceRatio = result.FactorOfCrackAppearance; result.PsiS = softeningLogic.GetSofteningFactor(); - result.CrackedStrainTuple = result.ReducedStrainTuple = GetStrainTuple(EndTuple); + result.CrackedStrainTuple = result.ReducedStrainTuple = GetStrainTuple(InputData.EndTuple); result.SofteningFactors = GetSofteningFactors(result.ReducedStrainTuple); result.IsSectionCracked = true; result.Description += "Section cracked in start tuple"; @@ -172,14 +187,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { result.IsValid = true; result.IsSectionCracked = false; - result.CrackedStrainTuple = result.ReducedStrainTuple = GetStrainTuple(EndTuple); + result.CrackedStrainTuple = result.ReducedStrainTuple = GetStrainTuple(InputData.EndTuple); result.SofteningFactors = GetSofteningFactors(result.ReducedStrainTuple); result.Description = "Section is not cracked"; } private StrainTuple GetStrainTuple(IForceTuple forceTuple) { ForceTupleInputData inputData = new(); - inputData.NdmCollection = NdmCollection; + inputData.NdmCollection = InputData.SectionNdmCollection; inputData.Tuple = forceTuple; forceTupleCalculator.InputData = inputData; forceTupleCalculator.Run(); @@ -188,13 +203,16 @@ namespace StructureHelperLogics.NdmCalculations.Cracking StrainTuple strainTuple = TupleConverter.ConvertToStrainTuple(loaderStrainMatrix); return strainTuple; } - private void Check() + private bool CheckInputData() { - CheckObject.IsNull(EndTuple); - if (StartTuple == EndTuple) + checkInputDataLogic.InputData = InputData; + if (checkInputDataLogic.Check() == false) { - throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": Section is not cracked"); + result.IsValid = false; + result.Description += checkInputDataLogic.CheckResult; + return false; } + return true; } public object Clone() { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculatorInputData.cs new file mode 100644 index 0000000..12c8f30 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculatorInputData.cs @@ -0,0 +1,24 @@ +using LoaderCalculator.Data.Ndms; +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 CrackForceCalculatorInputData : ICrackForceCalculatorInputData + { + public IForceTuple StartTuple { get; set; } + public IForceTuple EndTuple { get; set; } + public IEnumerable CheckedNdmCollection { get; set; } + public IEnumerable SectionNdmCollection { get; set; } + + public CrackForceCalculatorInputData() + { + StartTuple = new ForceTuple(); + EndTuple = new ForceTuple(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs new file mode 100644 index 0000000..6d26475 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs @@ -0,0 +1,30 @@ +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 CrackForceSteppedSearchCalculator : ICrackForceCalculator + { + public ICrackForceCalculatorInputData InputData { get; set; } + public string Name { get; set; } + + public IResult Result => throw new NotImplementedException(); + + public IShiftTraceLogger? TraceLogger { get; set; } + + public object Clone() + { + throw new NotImplementedException(); + } + + public void Run() + { + throw new NotImplementedException(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs index c0605be..49348fb 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs @@ -8,7 +8,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public class CrackInputDataUpdateStrategy : IUpdateStrategy + public class CrackInputDataUpdateStrategy : IUpdateStrategy { private IUpdateStrategy userCrackInputDataUpdateStrategy; public CrackInputDataUpdateStrategy(IUpdateStrategy userCrackInputDataUpdateStrategy) @@ -20,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { } - public void Update(CrackInputData targetObject, CrackInputData sourceObject) + public void Update(CrackCalculatorInputData targetObject, CrackCalculatorInputData sourceObject) { if (ReferenceEquals(targetObject, sourceObject)) { return; } CheckObject.CompareTypes(targetObject, sourceObject); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs index 42ce24b..86c7e50 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs @@ -10,7 +10,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { /// - public class CrackedConcreteNdmLogic : ISectionCrackedLogic + public class CrackedConcreteNdmLogic : IIsSectionCrackedByForceLogic { /// public INdm ConcreteNdm { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs index 08bed13..8cf37d0 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs @@ -58,7 +58,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking data.PsiSFactor = softeningLogic.GetSofteningFactor(); data.StressStateFactor = stressStateFactorLogic.GetStressStateFactor(); data.BondFactor = 0.5d; - data.Length = InputData.Length; + data.Length = InputData.LengthBeetwenCracks; data.ConcreteStrain = ConcreteStrain; data.RebarStrain = RebarStrain; return data; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculator.cs new file mode 100644 index 0000000..1856fe2 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculator.cs @@ -0,0 +1,10 @@ +using StructureHelperCommon.Models.Calculators; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public interface ICrackForceCalculator : ICalculator + { + ICrackForceCalculatorInputData InputData { get; set; } + string Name { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackedLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculatorInputData.cs similarity index 59% rename from StructureHelperLogics/NdmCalculations/Cracking/ICrackedLogic.cs rename to StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculatorInputData.cs index b7d1190..bc4ced3 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackedLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculatorInputData.cs @@ -1,5 +1,5 @@ using LoaderCalculator.Data.Ndms; -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using System; using System.Collections.Generic; @@ -9,11 +9,12 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - internal interface ICrackedLogic : ILogic + public interface ICrackForceCalculatorInputData: IInputData { + IForceTuple StartTuple { get; set; } IForceTuple EndTuple { get; set; } - IEnumerable NdmCollection { get; set; } - bool IsSectionCracked(double factor); + IEnumerable CheckedNdmCollection { get; set; } + IEnumerable SectionNdmCollection { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs index 19cdf81..97cb29d 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs @@ -1,12 +1,23 @@ -namespace StructureHelperLogics.NdmCalculations.Cracking +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperLogics.NdmCalculations.Cracking { + /// + /// + /// public interface ICrackWidthTupleResult { /// - /// Calculated crack width + /// Calculated crack width, m /// double CrackWidth { get; set; } + /// + /// True if actual crack width less than limit one + /// bool IsCrackLessThanUltimate { get; } + /// + /// Limit crack width, m + /// double UltimateCrackWidth { get; set; } } } \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByFactorLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByFactorLogic.cs new file mode 100644 index 0000000..84b8bba --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByFactorLogic.cs @@ -0,0 +1,34 @@ +using LoaderCalculator.Data.Ndms; +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 StructureHelperLogics.NdmCalculations.Cracking +{ + /// + /// Check crack appearence beetwen start force tuple and end force tuple + /// + public interface IIsSectionCrackedByFactorLogic : ILogic + { + IIsSectionCrackedByForceLogic IsSectionCrackedByForceLogic { get; set; } + /// + /// Start force tupple + /// + IForceTuple StartTuple { get; set; } + /// + /// End force tuple + /// + IForceTuple EndTuple { get; set; } + + /// + /// Returns result of checking of crack appearence + /// + /// factor beetwen start and end tuple, 0 is start tuple, 1 is end tuple + /// true when section is cracked + bool IsSectionCracked(double factor); + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ISectionCrackedLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs similarity index 89% rename from StructureHelperLogics/NdmCalculations/Cracking/ISectionCrackedLogic.cs rename to StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs index dcbd697..3226b72 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ISectionCrackedLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs @@ -12,14 +12,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Logic for checking collection of ndms for appearance of crack /// - public interface ISectionCrackedLogic : ILogic + public interface IIsSectionCrackedByForceLogic : ILogic { /// /// Force tuple for checking of cracks appearence /// IForceTuple Tuple { get; set; } /// - /// Collection of ndms which is checking fo cracking + /// Collection of ndms which is checking for cracking /// IEnumerable CheckedNdmCollection { get; set; } /// diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackedLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs similarity index 54% rename from StructureHelperLogics/NdmCalculations/Cracking/CrackedLogic.cs rename to StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs index 2dd229d..4b7a6d6 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackedLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs @@ -11,30 +11,29 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public class CrackedLogic : ICrackedLogic + public class IsSectionCrackedByFactorLogic : IIsSectionCrackedByFactorLogic { - private ISectionCrackedLogic sectionCrackedLogic; + public IIsSectionCrackedByForceLogic IsSectionCrackedByForceLogic { get; set; } public IForceTuple StartTuple { get; set; } public IForceTuple EndTuple { get; set; } - public IEnumerable NdmCollection { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } - public CrackedLogic(ISectionCrackedLogic sectionLogic) + public IsSectionCrackedByFactorLogic(IIsSectionCrackedByForceLogic sectionLogic) { - sectionCrackedLogic = sectionLogic; + IsSectionCrackedByForceLogic = sectionLogic; } - public CrackedLogic() : this (new SectionCrackedLogic()) + + public IsSectionCrackedByFactorLogic() : this(new IsSectionCrackedByForceLogic()) { } + public bool IsSectionCracked(double factor) { - sectionCrackedLogic.TraceLogger ??= TraceLogger?.GetSimilarTraceLogger(50); - + IsSectionCrackedByForceLogic.TraceLogger ??= TraceLogger?.GetSimilarTraceLogger(50); var actualTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factor); - sectionCrackedLogic.Tuple = actualTuple; - sectionCrackedLogic.SectionNdmCollection = NdmCollection; - return sectionCrackedLogic.IsSectionCracked(); + IsSectionCrackedByForceLogic.Tuple = actualTuple; + return IsSectionCrackedByForceLogic.IsSectionCracked(); } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/SectionCrackedLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs similarity index 88% rename from StructureHelperLogics/NdmCalculations/Cracking/SectionCrackedLogic.cs rename to StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs index 4a80f9d..3aa22b3 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/SectionCrackedLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs @@ -10,16 +10,17 @@ using System.Diagnostics.Eventing.Reader; namespace StructureHelperLogics.NdmCalculations.Cracking { /// - internal class SectionCrackedLogic : ISectionCrackedLogic + internal class IsSectionCrackedByForceLogic : IIsSectionCrackedByForceLogic { static readonly IStressLogic stressLogic = new StressLogic(); + /// public IForceTuple Tuple { get; set; } public IEnumerable CheckedNdmCollection { get; set; } public IEnumerable SectionNdmCollection { get; set; } public Accuracy Accuracy { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } - public SectionCrackedLogic() + public IsSectionCrackedByForceLogic() { if (Accuracy is null) { @@ -56,15 +57,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } var strainMatrix = calcResult.LoaderResults.ForceStrainPair.StrainMatrix; IEnumerable checkedNdmCollection; - if (CheckedNdmCollection is null) - { - checkedNdmCollection = SectionNdmCollection; - } - else - { - checkedNdmCollection = CheckedNdmCollection; - } - var isSectionCracked = stressLogic.IsSectionCracked(strainMatrix, checkedNdmCollection); + var isSectionCracked = stressLogic.IsSectionCracked(strainMatrix, CheckedNdmCollection); if (isSectionCracked == true) { TraceLogger?.AddMessage($"Cracks are appeared in cross-section for current force combination"); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs index a100c6f..4b498f6 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs @@ -13,9 +13,21 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class RebarCrackInputData : IInputData { + /// + /// Collection of ndms where work of crackable material in tension was assigned according to material properties + /// public IEnumerable CrackableNdmCollection { get; set; } + /// + /// Collection of ndms where work of concrete is disabled + /// public IEnumerable CrackedNdmCollection { get; set; } + /// + /// Force tuple for calculation + /// public ForceTuple ForceTuple { get; set; } - public double Length { get; set; } + /// + /// Base length beetwen cracks + /// + public double LengthBeetwenCracks { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs index 8118c60..58cd808 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs @@ -54,14 +54,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking CrackableNdmCollection = crackableNdmsLoc, CrackedNdmCollection = crackedNdmsLoc, ForceTuple = InputData.LongTermTuple.Clone() as ForceTuple, - Length = LongLength + LengthBeetwenCracks = LongLength }; var shortRebarData = new RebarCrackInputData() { CrackableNdmCollection = crackableNdmsLoc, CrackedNdmCollection = crackedNdmsLoc, ForceTuple = InputData.ShortTermTuple.Clone() as ForceTuple, - Length = ShortLength + LengthBeetwenCracks = ShortLength }; var rebarCalculatorData = new RebarCrackCalculatorInputData() { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs index afd6958..c77ae69 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs @@ -148,22 +148,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private CrackForceResult calculateCrackTuples(ForceTuple forceTuple, IEnumerable ndms) { - var sectionCrackedLogic = new SectionCrackedLogic() + var calculator = new CrackForceBynarySearchCalculator() { - SectionNdmCollection = ndms, - CheckedNdmCollection = new List() { concreteNdm }, - //TraceLogger = TraceLogger?.GetSimilarTraceLogger(100) - }; - var crackedLogis = new CrackedLogic(sectionCrackedLogic) - { - StartTuple = new ForceTuple(), - EndTuple = forceTuple, - //TraceLogger = TraceLogger?.GetSimilarTraceLogger(100) - }; - var calculator = new CrackForceCalculator(crackedLogis) - { - NdmCollection = ndms, - EndTuple = forceTuple, Accuracy = new Accuracy() { IterationAccuracy = 0.01d, @@ -171,6 +157,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking }, //TraceLogger = TraceLogger?.GetSimilarTraceLogger(150) }; + calculator.InputData.StartTuple = new ForceTuple(); + calculator.InputData.EndTuple = forceTuple; + calculator.InputData.CheckedNdmCollection = new List() { concreteNdm }; + calculator.InputData.SectionNdmCollection = ndms; calculator.Run(); return calculator.Result as CrackForceResult; } diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs index 53e4380..37fa73a 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs @@ -66,9 +66,11 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations { CenterX = options.Center.X, CenterY = options.Center.Y, - Area = options.Area, + //Area = options.Area, //to do solve problem with additional concrete ndm + Area = 0,//options.Area, //to do solve problem with additional concrete ndm Material = material, - StressScale = -1d + //StressScale = -1d + StressScale = 1d//-1d }; NdmTransform.SetPrestrain(concreteNdm, TupleConverter.ConvertToLoaderStrainMatrix(prestrain)); return concreteNdm; diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs index 393cde9..1caa1e3 100644 --- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs +++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs @@ -34,9 +34,9 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.CrackCalculatorT CalcTerm = CalcTerms.ShortTerm }; var ndms = triangulateLogic.GetNdms(); - var calculator = new CrackForceCalculator(); - calculator.EndTuple = new ForceTuple() { Mx = -50e3d, My = -50e3d, Nz = 0d }; - calculator.NdmCollection = ndms; + var calculator = new CrackForceBynarySearchCalculator(); + calculator.InputData.EndTuple = new ForceTuple() { Mx = -50e3d, My = -50e3d, Nz = 0d }; + calculator.InputData.CheckedNdmCollection = calculator.InputData.SectionNdmCollection = ndms; //Act calculator.Run(); var result = (CrackForceResult)calculator.Result; diff --git a/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs b/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs new file mode 100644 index 0000000..045537e --- /dev/null +++ b/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs @@ -0,0 +1,136 @@ +using NUnit.Framework; +using Moq; +using System.Collections.Generic; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Primitives; +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperTests.UnitTests.Calcuators +{ + + + [TestFixture] + public class CheckForceTupleInputDataLogicTests + { + private Mock _mockInputData; + private Mock _mockTraceLogger; + private CheckForceTupleInputDataLogic _checkLogic; + + [SetUp] + public void SetUp() + { + _mockInputData = new Mock(); + _mockTraceLogger = new Mock(); + + _checkLogic = new CheckForceTupleInputDataLogic(_mockInputData.Object, _mockTraceLogger.Object); + } + + [Test] + public void Check_InputDataIsNull_ThrowsStructureHelperException() + { + // Arrange + _checkLogic = new CheckForceTupleInputDataLogic(null, _mockTraceLogger.Object); + + // Act & Assert + var ex = Assert.Throws(() => _checkLogic.Check()); + Assert.That(ex.Message, Is.EqualTo(ErrorStrings.ParameterIsNull + ": Input data")); + _mockTraceLogger.Verify(x => x.AddMessage(ErrorStrings.ParameterIsNull + ": Input data"), Times.Once); + } + + [Test] + public void Check_NdmCollectionIsNullOrEmpty_ReturnsFalseAndLogsError() + { + // Arrange + _mockInputData.Setup(x => x.NdmCollection).Returns((IEnumerable)null); + + // Act + var result = _checkLogic.Check(); + + // Assert + Assert.IsFalse(result); + //Assert.That(_checkLogic.CheckResult, Is.EqualTo("Ndm collection is null or empty")); + _mockTraceLogger.Verify(x => x.AddMessage("\nNdm collection is null or empty"), Times.Once); + } + + [Test] + public void Check_TupleIsNull_ReturnsFalseAndLogsError() + { + // Arrange + _mockInputData.Setup(x => x.NdmCollection).Returns(new List()); + _mockInputData.Setup(x => x.Tuple).Returns((IForceTuple)null); + + // Act + var result = _checkLogic.Check(); + + // Assert + Assert.IsFalse(result); + //Assert.That(_checkLogic.CheckResult, Is.EqualTo("Force tuple is null")); + _mockTraceLogger.Verify(x => x.AddMessage("\nForce tuple is null"), Times.Once); + } + + [Test] + public void Check_AccuracyIsNull_ReturnsFalseAndLogsError() + { + // Arrange + _mockInputData.Setup(x => x.NdmCollection).Returns(new List()); + _mockInputData.Setup(x => x.Tuple).Returns(new ForceTuple()); + _mockInputData.Setup(x => x.Accuracy).Returns((IAccuracy)null); + + // Act + var result = _checkLogic.Check(); + + // Assert + Assert.IsFalse(result); + //Assert.That(_checkLogic.CheckResult, Is.EqualTo("Accuracy requirements is not assigned")); + _mockTraceLogger.Verify(x => x.AddMessage("\nAccuracy requirements is not assigned"), Times.Once); + } + + [Test] + public void Check_AccuracyValuesAreInvalid_ReturnsFalseAndLogsErrors() + { + // Arrange + var mockAccuracy = new Mock(); + mockAccuracy.Setup(x => x.IterationAccuracy).Returns(0); + mockAccuracy.Setup(x => x.MaxIterationCount).Returns(0); + + _mockInputData.Setup(x => x.NdmCollection).Returns(new List()); + _mockInputData.Setup(x => x.Tuple).Returns(new ForceTuple()); + _mockInputData.Setup(x => x.Accuracy).Returns(mockAccuracy.Object); + + // Act + var result = _checkLogic.Check(); + + // Assert + Assert.IsFalse(result); + //Assert.That(_checkLogic.CheckResult, Is.EqualTo("Value of accuracy 0 must be grater than zeroMax number of iteration 0 must be grater than zero")); + _mockTraceLogger.Verify(x => x.AddMessage("\nValue of accuracy 0 must be grater than zero"), Times.Once); + _mockTraceLogger.Verify(x => x.AddMessage("\nMax number of iteration 0 must be grater than zero"), Times.Once); + } + + [Test] + public void Check_AllConditionsMet_ReturnsTrue() + { + // Arrange + var mockAccuracy = new Mock(); + mockAccuracy.Setup(x => x.IterationAccuracy).Returns(1); + mockAccuracy.Setup(x => x.MaxIterationCount).Returns(10); + + _mockInputData.Setup(x => x.NdmCollection).Returns(new List { new Mock().Object }); + _mockInputData.Setup(x => x.Tuple).Returns(new ForceTuple()); + _mockInputData.Setup(x => x.Accuracy).Returns(mockAccuracy.Object); + + // Act + var result = _checkLogic.Check(); + + // Assert + Assert.IsTrue(result); + Assert.That(_checkLogic.CheckResult, Is.EqualTo(string.Empty)); + } + } + +} diff --git a/StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs b/StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs index 7378cea..e9a3313 100644 --- a/StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs +++ b/StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs @@ -7,15 +7,14 @@ namespace StructureHelperTests.UnitTests.Calcuators { [TestCase(0d, 1d, 0.5d, 0.5d)] [TestCase(0d, 10d, 5d, 5d)] - public void Run_ShouldPass_Valid(double startValue, double EndValue, double predicateValue, double expectedValue) + public void Run_ShouldPass_Valid(double startValue, double endValue, double predicateValue, double expectedValue) { //Arrange - var calculator = new FindParameterCalculator() - { - StartValue = startValue, - EndValue = EndValue, - Predicate = x => x > predicateValue - }; + var calculator = new FindParameterCalculator(); + calculator.InputData.StartValue = startValue; + calculator.InputData.EndValue = endValue; ; + calculator.InputData.Predicate = x => x > predicateValue; + //Act calculator.Run(); var result = calculator.Result as FindParameterResult; @@ -26,15 +25,13 @@ namespace StructureHelperTests.UnitTests.Calcuators } [TestCase(0d, 1d, 5d, 5d, false)] [TestCase(0d, 10d, 15d, 15d, false)] - public void Run_ShouldPass_NotValid(double startValue, double EndValue, double predicateValue, double expectedValue, bool isValid) + public void Run_ShouldPass_NotValid(double startValue, double endValue, double predicateValue, double expectedValue, bool isValid) { //Arrange - var calculator = new FindParameterCalculator() - { - StartValue = startValue, - EndValue = EndValue, - Predicate = x => x > predicateValue - }; + var calculator = new FindParameterCalculator(); + calculator.InputData.StartValue = startValue; + calculator.InputData.EndValue = endValue; ; + calculator.InputData.Predicate = x => x > predicateValue; //Act calculator.Run(); var result = calculator.Result as FindParameterResult;