diff --git a/StructureHelperCommon/Models/Calculators/IAccuracy.cs b/StructureHelperCommon/Models/Calculators/IAccuracy.cs index 6526300..613cc19 100644 --- a/StructureHelperCommon/Models/Calculators/IAccuracy.cs +++ b/StructureHelperCommon/Models/Calculators/IAccuracy.cs @@ -1,8 +1,17 @@ namespace StructureHelperCommon.Models.Calculators { + /// + /// Rate of calculation which based on iteration of finished accuracy + /// public interface IAccuracy { + /// + /// Max accuracy of iteration + /// double IterationAccuracy { get; set; } + /// + /// Limit iteration count for calculation + /// int MaxIterationCount { get; set; } } } diff --git a/StructureHelperCommon/Models/Calculators/IInputData.cs b/StructureHelperCommon/Models/Calculators/IInputData.cs index 7b955b3..3757d8a 100644 --- a/StructureHelperCommon/Models/Calculators/IInputData.cs +++ b/StructureHelperCommon/Models/Calculators/IInputData.cs @@ -9,6 +9,9 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Calculators { + /// + /// Base interface of input data for calculation + /// public interface IInputData { } diff --git a/StructureHelperCommon/Models/Calculators/IResult.cs b/StructureHelperCommon/Models/Calculators/IResult.cs index 76ba85d..23663b8 100644 --- a/StructureHelperCommon/Models/Calculators/IResult.cs +++ b/StructureHelperCommon/Models/Calculators/IResult.cs @@ -6,12 +6,18 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Calculators { + /// + /// Base interface of result of calculation + /// public interface IResult { /// /// True if result of calculation is valid /// bool IsValid { get; set; } + /// + /// Description of result of calculation + /// string? Description { get; set; } } } diff --git a/StructureHelperCommon/Models/Loggers/ITraceLogger.cs b/StructureHelperCommon/Models/Loggers/ITraceLogger.cs index d6a4689..cb85341 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, int shiftPriority = 0); + void AddMessage(string message, TraceLogStatuses status, int shiftPriority); + void AddMessage(string message, TraceLogStatuses status); 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 7f6d282..39645c5 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, int shiftPrioriry = 0) + public void AddMessage(string message, TraceLogStatuses status, int shiftPrioriry) { // if status in (fatal, error, warning) they must be kept as they are if (status <= TraceLogStatuses.Warning & KeepErrorStatus == true) @@ -62,5 +62,10 @@ namespace StructureHelperCommon.Models { AddMessage(message, TraceLogStatuses.Info,0); } + + public void AddMessage(string message, TraceLogStatuses status) + { + AddMessage(message, status, 0); + } } } diff --git a/StructureHelperCommon/Models/Loggers/TraceLogger.cs b/StructureHelperCommon/Models/Loggers/TraceLogger.cs index 6a5b9e3..4f9a424 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, int shiftPrioriry = 0) + public void AddMessage(string message, TraceLogStatuses status, int shiftPrioriry) { if (status == TraceLogStatuses.Fatal) { message = $"Fatal error! {message}"; } if (status == TraceLogStatuses.Error) { message = $"Error! {message}"; } @@ -27,7 +27,7 @@ namespace StructureHelperCommon.Models TraceLoggerEntries.Add(new StringLogEntry() { Message = message, - Priority = LoggerService.GetPriorityByStatus(status) + Priority = LoggerService.GetPriorityByStatus(status) + shiftPrioriry, }); } public void AddMessage(string message, int priority) @@ -35,7 +35,7 @@ namespace StructureHelperCommon.Models TraceLoggerEntries.Add(new StringLogEntry() { Message = message, - Priority = priority + Priority = priority, }); } @@ -43,5 +43,14 @@ namespace StructureHelperCommon.Models { AddMessage(message, TraceLogStatuses.Info,0); } + + public void AddMessage(string message, TraceLogStatuses status) + { + TraceLoggerEntries.Add(new StringLogEntry() + { + Message = message, + Priority = LoggerService.GetPriorityByStatus(status) + }); + } } } diff --git a/StructureHelperCommon/Models/Shapes/IPointShape.cs b/StructureHelperCommon/Models/Shapes/IPointShape.cs index 9692b68..a117bc6 100644 --- a/StructureHelperCommon/Models/Shapes/IPointShape.cs +++ b/StructureHelperCommon/Models/Shapes/IPointShape.cs @@ -1,7 +1,13 @@ namespace StructureHelperCommon.Models.Shapes { + /// + /// Geomentry primitive of point + /// public interface IPointShape : IShape { + /// + /// Area of point + /// double Area { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs index f8ef86b..dc43b52 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs @@ -188,7 +188,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces var inputData = new ForceTupleInputData() { NdmCollection = ndmCollection, - Tuple = tuple, + ForceTuple = tuple, Accuracy = accuracy }; var calculator = new ForceTupleCalculator(); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs index a527203..9b446d7 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs @@ -9,11 +9,16 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { + /// public class ForceTupleInputData : IForceTupleInputData { + /// public IEnumerable NdmCollection { get; set; } - public IForceTuple Tuple { get; set; } + /// + public IForceTuple ForceTuple { get; set; } + /// public IAccuracy Accuracy { get; set; } + public ForceTupleInputData() { Accuracy ??= new Accuracy() { IterationAccuracy = 0.01d, MaxIterationCount = 1000 }; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs index 857047d..9bbff11 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs @@ -9,10 +9,22 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { + /// + /// Input data for Force Tuple Calculator + /// public interface IForceTupleInputData : IInputData { + /// + /// Collection of ndma-parts for calculation + /// IEnumerable NdmCollection { get; set; } - IForceTuple Tuple { get; set; } + /// + /// Force tuple which is used for calculation + /// + IForceTuple ForceTuple { get; set; } + /// + /// Settings of iteration + /// IAccuracy Accuracy { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs index be5405b..b189d3c 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs @@ -69,7 +69,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces Mx = point3D.X, My = point3D.Y }; - inputData.Tuple = tuple; + inputData.ForceTuple = tuple; inputData.NdmCollection = Ndms; calculator.Run(); if (logger is not null) diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs index 41886d7..7f385f5 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs @@ -47,7 +47,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces string errorString = "\nNdm collection is null or empty"; TraceMessage(errorString); } - if (InputData.Tuple is null) + if (InputData.ForceTuple is null) { result = false; string errorString = "\nForce tuple is null"; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs index 0a05ed3..976f5b0 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs @@ -68,7 +68,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces TraceService.TraceNdmCollection(TraceLogger, InputData.NdmCollection); } TraceLogger?.AddMessage(string.Intern("Input force combination")); - TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.Tuple)); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.ForceTuple)); TraceLogger?.AddMessage($"Required accuracy rate {InputData.Accuracy.IterationAccuracy}"); TraceLogger?.AddMessage($"Maximum iteration count {InputData.Accuracy.MaxIterationCount}"); } @@ -131,9 +131,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces MaxIterationCount = InputData.Accuracy.MaxIterationCount, StartForceMatrix = new ForceMatrix { - Mx = InputData.Tuple.Mx, - My = InputData.Tuple.My, - Nz = InputData.Tuple.Nz + Mx = InputData.ForceTuple.Mx, + My = InputData.ForceTuple.My, + Nz = InputData.ForceTuple.Nz } }, ActionToOutputResults = ShowResultToTrace, diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs index 88884c6..2442ded 100644 --- a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs @@ -223,7 +223,7 @@ namespace StructureHelperLogics.NdmCalculations.Buckling IForceTupleInputData inputData = new ForceTupleInputData() { NdmCollection = ndmCollection, - Tuple = tuple, Accuracy = Accuracy + ForceTuple = tuple, Accuracy = Accuracy }; IForceTupleCalculator calculator = new ForceTupleCalculator() { InputData = inputData }; return calculator; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs similarity index 100% rename from StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs rename to StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackForceCalculatorInputDataLogic.cs similarity index 94% rename from StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs rename to StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackForceCalculatorInputDataLogic.cs index e6e2ad0..0c3aab6 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackForceCalculatorInputDataLogic.cs @@ -8,7 +8,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public class CheckCrackForceCalculatorInputData : ICheckInputDataLogic + public class CheckCrackForceCalculatorInputDataLogic : ICheckInputDataLogic { private string checkResult; private bool result; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackWidthSP63InputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackWidthSP63InputDataLogic.cs new file mode 100644 index 0000000..f823346 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackWidthSP63InputDataLogic.cs @@ -0,0 +1,78 @@ +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 CheckCrackWidthSP63InputDataLogic : ICheckInputDataLogic + { + private string checkResult; + private bool result; + + public CrackWidthLogicInputDataSP63 InputData { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public CheckCrackWidthSP63InputDataLogic(IShiftTraceLogger? traceLogger) + { + this.TraceLogger = traceLogger; + } + + public CheckCrackWidthSP63InputDataLogic() :this(null) + { + + } + + public bool Check() + { + result = true; + checkResult = string.Empty; + string errorString; + if (InputData.LengthBetweenCracks <= 0d) + { + errorString = ErrorStrings.DataIsInCorrect + $": length between cracks Lcrc={InputData.LengthBetweenCracks} must be greater than zero"; + TraceMessage(errorString); + result = false; + } + if (InputData.TermFactor <= 0d) + { + errorString = ErrorStrings.DataIsInCorrect + $": Term factor fi1 {InputData.TermFactor} must be greater than zero"; + TraceMessage(errorString); + result = false; + } + if (InputData.BondFactor <= 0d) + { + errorString = ErrorStrings.DataIsInCorrect + $": Bond factor fi2 {InputData.BondFactor} must be greater than zero"; + TraceMessage(errorString); + result = false; + } + if (InputData.StressStateFactor <= 0d) + { + errorString = ErrorStrings.DataIsInCorrect + $": Stress factor fi3 factor {InputData.StressStateFactor} must be greater than zero"; + TraceMessage(errorString); + result = false; + } + if (InputData.PsiSFactor <= 0d) + { + errorString = ErrorStrings.DataIsInCorrect + $": PsiS factor {InputData.PsiSFactor} must be greater than zero"; + TraceMessage(errorString); + result = false; + } + return result; + } + + private void TraceMessage(string errorString) + { + checkResult += errorString + "\n"; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckRebarCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckRebarCrackCalculatorInputDataLogic.cs new file mode 100644 index 0000000..5394320 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckRebarCrackCalculatorInputDataLogic.cs @@ -0,0 +1,61 @@ +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.Cracking +{ + public class CheckRebarCrackCalculatorInputDataLogic : ICheckInputDataLogic + { + private string checkResult; + private bool result; + + public IRebarCrackCalculatorInputData InputData { get; set; } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public bool Check() + { + result = true; + checkResult = string.Empty; + if (InputData is null) + { + TraceMessage(ErrorStrings.ParameterIsNull + ": input data"); + result = false; + } + if (InputData.LongRebarData is null) + { + TraceMessage(ErrorStrings.ParameterIsNull + ": long term input data for rebar"); + result = false; + } + if (InputData.ShortRebarData is null) + { + TraceMessage(ErrorStrings.ParameterIsNull + ": short term input data for rebar"); + result = false; + } + if (InputData.RebarPrimitive is null) + { + TraceMessage(ErrorStrings.ParameterIsNull + ": rebar primitive"); + result = false; + } + if (InputData.UserCrackInputData is null) + { + TraceMessage(ErrorStrings.ParameterIsNull + ": user crack input data"); + result = false; + } + return result; + } + + private void TraceMessage(string errorString) + { + checkResult += errorString + "\n"; + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckTupleCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckTupleCalculatorInputDataLogic.cs similarity index 95% rename from StructureHelperLogics/NdmCalculations/Cracking/CheckTupleCalculatorInputData.cs rename to StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckTupleCalculatorInputDataLogic.cs index c59f1ec..5ec5d30 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CheckTupleCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckTupleCalculatorInputDataLogic.cs @@ -11,7 +11,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { /// - public class CheckTupleCalculatorInputData : ICheckInputDataLogic + public class CheckTupleCalculatorInputDataLogic : ICheckInputDataLogic { const string userDataIsNull = "User crack input data is null"; private const string CollectionOfPrimitivesIsNull = "Collection does not have any primitives"; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs index 23046b6..5ac3b05 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs @@ -45,7 +45,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking forceTupleCalculator = new ForceTupleCalculator(); InputData = new CrackForceCalculatorInputData(); } - public CrackForceBynarySearchCalculator() : this(new IsSectionCrackedByFactorLogic(), new CheckCrackForceCalculatorInputData()) + public CrackForceBynarySearchCalculator() : this(new IsSectionCrackedByFactorLogic(), new CheckCrackForceCalculatorInputDataLogic()) { } @@ -195,7 +195,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { ForceTupleInputData inputData = new(); inputData.NdmCollection = InputData.SectionNdmCollection; - inputData.Tuple = forceTuple; + inputData.ForceTuple = forceTuple; forceTupleCalculator.InputData = inputData; forceTupleCalculator.Run(); var result = forceTupleCalculator.Result as IForcesTupleResult; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceResult.cs index 6e05133..5647a82 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceResult.cs @@ -9,19 +9,54 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { + /// + /// Result of crack calculation + /// public class CrackForceResult : IResult { + /// public bool IsValid { get; set; } + /// public string Description { get; set; } + /// + /// True when section is cracked + /// public bool IsSectionCracked { get; set; } + /// + /// Factor of load beetwen start tuple and end tuple when cracks are appeared + /// public double FactorOfCrackAppearance { get; set; } + /// + /// Start force tuple of range where force of cracking is looking for + /// public IForceTuple StartTuple { get; set; } + /// + /// End force tuple of range where force of cracking is looking for + /// public IForceTuple EndTuple { get; set; } + /// + /// Force tuple which correspondent to first crack appearence + /// public IForceTuple TupleOfCrackAppearance { get; set; } + /// + /// General curvature in cracked section + /// public StrainTuple CrackedStrainTuple { get; set; } + /// + /// Average general curvature with considering of cracking + /// public StrainTuple ReducedStrainTuple { get; set; } + /// + /// Factor of softening of stifness with considering of cracks + /// public StrainTuple SofteningFactors { get; set; } + /// + /// Collection of ndms which crack properties looking for + /// public IEnumerable NdmCollection { get; set; } + /// + /// Common softening factor + /// public double PsiS { get; set; } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs index 49348fb..5e0acef 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs @@ -10,8 +10,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class CrackInputDataUpdateStrategy : IUpdateStrategy { - private IUpdateStrategy userCrackInputDataUpdateStrategy; - public CrackInputDataUpdateStrategy(IUpdateStrategy userCrackInputDataUpdateStrategy) + private IUpdateStrategy userCrackInputDataUpdateStrategy; + public CrackInputDataUpdateStrategy(IUpdateStrategy userCrackInputDataUpdateStrategy) { this.userCrackInputDataUpdateStrategy = userCrackInputDataUpdateStrategy; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculationLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculationLogic.cs new file mode 100644 index 0000000..c87b4f0 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculationLogic.cs @@ -0,0 +1,188 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Loggers; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public class CrackWidthCalculationLogic : ICrackWidthCalculationLogic + { + private ICrackWidthLogic crackWidthLogic; + private RebarCrackResult result; + private ICrackSofteningLogic crackSofteningLogic; + private RebarStressResult rebarStressResult; + private ICrackWidthLogicInputData acrc2InputData; + private ICrackWidthLogicInputData acrc1InputData; + private ICrackWidthLogicInputData acrc3InputData; + /// + /// Width of crack from long term loads with long term properties of concrete + /// + private double longTermLoadLongTermConcreteCrackWidth; + /// + /// Width of crack from full (include short term) loads with short term properties of concrete + /// + private double fullLoadShortConcreteCrackWidth; + /// + /// Width of crack from long term loads with short term properties of concrete + /// + private double longTermLoadShortConcreteWidth; + private IRebarStressCalculator rebarStressCalculator; + + public IRebarCrackCalculatorInputData InputData { get; set; } + public RebarCrackResult Result => result; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public CrackWidthCalculationLogic(IRebarStressCalculator rebarStressCalculator, ICrackWidthLogic crackWidthLogic, IShiftTraceLogger? traceLogger) + { + this.rebarStressCalculator = rebarStressCalculator; + this.crackWidthLogic = crackWidthLogic; + this.TraceLogger = traceLogger; + } + + public CrackWidthCalculationLogic() : this (new RebarStressCalculator(), new CrackWidthLogicSP63(), null) + { + + } + + public void Run() + { + PrepareNewResult(); + ProcessCrackWidthCalculation(); + } + + private void PrepareNewResult() + { + result = new() + { + IsValid = true, + Description = string.Empty, + }; + } + + private void ProcessCrackWidthCalculation() + { + CrackWidthRebarTupleResult longRebarResult = ProcessLongTermCalculations(); + CrackWidthRebarTupleResult shortRebarResult = ProcessShortTermCalculations(); + result.LongTermResult = longRebarResult; + result.ShortTermResult = shortRebarResult; + } + + public CrackWidthRebarTupleResult ProcessShortTermCalculations() + { + crackSofteningLogic = GetSofteningLogic(InputData.ShortRebarData); + rebarStressResult = GetRebarStressResult(InputData.ShortRebarData); + acrc2InputData = GetCrackWidthInputData(crackSofteningLogic, InputData.ShortRebarData, CalcTerms.ShortTerm); + + crackWidthLogic.InputData = acrc3InputData; + longTermLoadShortConcreteWidth = crackWidthLogic.GetCrackWidth(); + crackWidthLogic.InputData = acrc2InputData; + fullLoadShortConcreteCrackWidth = crackWidthLogic.GetCrackWidth(); + + double acrcShort = longTermLoadLongTermConcreteCrackWidth + fullLoadShortConcreteCrackWidth - longTermLoadShortConcreteWidth; + TraceLogger?.AddMessage($"Short crack width acrc = acrc,1 + acrc,2 - acrc,3 = {longTermLoadLongTermConcreteCrackWidth} + {fullLoadShortConcreteCrackWidth} - {longTermLoadShortConcreteWidth} = {acrcShort}(m)"); + var shortRebarResult = new CrackWidthRebarTupleResult() + { + CrackWidth = acrcShort, + UltimateCrackWidth = InputData.UserCrackInputData.UltimateShortCrackWidth, + RebarStressResult = rebarStressResult, + SofteningFactor = crackSofteningLogic.GetSofteningFactor() + }; + TraceCrackResult(shortRebarResult); + return shortRebarResult; + } + + public CrackWidthRebarTupleResult ProcessLongTermCalculations() + { + crackSofteningLogic = GetSofteningLogic(InputData.LongRebarData); + rebarStressResult = GetRebarStressResult(InputData.LongRebarData); + acrc1InputData = GetCrackWidthInputData(crackSofteningLogic, InputData.LongRebarData, CalcTerms.LongTerm); + acrc3InputData = GetCrackWidthInputData(crackSofteningLogic, InputData.LongRebarData, CalcTerms.ShortTerm); + crackWidthLogic.InputData = acrc1InputData; + longTermLoadLongTermConcreteCrackWidth = crackWidthLogic.GetCrackWidth(); + var longRebarResult = new CrackWidthRebarTupleResult() + { + CrackWidth = longTermLoadLongTermConcreteCrackWidth, + UltimateCrackWidth = InputData.UserCrackInputData.UltimateLongCrackWidth, + RebarStressResult = rebarStressResult, + SofteningFactor = crackSofteningLogic.GetSofteningFactor() + }; + TraceLogger?.AddMessage($"Long crack width acrc = acrc,1 = {longTermLoadLongTermConcreteCrackWidth}(m)"); + TraceLogger?.AddMessage($"Ultimate long crack width acrc,ult = {longRebarResult.UltimateCrackWidth}(m)"); + TraceCrackResult(longRebarResult); + return longRebarResult; + } + + private void TraceCrackResult(CrackWidthRebarTupleResult rebarResult) + { + if (rebarResult.IsCrackLessThanUltimate == false) + { + TraceLogger?.AddMessage($"Checking crack width is failure, actual crack width acrc = {rebarResult.CrackWidth} > ultimate crack width acrc,ult = {rebarResult.UltimateCrackWidth}", TraceLogStatuses.Warning); + } + else + { + TraceLogger?.AddMessage($"Checking crack width is ok, actual crack width acrc = {rebarResult.CrackWidth} <= ultimate crack width acrc,ult = {rebarResult.UltimateCrackWidth}"); + } + } + + private ICrackSofteningLogic GetSofteningLogic(IRebarCrackInputData rebarData) + { + ICrackSofteningLogic crackSofteningLogic; + if (InputData.UserCrackInputData.SetSofteningFactor == true) + { + crackSofteningLogic = new StabSoftetingLogic(InputData.UserCrackInputData.SofteningFactor) + { + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + } + else + { + crackSofteningLogic = new RebarStressSofteningLogic() + { + RebarPrimitive = InputData.RebarPrimitive, + InputData = rebarData, + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + } + return crackSofteningLogic; + } + + private ICrackWidthLogicInputData GetCrackWidthInputData(ICrackSofteningLogic crackSofteningLogic, IRebarCrackInputData inputData, CalcTerms calcTerm) + { + + var factoryInputData = new CrackWidthLogicInputDataFactory(crackSofteningLogic) + { + CalcTerm = calcTerm, + InputData = inputData, + RebarStrain = rebarStressResult.RebarStrain, + ConcreteStrain = rebarStressResult.ConcreteStrain, + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + var crackWidthInputData = factoryInputData.GetCrackWidthLogicInputData(); + return crackWidthInputData; + } + + public RebarStressResult GetRebarStressResult(IRebarCrackInputData inputData) + { + rebarStressCalculator.InputData.ForceTuple = inputData.ForceTuple; + rebarStressCalculator.InputData.NdmCollection = inputData.CrackedNdmCollection; + rebarStressCalculator.InputData.RebarPrimitive = InputData.RebarPrimitive; + rebarStressCalculator.Run(); + var result = rebarStressCalculator.Result as RebarStressResult; + if (result.IsValid == false) + { + string errorString = LoggerStrings.CalculationError + result.Description; + TraceLogger?.AddMessage($"Rebar name: {InputData.RebarPrimitive.Name}\n" + errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + return result; + } + + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicInputDataSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicInputDataSP63.cs index 7536a3a..269cdf0 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicInputDataSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicInputDataSP63.cs @@ -10,7 +10,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public double RebarStrain { get; set; } public double ConcreteStrain { get; set; } - public double Length { get; set; } + public double LengthBetweenCracks { get; set; } public double TermFactor { get; set; } public double BondFactor { get; set; } public double StressStateFactor { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs index 8cf70a9..f0e7a14 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Loggers; using System; @@ -6,76 +7,85 @@ using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; +using System.Windows.Documents; namespace StructureHelperLogics.NdmCalculations.Cracking { public class CrackWidthLogicSP63 : ICrackWidthLogic { CrackWidthLogicInputDataSP63 inputData; + private double widthOfCrack; + private ICheckInputDataLogic checkInputDataLogic; + public ICrackWidthLogicInputData InputData {get;set;} public IShiftTraceLogger? TraceLogger { get; set; } + public CrackWidthLogicSP63(ICheckInputDataLogic checkInputDataLogic, IShiftTraceLogger? traceLogger) + { + this.checkInputDataLogic = checkInputDataLogic; + this.TraceLogger = traceLogger; + } + + public CrackWidthLogicSP63() : this (new CheckCrackWidthSP63InputDataLogic(), null) + { + + } + public double GetCrackWidth() { 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($"Length between cracks Ls = {inputData.Length}", TraceLogStatuses.Service); + TraceLogger?.AddMessage("Method of crack width calculation based on SP 63.13330.2018"); + TraceInputData(); //check if strain of concrete greater than strain of rebar + CalculateWidthOfCrack(); + return widthOfCrack; + } + + private void CalculateWidthOfCrack() + { double rebarElongation = inputData.RebarStrain - inputData.ConcreteStrain; if (rebarElongation < 0d) { TraceLogger?.AddMessage($"Elongation of rebar is negative, may be rebar is under compression, width of crack a,crc = 0"); - return 0d; + widthOfCrack = 0d; + } + else + { + TraceLogger?.AddMessage($"Rebar elongation Epsilon = {inputData.RebarStrain} - {inputData.ConcreteStrain} = {rebarElongation}(dimensionless)"); + widthOfCrack = rebarElongation * inputData.LengthBetweenCracks; + widthOfCrack *= inputData.TermFactor * inputData.BondFactor * inputData.StressStateFactor * inputData.PsiSFactor; + TraceLogger?.AddMessage($"Width of crack a,crc = {inputData.TermFactor} * {inputData.BondFactor} * {inputData.StressStateFactor} * {inputData.PsiSFactor} * {rebarElongation} * {inputData.LengthBetweenCracks}(m) = {widthOfCrack}(m)"); } - 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 = {inputData.TermFactor} * {inputData.BondFactor} * {inputData.StressStateFactor} * {inputData.PsiSFactor} * {rebarElongation} * {inputData.Length}(m) = {width}(m)"); - return width; } - private void CheckOptions() + private void TraceInputData() + { + 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.LengthBetweenCracks}", TraceLogStatuses.Service); + } + + private bool CheckOptions() { string errorString = string.Empty; if (InputData is not CrackWidthLogicInputDataSP63) { errorString = ErrorStrings.ExpectedWas(typeof(CrackWidthLogicInputDataSP63), InputData.GetType()); - } - inputData = InputData as CrackWidthLogicInputDataSP63; - if (inputData.Length <=0d) - { - 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 greater than zero"; - - } - if (inputData.BondFactor <= 0d) - { - 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 greater than zero"; - - } - if (inputData.PsiSFactor <= 0d) - { - errorString = ErrorStrings.DataIsInCorrect + $": PsiS factor {inputData.PsiSFactor} must be greater than zero"; - } - if (errorString != string.Empty) - { - TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); throw new StructureHelperException(errorString); } + inputData = InputData as CrackWidthLogicInputDataSP63; + checkInputDataLogic.InputData = inputData; + checkInputDataLogic.TraceLogger = TraceLogger; + if (checkInputDataLogic.Check() != true) + { + throw new StructureHelperException(errorString); + return false; + } TraceLogger?.AddMessage($"Checking parameters has done succefully", TraceLogStatuses.Service); + return true; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs index 8cf37d0..1cdd6fb 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs @@ -31,7 +31,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public double ConcreteStrain { get; set;} public CalcTerms CalcTerm { get; set; } - public RebarCrackInputData InputData { get; set; } + public IRebarCrackInputData InputData { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } public CrackWidthLogicInputDataFactory(ICrackSofteningLogic softeningLogic) @@ -58,7 +58,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking data.PsiSFactor = softeningLogic.GetSofteningFactor(); data.StressStateFactor = stressStateFactorLogic.GetStressStateFactor(); data.BondFactor = 0.5d; - data.Length = InputData.LengthBeetwenCracks; + data.LengthBetweenCracks = InputData.LengthBeetwenCracks; data.ConcreteStrain = ConcreteStrain; data.RebarStrain = RebarStrain; return data; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculationLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculationLogic.cs new file mode 100644 index 0000000..35c3ddb --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculationLogic.cs @@ -0,0 +1,15 @@ +using StructureHelperCommon.Infrastructures.Interfaces; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public interface ICrackWidthCalculationLogic : ILogic + { + IRebarCrackCalculatorInputData InputData { get; set; } + RebarCrackResult Result { get; } + + void Run(); + CrackWidthRebarTupleResult ProcessLongTermCalculations(); + CrackWidthRebarTupleResult ProcessShortTermCalculations(); + RebarStressResult GetRebarStressResult(IRebarCrackInputData inputData); + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogicInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogicInputData.cs index 1ba88db..e715ce9 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogicInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogicInputData.cs @@ -1,4 +1,5 @@ -using System; +using StructureHelperCommon.Models.Calculators; +using System; using System.Collections.Generic; using System.Linq; using System.Text; @@ -6,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public interface ICrackWidthLogicInputData + public interface ICrackWidthLogicInputData : IInputData { /// /// strain of rebar, dimensionless @@ -19,6 +20,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Length between cracks in meters /// - double Length { get; set; } + double LengthBetweenCracks { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackCalculatorInputData.cs new file mode 100644 index 0000000..d375f62 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackCalculatorInputData.cs @@ -0,0 +1,28 @@ +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + /// + /// Input data for rebar crack calculator + /// + public interface IRebarCrackCalculatorInputData : IInputData + { + /// + /// Long term rebar data + /// + IRebarCrackInputData? LongRebarData { get; set; } + /// + /// Short term rebar data + /// + IRebarCrackInputData? ShortRebarData { get; set; } + /// + /// Rebar primitive + /// + IRebarPrimitive RebarPrimitive { get; set; } + /// + /// User settings for crack calculations + /// + IUserCrackInputData UserCrackInputData { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackInputData.cs new file mode 100644 index 0000000..a6c13a5 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackInputData.cs @@ -0,0 +1,29 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + /// + /// Input data for calculating of width of crack by ndm collection + /// + public interface IRebarCrackInputData : IInputData + { + /// + /// Collection of ndms where work of crackable material in tension was assigned according to material properties + /// + IEnumerable CrackableNdmCollection { get; set; } + /// + /// Collection of ndms where work of concrete is disabled + /// + IEnumerable CrackedNdmCollection { get; set; } + /// + /// Force tuple for calculation + /// + ForceTuple ForceTuple { get; set; } + /// + /// Base length beetwen cracks + /// + double LengthBeetwenCracks { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculator.cs new file mode 100644 index 0000000..4ce9d29 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculator.cs @@ -0,0 +1,9 @@ +using StructureHelperCommon.Models.Calculators; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public interface IRebarStressCalculator : ICalculator + { + IRebarStressCalculatorInputData InputData { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculatorInputData.cs new file mode 100644 index 0000000..e8947ad --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculatorInputData.cs @@ -0,0 +1,31 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + /// + /// Input data for rebar stress calculator + /// + public interface IRebarStressCalculatorInputData : IInputData + { + /// + /// Force tuple for calculting + /// + ForceTuple ForceTuple { get; set; } + /// + /// Collection of ndms of cross-section (as usual without concrete tensile strength) + /// + IEnumerable NdmCollection { get; set; } + /// + /// Rebar which stress and strain will be obtained for + /// + IRebarPrimitive RebarPrimitive { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IUserCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/IUserCrackInputData.cs new file mode 100644 index 0000000..d12a077 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/IUserCrackInputData.cs @@ -0,0 +1,14 @@ +using StructureHelperCommon.Models.Calculators; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public interface IUserCrackInputData : IInputData + { + double LengthBetweenCracks { get; set; } + bool SetLengthBetweenCracks { get; set; } + bool SetSofteningFactor { get; set; } + double SofteningFactor { get; set; } + double UltimateLongCrackWidth { get; set; } + double UltimateShortCrackWidth { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs index 3aa22b3..54601f1 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs @@ -40,7 +40,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking var inputData = new ForceTupleInputData() { Accuracy = Accuracy, - Tuple = Tuple, + ForceTuple = Tuple, NdmCollection = SectionNdmCollection }; var calculator = new ForceTupleCalculator() { InputData = inputData }; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs index c2f40f2..ad2cacc 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs @@ -1,5 +1,6 @@ using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; @@ -10,10 +11,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class RebarCrackCalculator : IRebarCrackCalculator { - private ICrackSofteningLogic crackSofteningLogic; - private ICrackWidthLogic crackWidthLogic = new CrackWidthLogicSP63(); + private ICrackWidthCalculationLogic crackWidthCalculationLogic; private RebarCrackResult result; - private RebarStressResult rebarStressResult; + private ICheckInputDataLogic checkInputDataLogic; public string Name { get; set; } public RebarCrackCalculatorInputData InputData { get; set; } @@ -22,139 +22,89 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public Action ActionToOutputResults { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } + public RebarCrackCalculator(ICheckInputDataLogic checkInputDataLogic, + ICrackWidthCalculationLogic crackWidthCalculationLogic, + IShiftTraceLogger? traceLogger) + { + this.checkInputDataLogic = checkInputDataLogic; + this.crackWidthCalculationLogic = crackWidthCalculationLogic; + this.TraceLogger = traceLogger; + } + + public RebarCrackCalculator() + : this(new CheckRebarCrackCalculatorInputDataLogic(), + new CrackWidthCalculationLogic(), + null) + { + + } + public void Run() { TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Debug); - result = new() - { - IsValid = true - }; TraceLogger?.AddMessage($"Rebar primitive {InputData.RebarPrimitive.Name}"); + PrepareNewResult(); + if (CheckInputData() != true) + { + return; + } - //double acrc1 = GetCrackWidth() - - - crackWidthLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50); try { - GetSofteningLogic(InputData.LongRebarData); - rebarStressResult = GetRebarStressResult(InputData.LongRebarData); - var dataAcrc1 = GetCrackWidthInputData(InputData.LongRebarData, CalcTerms.LongTerm); - var dataAcrc3 = GetCrackWidthInputData(InputData.LongRebarData, CalcTerms.ShortTerm); - crackWidthLogic.InputData = dataAcrc1; - var acrc1 = crackWidthLogic.GetCrackWidth(); - var longRebarResult = new CrackWidthRebarTupleResult() - { - CrackWidth = acrc1, - UltimateCrackWidth = InputData.UserCrackInputData.UltimateLongCrackWidth, - 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)"); - TraceCrackResult(longRebarResult); - - - GetSofteningLogic(InputData.ShortRebarData); - rebarStressResult = GetRebarStressResult(InputData.ShortRebarData); - var dataAcrc2 = GetCrackWidthInputData(InputData.ShortRebarData, CalcTerms.ShortTerm); - - crackWidthLogic.InputData = dataAcrc3; - var acrc3 = crackWidthLogic.GetCrackWidth(); - crackWidthLogic.InputData = dataAcrc2; - var acrc2 = crackWidthLogic.GetCrackWidth(); - - double acrcShort = acrc1 + acrc2 - acrc3; - TraceLogger?.AddMessage($"Short crack width acrc = acrc,1 + acrc,2 - acrc,3 = {acrc1} + {acrc2} - {acrc3} = {acrcShort}(m)"); - var shortRebarResult = new CrackWidthRebarTupleResult() - { - CrackWidth = acrcShort, - UltimateCrackWidth = InputData.UserCrackInputData.UltimateShortCrackWidth, - RebarStressResult = rebarStressResult, - SofteningFactor = crackSofteningLogic.GetSofteningFactor() - }; - TraceCrackResult(shortRebarResult); - result.LongTermResult = longRebarResult; - result.ShortTermResult = shortRebarResult; + ProcessCrackWidthCalculation(); } catch (Exception ex) { - TraceLogger?.AddMessage($"Error of crack width calculation {ex}", TraceLogStatuses.Error); - result.IsValid = false; - result.Description += "\n" + ex; + ProcessIncorrectCalculation(ex); } result.RebarPrimitive = InputData.RebarPrimitive; } - private void TraceCrackResult(CrackWidthRebarTupleResult rebarResult) + private bool CheckInputData() { - if (rebarResult.IsCrackLessThanUltimate == false) + checkInputDataLogic.InputData = InputData; + checkInputDataLogic.TraceLogger = TraceLogger; + if (checkInputDataLogic.Check() == true) { - TraceLogger?.AddMessage($"Checking crack width is failure, actual crack width acrc = {rebarResult.CrackWidth} > ultimate crack width acrc,ult = {rebarResult.UltimateCrackWidth}", TraceLogStatuses.Warning); - } - else - { - TraceLogger?.AddMessage($"Checking crack width is ok, actual crack width acrc = {rebarResult.CrackWidth} <= ultimate crack width acrc,ult = {rebarResult.UltimateCrackWidth}"); + return true; } + result.IsValid = false; + result.Description += checkInputDataLogic.CheckResult; + return false; } - private void GetSofteningLogic(RebarCrackInputData rebarData) + private void ProcessIncorrectCalculation(Exception ex) { - if (InputData.UserCrackInputData.SetSofteningFactor == true) - { - crackSofteningLogic = new StabSoftetingLogic(InputData.UserCrackInputData.SofteningFactor) - { - TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) - }; - } - else - { - crackSofteningLogic = new RebarStressSofteningLogic() - { - RebarPrimitive = InputData.RebarPrimitive, - InputData = rebarData, - TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) - }; - } + TraceLogger?.AddMessage($"Error of crack width calculation {ex}", TraceLogStatuses.Error); + result.IsValid = false; + result.Description += "\n" + ex; } - private ICrackWidthLogicInputData GetCrackWidthInputData(RebarCrackInputData inputData, CalcTerms calcTerm) + private void ProcessCrackWidthCalculation() { - - var factoryInputData = new CrackWidthLogicInputDataFactory(crackSofteningLogic) + crackWidthCalculationLogic.TraceLogger = TraceLogger; + crackWidthCalculationLogic.InputData = InputData; + crackWidthCalculationLogic.Run(); + if (crackWidthCalculationLogic.Result.IsValid == true) { - CalcTerm = calcTerm, - InputData = inputData, - RebarStrain = rebarStressResult.RebarStrain, - ConcreteStrain = rebarStressResult.ConcreteStrain, - TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + result = crackWidthCalculationLogic.Result; + return; + } + result.IsValid = false; + result.Description += crackWidthCalculationLogic.Result.Description; + } + + private void PrepareNewResult() + { + result = new() + { + IsValid = true, + Description = string.Empty, }; - var crackWidthInputData = factoryInputData.GetCrackWidthLogicInputData(); - return crackWidthInputData; } - public object Clone() { throw new NotImplementedException(); } - - private RebarStressResult GetRebarStressResult(RebarCrackInputData inputData) - { - var calculator = new RebarStressCalculator() - { - ForceTuple = inputData.ForceTuple, - NdmCollection = inputData.CrackedNdmCollection, - RebarPrimitive = InputData.RebarPrimitive - }; - calculator.Run(); - var result = calculator.Result as RebarStressResult; - if (result.IsValid == false) - { - string errorString = LoggerStrings.CalculationError + result.Description; - TraceLogger?.AddMessage($"Rebar name: {InputData.RebarPrimitive.Name}\n" + errorString, TraceLogStatuses.Error); - throw new StructureHelperException(errorString); - } - return result; - } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculatorInputData.cs index 085847e..2f59114 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculatorInputData.cs @@ -12,17 +12,15 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Class of input data for rebar crack calculator /// - public class RebarCrackCalculatorInputData : IInputData + public class RebarCrackCalculatorInputData : IRebarCrackCalculatorInputData { - /// - /// Long term rebar data - /// - public RebarCrackInputData? LongRebarData { get; set; } - /// - /// Short term rebar data - /// - public RebarCrackInputData? ShortRebarData { get; set; } - public RebarPrimitive RebarPrimitive { get; set; } - public UserCrackInputData UserCrackInputData { get; set; } + /// + public IRebarCrackInputData? LongRebarData { get; set; } + /// + public IRebarCrackInputData? ShortRebarData { get; set; } + /// + public IRebarPrimitive RebarPrimitive { get; set; } + /// + public IUserCrackInputData? UserCrackInputData { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs index 4b498f6..2c21cba 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs @@ -11,23 +11,16 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public class RebarCrackInputData : IInputData + /// + public class RebarCrackInputData : IRebarCrackInputData { - /// - /// 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; } - /// - /// Base length beetwen cracks - /// + /// public double LengthBeetwenCracks { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs index 74a6548..1894c13 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs @@ -20,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Specific rebar primitive /// - public RebarPrimitive RebarPrimitive { get; set; } + public IRebarPrimitive RebarPrimitive { get; set; } /// /// Result of calculation of crack for long term /// diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs index 52f0c5f..4c8358d 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs @@ -12,28 +12,75 @@ using StructureHelperLogics.NdmCalculations.Triangulations; namespace StructureHelperLogics.NdmCalculations.Cracking { - public class RebarStressCalculator : ICalculator + public class RebarStressCalculator : IRebarStressCalculator { + private const CalcTerms termOfLoadForCrackCalculation = CalcTerms.ShortTerm; + private const LimitStates limitStateForCrackCalcultion = LimitStates.SLS; private IStressLogic stressLogic; private Ndm concreteNdm; private RebarNdm rebarNdm; private RebarStressResult result; - public ForceTuple ForceTuple { get; set; } - public IEnumerable NdmCollection { get; set; } - public RebarPrimitive RebarPrimitive { get; set; } + public IRebarStressCalculatorInputData InputData { get; set; } public string Name { get; set; } public IResult Result => result; public IShiftTraceLogger? TraceLogger { get; set; } - public StrainTuple GetStrainTuple() + + public RebarStressCalculator(IStressLogic stressLogic) + { + this.stressLogic = stressLogic; + InputData = new RebarStressCalculatorInputData(); + } + public RebarStressCalculator() : this(new StressLogic()) + { + + } + + + public void Run() + { + PrepareNewResult(); + if (CheckInputData() != true) + { + return; + } + GetNdmCollectionByPrimitives(); + ProcessResult(); + } + + private bool CheckInputData() + { + return true; + } + + private void ProcessResult() + { + var strainTuple = GetStrainTuple(); + result.StrainTuple = strainTuple; + var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple); + result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm); + result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm); + result.ConcreteStrain = -concreteNdm.Prestrain; + } + + private void PrepareNewResult() + { + result = new RebarStressResult() + { + IsValid = true, + Description = string.Empty + }; + } + + private StrainTuple GetStrainTuple() { IForceTupleInputData inputData = new ForceTupleInputData() { - NdmCollection = NdmCollection, - Tuple = ForceTuple + NdmCollection = InputData.NdmCollection, + ForceTuple = InputData.ForceTuple }; IForceTupleCalculator calculator = new ForceTupleCalculator() { @@ -50,45 +97,19 @@ namespace StructureHelperLogics.NdmCalculations.Cracking var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix); return strain; } - public RebarStressCalculator(IStressLogic stressLogic) - { - this.stressLogic = stressLogic; - } - public RebarStressCalculator() : this(new StressLogic()) - { - - } - - public void Run() - { - GetNdmCollectionFromPrimitives(); - result = new RebarStressResult() - { - IsValid = true, - Description = string.Empty - }; - var strainTuple = GetStrainTuple(); - result.StrainTuple = strainTuple; - var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple); - result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm); - result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm); - result.ConcreteStrain = - concreteNdm.Prestrain; - } - - - private void GetNdmCollectionFromPrimitives() + private void GetNdmCollectionByPrimitives() { var options = new TriangulationOptions() { - CalcTerm = CalcTerms.ShortTerm, - LimiteState = LimitStates.SLS, + CalcTerm = termOfLoadForCrackCalculation, + LimiteState = limitStateForCrackCalcultion, }; - concreteNdm = RebarPrimitive.GetConcreteNdm(options); + concreteNdm = InputData.RebarPrimitive.GetConcreteNdm(options); concreteNdm.StressScale = 1d; - rebarNdm = RebarPrimitive.GetRebarNdm(options); + rebarNdm = InputData.RebarPrimitive.GetRebarNdm(options); } - + /// public object Clone() { throw new NotImplementedException(); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculatorInputData.cs new file mode 100644 index 0000000..fee7be2 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculatorInputData.cs @@ -0,0 +1,22 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + /// + public class RebarStressCalculatorInputData : IRebarStressCalculatorInputData + { + /// + public ForceTuple ForceTuple { get; set; } + /// + public IEnumerable NdmCollection { get; set; } + /// + public IRebarPrimitive RebarPrimitive { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs index c24bac3..da257ca 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs @@ -8,15 +8,30 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { + /// + /// Result of calculation of stress and strain in rebar + /// public class RebarStressResult : IResult { /// public bool IsValid { get; set; } /// public string? Description { get; set; } + /// + /// Strain tuple which stress and strain is obtained for + /// public StrainTuple StrainTuple { get; set; } + /// + /// Stress in rebar, Pa + /// public double RebarStress { get; set; } + /// + /// Strain in rebar, dimensionless + /// public double RebarStrain { get; set; } + /// + /// Strain in fake concrete ndm-part which rounds rebas and locatade at axis of rebar (refrence strain in concrete) + /// public double ConcreteStrain { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs index c77ae69..1997c14 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs @@ -28,8 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// Rebar resul for actual force combination /// private RebarStressResult actualRebarResult; - - + private TriangulationOptions options; private INdm? concreteNdm; private INdm? rebarNdm; @@ -38,8 +37,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private double rebarActualStress; private double softeningFactor; private double minValueOfFactor = 0.2d; - private RebarPrimitive rebarPrimitive; - private RebarCrackInputData inputData; + private IRebarPrimitive rebarPrimitive; + private IRebarCrackInputData inputData; public double MinValueOfFactor { @@ -49,7 +48,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking IsResultActual = false; } } - public RebarPrimitive RebarPrimitive + public IRebarPrimitive RebarPrimitive { get => rebarPrimitive; set { @@ -57,7 +56,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking IsResultActual = false; } } - public RebarCrackInputData InputData + public IRebarCrackInputData InputData { get => inputData; set { @@ -72,7 +71,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { if (IsResultActual == false) { - GetNdms(); + GetRebarAndConcreteNdms(); softeningFactor = GetPsiSFactor(InputData.ForceTuple, InputData.CrackableNdmCollection); IsResultActual = true; } @@ -80,9 +79,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } - private void GetNdms() + private void GetRebarAndConcreteNdms() { - var options = new TriangulationOptions() + options = new TriangulationOptions() { CalcTerm = CalcTerms.ShortTerm, LimiteState = LimitStates.SLS, @@ -92,10 +91,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking rebarNdm = RebarPrimitive.GetRebarNdm(options); } - private double GetPsiSFactor(ForceTuple forceTuple, IEnumerable crackableNndms) + private double GetPsiSFactor(ForceTuple forceTuple, IEnumerable crackableNdms) { - var crackResult = calculateCrackTuples(forceTuple, crackableNndms); + var crackResult = calculateCrackTuples(forceTuple, crackableNdms); if (crackResult.IsValid == false) { string errorString = LoggerStrings.CalculationError + crackResult.Description; @@ -103,7 +102,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking throw new StructureHelperException(errorString); } - actualRebarResult = GetRebarStressResult(forceTuple); + actualRebarResult = GetRebarStressResultByForceTuple(forceTuple); rebarActualStrain = actualRebarResult.RebarStrain; rebarActualStress = actualRebarResult.RebarStress; TraceLogger?.AddMessage($"Actual strain of rebar EpsilonS = {rebarActualStrain}(dimensionless)"); @@ -120,7 +119,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage($"Section is cracked in start force combination, PsiS = 1.0"); return 1d; } - crackRebarResult = GetRebarStressResult(crackResult.TupleOfCrackAppearance as ForceTuple); + crackRebarResult = GetRebarStressResultByForceTuple(crackResult.TupleOfCrackAppearance as ForceTuple); var stressInCracking = crackRebarResult.RebarStress; TraceLogger?.AddMessage($"Stress in rebar immediately after cracking Sigma,scrc = {stressInCracking}(Pa)"); @@ -165,14 +164,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking return calculator.Result as CrackForceResult; } - private RebarStressResult GetRebarStressResult(ForceTuple forceTuple) + private RebarStressResult GetRebarStressResultByForceTuple(ForceTuple forceTuple) { - var calculator = new RebarStressCalculator() - { - ForceTuple = forceTuple, - NdmCollection = InputData.CrackedNdmCollection, - RebarPrimitive = RebarPrimitive - }; + var calculator = new RebarStressCalculator(); + calculator.InputData.ForceTuple = forceTuple; + calculator.InputData.NdmCollection = InputData.CrackedNdmCollection; + calculator.InputData.RebarPrimitive = RebarPrimitive; calculator.Run(); var result = calculator.Result as RebarStressResult; if (result.IsValid == false) diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs index d4f5255..8511f3e 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs @@ -47,7 +47,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking this.checkInputDataLogic = checkInputDataLogic; } - public TupleCrackCalculator() : this (new CheckTupleCalculatorInputData()) + public TupleCrackCalculator() : this (new CheckTupleCalculatorInputDataLogic()) { } @@ -155,7 +155,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking IForceTupleInputData inputData = new ForceTupleInputData() { NdmCollection = ndms, - Tuple = forceTuple + ForceTuple = forceTuple }; IForceTupleCalculator calculator = new ForceTupleCalculator() { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputData.cs index 7816977..c9d31bd 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputData.cs @@ -10,24 +10,24 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Settings for crack calculations assigned by user /// - public class UserCrackInputData : IInputData + public class UserCrackInputData : IUserCrackInputData { /// /// Flag of assigning of user value of softening factor /// - public bool SetSofteningFactor {get;set;} + public bool SetSofteningFactor { get; set; } /// /// User value of softening factor, dimensionless /// - public double SofteningFactor {get;set;} + public double SofteningFactor { get; set; } /// /// Flag of assigning of user value of length between cracks /// - public bool SetLengthBetweenCracks {get;set;} + public bool SetLengthBetweenCracks { get; set; } /// /// Length between cracks, m /// - public double LengthBetweenCracks {get;set;} + public double LengthBetweenCracks { get; set; } /// /// Ultimate long-term crack width, m /// diff --git a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs index 910a6e8..8d2714b 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs @@ -8,9 +8,9 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - internal class UserCrackInputDataUpdateStrategy : IUpdateStrategy + internal class UserCrackInputDataUpdateStrategy : IUpdateStrategy { - public void Update(UserCrackInputData targetObject, UserCrackInputData sourceObject) + public void Update(IUserCrackInputData targetObject, IUserCrackInputData sourceObject) { if (ReferenceEquals(targetObject, sourceObject)) { return; } CheckObject.CompareTypes(targetObject, sourceObject); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/IPointPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/IPointPrimitive.cs index 75ecff6..303b662 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/IPointPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/IPointPrimitive.cs @@ -8,6 +8,9 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { + /// + /// Geometry primitive of point + /// public interface IPointPrimitive : INdmPrimitive, IPointShape { } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/IRebarPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/IRebarPrimitive.cs index ed415a7..0a5628c 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/IRebarPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/IRebarPrimitive.cs @@ -3,6 +3,9 @@ using StructureHelperLogics.NdmCalculations.Triangulations; namespace StructureHelperLogics.NdmCalculations.Primitives { + /// + /// Geometry primitive of rebar (bar of reinforcement) + /// public interface IRebarPrimitive : IPointPrimitive, IHasHostPrimitive { Ndm GetConcreteNdm(ITriangulationOptions triangulationOptions); diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs index f78021c..e0c7b38 100644 --- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs +++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs @@ -11,7 +11,7 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT { public class RCSectionsTest { - [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, -0.00068654617067958799d, -0.0030411189808055242d, 0.00034289928716916179d)] + [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, -0.00068471024318306586d, -0.0030411189808055242d, 0.00034289928716916179d)] public void Run_ShouldPass(double width, double height, double topDiametr, double bottomDiametr, int widthCount, int heightCount, bool isBuckling, double expectedKx, double expectedKy, double expectedEpsZ) { //Arrange diff --git a/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs b/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs index 045537e..a993eb5 100644 --- a/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs +++ b/StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs @@ -62,7 +62,7 @@ namespace StructureHelperTests.UnitTests.Calcuators { // Arrange _mockInputData.Setup(x => x.NdmCollection).Returns(new List()); - _mockInputData.Setup(x => x.Tuple).Returns((IForceTuple)null); + _mockInputData.Setup(x => x.ForceTuple).Returns((IForceTuple)null); // Act var result = _checkLogic.Check(); @@ -78,7 +78,7 @@ namespace StructureHelperTests.UnitTests.Calcuators { // Arrange _mockInputData.Setup(x => x.NdmCollection).Returns(new List()); - _mockInputData.Setup(x => x.Tuple).Returns(new ForceTuple()); + _mockInputData.Setup(x => x.ForceTuple).Returns(new ForceTuple()); _mockInputData.Setup(x => x.Accuracy).Returns((IAccuracy)null); // Act @@ -99,7 +99,7 @@ namespace StructureHelperTests.UnitTests.Calcuators 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.ForceTuple).Returns(new ForceTuple()); _mockInputData.Setup(x => x.Accuracy).Returns(mockAccuracy.Object); // Act @@ -121,7 +121,7 @@ namespace StructureHelperTests.UnitTests.Calcuators 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.ForceTuple).Returns(new ForceTuple()); _mockInputData.Setup(x => x.Accuracy).Returns(mockAccuracy.Object); // Act diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthCalculationLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthCalculationLogicTests.cs new file mode 100644 index 0000000..8819164 --- /dev/null +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthCalculationLogicTests.cs @@ -0,0 +1,107 @@ +using NUnit.Framework; +using Moq; +using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Cracking; + +namespace StructureHelperTests.UnitTests.Ndms.Cracks +{ + + + [TestFixture] + public class CrackWidthCalculationLogicTests + { + private Mock _calculator; + private Mock _mockCrackWidthLogic; + private Mock _mockTraceLogger; + private CrackWidthCalculationLogic _logic; + private IRebarCrackCalculatorInputData _inputData; + + [SetUp] + public void SetUp() + { + _calculator = new Mock(); + _mockCrackWidthLogic = new Mock(); + _mockTraceLogger = new Mock(); + _inputData = new RebarCrackCalculatorInputData + { + + }; + + _inputData.UserCrackInputData = new UserCrackInputData(); + + _logic = new CrackWidthCalculationLogic(_calculator.Object, _mockCrackWidthLogic.Object, _mockTraceLogger.Object) + { + InputData = _inputData + }; + } + + [Test] + public void Run_ShouldPrepareNewResultAndProcessCalculations() + { + // Arrange + _mockCrackWidthLogic.Setup(m => m.GetCrackWidth()) + .Returns(0.5); // Mock the GetCrackWidth method + + // Act + _logic.Run(); + + // Assert + Assert.NotNull(_logic.Result); + Assert.IsTrue(_logic.Result.IsValid); + _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny()), Times.AtLeastOnce); + } + + [Test] + public void ProcessLongTermCalculation_ShouldReturnExpectedResult() + { + // Arrange + _mockCrackWidthLogic.SetupSequence(m => m.GetCrackWidth()) + .Returns(0.5) // longTermLoadLongTermConcreteCrackWidth + .Returns(0.2); // longTermLoadShortConcreteWidth + + // Act + var result = _logic.ProcessLongTermCalculations(); + + // Assert + Assert.NotNull(result); + Assert.AreEqual(0.5, result.CrackWidth); + _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny()), Times.AtLeastOnce); + } + + [Test] + public void ProcessShortTermCalculations_ShouldReturnExpectedResult() + { + // Arrange + _mockCrackWidthLogic.SetupSequence(m => m.GetCrackWidth()) + .Returns(0.2) // longTermLoadShortConcreteWidth + .Returns(0.3); // fullLoadShortConcreteCrackWidth + + // Act + var result = _logic.ProcessShortTermCalculations(); + + // Assert + Assert.NotNull(result); + Assert.AreEqual(0.0, result.CrackWidth); // Assuming acrcShort would be 0 in this scenario + _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny()), Times.AtLeastOnce); + } + + [Test] + public void GetRebarStressResult_ShouldReturnValidResult() + { + // Arrange + var mockRebarStressCalculator = new Mock(); + var expectedResult = new RebarStressResult { IsValid = true }; + mockRebarStressCalculator.Setup(c => c.Run()); + mockRebarStressCalculator.Setup(c => c.Result).Returns(expectedResult); + + // Act + var result = _logic.GetRebarStressResult(_inputData.ShortRebarData); + + // Assert + Assert.NotNull(result); + Assert.IsTrue(result.IsValid); + _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny(), TraceLogStatuses.Error), Times.Never); + } + } + +} diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs index 4a52d15..4f3d32f 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthLogicSP63Test.cs @@ -23,7 +23,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks PsiSFactor = 1d, RebarStrain = rebarStrain, ConcreteStrain = concreteStrain, - Length = length + LengthBetweenCracks = length }; var logic = new CrackWidthLogicSP63() { InputData = inputData }; diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckCrackWidthSP63InputDataLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckCrackWidthSP63InputDataLogicTests.cs new file mode 100644 index 0000000..7026033 --- /dev/null +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckCrackWidthSP63InputDataLogicTests.cs @@ -0,0 +1,100 @@ +using NUnit.Framework; +using Moq; +using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Cracking; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperTests.UnitTests.Ndms.Cracks.InputDataTests +{ + + [TestFixture] + public class CrackWidthCalculationLogicTests + { + private Mock _calculator; + private Mock mockCrackWidthLogic; + private Mock mockTraceLogger; + private Mock mockInputData; + private Mock mockUserCrackInputData; + private Mock mockRebarPrimitive; + private Mock mockRebarStressCalculator; + private CrackWidthCalculationLogic crackWidthCalculationLogic; + private Mock mockRebarCrackInputData; + + [SetUp] + public void SetUp() + { + _calculator = new Mock(); + mockCrackWidthLogic = new Mock(); + mockTraceLogger = new Mock(); + mockInputData = new Mock(); + mockUserCrackInputData = new Mock(); + mockRebarPrimitive = new Mock(); + mockRebarStressCalculator = new Mock(); + mockRebarCrackInputData = new Mock(); + + mockInputData.Setup(x => x.UserCrackInputData).Returns(mockUserCrackInputData.Object); + mockInputData.Setup(x => x.LongRebarData).Returns(mockRebarCrackInputData.Object); + mockInputData.Setup(x => x.ShortRebarData).Returns(mockRebarCrackInputData.Object); + mockInputData.Setup(x => x.RebarPrimitive).Returns(mockRebarPrimitive.Object); + + mockRebarCrackInputData.Setup(x => x.ForceTuple).Returns(new ForceTuple()); + + crackWidthCalculationLogic = new CrackWidthCalculationLogic(_calculator.Object, mockCrackWidthLogic.Object, mockTraceLogger.Object) + { + InputData = mockInputData.Object + }; + } + + [Test] + public void Run_ShouldPrepareNewResultAndProcessCalculations() + { + // Arrange + mockCrackWidthLogic.Setup(x => x.GetCrackWidth()).Returns(0.5); + + // Act + crackWidthCalculationLogic.Run(); + + // Assert + mockCrackWidthLogic.Verify(x => x.GetCrackWidth(), Times.AtLeastOnce); + Assert.IsNotNull(crackWidthCalculationLogic.Result); + Assert.IsTrue(crackWidthCalculationLogic.Result.IsValid); + } + + [Test] + public void ProcessShortTermCalculations_ShouldCalculateCorrectShortTermCrackWidth() + { + // Arrange + mockUserCrackInputData.Setup(x => x.UltimateShortCrackWidth).Returns(1.0); + mockCrackWidthLogic.SetupSequence(x => x.GetCrackWidth()) + .Returns(0.6) // longTermLoadShortConcreteWidth + .Returns(0.8); // fullLoadShortConcreteCrackWidth + + crackWidthCalculationLogic.InputData = mockInputData.Object; + + // Act + var shortTermResult = crackWidthCalculationLogic.ProcessShortTermCalculations(); + + // Assert + Assert.AreEqual(1.2, shortTermResult.CrackWidth); + Assert.AreEqual(1.0, shortTermResult.UltimateCrackWidth); + } + + [Test] + public void ProcessLongTermCalculations_ShouldCalculateCorrectLongTermCrackWidth() + { + // Arrange + mockUserCrackInputData.Setup(x => x.UltimateLongCrackWidth).Returns(1.2); + mockCrackWidthLogic.Setup(x => x.GetCrackWidth()).Returns(0.9); + + // Act + var longTermResult = crackWidthCalculationLogic.ProcessLongTermCalculations(); + + // Assert + Assert.AreEqual(0.9, longTermResult.CrackWidth); + Assert.AreEqual(1.2, longTermResult.UltimateCrackWidth); + } + } + + +} diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs index d6bfb85..6f716e9 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs @@ -10,12 +10,12 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks.InputDataTests; [TestFixture] public class CheckTupleCalculatorInputDataTests { - private CheckTupleCalculatorInputData _checkTupleCalculatorInputData; + private CheckTupleCalculatorInputDataLogic _checkTupleCalculatorInputData; [SetUp] public void SetUp() { - _checkTupleCalculatorInputData = new CheckTupleCalculatorInputData(); + _checkTupleCalculatorInputData = new CheckTupleCalculatorInputDataLogic(); } [Test]