Crack edit window was added

2024-05-18 21:45:25 +05:00
parent 845929406e
commit ed2846dc8c
20 changed files with 534 additions and 58 deletions
--- a/StructureHelperLogics/NdmCalculations/Analyses/Logics/CalculatorUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/Logics/CalculatorUpdateStrategy.cs
@@ -5,6 +5,7 @@ using StructureHelperCommon.Services;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
+using StructureHelperLogics.NdmCalculations.Cracking;
 using StructureHelperLogics.NdmCalculations.Primitives;
 using System;
 using System.Collections.Generic;
@@ -28,6 +29,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Logics
            {
                new LimitCurvesCalculatorUpdateStrategy().Update(limitCurves, (LimitCurvesCalculator)sourceObject);
            }
+            else if (targetObject is CrackCalculator crackCalculator)
+            {
+                new CrackCalculatorUpdateStrategy().Update(crackCalculator, (CrackCalculator)sourceObject);
+            }
            else
            {
                ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(INdmPrimitive), sourceObject.GetType());
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthTupleResult.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthTupleResult.cs
@@ -13,7 +13,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
        public double CrackWidth { get; set; }
        public double UltimateCrackWidth { get; set; }
        public bool IsCrackLessThanUltimate => CrackWidth <= UltimateCrackWidth;
-        public double RebarStrain { get; set; }
-        public double ConcreteStrain { get; set; }
+        public RebarStressResult RebarStressResult { get; set; }
+        public double SofteningFactor { get; set; }
    }
 }
--- a/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs
@@ -26,6 +26,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
        readonly IAverageDiameterLogic diameterLogic;
        readonly ITensileConcreteAreaLogic concreteAreaLogic;
        ITensionRebarAreaLogic rebarAreaLogic;
+        private IStressLogic stressLogic => new StressLogic();

        /// <inheritdoc/>
        public IEnumerable<INdm> NdmCollection { get; set; }
@@ -44,7 +45,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            this
            (   new EquivalentDiameterLogic(),
                new TensileConcreteAreaLogicSP63(),
-                new TensionRebarAreaSimpleSumLogic())
+                new TensionRebarAreaByStrainLogic())
        {      }
        /// <inheritdoc/>
        public double GetLength()
@@ -104,8 +105,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking

        private double GetAverageDiameter(IEnumerable<RebarNdm?> rebars)
        {
+            var tesileRebars = rebars
+                .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d);
            diameterLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
-            diameterLogic.Rebars = rebars;
+            diameterLogic.Rebars = tesileRebars;
            var rebarDiameter = diameterLogic.GetAverageDiameter();
            TraceLogger?.AddMessage($"Average rebar diameter ds = {rebarDiameter}");
            return rebarDiameter;
--- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs
@@ -47,9 +47,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                {
                    CrackWidth = acrc1,
                    UltimateCrackWidth = InputData.UserCrackInputData.UltimateLongCrackWidth,
-                    RebarStrain = rebarStressResult.RebarStrain,
-                    ConcreteStrain = rebarStressResult.ConcreteStrain
+                    RebarStressResult = rebarStressResult
                };
+                TraceLogger?.AddMessage($"Long crack width acrc = acrc,1 = {acrc1}(m)");
+                TraceLogger?.AddMessage($"Ultimate long crack width acrc,ult = {longRebarResult.UltimateCrackWidth}(m)");
+                TraceCrackResult(longRebarResult);
+

                GetSofteningLogic(InputData.ShortRebarData);
                rebarStressResult = GetRebarStressResult(InputData.ShortRebarData);
@@ -61,14 +64,16 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                var acrc3 = crackWidthLogic.GetCrackWidth();

                double acrcShort = acrc1 - acrc2 + acrc3;
