Force crack calculator was fixed

2024-08-04 23:01:10 +05:00
parent e7c7211f54
commit 3eb5aa2b96
54 changed files with 1031 additions and 300 deletions
--- a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs
@@ -18,12 +18,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
    /// <summary>
    /// Logic of checking of input data for crack calcultor 
    /// </summary>
-    public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<CrackInputData>
+    public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<CrackCalculatorInputData>
    {
        private bool result;
        private ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic;

-        public CrackInputData InputData {  get; set; }
+        public CrackCalculatorInputData InputData {  get; set; }


        public string CheckResult { get; private set; }
--- a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs
+++ 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<ICrackForceCalculatorInputData>
+    {
+        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);
+        }
+    }
+}
--- 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<CrackInputData> checkInputDataLogic;
+        private ICheckInputDataLogic<CrackCalculatorInputData> 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<CrackInputData> checkInputDataLogic)
+        public CrackCalculator(CrackCalculatorInputData inputData, ICheckInputDataLogic<CrackCalculatorInputData> 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
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.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
    {
        /// <inheritdoc/>
        public List<INdmPrimitive> Primitives { get; private set; }
        /// <inheritdoc/>
        public List<IForceAction> ForceActions { get; private set; }
        public UserCrackInputData UserCrackInputData { get; set; }
-        public CrackInputData()
+        public CrackCalculatorInputData()
        {
            Primitives = new();
            ForceActions = new();
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
@@ -10,9 +10,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
    public class CrackCalculatorUpdateStrategy : IUpdateStrategy<CrackCalculator>
    {
-        private IUpdateStrategy<CrackInputData> inputDataUpdateStrategy;
+        private IUpdateStrategy<CrackCalculatorInputData> inputDataUpdateStrategy;

-        public CrackCalculatorUpdateStrategy(IUpdateStrategy<CrackInputData> inputDataUpdateStrategy)
+        public CrackCalculatorUpdateStrategy(IUpdateStrategy<CrackCalculatorInputData> inputDataUpdateStrategy)
        {
            this.inputDataUpdateStrategy = inputDataUpdateStrategy;
        }
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.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<ICrackForceCalculatorInputData> 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<INdm> 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<ICrackForceCalculatorInputData> 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()
        {
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculatorInputData.cs
+++ 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<INdm> CheckedNdmCollection { get; set; }
+        public IEnumerable<INdm> SectionNdmCollection { get; set; }
+
+        public CrackForceCalculatorInputData()
+        {
+            StartTuple = new ForceTuple();
+            EndTuple = new ForceTuple();
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs
+++ 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();
+        }
+    }
+}
--- 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<CrackInputData>
+    public class CrackInputDataUpdateStrategy : IUpdateStrategy<CrackCalculatorInputData>
    {
        private IUpdateStrategy<UserCrackInputData> userCrackInputDataUpdateStrategy;
        public CrackInputDataUpdateStrategy(IUpdateStrategy<UserCrackInputData> 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);
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs
@@ -10,7 +10,7 @@ using System.Threading.Tasks;
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
    /// <inheritdoc/>
-    public class CrackedConcreteNdmLogic : ISectionCrackedLogic
+    public class CrackedConcreteNdmLogic : IIsSectionCrackedByForceLogic
    {
        /// <inheritdoc/>
        public INdm ConcreteNdm { get; set; }
--- 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;
--- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculator.cs
+++ 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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculatorInputData.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<INdm> NdmCollection { get; set; }
-        bool IsSectionCracked(double factor);
+        IEnumerable<INdm> CheckedNdmCollection { get; set; }
+        IEnumerable<INdm> SectionNdmCollection { get; set; }
    }
 }
--- 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
 {
+    /// <summary>
+    /// 
+    /// </summary>
    public interface ICrackWidthTupleResult
    {
        /// <summary>
-        /// Calculated crack width
+        /// Calculated crack width, m
        /// </summary>
        double CrackWidth { get; set; }
+        /// <summary>
+        /// True if actual crack width less than limit one
+        /// </summary>
        bool IsCrackLessThanUltimate { get; }
+        /// <summary>
+        /// Limit crack width, m
+        /// </summary>
        double UltimateCrackWidth { get; set; }
    }
 }
--- a/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByFactorLogic.cs
+++ 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
+{
+    /// <summary>
+    /// Check crack appearence beetwen start force tuple and end force tuple
+    /// </summary>
+    public interface IIsSectionCrackedByFactorLogic : ILogic
+    {
+        IIsSectionCrackedByForceLogic IsSectionCrackedByForceLogic { get; set; }
+        /// <summary>
+        /// Start force tupple
+        /// </summary>
+        IForceTuple StartTuple { get; set; }
+        /// <summary>
+        /// End force tuple
+        /// </summary>
+        IForceTuple EndTuple { get; set; }
+
+        /// <summary>
+        /// Returns result of checking of crack appearence
+        /// </summary>
+        /// <param name="factor">factor beetwen start and end tuple, 0 is start tuple, 1 is end tuple</param>
+        /// <returns>true when section is cracked</returns>
+        bool IsSectionCracked(double factor);
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs
@@ -12,14 +12,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
    /// <summary>
    /// Logic for checking collection of ndms for appearance of crack
    /// </summary>
-    public interface ISectionCrackedLogic : ILogic
+    public interface IIsSectionCrackedByForceLogic : ILogic
    {
        /// <summary>
        /// Force tuple for checking of cracks appearence
        /// </summary>
        IForceTuple Tuple { get; set; }
        /// <summary>
-        /// Collection of ndms which is checking fo cracking
+        /// Collection of ndms which is checking for cracking
        /// </summary>
        IEnumerable<INdm> CheckedNdmCollection { get; set; }
        /// <summary>
--- a/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.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<INdm> 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();
        }
    }
 }
--- a/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs
@@ -10,16 +10,17 @@ using System.Diagnostics.Eventing.Reader;
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
    /// <inheritdoc/>
-    internal class SectionCrackedLogic : ISectionCrackedLogic
+    internal class IsSectionCrackedByForceLogic : IIsSectionCrackedByForceLogic
    {
        static readonly IStressLogic stressLogic = new StressLogic();
+        /// <inheritdoc/>
        public IForceTuple Tuple { get; set; }
        public IEnumerable<INdm> CheckedNdmCollection { get; set; }
        public IEnumerable<INdm> 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<INdm> 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");
--- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs
@@ -13,9 +13,21 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
    public class RebarCrackInputData : IInputData
    {
+        /// <summary>
+        /// Collection of ndms where work of crackable material in tension was assigned according to material properties
+        /// </summary>
        public IEnumerable<INdm> CrackableNdmCollection { get; set; }
+        /// <summary>
+        /// Collection of ndms where work of concrete is disabled
+        /// </summary>
        public IEnumerable<INdm> CrackedNdmCollection { get; set; }
+        /// <summary>
+        /// Force tuple for calculation
+        /// </summary>
        public ForceTuple ForceTuple { get; set; }
-        public double Length { get; set; }
+        /// <summary>
+        /// Base length beetwen cracks
+        /// </summary>
+        public double LengthBeetwenCracks { get; set; }
    }
 }
--- 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()
            {
--- 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<INdm> ndms)
        {
-            var sectionCrackedLogic = new SectionCrackedLogic()
+            var calculator = new CrackForceBynarySearchCalculator()
            {
-                SectionNdmCollection = ndms,
-                CheckedNdmCollection = new List<INdm>() { 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<INdm>() { concreteNdm };
+            calculator.InputData.SectionNdmCollection = ndms;
            calculator.Run();
            return calculator.Result as CrackForceResult;
        }