Add curvature calculator DTOs

StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs

@@ -69,7 +69,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
 
         private void CheckPrimitives()
         {
-            checkPrimitiveCollectionLogic ??= new CheckPrimitiveCollectionLogic(
+            checkPrimitiveCollectionLogic ??= new HasPrimitivesCheckLogic(
                 TraceLogger,
                 new CheckRebarPrimitiveLogic()
                 {

StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs

@@ -12,12 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         /// <inheritdoc/>
         public IForceTuple ForceTuple { get; set; }
         /// <inheritdoc/>
-        public IAccuracy Accuracy { get; set; }
-        public bool CheckStrainLimit { get; set; }
-
-        public ForceTupleInputData()
-        {
-            Accuracy ??= new Accuracy() { IterationAccuracy = 0.01d, MaxIterationCount = 1000 };
-        }
+        public IAccuracy Accuracy { get; set; } = new Accuracy() { IterationAccuracy = 0.01d, MaxIterationCount = 1000 };
+        public bool CheckStrainLimit { get; set; } = true;
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs

@@ -91,7 +91,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
                 Mx = point3D.X,
                 My = point3D.Y
             };
-            logic.Tuple = tuple;
+            logic.ForceTuple = tuple;
             logic.SectionNdmCollection = Ndms;
             try
             {

StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CalculatorCloningStrategyContainer.cs

@@ -1,5 +1,6 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
+using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
 using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Cracking;
 using System;
@@ -11,7 +12,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
     public class CalculatorCloningStrategyContainer : ICalculatorCloningStrategyContainer
     {
         private ICloningStrategy cloningStrategy;
-
+        private IUpdateStrategy<IValueDiagramCalculator> valueDiagramCalculatorStrategy;
+        private IUpdateStrategy<ICurvatureCalculator> curvatureCalculatorStrategy;
 
         public IUpdateStrategy<IForceCalculator> ForceCalculatorStrategy => new ForceCalculatorUpdateCloningStrategy(cloningStrategy);
 
@@ -19,7 +21,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
 
         public IUpdateStrategy<ILimitCurvesCalculator> LimitCurvesCalculatorStrategy => new LimitCurvesCalculatorUpdateCloningStrategy(cloningStrategy);
 
-        public IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy => new ValueDiagramCalculatorUpdateCloningStrategy(cloningStrategy);
+        public IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy => valueDiagramCalculatorStrategy ??= new ValueDiagramCalculatorUpdateCloningStrategy(cloningStrategy);
+        public IUpdateStrategy<ICurvatureCalculator> CurvatureCalculatorStrategy => curvatureCalculatorStrategy ??= new CurvatureCalculatorUpdateCloningStrategy(cloningStrategy);
         public CalculatorCloningStrategyContainer(ICloningStrategy cloningStrategy)
         {
             this.cloningStrategy = cloningStrategy;

StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs

@@ -6,6 +6,7 @@ using StructureHelperCommon.Models.Parameters;
 using StructureHelperCommon.Services;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
+using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
 using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Cracking;
 using StructureHelperLogics.NdmCalculations.Primitives;
@@ -65,6 +66,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
                 {
                     cloningStrategyContainer.ValueDiagramCalculatorStrategy.Update(newCalculator as IValueDiagramCalculator, valueDiagramCalculator);
                 }
+                else if (calculator is ICurvatureCalculator curvatureCalculator)
+                {
+                    cloningStrategyContainer.CurvatureCalculatorStrategy.Update(newCalculator as ICurvatureCalculator, curvatureCalculator);
+                }
                 else
                 {
                     throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(calculator));

StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ICalculatorCloningStrategyContainer.cs

@@ -1,4 +1,5 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
 using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Cracking;
 
@@ -10,5 +11,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         IUpdateStrategy<ICrackCalculator> CrackCalculatorStrategy { get; }
         IUpdateStrategy<ILimitCurvesCalculator> LimitCurvesCalculatorStrategy { get; }
         IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy { get; }
+        IUpdateStrategy<ICurvatureCalculator> CurvatureCalculatorStrategy { get; }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs

@@ -27,7 +27,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
             TraceLogger?.AddMessage($"Logic of analisys based on calculating sum of secant stifness of elementary parts EA,i = A,i * Esec,i");
             TraceLogger?.AddMessage($"Calculating geometry properties for strains");
             TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(StrainTuple));
-            var loaderStainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(StrainTuple);
+            var loaderStainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(StrainTuple);
             var (MxFactor, MyFactor, NzFactor) = GeometryOperations.GetSofteningsFactors(NdmCollection, loaderStainMatrix);
             TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.SndAxisName}-plane: EIx_cracked / EIx_uncracked = {MxFactor}");
             TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.FstAxisName}-plane: EIy_cracked / EIy_uncracked = {MyFactor}");

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs

@@ -1,4 +1,5 @@
-using StructureHelperCommon.Models;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Calculators;
 using System;
 using System.Collections.Generic;
@@ -8,7 +9,13 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
     public class CurvatureCalculator : ICurvatureCalculator
     {
-        private ICurvatureCalculatorResult result;
+        private CurvatureCalculatorResult result;
+        private ICheckEntityLogic<ICurvatureCalculatorInputData> inputDataCheckLogic;
+        private ICurvatureCalcualtorLogic calculatorLogic;
+        private ICurvatureCalcualtorLogic CalculatorLogic => calculatorLogic ??= new CurvatureCalculatorLogic() { InputData = InputData, TraceLogger = TraceLogger};
+
+        private ICheckEntityLogic<ICurvatureCalculatorInputData> InputDataCheckLogic => inputDataCheckLogic ??= new CurvatureCalculatorInputDataCheckLogic(TraceLogger) { Entity = InputData};
+
         public Guid Id { get; }
         public string Name { get; set; } = string.Empty;
         public ICurvatureCalculatorInputData InputData { get; set; } = new CurvatureCalculatorInputData(Guid.NewGuid());
@@ -34,7 +41,43 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 
         public void Run()
         {
-            throw new NotImplementedException();
+            PrepareNewResult();
+            if (CheckInputData() == false)  {return;}
+            GetResultByLogic();
+        }
+
+        private void GetResultByLogic()
+        {
+            try
+            {
+                CalculatorLogic.Run();
+                result = CalculatorLogic.Result as CurvatureCalculatorResult;
+            }
+            catch (Exception ex)
+            {
+                result.IsValid = false;
+                result.Description += ex.Message;
+            }
+        }
+
+        private void PrepareNewResult()
+        {
+            result = new()
+            {
+                IsValid = true,
+                InputData = InputData,
+            };
+        }
+
+        private bool CheckInputData()
+        {
+            if (InputDataCheckLogic.Check() == false)
+            {
+                result.IsValid = false;
+                result.Description += inputDataCheckLogic.CheckResult;
+                return false;
+            }
+            return true;
         }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorInputData.cs

@@ -9,8 +9,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
         public List<IForceAction> ForceActions { get; } = [];
 
         public List<INdmPrimitive> Primitives { get; } = [];
-        public double DeflectionFactor { get; set; } = 0.1042;
-        public double SpanLength { get; set; } = 6.0;
+        public IDeflectionFactor DeflectionFactor { get; set; } = new DeflectionFactor(Guid.NewGuid());
 
         public CurvatureCalculatorInputData(Guid id)
         {

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorResult.cs

@@ -0,0 +1,12 @@
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureCalculatorResult : ICurvatureCalculatorResult
+    {
+        public ICurvatureCalculatorInputData InputData { get; set; }
+
+        public List<ICurvatureForceCalculatorResult> ForceCalculatorResults { get; } = [];
+
+        public bool IsValid { get; set; } = true;
+        public string? Description { get; set; } = string.Empty;
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculator.cs

@@ -0,0 +1,87 @@
+using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.NdmCalculations.Cracking;
+using StructureHelperLogics.Services.NdmPrimitives;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureForceCalculator : ICurvatureForceCalculator
+    {
+        private CurvatureForceCalculatorResult result;
+        public ICurvatureForceCalculatorInputData InputData { get; set; }
+
+        public IResult Result => result;
+
+        public IShiftTraceLogger? TraceLogger { get; set; }
+
+        public Guid Id => throw new NotImplementedException();
+
+        public object Clone()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Run()
+        {
+            PrepareResult();
+            if (CheckForCracks(InputData.ShortTermTuple, CalcTerms.ShortTerm) || CheckForCracks(InputData.ShortTermTuple, CalcTerms.ShortTerm))
+            {
+                ProcessCrackedSection();
+            }
+            else
+            {
+                ProcessUncrackedSection();
+            }
+        }
+
+        private void ProcessCrackedSection()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ProcessUncrackedSection()
+        {
+            CurvatureTermCalculatorInputData inputData = new()
+            {
+                Primitives = InputData.Primitives,
+                DeflectionFactor = InputData.DeflectionFactor
+            };
+            var calculator = new CurvatureTermUncrackedCalculator() { InputData = inputData };
+            inputData.ForceTuple = InputData.LongTermTuple;
+            inputData.CalculationTerm = CalcTerms.LongTerm;
+            calculator.Run();
+            var calcResult = calculator.Result as CurvatureTermCalculatorResult;
+            if (calcResult.IsValid == false)
+            {
+                result.IsValid = false;
+            }
+            result.LongTermResult = calcResult;
+        }
+
+        private bool CheckForCracks(IForceTuple forceTuple, CalcTerms calcTerm)
+        {
+            var triangulateLogic = new TriangulatePrimitiveLogic()
+            {
+                Primitives = InputData.Primitives,
+                LimitState = LimitStates.SLS,
+                CalcTerm = calcTerm,
+                TraceLogger = TraceLogger
+            };
+            var ndms = triangulateLogic.GetNdms();
+            var logic = new IsSectionCrackedByForceLogic()
+            {
+                ForceTuple = forceTuple,
+                CheckedNdmCollection = ndms,
+                SectionNdmCollection = ndms
+            };
+            return logic.IsSectionCracked();
+        }
+
+        private void PrepareResult()
+        {
+            result = new();
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorInputData.cs

@@ -0,0 +1,13 @@
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureForceCalculatorInputData : ICurvatureForceCalculatorInputData
+    {
+        public IForceTuple LongTermTuple { get; set; }
+        public IForceTuple ShortTermTuple { get; set; }
+        public List<INdmPrimitive> Primitives { get; set; } = [];
+        public IDeflectionFactor DeflectionFactor { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorResult.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureForceCalculatorResult : ICurvatureForceCalculatorResult
+    {
+        public ICurvatureForceCalculatorInputData InputData { get; set; }
+        public ICurvatureTermCalculatorResult LongTermResult { get; set; }
+        public ICurvatureTermCalculatorResult ShortTermResult { get; set; }
+        public bool IsValid { get; set; } = true;
+        public string? Description { get; set; } = string.Empty;
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalcualtor.cs

@@ -6,10 +6,10 @@ using System.Text;
 
 namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
-    public class CurvatureTermCalcualtor : ICurvatureTermCalcualtor
+    public class CurvatureTermCalcualtor : ICurvatureTermCalculator
     {
-        private ICurvatureTermCalcualtorResult result;
-        public ICurvatureTermCalcualtorInputData InputData { get; set; }
+        private ICurvatureTermCalculatorResult result;
+        public ICurvatureTermCalculatorInputData InputData { get; set; }
 
         public IResult Result => result;
 

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorInputData.cs

@@ -0,0 +1,16 @@
+using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureTermCalculatorInputData : ICurvatureTermCalculatorInputData
+    {
+        public IForceTuple ForceTuple { get; set; }
+        public CalcTerms LoadTerm { get; set; }
+        public CalcTerms CalculationTerm { get; set; }
+
+        public List<INdmPrimitive> Primitives { get; set; } = [];
+        public IDeflectionFactor DeflectionFactor { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorResult.cs

@@ -0,0 +1,16 @@
+using StructureHelperCommon.Models.Forces;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureTermCalculatorResult : ICurvatureTermCalculatorResult
+    {
+        public ICurvatureTermCalculatorInputData InputData { get; set; }
+        public IForceTuple CurvatureValues { get; set; }
+        public IForceTuple Deflections { get; set; }
+        public bool IsValid { get; set; } = true;
+        public string? Description { get; set; } = string.Empty;
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermUncrackedCalculator.cs

@@ -0,0 +1,98 @@
+using LoaderCalculator.Data.Ndms;
+using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Services.Forces;
+using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
+using StructureHelperLogics.Services.NdmPrimitives;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureTermUncrackedCalculator : ICurvatureTermCalculator
+    {
+        private CurvatureTermCalculatorResult result;
+        private List<INdm> ndms;
+
+        public ICurvatureTermCalculatorInputData InputData { get; set; }
+
+        public IResult Result => result;
+
+        public IShiftTraceLogger? TraceLogger { get; set; }
+
+        public Guid Id => throw new NotImplementedException();
+
+        public object Clone()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Run()
+        {
+            PrepareNewResult();
+            TriangulatePrimitives();
+            Calculate();
+        }
+
+        private void Calculate()
+        {
+            try
+            {
+                var inputData = new ForceTupleInputData()
+                {
+                    NdmCollection = ndms,
+                    ForceTuple = InputData.ForceTuple
+                };
+                var calculator = new ForceTupleCalculator()
+                {
+                    InputData = inputData,
+                };
+                calculator.Run();
+                var calcResult = calculator.Result as IForceTupleCalculatorResult;
+                if (calcResult.IsValid != true)
+                {
+                    result.IsValid = false;
+                    result.Description += calcResult.Description;
+                    return;
+                }
+                result.CurvatureValues = ForceTupleConverter.ConvertToForceTuple(calcResult.LoaderResults.StrainMatrix);
+                ConvertCurvaturesToDeflections();
+            }
+            catch (Exception ex)
+            {
+                result.IsValid = false;
+                result.Description = ex.Message;
+            }
+        }
+
+        private void ConvertCurvaturesToDeflections()
+        {
+            ForceTuple deflections = new();
+            double spanLength = InputData.DeflectionFactor.SpanLength;
+            deflections.Mx = InputData.DeflectionFactor.DeflectionFactors.Mx * result.CurvatureValues.Mx * spanLength * spanLength;
+            deflections.My = InputData.DeflectionFactor.DeflectionFactors.My * result.CurvatureValues.My * spanLength * spanLength;
+            deflections.Nz = InputData.DeflectionFactor.DeflectionFactors.Nz * result.CurvatureValues.Nz * spanLength;
+            result.Deflections = deflections;
+        }
+
+        private void TriangulatePrimitives()
+        {
+            var triangulateLogic = new TriangulatePrimitiveLogic()
+            {
+                Primitives = InputData.Primitives,
+                LimitState = LimitStates.SLS,
+                CalcTerm = InputData.CalculationTerm,
+                TraceLogger = TraceLogger
+            };
+            ndms = triangulateLogic.GetNdms();
+        }
+
+        private void PrepareNewResult()
+        {
+            result = new();
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/DeflectionFactor.cs

@@ -0,0 +1,43 @@
+using StructureHelperCommon.Models.Forces;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class DeflectionFactor : IDeflectionFactor
+    {
+        private const double bendCurveFactor = 0.1042;
+        private const double longitudinalFactor = 1.0;
+        private const double maxDeflection = 0.02;
+
+        public IForceTuple DeflectionFactors { get; set; }
+        public double SpanLength { get; set; } = 6.0;
+        public IForceTuple MaxDeflections { get; set; }
+
+        public Guid Id { get; }
+
+        public DeflectionFactor(Guid id)
+        {
+            Id = id;
+            DeflectionFactors = new ForceTuple()
+            {
+                Mx = bendCurveFactor,
+                My = bendCurveFactor,
+                Mz = longitudinalFactor,
+                Nz = longitudinalFactor,
+                Qx = longitudinalFactor,
+                Qy = longitudinalFactor
+            };
+            MaxDeflections = new ForceTuple()
+            {
+                Mx = maxDeflection,
+                My = maxDeflection,
+                Mz = maxDeflection,
+                Nz = maxDeflection,
+                Qx = maxDeflection,
+                Qy = maxDeflection,
+            };
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorInputData.cs

@@ -1,15 +1,15 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
 using StructureHelperLogics.NdmCalculations.Primitives;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
+    /// <summary>
+    /// Input data for calculator of curvature of cross-section
+    /// </summary>
     public interface ICurvatureCalculatorInputData : IInputData, ISaveable, IHasForceActions, IHasPrimitives
     {
-        double DeflectionFactor { get; set; }
-        double SpanLength { get; set; }
+        IDeflectionFactor DeflectionFactor { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculator.cs

@@ -5,7 +5,8 @@ using System.Text;
 
 namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
-    public interface ICurvatureForceCalcualtor : ILogicCalculator
+    public interface ICurvatureForceCalculator : ILogicCalculator
     {
+        ICurvatureForceCalculatorInputData InputData { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorInputData.cs

@@ -1,14 +1,13 @@
 using StructureHelperCommon.Models.Calculators;
 using StructureHelperCommon.Models.Forces;
 using StructureHelperLogics.NdmCalculations.Primitives;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
     public interface ICurvatureForceCalculatorInputData : IInputData, IHasPrimitives
     {
-        IDesignForceTuple DesignForceTuple { get; set; }
+        IForceTuple LongTermTuple { get; set; }
+        IForceTuple ShortTermTuple { get; set; }
+        IDeflectionFactor DeflectionFactor { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs

@@ -5,7 +5,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
     public interface ICurvatureForceCalculatorResult : IResult
     {
         ICurvatureForceCalculatorInputData InputData { get; set; }
-        ICurvatureTermCalcualtorResult LongTermResult { get; set; }
-        ICurvatureTermCalcualtorResult ShortTermResult { get; set; }
+        ICurvatureTermCalculatorResult LongTermResult { get; set; }
+        ICurvatureTermCalculatorResult ShortTermResult { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorResult.cs

@@ -1,13 +0,0 @@
-using StructureHelperCommon.Models.Calculators;
-using StructureHelperCommon.Models.Forces;
-
-namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
-{
-    public interface ICurvatureTermCalcualtorResult : IResult
-    {
-        ICurvatureTermCalcualtorInputData InputData { get; set; }
-        IForceTuple CurvatureValue { get; set; }
-        IForceTuple Deflection { get; set; }
-
-    }
-}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculator.cs

@@ -5,8 +5,8 @@ using System.Text;
 
 namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
-    public interface ICurvatureTermCalcualtor : ILogicCalculator
+    public interface ICurvatureTermCalculator : ILogicCalculator
     {
-        ICurvatureTermCalcualtorInputData InputData { get; set; }
+        ICurvatureTermCalculatorInputData InputData { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorInputData.cs

@@ -5,10 +5,11 @@ using StructureHelperLogics.NdmCalculations.Primitives;
 
 namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
-    public interface ICurvatureTermCalcualtorInputData : IInputData, IHasPrimitives
+    public interface ICurvatureTermCalculatorInputData : IInputData, IHasPrimitives
     {
-        IForceTuple DesignForceTuple { get; set; }
+        IForceTuple ForceTuple { get; set; }
         CalcTerms LoadTerm { get; set; }
         CalcTerms CalculationTerm { get; set; }
+        IDeflectionFactor DeflectionFactor { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorResult.cs

@@ -0,0 +1,13 @@
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureTermCalculatorResult : IResult
+    {
+        ICurvatureTermCalculatorInputData InputData { get; set; }
+        IForceTuple CurvatureValues { get; set; }
+        IForceTuple Deflections { get; set; }
+
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/IDeflectionFactor.cs

@@ -0,0 +1,24 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    /// <summary>
+    /// Implements properties for calculation deflections
+    /// </summary>
+    public interface IDeflectionFactor : ISaveable
+    {
+        /// <summary>
+        /// Factors for calculating deflections, dimensionless
+        /// </summary>
+        IForceTuple DeflectionFactors { get; set; }
+        /// <summary>
+        /// Maximum deflections, metres
+        /// </summary>
+        double SpanLength { get; set; }
+        IForceTuple MaxDeflections { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataCheckLogic.cs

@@ -0,0 +1,78 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Forces.Logics;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using StructureHelperLogics.NdmCalculations.Primitives.Logics;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureCalculatorInputDataCheckLogic : CheckEntityLogic<ICurvatureCalculatorInputData>
+    {
+        private ICheckEntityLogic<IHasPrimitives> primitivesCheckLogic;
+        private ICheckEntityLogic<IEnumerable<IForceAction>> actionsCheckLogic;
+        private bool result;
+
+        private ICheckEntityLogic<IEnumerable<IForceAction>> ActionsCheckLogic => actionsCheckLogic ??= new CheckForceActionsLogic(TraceLogger);
+
+        private ICheckEntityLogic<IHasPrimitives> PrimitivesCheckLogic => primitivesCheckLogic ??= new HasPrimitivesCheckLogic();
+
+        public CurvatureCalculatorInputDataCheckLogic(IShiftTraceLogger traceLogger)
+        {
+            TraceLogger = traceLogger;
+            CheckRebarPrimitiveLogic checkRebarPrimitiveLogic = new()
+            {
+                CheckRebarHostMaterial = false,
+                CheckRebarPlacement = false
+            };
+            primitivesCheckLogic = new HasPrimitivesCheckLogic(TraceLogger, checkRebarPrimitiveLogic);
+        }
+
+        public override bool Check()
+        {
+            result = true;
+            if (Entity is null)
+            {
+                string errorString = ErrorStrings.ParameterIsNull + ": curvature calculator input data";
+                TraceMessage(errorString);
+                throw new StructureHelperException(errorString);
+            }
+            if (Entity.Primitives is null || !Entity.Primitives.Any())
+            {
+                TraceMessage("Calculator does not contain any primitives");
+                result = false;
+            }
+            if (Entity.ForceActions is null || !Entity.ForceActions.Any())
+            {
+                TraceMessage("Calculator does not contain any forces");
+                result = false;
+            }
+            CheckPrimitives();
+            CheckActions();
+            return result;
+        }
+
+        private void CheckPrimitives()
+        {
+            PrimitivesCheckLogic.Entity = Entity;
+            if (PrimitivesCheckLogic.Check() == false)
+            {
+                result = false;
+            }
+            TraceMessage(PrimitivesCheckLogic.CheckResult);
+
+        }
+
+        private void CheckActions()
+        {
+            ActionsCheckLogic.Entity = Entity.ForceActions;
+            if (ActionsCheckLogic.Check() == false)
+            {
+                result = false;
+            }
+            TraceMessage(ActionsCheckLogic.CheckResult);
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs

@@ -5,6 +5,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
     public class CurvatureCalculatorInputDataUpdateStrategy : IParentUpdateStrategy<ICurvatureCalculatorInputData>
     {
+        private IUpdateStrategy<IDeflectionFactor> deflectionUpdateStrategy;
+        private IUpdateStrategy<IDeflectionFactor> DeflectionUpdateStrategy => deflectionUpdateStrategy ??= new DeflectionFactorUpdateStrategy();
+
         public bool UpdateChildren { get; set; } = true;
 
         public void Update(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject)
@@ -13,19 +16,23 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
             CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
             if (ReferenceEquals(targetObject, sourceObject))
                 return;
-            targetObject.DeflectionFactor = sourceObject.DeflectionFactor;
-            targetObject.SpanLength = sourceObject.SpanLength;
+
             if (UpdateChildren == true)
             {
-                CheckObject.ThrowIfNull(sourceObject.Primitives);
-                CheckObject.ThrowIfNull(targetObject.Primitives);
+                CheckProperties(targetObject, sourceObject);
                 targetObject.Primitives.Clear();
                 targetObject.Primitives.AddRange(sourceObject.Primitives);
-                CheckObject.ThrowIfNull(sourceObject.ForceActions);
-                CheckObject.ThrowIfNull(targetObject.ForceActions);
                 targetObject.ForceActions.Clear();
                 targetObject.ForceActions.AddRange(sourceObject.ForceActions);
             }
         }
+
+        private static void CheckProperties(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject)
+        {
+            CheckObject.ThrowIfNull(sourceObject.Primitives);
+            CheckObject.ThrowIfNull(targetObject.Primitives);
+            CheckObject.ThrowIfNull(sourceObject.ForceActions);
+            CheckObject.ThrowIfNull(targetObject.ForceActions);
+        }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorLogic.cs

@@ -0,0 +1,99 @@
+using LoaderCalculator.Data.Ndms;
+using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Sections;
+using StructureHelperCommon.Models.Sections.Logics;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperLogics.Services.NdmPrimitives;
+using System;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureCalculatorLogic : ICurvatureCalcualtorLogic
+    {
+        private const LimitStates limitState = LimitStates.SLS;
+        private CurvatureCalculatorResult result;
+        private ICurvatureForceCalculator forceCalculator;
+        private ICurvatureForceCalculator ForceCalculator => forceCalculator ??= new CurvatureForceCalculator();
+        private IPoint2D gravityCenter;
+
+        public ICurvatureCalculatorInputData InputData { get; set; }
+
+        public IResult Result => result;
+
+        public IShiftTraceLogger? TraceLogger { get; set; }
+
+        public void Run()
+        {
+            PrepareNewResult();
+            SetGravityCenter();
+            try
+            {
+                Calculate();
+            }
+            catch (Exception ex)
+            {
+                result.IsValid = false;
+                result.Description += ex.Message;
+            }
+        }
+
+        private void Calculate()
+        {
+            foreach (var action in InputData.ForceActions)
+            {
+                var combinationList = action.GetCombinations();
+                foreach (var combination in combinationList)
+                {
+                    var longTuple = combination.DesignForces.Single(x => x.LimitState == limitState && x.CalcTerm == CalcTerms.LongTerm).ForceTuple;
+                    var shortTuple = combination.DesignForces.Single(x => x.LimitState == limitState && x.CalcTerm == CalcTerms.ShortTerm).ForceTuple;
+                    if (action.SetInGravityCenter == true)
+                    {
+                        IProcessorLogic<IForceTuple> forceLogic = new ForceTupleCopier(longTuple);
+                        forceLogic = new ForceTupleMoveToPointDecorator(forceLogic) { Point2D = gravityCenter };
+                        longTuple = forceLogic.GetValue();
+                        forceLogic = new ForceTupleCopier(shortTuple);
+                        forceLogic = new ForceTupleMoveToPointDecorator(forceLogic) { Point2D = gravityCenter };
+                        shortTuple = forceLogic.GetValue();
+                    }
+                    CurvatureForceCalculatorInputData forceInputData = new()
+                    {
+                        LongTermTuple = longTuple,
+                        ShortTermTuple = shortTuple,
+                        Primitives = InputData.Primitives,
+                        DeflectionFactor = InputData.DeflectionFactor
+                    };
+                    ForceCalculator.InputData = forceInputData;
+                    ForceCalculator.Run();
+                    result.ForceCalculatorResults.Add((ICurvatureForceCalculatorResult)ForceCalculator.Result);
+                }
+            }
+        }
+
+        private void SetGravityCenter()
+        {
+            var triangulateLogic = new TriangulatePrimitiveLogic()
+            {
+                Primitives = InputData.Primitives,
+                LimitState = LimitStates.ULS,
+                CalcTerm = CalcTerms.ShortTerm,
+                TraceLogger = TraceLogger
+            };
+            var ndms = triangulateLogic.GetNdms();
+            var (Cx, Cy) = LoaderCalculator.Logics.Geometry.GeometryOperations.GetGravityCenter(ndms);
+            gravityCenter = new Point2D() { X = Cx, Y = Cy };
+        }
+
+        private void PrepareNewResult()
+        {
+            result = new CurvatureCalculatorResult()
+            {
+                IsValid = true,
+                Description = string.Empty,
+                InputData = InputData
+            };
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorUpdateCloningStrategy.cs

@@ -0,0 +1,46 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using StructureHelperLogics.NdmCalculations.Primitives.Logics;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureCalculatorUpdateCloningStrategy : IUpdateStrategy<ICurvatureCalculator>
+    {
+        private readonly ICloningStrategy cloningStrategy;
+        private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
+        private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
+        private IUpdateStrategy<IHasForceActions> ForcesUpdateStrategy => forcesUpdateStrategy ??= new HasForceActionUpdateCloningStrategy(cloningStrategy);
+        private IUpdateStrategy<IHasPrimitives> PrimitivesUpdateStrategy => primitivesUpdateStrategy ??= new HasPrimitivesUpdateCloningStrategy(cloningStrategy);
+
+        public CurvatureCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy)
+        {
+            this.cloningStrategy = cloningStrategy;
+        }
+
+        public CurvatureCalculatorUpdateCloningStrategy(
+            ICloningStrategy cloningStrategy,
+            IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
+            IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy)
+        {
+            this.cloningStrategy = cloningStrategy;
+            this.forcesUpdateStrategy = forcesUpdateStrategy;
+            this.primitivesUpdateStrategy = primitivesUpdateStrategy;
+        }
+
+        public void Update(ICurvatureCalculator targetObject, ICurvatureCalculator sourceObject)
+        {
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            var sourceData = sourceObject.InputData;
+            var targetData = targetObject.InputData;
+            PrimitivesUpdateStrategy.Update(targetData, sourceData);
+            ForcesUpdateStrategy.Update(targetData, sourceData);
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/DeflectionFactorUpdateStrategy.cs

@@ -0,0 +1,32 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Services;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class DeflectionFactorUpdateStrategy : IParentUpdateStrategy<IDeflectionFactor>
+    {
+        public bool UpdateChildren { get; set; } = true;
+
+        public void Update(IDeflectionFactor targetObject, IDeflectionFactor sourceObject)
+        {
+            CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject));
+            CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
+            if (ReferenceEquals(targetObject, sourceObject))
+                return;
+            targetObject.SpanLength = sourceObject.SpanLength;
+            if (UpdateChildren == true)
+            {
+                CheckObject.ThrowIfNull(sourceObject.DeflectionFactors);
+                CheckObject.ThrowIfNull(targetObject.DeflectionFactors);
+                CheckObject.ThrowIfNull(sourceObject.MaxDeflections);
+                CheckObject.ThrowIfNull(targetObject.MaxDeflections);
+                targetObject.DeflectionFactors = sourceObject.DeflectionFactors.Clone() as IForceTuple;
+                targetObject.MaxDeflections = sourceObject.MaxDeflections.Clone() as IForceTuple;
+            }
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/ICurvatureCalcualtorLogic.cs

@@ -1,11 +1,12 @@
-using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Calculators;
 using System;
 using System.Collections.Generic;
 using System.Text;
 
 namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
 {
-    internal interface ICurvatureCalcualtorLogic
+    internal interface ICurvatureCalcualtorLogic : ILogic
     {
         ICurvatureCalculatorInputData InputData {get;set;}
         IResult Result { get; }

StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs

@@ -61,7 +61,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
                     var newTuple = forcelogic.GetValue();
                     GetForceTupleResult(forceAction, newTuple);
                 }
-
             }
         }
 

StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs

@@ -8,13 +8,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
     public class ValueDiagramCalculatorUpdateCloningStrategy : IUpdateStrategy<IValueDiagramCalculator>
     {
         private readonly ICloningStrategy cloningStrategy;
-        private readonly IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
-        private readonly IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
+        private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
+        private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
+        private IUpdateStrategy<IHasForceActions> ForcesUpdateStrategy => forcesUpdateStrategy ??= new HasForceActionUpdateCloningStrategy(cloningStrategy);
+        private IUpdateStrategy<IHasPrimitives> PrimitivesUpdateStrategy => primitivesUpdateStrategy ??= new HasPrimitivesUpdateCloningStrategy(cloningStrategy);
 
-        public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
-            cloningStrategy,
-            new HasForceActionUpdateCloningStrategy(cloningStrategy),
-            new HasPrimitivesUpdateCloningStrategy(cloningStrategy))
+        public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy)
         {
             this.cloningStrategy = cloningStrategy;
         }
@@ -37,8 +36,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             var sourceData = sourceObject.InputData;
             var targetData = targetObject.InputData;
-            primitivesUpdateStrategy.Update(targetData, sourceData);
-            forcesUpdateStrategy.Update(targetData, sourceData);
+            PrimitivesUpdateStrategy.Update(targetData, sourceData);
+            ForcesUpdateStrategy.Update(targetData, sourceData);
         }
     }
 }

StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs

@@ -6,11 +6,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics
     public class ValueDiagramCheckLogic : CheckEntityLogic<IValueDiagram>
     {
         private const double minDistance = 1e-3;
-        private bool result;
 
         public override bool Check()
         {
-            result = true;
+            bool result = true;
             if (Entity is null)
             {
                 string errorString = ErrorStrings.ParameterIsNull + ": value diagram";

StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs

@@ -33,7 +33,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
                 CheckRebarHostMaterial = false,
                 CheckRebarPlacement = false
             };
-            primitivesCheckLogic = new CheckPrimitiveCollectionLogic(TraceLogger, checkRebarPrimitiveLogic);
+            primitivesCheckLogic = new HasPrimitivesCheckLogic(TraceLogger, checkRebarPrimitiveLogic);
             actionsCheckLogic = new CheckForceActionsLogic(TraceLogger);
         }
 

StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs

@@ -28,7 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             this.checkPrimitiveCollectionLogic = checkPrimitiveCollectionLogic;
         }
 
-        public CheckCrackCalculatorInputDataLogic() : this (new CheckPrimitiveCollectionLogic())
+        public CheckCrackCalculatorInputDataLogic() : this (new HasPrimitivesCheckLogic())
         {
             
         }

StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs

@@ -199,7 +199,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             forceTupleCalculator.Run();
             var result = forceTupleCalculator.Result as IForceTupleCalculatorResult;
             var loaderStrainMatrix = result.LoaderResults.ForceStrainPair.StrainMatrix;
-            StrainTuple strainTuple = TupleConverter.ConvertToStrainTuple(loaderStrainMatrix);
+            StrainTuple strainTuple = ForceTupleConverter.ConvertToStrainTuple(loaderStrainMatrix);
             return strainTuple;
         }
         private bool CheckInputData()

StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs

@@ -15,7 +15,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         /// <inheritdoc/>
         public INdm ConcreteNdm { get; set; }
         /// <inheritdoc/>
-        public IForceTuple Tuple { get; set; }
+        public IForceTuple ForceTuple { get; set; }
         /// <inheritdoc/>
         public IEnumerable<INdm> CheckedNdmCollection { get; set; }
         /// <inheritdoc/>

StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCracked.cs

@@ -0,0 +1,13 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking
+{
+    public interface IIsSectionCracked : ILogic
+    {
+        /// <summary>
+        /// Returns result of checking of cracks appearence
+        /// </summary>
+        /// <returns>True if Checked collectition contains cracked elements</returns>
+        bool IsSectionCracked();
+    }
+}

StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs

@@ -1,23 +1,17 @@
 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>
     /// Logic for checking collection of ndms for appearance of crack
     /// </summary>
-    public interface IIsSectionCrackedByForceLogic : ILogic
+    public interface IIsSectionCrackedByForceLogic : IIsSectionCracked
     {
         /// <summary>
         /// Force tuple for checking of cracks appearence
         /// </summary>
-        IForceTuple Tuple { get; set; }
+        IForceTuple ForceTuple { get; set; }
         /// <summary>
         /// Collection of ndms which is checking for cracking
         /// </summary>
@@ -26,10 +20,5 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         /// Full ndms collection of cross-section
         /// </summary>
         IEnumerable<INdm> SectionNdmCollection { get; set; }
-        /// <summary>
-        /// Returns result of checking of cracks appearence
-        /// </summary>
-        /// <returns>True if Checked collectition contains cracked elements</returns>
-        bool IsSectionCracked();
     }
 }

StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs

@@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         {
             IsSectionCrackedByForceLogic.TraceLogger ??= TraceLogger?.GetSimilarTraceLogger(50);
             var actualTuple = ForceTupleService.InterpolateTuples(StartTuple, EndTuple, factor);
-            IsSectionCrackedByForceLogic.Tuple = actualTuple;
+            IsSectionCrackedByForceLogic.ForceTuple = actualTuple;
             return IsSectionCrackedByForceLogic.IsSectionCracked();
         }
     }

StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs

@@ -14,33 +14,22 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
     {
         static readonly IStressLogic stressLogic = new StressLogic();
         /// <inheritdoc/>
-        public IForceTuple Tuple { get; set; }
+        public IForceTuple ForceTuple { get; set; }
         public IEnumerable<INdm> CheckedNdmCollection { get; set; }
         public IEnumerable<INdm> SectionNdmCollection { get; set; }
-        public Accuracy Accuracy { get; set; }
+        public Accuracy Accuracy { get; set; } = new Accuracy() { IterationAccuracy = 0.001d, MaxIterationCount = 10000};
         public IShiftTraceLogger? TraceLogger { get; set; }
 
-        public IsSectionCrackedByForceLogic()
-        {
-            if (Accuracy is null)
-            {
-                Accuracy = new Accuracy()
-                {
-                    IterationAccuracy = 0.001d,
-                    MaxIterationCount = 10000
-                };
-            }
-        }
         public bool IsSectionCracked()
         {
             TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
             TraceLogger?.AddMessage($"It is assumed, that cracks appearence if: cross-section has elementary parts of concrete and strain of concrete greater than limit value");
             TraceLogger?.AddMessage($"Force combination for cracking check");
-            TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(Tuple));
+            TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(ForceTuple));
             var inputData = new ForceTupleInputData()
             {
                 Accuracy = Accuracy,
-                ForceTuple = Tuple,
+                ForceTuple = ForceTuple,
                 NdmCollection = SectionNdmCollection
             };
             var calculator = new ForceTupleCalculator() { InputData = inputData };

StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs

@@ -60,7 +60,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         {
             var strainTuple = GetStrainTuple();
             result.StrainTuple = strainTuple;
-            var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
+            var strainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
             result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm);
             result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm);
             result.ConcreteStrain = -concreteNdm.PrestrainLogic.GetAll().Sum(x => x.PrestrainValue);
@@ -94,7 +94,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                 //TraceLogger?.AddMessage(LoggerStrings.CalculationError + $": {forceResult.Description}", TraceLogStatuses.Error);
                 throw new StructureHelperException(ErrorStrings.CalculationError);
             }
-            var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
+            var strain = ForceTupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
             return strain;
         }
 

StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs

@@ -175,7 +175,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                 TraceLogger?.AddMessage("Bearing capacity of cross-section is not enough for action", TraceLogStatuses.Error);
                 return null;
             }
-            var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
+            var strain = ForceTupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
             return strain;
         }
 
@@ -183,7 +183,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         {
             lengthLogic.NdmCollection = elasticNdms;
             lengthLogic.TraceLogger = TraceLogger;
-            lengthLogic.StrainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
+            lengthLogic.StrainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
             return lengthLogic.GetLength();
         }
 

StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs

@@ -1,14 +1,8 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
-using StructureHelperCommon.Models.Calculators;
 using StructureHelperCommon.Models.Materials;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
-namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
+namespace StructureHelperLogics.NdmCalculations.Primitives
 {
     public class CheckRebarPrimitiveLogic : ICheckEntityLogic<IRebarNdmPrimitive>
     {

StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesCheckLogic.cs

@@ -1,10 +1,11 @@
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
+using StructureHelperLogics.NdmCalculations.Primitives.Logics;
 
-namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
+namespace StructureHelperLogics.NdmCalculations.Primitives
 {
-    public class CheckPrimitiveCollectionLogic : ICheckEntityLogic<IHasPrimitives>
+    public class HasPrimitivesCheckLogic : ICheckEntityLogic<IHasPrimitives>
     {
         private const string collectionDoesntHaveAnyPrimitives = "Calculator does not contain any primitives\n";
         private const string checkRebarLogic = ": check rebar logic";
@@ -19,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
 
         public IShiftTraceLogger? TraceLogger { get; set; }
 
-        public CheckPrimitiveCollectionLogic(
+        public HasPrimitivesCheckLogic(
             IShiftTraceLogger shiftTraceLogger,
             ICheckEntityLogic<IRebarNdmPrimitive> checkRebarPrimitiveLogic)
         {
@@ -27,7 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
             this.checkRebarPrimitiveLogic = checkRebarPrimitiveLogic;
         }
 
-        public CheckPrimitiveCollectionLogic() : this (new ShiftTraceLogger(), new CheckRebarPrimitiveLogic())
+        public HasPrimitivesCheckLogic() : this (new ShiftTraceLogger(), new CheckRebarPrimitiveLogic())
         {
             
         }

StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogic.cs

@@ -25,7 +25,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
                 Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm)
             };
             List<INdm> ndmCollection = new () { ndm};
-            NdmTransform.SetPrestrain(ndmCollection, TupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
+            NdmTransform.SetPrestrain(ndmCollection, ForceTupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
             return ndmCollection;
         }
 

StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs

@@ -47,7 +47,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
                 Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm)
             };
             ;
-            NdmTransform.SetPrestrain(rebarNdm, TupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
+            NdmTransform.SetPrestrain(rebarNdm, ForceTupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
             return rebarNdm;
         }
 
@@ -74,7 +74,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
                 //StressScale = -1d
                 StressScale = 1d//-1d
             };
-            NdmTransform.SetPrestrain(concreteNdm, TupleConverter.ConvertToLoaderStrainMatrix(prestrain));
+            NdmTransform.SetPrestrain(concreteNdm, ForceTupleConverter.ConvertToLoaderStrainMatrix(prestrain));
             return concreteNdm;
         }