-                TraceLogger?.AddMessage($"Long crack width acrc = acrc,1 = {acrc1}(m)");
                TraceLogger?.AddMessage($"Short crack width acrc = acrc,1 - acrc,2 + acrc,3 = {acrc1} - {acrc2} + {acrc3} = {acrcShort}(m)");
                var shortRebarResult = new CrackWidthTupleResult()
                {
                    CrackWidth = acrcShort,
-                    UltimateCrackWidth = InputData.UserCrackInputData.UltimateShortCrackWidth
+                    UltimateCrackWidth = InputData.UserCrackInputData.UltimateShortCrackWidth,
+                    RebarStressResult = rebarStressResult
                };
+                TraceCrackResult(shortRebarResult);
                result.LongTermResult = longRebarResult;
+                result.ShortTermResult = shortRebarResult;
            }
            catch (Exception ex)
            {
@@ -78,6 +83,18 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            result.RebarPrimitive = InputData.RebarPrimitive;
        }

+        private void TraceCrackResult(CrackWidthTupleResult rebarResult)
+        {
+            if (rebarResult.IsCrackLessThanUltimate == false)
+            {
+                TraceLogger?.AddMessage($"Checking crack width is failure, actual crack width acrc = {rebarResult.CrackWidth} > ultimate crack width acrc,ult = {rebarResult.UltimateCrackWidth}", TraceLogStatuses.Warning);
+            }
+            else
+            {
+                TraceLogger?.AddMessage($"Checking crack width is ok, actual crack width acrc = {rebarResult.CrackWidth} <= ultimate crack width acrc,ult = {rebarResult.UltimateCrackWidth}");
+            }
+        }
+
        private void GetSofteningLogic(RebarCrackInputData rebarData)
        {
            if (InputData.UserCrackInputData.SetSofteningFactor == true)
--- a/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs
@@ -20,27 +20,64 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
    public class RebarStressSofteningLogic : ICrackSofteningLogic
    {
-        private IStressLogic stressLogic;
-        private RebarStressResult afterCrackingRebarResult;
+        /// <summary>
+        /// Rebar result immediately after cracking appearance
+        /// </summary>
+        private RebarStressResult crackRebarResult;
+        /// <summary>
+        /// Rebar resul for actual force combination
+        /// </summary>
        private RebarStressResult actualRebarResult;


-        private INdm concreteNdm;
-        private INdm rebarNdm;
+        private INdm? concreteNdm;
+        private INdm? rebarNdm;

-        private double rebarStrainActual;
+        private double rebarActualStrain;
        private double concreteStrainActual;
-        private double rebarStressActual;
+        private double rebarActualStress;
+        private double softeningFactor;
+        private double minValueOfFactor = 0.2d;
+        private RebarPrimitive rebarPrimitive;
+        private RebarCrackInputData inputData;

-        public double MinValueOfFactor { get; set; } = 0.2d;
-        public RebarPrimitive RebarPrimitive { get; set; }
-        public RebarCrackInputData InputData { get; set; }
+        public double MinValueOfFactor
+        {
+            get => minValueOfFactor; set
+            {
+                minValueOfFactor = value;
+                IsResultActual = false;
+            }
+        }
+        public RebarPrimitive RebarPrimitive
+        {
+            get => rebarPrimitive; set
+            {
+                rebarPrimitive = value;
+                IsResultActual = false;
+            }
+        }
+        public RebarCrackInputData InputData
+        {
+            get => inputData; set
+            {
+                inputData = value;
+                IsResultActual = false;
+            }
+        }
        public IShiftTraceLogger? TraceLogger { get; set; }
+        public bool IsResultActual { get; private set; } = false;

        public double GetSofteningFactor()
        {
-            GetNdms();
-            return GetPsiSFactor(InputData.ForceTuple, InputData.CrackableNdmCollection, InputData.CrackedNdmCollection);
+            if (IsResultActual == false)
+            {
+                GetNdms();
+                softeningFactor = GetPsiSFactor(InputData.ForceTuple, InputData.CrackableNdmCollection);
+                IsResultActual = true;
+            }
+            return softeningFactor;
+            
        }

        private void GetNdms()
@@ -55,7 +92,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            rebarNdm = RebarPrimitive.GetRebarNdm(options);
        }

-        private double GetPsiSFactor(ForceTuple forceTuple, IEnumerable<INdm> crackableNndms, IEnumerable<INdm> crackedNndms)
+        private double GetPsiSFactor(ForceTuple forceTuple, IEnumerable<INdm> crackableNndms)
        {

            var crackResult = calculateCrackTuples(forceTuple, crackableNndms);
@@ -66,11 +103,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                throw new StructureHelperException(errorString);
            }

-
            actualRebarResult = GetRebarStressResult(forceTuple);
-            rebarStrainActual = actualRebarResult.RebarStrain;
-            rebarStressActual = actualRebarResult.RebarStress;
-            TraceLogger?.AddMessage($"Actual strain of rebar EpsilonS = {rebarStrainActual}(dimensionless)");
+            rebarActualStrain = actualRebarResult.RebarStrain;
+            rebarActualStress = actualRebarResult.RebarStress;
+            TraceLogger?.AddMessage($"Actual strain of rebar EpsilonS = {rebarActualStrain}(dimensionless)");
            concreteStrainActual = concreteNdm.Prestrain;
            //concreteStrainActual = stressLogic.GetTotalStrain(TupleConverter.ConvertToLoaderStrainMatrix(strainTupleActual), concreteNdm);
            TraceLogger?.AddMessage($"Actual strain of concrete on the axis of rebar EpsilonC = {concreteStrainActual}(dimensionless)");
@@ -84,11 +120,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                TraceLogger?.AddMessage($"Section is cracked in start force combination, PsiS = 1.0");
                return 1d;
            }
