Checkig Iput data of crack calculator was changed

StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs

@@ -60,14 +60,16 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         private void MultiThreadProc(IEnumerable<IPoint2D> points)
         {
             Task<IPoint2D>[] tasks = new Task<IPoint2D>[points.Count()];
-            for (int i = 0; i < points.Count(); i++)
+            int pointCount = points.Count();
+            List<IPoint2D> PointList = points.ToList();
+            for (int i = 0; i < pointCount; i++)
             {
-                var point = points.ToList()[i];
+                var point = PointList[i];
                 tasks[i] = new Task<IPoint2D>(() => FindResultPoint(point));
                 tasks[i].Start();
             }
             Task.WaitAll(tasks);
-            for (int j = 0; j < points.Count(); j++)
+            for (int j = 0; j < pointCount; j++)
             {
                 var taskResult = tasks[j].Result;
                 resultList.Add(taskResult);

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

@@ -50,7 +50,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
             Point2D minPoint = new(), maxPoint = new();
             foreach (var item in ndmCollection)
             {
-                var strain = stressLogic.GetTotalStrain(strainMatrix, item);
+                var strain = stressLogic.GetSectionStrain(strainMatrix, item);
                 if (strain < minStrain)
                 {
                     minStrain = strain;

StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs

@@ -205,7 +205,7 @@ namespace StructureHelperLogics.NdmCalculations.Buckling
             var stressLogic = new StressLogic();
             foreach (var item in ndmCollection)
             {
-                var strain = stressLogic.GetTotalStrain(strains, item); 
+                var strain = stressLogic.GetSectionStrain(strains, item); 
                 if (strain > maxStrain)
                 {
                     maxStrain = strain;

StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs

@@ -0,0 +1,119 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Loggers;
+using StructureHelperCommon.Models.Materials;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking
+{
+    /// <summary>
+    /// Logic of checking of input data for crack calcultor 
+    /// </summary>
+    public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic
+    {
+        private string checkResult;
+        private CrackInputData inputData;
+        private bool result;
+
+        public IInputData InputData
+        {
+            get => inputData;
+            set
+            {
+                if (value is CrackInputData data)
+                {
+                    inputData = data;
+                }
+                else
+                {
+                    throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(CrackInputData), value));
+                }
+            }
+        }
+
+        public string CheckResult => checkResult;
+
+        public IShiftTraceLogger? TraceLogger { get; set; }
+        public CheckCrackCalculatorInputDataLogic(CrackInputData inputData)
+        {
+            this.inputData = inputData;
+        }
+        public bool Check()
+        {
+            TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Debug);
+            result = true;
+            checkResult = string.Empty;
+            CheckPrimitives();
+            CheckActions();
+            return result;
+        }
+
+        private void CheckActions()
+        {
+            if (inputData.ForceActions is null || (!inputData.ForceActions.Any()))
+            {
+                result = false;
+                string message = "Calculator does not contain any actions\n";
+                checkResult += message;
+                TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
+            };
+        }
+
+        private void CheckPrimitives()
+        {
+            if (inputData.Primitives is null || (!inputData.Primitives.Any()))
+            {
+                result = false;
+                string message = "Calculator does not contain any primitives\n";
+                checkResult += message;
+                TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
+            }
+            else
+            {
+                foreach (var primitive in inputData.Primitives)
+                {
+                    if (primitive is RebarPrimitive rebar)
+                    {
+                        CheckRebar(rebar);
+                    }
+                }
+            }
+        }
+
+        private void CheckRebar(RebarPrimitive rebar)
+        {
+            if (rebar.HostPrimitive is null)
+            {
+                result = false;
+                string message = $"Primitive {rebar.Name} does not have a host\n";
+                checkResult += message;
+                TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
+            }
+            else
+            {
+                bool isPrimitivesContainRebarHost = inputData.Primitives.Contains(rebar.HostPrimitive);
+                if (isPrimitivesContainRebarHost == false)
+                {
+                    result = false;
+                    string message = $"Host {rebar.Name}({rebar.HostPrimitive.Name}) is not included in primitives\n";
+                    checkResult += message;
+                    TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
+                }
+            }
+            if (rebar.HostPrimitive.HeadMaterial.HelperMaterial is not ICrackedMaterial)
+            {
+                result = false;
+                string message = $"Material of host of {rebar.Name} does not support cracking\n";
+                checkResult += message;
+                TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
+            }
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs

@@ -23,6 +23,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         private CrackResult result;
         private IGetTupleInputDatasLogic datasLogic;
         private CrackCalculatorUpdateStrategy updateStrategy = new();
+        private ICheckInputDataLogic checkInputDataLogic;
 
         public string Name { get; set; }
         public CrackInputData InputData { get; set; }
@@ -44,6 +45,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         public void Run()
         {
             PrepareNewResult();
+            CheckInputData();
             TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
             try
             {
@@ -58,6 +60,19 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             }
         }
 
+        private void CheckInputData()
+        {
+            checkInputDataLogic = new CheckCrackCalculatorInputDataLogic(InputData)
+            {
+                TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
+            };
+            if (checkInputDataLogic.Check() == false)
+            {
+                result.IsValid = false;
+                result.Description += checkInputDataLogic.CheckResult;
+            }
+        }
+
         private void ProcessCalculations()
         {
             datasLogic = new GetTupleInputDatasLogic(InputData.Primitives, InputData.ForceActions, InputData.UserCrackInputData)

StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs

@@ -35,7 +35,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             TraceLogger?.AddMessage($"Rebar elongation Epsilon = {inputData.RebarStrain} - {inputData.ConcreteStrain} = {rebarElongation}(dimensionless)");
             double width = rebarElongation * inputData.Length;
             width *= inputData.TermFactor * inputData.BondFactor * inputData.StressStateFactor * inputData.PsiSFactor;
-            TraceLogger?.AddMessage($"Width of crack a,crc = {width}(m)");
+            TraceLogger?.AddMessage($"Width of crack a,crc = {inputData.TermFactor} * {inputData.BondFactor} * {inputData.StressStateFactor} * {inputData.PsiSFactor} * {rebarElongation} * {inputData.Length}(m) = {width}(m)");
             return width;
         }
 

StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs

@@ -52,9 +52,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                     resultList.Add(new TupleCrackInputData()
                     {
                         IsValid = true,
+                        TupleName = action.Name,
                         LongTermTuple = tuple.LongTuple,
                         ShortTermTuple = tuple.ShortTuple,
-                        NdmPrimitives = Primitives,
+                        Primitives = Primitives,
                         UserCrackInputData = UserCrackInputData
                     });
                 }

StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs

@@ -2,6 +2,9 @@
 {
     public interface ICrackWidthTupleResult
     {
+        /// <summary>
+        /// Calculated crack width
+        /// </summary>
         double CrackWidth { get; set; }
         bool IsCrackLessThanUltimate { get; }
         double UltimateCrackWidth { get; set; }

StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs

@@ -106,7 +106,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         private double GetAverageDiameter(IEnumerable<RebarNdm?> rebars)
         {
             var tesileRebars = rebars
-                .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d);
+                .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d);
             diameterLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
             diameterLogic.Rebars = tesileRebars;
             var rebarDiameter = diameterLogic.GetAverageDiameter();

StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs

@@ -8,12 +8,26 @@ using System.Threading.Tasks;
 
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
+    /// <summary>
+    /// Result of calculation of crack for specific result
+    /// </summary>
     public class RebarCrackResult : IResult
     {
+        /// <inheritdoc/>
         public bool IsValid { get; set; }
+        /// <inheritdoc/>
         public string Description { get; set; }
+        /// <summary>
+        /// Specific rebar primitive
+        /// </summary>
         public RebarPrimitive RebarPrimitive { get; set; }
+        /// <summary>
+        /// Result of calculation of crack for long term
+        /// </summary>
         public CrackWidthRebarTupleResult LongTermResult { get; set; }
+        /// <summary>
+        /// Result of calculation of crack for short term
+        /// </summary>
         public CrackWidthRebarTupleResult ShortTermResult { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs

@@ -62,7 +62,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 
         public void Run()
         {
-            GetNdms();
+            GetNdmCollectionFromPrimitives();
             result = new RebarStressResult()
             {
                 IsValid = true,
@@ -71,13 +71,13 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             var strainTuple = GetStrainTuple();
             result.StrainTuple = strainTuple;
             var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
-            result.RebarStrain = stressLogic.GetTotalStrain(strainMatrix, rebarNdm);
+            result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm);
             result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm);
             result.ConcreteStrain = concreteNdm.Prestrain;
         }
 
 
-        private void GetNdms()
+        private void GetNdmCollectionFromPrimitives()
         {
             var options = new TriangulationOptions()
             {

StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs

@@ -10,7 +10,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
     public class RebarStressResult : IResult
     {
+        /// <inheritdoc/>
         public bool IsValid { get; set; }
+        /// <inheritdoc/>
         public string? Description { get; set; }
         public StrainTuple StrainTuple { get; set; } 
         public double RebarStress { get; set; }

StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs

@@ -29,7 +29,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
 
             var rebarCollection = NdmCollection
-                .Where(x => x is RebarNdm & stressLogic.GetTotalStrain(StrainMatrix, x) > 0d);
+                .Where(x => x is RebarNdm & stressLogic.GetSectionStrain(StrainMatrix, x) > 0d);
             var rebarArea = rebarCollection.
                 Sum(x => x.Area * x.StressScale);
             TraceLogger?.AddMessage($"Summary rebar area As = {rebarArea}");

StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs

@@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
             TraceLogger?.AddMessage("Method of obtaining of summary area of rebars in tension based on areas which are proportional by maximum strain");
             var rebars = Rebars
-                .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d);
+                .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d);
             if (!rebars.Any())
             {
                 string errorString = ErrorStrings.DataIsInCorrect + ": Collection of rebars does not contain any tensile rebars";
@@ -40,7 +40,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                 throw new StructureHelperException(errorString);
             }
             var maxStrain = rebars
-                .Select(x => stressLogic.GetTotalStrain(StrainMatrix, x))
+                .Select(x => stressLogic.GetSectionStrain(StrainMatrix, x))
                 .Max();
             TraceLogger?.AddMessage($"Maximum strain maxStrain = {maxStrain}");
             if (TraceLogger is not null)
@@ -51,7 +51,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             foreach (var rebar in rebars)
             {
                 double area = rebar.Area * rebar.StressScale;
-                double strain = stressLogic.GetTotalStrain(StrainMatrix, rebar);
+                double strain = stressLogic.GetSectionStrain(StrainMatrix, rebar);
                 TraceLogger?.AddMessage($"Rebar area = {area}(m^2)");
                 TraceLogger?.AddMessage($"Rebar strain = {strain}");
                 var reducedArea = area * strain / maxStrain;

StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs

@@ -11,6 +11,9 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
+//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia
+//All rights reserved.
+
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
     public class TensionRebarAreaSimpleSumLogic : ITensionRebarAreaLogic
@@ -32,7 +35,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
             TraceLogger?.AddMessage("Method of obtaining of summary area of rebars in tension based on ordinary summarizing of areas");
             var rebars = Rebars
-                .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d);
+                .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d);
             if (!rebars.Any())
             {
                 string errorString = ErrorStrings.DataIsInCorrect + ": Collection of rebars does not contain any tensile rebars";

StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs

@@ -1,4 +1,5 @@
 using LoaderCalculator.Data.Ndms;
+using StructureHelper.Models.Materials;
 using StructureHelperCommon.Infrastructures.Enums;
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Models;
@@ -26,6 +27,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         private StrainTuple shortDefaultStrainTuple;
         private double longLength;
         private double shortLength;
+        private object locker = new();
 
         public string Name { get; set; }
         public TupleCrackInputData InputData { get; set; }
@@ -68,6 +70,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         {
             CheckInputData();
             Triangulate();
+
             longDefaultStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, crackableNdms);
             shortDefaultStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, crackableNdms);
             var longElasticStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, elasticNdms);
@@ -85,17 +88,28 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                 shortLength = GetLengthBetweenCracks(shortElasticStrainTuple);
             }
             CalcCrackForce();
-            foreach (var rebar in rebarPrimitives)
-            {
-                RebarCrackCalculatorInputData rebarCalculatorData = GetRebarCalculatorInputData(rebar);
-                var calculator = new RebarCrackCalculator
+            //for (int j = 0; j < 100000; j++)
+            //{
+                result.RebarResults.Clear();
+                int rebarCount = rebarPrimitives.Count;
+                Task<RebarCrackResult>[] tasks = new Task<RebarCrackResult>[rebarCount];
+                for (int i = 0; i < rebarCount; i++)
                 {
-                    InputData = rebarCalculatorData,
-                    TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
-                };
-                calculator.Run();
-                var rebarResult = calculator.Result as RebarCrackResult;
-                result.RebarResults.Add(rebarResult);
+                    var rebar = rebarPrimitives[i];
+                    tasks[i] = new Task<RebarCrackResult>(() => ProcessRebar(rebar));
+                    tasks[i].Start();
+                }
+                Task.WaitAll(tasks);
+                for (int i = 0; i < rebarCount; i++)
+                {
+                    result.RebarResults.Add(tasks[i].Result);
+                }
+            //}
+            
+            if (result.RebarResults.Any(x => x.IsValid == false))
+            {
+                result.IsValid = false;
+                return;
             }
             result.LongTermResult = new()
             {
@@ -109,25 +123,50 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             };
         }
 
+        private RebarCrackResult ProcessRebar(RebarPrimitive rebar)
+        {
+            RebarCrackCalculatorInputData rebarCalculatorData = GetRebarCalculatorInputData(rebar);
+            var calculator = new RebarCrackCalculator
+            {
+                InputData = rebarCalculatorData,
+                TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
+            };
+            calculator.Run();
+            var rebarResult = calculator.Result as RebarCrackResult;
+            return rebarResult;
+        }
+
         private RebarCrackCalculatorInputData GetRebarCalculatorInputData(RebarPrimitive rebar)
         {
+            IEnumerable<INdm> crackableNdmsLoc = null;
+            IEnumerable<INdm> crackedNdmsLoc = null;
+            RebarPrimitive rebarCopy = null;
+            lock (locker)
+            {
+                rebarCopy = rebar.Clone() as RebarPrimitive;
+                rebarCopy.HeadMaterial = rebarCopy.HeadMaterial.Clone() as IHeadMaterial;
+                var triangulationLogicLoc = new CrackedSectionTriangulationLogic(InputData.Primitives);
+                crackableNdmsLoc = triangulationLogicLoc.GetNdmCollection();
+                crackedNdmsLoc = triangulationLogicLoc.GetCrackedNdmCollection();
+            }
+
             var longRebarData = new RebarCrackInputData()
             {
-                CrackableNdmCollection = crackableNdms,
-                CrackedNdmCollection = crackedNdms,
-                ForceTuple = InputData.LongTermTuple as ForceTuple,
+                CrackableNdmCollection = crackableNdmsLoc,
+                CrackedNdmCollection = crackedNdmsLoc,
+                ForceTuple = InputData.LongTermTuple.Clone() as ForceTuple,
                 Length = longLength
             };
             var shortRebarData = new RebarCrackInputData()
             {
                 CrackableNdmCollection = crackableNdms,
                 CrackedNdmCollection = crackedNdms,
-                ForceTuple = InputData.ShortTermTuple as ForceTuple,
+                ForceTuple = InputData.ShortTermTuple.Clone() as ForceTuple,
                 Length = shortLength
             };
             var rebarCalculatorData = new RebarCrackCalculatorInputData()
             {
-                RebarPrimitive = rebar,
+                RebarPrimitive = rebarCopy,
                 LongRebarData = longRebarData,
                 ShortRebarData = shortRebarData,
                 UserCrackInputData = InputData.UserCrackInputData
@@ -153,6 +192,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             {
                 result.IsValid = false;
                 result.Description += forceResult.Description;
+                TraceLogger?.AddMessage("Bearing capacity of cross-section is not enough for action", TraceLogStatuses.Error);
+                return null;
             }
             var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
             return strain;
@@ -171,7 +212,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 
         private void Triangulate()
         {
-            triangulationLogic = new CrackedSectionTriangulationLogic(InputData.NdmPrimitives)
+            triangulationLogic = new CrackedSectionTriangulationLogic(InputData.Primitives)
             {
                 //TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
             };
@@ -192,7 +233,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 
         private void CheckInputData()
         {
-            if (InputData.NdmPrimitives is null || InputData.NdmPrimitives.Count == 0)
+            if (InputData.Primitives is null || InputData.Primitives.Count == 0)
             {
                 throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": input data doesn't have any primitives");
             }    

StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs

@@ -8,14 +8,32 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
+//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia
+//All rights reserved.
+
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
-    public class TupleCrackInputData : IInputData
+    /// <summary>
+    /// Input data for calculation of crack for specific force tuple
+    /// </summary>
+    public class TupleCrackInputData : IInputData, IHasPrimitives
     {
+        /// <inheritdoc/>
         public bool IsValid { get; set; }
+        public string TupleName { get; set; }
+        /// <summary>
+        /// Force tuple for long term calculations
+        /// </summary>
         public IForceTuple? LongTermTuple { get; set; }
+        /// <summary>
+        /// Force tuple for short term calculations
+        /// </summary>
         public IForceTuple? ShortTermTuple { get; set; }
-        public List<INdmPrimitive>? NdmPrimitives {get;set;}
+        /// <inheritdoc/>
+        public List<INdmPrimitive>? Primitives { get; set;}
+        /// <summary>
+        /// Settings ajusted by user
+        /// </summary>
         public UserCrackInputData UserCrackInputData { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs

@@ -6,21 +6,25 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
+//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia
+//All rights reserved.
+
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
+    /// <summary>
+    /// Result of crack calculation for specific force tuple
+    /// </summary>
     public class TupleCrackResult : IResult
     {
+        /// <inheritdoc/>
         public bool IsValid { get; set; }
+        /// <inheritdoc/>
         public string Description { get; set; }
         public TupleCrackInputData InputData { get; set; }
         public bool IsCracked { get; set; }
         public List<RebarCrackResult>  RebarResults { get; private set; }
         public CrackWidthRebarTupleResult LongTermResult { get; set; }
         public CrackWidthRebarTupleResult ShortTermResult { get; set; }
-        //public double MaxLongTermCrackWidth => RebarResults.Select(x => x.LongTermResult.CrackWidth).Max();
-        //public double MaxShortTermCrackWidth => RebarResults.Select(x => x.ShortTermResult.CrackWidth).Max();
-        //public bool IsLongCrackLessThanUltimate => MaxLongTermCrackWidth <= InputData.UserCrackInputData.UltimateLongCrackWidth;
-        //public bool IsShortCrackLessThanUltimate => MaxShortTermCrackWidth <= InputData.UserCrackInputData.UltimateShortCrackWidth;
 
         public TupleCrackResult()
         {