-            afterCrackingRebarResult = GetRebarStressResult(crackResult.TupleOfCrackAppearance as ForceTuple);
+            crackRebarResult = GetRebarStressResult(crackResult.TupleOfCrackAppearance as ForceTuple);

-            var stressInCracking = afterCrackingRebarResult.RebarStress;
+            var stressInCracking = crackRebarResult.RebarStress;
            TraceLogger?.AddMessage($"Stress in rebar immediately after cracking Sigma,scrc = {stressInCracking}(Pa)");
-            TraceLogger?.AddMessage($"Actual stress in rebar Sigma,s = {rebarStressActual}(Pa)");
+            TraceLogger?.AddMessage($"Actual stress in rebar Sigma,s = {rebarActualStress}(Pa)");
            double psiS = GetExponentialSofteningFactor(stressInCracking);
            TraceLogger?.AddMessage($"PsiS = {psiS}");
            //return 0.94d;
@@ -97,7 +133,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking

        private double GetExponentialSofteningFactor(double stressInCracking)
        {
-            var stressRatio = stressInCracking / rebarStressActual;
+            var stressRatio = stressInCracking / rebarActualStress;
            var logic = new ExpSofteningLogic()
            {
                ForceRatio = stressRatio,
@@ -116,13 +152,13 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            {
                NdmCollection = ndms,
                CheckedNdmCollection = new List<INdm>() { concreteNdm },
-                TraceLogger = TraceLogger?.GetSimilarTraceLogger(100)
+                //TraceLogger = TraceLogger?.GetSimilarTraceLogger(100)
            };
            var crackedLogis = new CrackedLogic(sectionCrackedLogic)
            {
                StartTuple = new ForceTuple(),
                EndTuple = forceTuple,
-                TraceLogger = TraceLogger?.GetSimilarTraceLogger(100)
+                //TraceLogger = TraceLogger?.GetSimilarTraceLogger(100)
            };
            var calculator = new CrackForceCalculator(crackedLogis)
            {
@@ -133,7 +169,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                    IterationAccuracy = 0.01d,
                    MaxIterationCount = 1000
                },
-                TraceLogger = TraceLogger?.GetSimilarTraceLogger(150)
+                //TraceLogger = TraceLogger?.GetSimilarTraceLogger(150)
            };
            calculator.Run();
            return calculator.Result as CrackForceResult;