Add lib material tests

2025-12-21 10:54:30 +05:00
parent 7e82e5ee9d
commit ac34a26c15
16 changed files with 504 additions and 157 deletions
--- a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
@@ -3,6 +3,7 @@ using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Forces.Logics;
 using StructureHelperCommon.Models.Loggers;
+using StructureHelperLogics.NdmCalculations.Cracking.CheckLogics;
 using StructureHelperLogics.NdmCalculations.Primitives;
 using StructureHelperLogics.NdmCalculations.Primitives.Logics;

@@ -11,57 +12,65 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
    /// <summary>
    /// Logic of checking of input data for crack calcultor 
    /// </summary>
-    public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<ICrackCalculatorInputData>
+    public class CheckCrackCalculatorInputDataLogic : CheckEntityLogic<ICrackCalculatorInputData>
    {
        private bool result;
        private ICheckEntityLogic<IHasPrimitives> checkPrimitiveCollectionLogic;
-
-        public ICrackCalculatorInputData InputData {  get; set; }
-
-
-        public string CheckResult { get; private set; }
-
-        public IShiftTraceLogger? TraceLogger { get; set; }
+        private ICheckEntityLogic<IEnumerable<INdmPrimitive>> checkMaterialsForCrackingLogic;
+        private ICheckEntityLogic<IEnumerable<INdmPrimitive>> CheckMaterialsForCrackingLogic => checkMaterialsForCrackingLogic ??= new PrimitivesForCrackMaterialCheckLogic();
+        private ICheckEntityLogic<IHasPrimitives> CheckPrimitiveCollectionLogic => checkPrimitiveCollectionLogic ??= new HasPrimitivesCheckLogic() ;

        public CheckCrackCalculatorInputDataLogic(ICheckEntityLogic<IHasPrimitives> checkPrimitiveCollectionLogic)
        {
            this.checkPrimitiveCollectionLogic = checkPrimitiveCollectionLogic;
        }

-        public CheckCrackCalculatorInputDataLogic() : this (new HasPrimitivesCheckLogic())
+        public CheckCrackCalculatorInputDataLogic()
        {
            
        }

-        public bool Check()
+        public override bool Check()
        {
            TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug);
            result = true;
            CheckResult = string.Empty;
+            CheckCrackingMaterials();
            CheckPrimitives();
            CheckActions();
            return result;
        }

+        private void CheckCrackingMaterials()
+        {
+            CheckMaterialsForCrackingLogic.TraceLogger = TraceLogger;
+            CheckMaterialsForCrackingLogic.Entity = Entity.Primitives;
+            if (CheckMaterialsForCrackingLogic.Check() == false)
+            {
+                result = false;
+                CheckResult += CheckMaterialsForCrackingLogic.CheckResult;
+            }
+        }
+
        private void CheckPrimitives()
        {
-            if (checkPrimitiveCollectionLogic is null)
+            if (CheckPrimitiveCollectionLogic is null)
            {
                throw new StructureHelperException(ErrorStrings.ParameterIsNull + ": check primitive logic");
            }
-            checkPrimitiveCollectionLogic.Entity = InputData;
-            checkPrimitiveCollectionLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger();
-            if (checkPrimitiveCollectionLogic.Check() == false)
+            CheckPrimitiveCollectionLogic.Entity = Entity;
+            CheckPrimitiveCollectionLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger();
+            if (CheckPrimitiveCollectionLogic.Check() == false)
            {
                result = false;
-                CheckResult += checkPrimitiveCollectionLogic.CheckResult;
-                TraceLogger?.AddMessage(checkPrimitiveCollectionLogic.CheckResult, TraceLogStatuses.Error);
+                CheckResult += CheckPrimitiveCollectionLogic.CheckResult;
+                TraceLogger?.AddMessage(CheckPrimitiveCollectionLogic.CheckResult, TraceLogStatuses.Error);
            }
        }

        private void CheckActions()
        {
-            if (InputData.ForceActions is null || (!InputData.ForceActions.Any()))
+            if (Entity.ForceActions is null || (!Entity.ForceActions.Any()))
            {
                result = false;
                string message = "Calculator does not contain any actions\n";
@@ -71,7 +80,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            };
            var checkLogic = new CheckForceActionsLogic(TraceLogger)
            {
-                Entity = InputData.ForceActions
+                Entity = Entity.ForceActions
            };
            if (checkLogic.Check() == false)
            {
@@ -84,7 +93,5 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            CheckResult += errorString + "\n";
            TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
        }
-
-
    }
 }
--- a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/PrimitivesForCrackMaterialCheckLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/PrimitivesForCrackMaterialCheckLogic.cs
@@ -0,0 +1,40 @@
+using LoaderCalculator.Data.Materials;
+using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking.CheckLogics
+{
+    /// <summary>
+    /// Checks whether a collection of NDM primitives contains
+    /// at least one material that supports crack appearance.
+    /// </summary>
+    public class PrimitivesForCrackMaterialCheckLogic
+        : CheckEntityLogic<IEnumerable<INdmPrimitive>>
+    {
+        public override bool Check()
+        {
+            if (Entity is null)
+            {
+                TraceMessage("Collection of primitives is null");
+                return false;
+            }
+
+            CheckResult = string.Empty;
+
+            bool hasCrackMaterial = Entity.Any(primitive =>
+                primitive?.NdmElement?.HeadMaterial?
+                    .GetLoaderMaterial(LimitStates.SLS, CalcTerms.ShortTerm)
+                is ICrackMaterial);
+
+            if (!hasCrackMaterial)
+            {
+                TraceMessage(
+                    "Collection of primitives does not have material which supports cracking");
+            }
+
+            return hasCrackMaterial;
+        }
+    }
+}
+
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs
@@ -1,18 +1,11 @@
 using StructureHelperCommon.Infrastructures.Enums;
 using StructureHelperCommon.Infrastructures.Interfaces;
-using StructureHelperCommon.Infrastructures.Settings;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Calculators;
-using StructureHelperCommon.Models.Forces;
 using StructureHelperCommon.Models.Loggers;
 using StructureHelperLogics.Models.Materials;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
 using StructureHelperLogics.NdmCalculations.Primitives;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;

 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
@@ -24,20 +17,24 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
        const CalcTerms shortTerm = CalcTerms.ShortTerm;
        private const double maxSizeOfCrossSection = 1d;
        private CrackResult result;
+
        private IGetTupleInputDatasLogic datasLogic;
+
+        private ICheckEntityLogic<ICrackCalculatorInputData> checkInputDataLogic;
        private IUpdateStrategy<ICrackCalculator> updateStrategy;
-        private ICheckInputDataLogic<ICrackCalculatorInputData> checkInputDataLogic;
+        private ICheckEntityLogic<ICrackCalculatorInputData> CheckInputDataLogic => checkInputDataLogic ??= new CheckCrackCalculatorInputDataLogic();
+        private IUpdateStrategy<ICrackCalculator> UpdateStrategy => updateStrategy ??= new CrackCalculatorUpdateStrategy();

        public Guid Id { get; } = Guid.NewGuid();

-        public string Name { get; set; }
+        public string Name { get; set; } = string.Empty;
        public ICrackCalculatorInputData InputData { get; set; }
        public IResult Result => result;

        public IShiftTraceLogger? TraceLogger { get; set; }
        public bool ShowTraceData { get; set; }

-        public CrackCalculator(ICheckInputDataLogic<ICrackCalculatorInputData> checkInputDataLogic,
+        public CrackCalculator(ICheckEntityLogic<ICrackCalculatorInputData> checkInputDataLogic,
            IUpdateStrategy<ICrackCalculator> updateStrategy,
            IShiftTraceLogger traceLogger
            )
@@ -45,18 +42,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            this.checkInputDataLogic = checkInputDataLogic;
            this.updateStrategy = updateStrategy;
            this.TraceLogger = traceLogger;
-            Name = string.Empty;
        }

-        public CrackCalculator()
-            : this(new CheckCrackCalculatorInputDataLogic(),
-                  new CrackCalculatorUpdateStrategy(),
-                  new ShiftTraceLogger())
-        { }
-
-        public CrackCalculator(Guid id) : this()
+        public CrackCalculator(Guid id, IShiftTraceLogger traceLogger)
        {
            Id = id;
+            TraceLogger = traceLogger;
        }

        public object Clone()
@@ -64,18 +55,21 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            CrackCalculatorInputData crackInputData = new CrackCalculatorInputData();
            var checkDataLogic = new CheckCrackCalculatorInputDataLogic()
            {
-                InputData = InputData
+                Entity = InputData
            };
            var newItem = new CrackCalculator(checkDataLogic, new CrackCalculatorUpdateStrategy(), new ShiftTraceLogger());
            newItem.InputData = crackInputData;
-            updateStrategy.Update(newItem, this);
+            UpdateStrategy.Update(newItem, this);
            return newItem;
        }

        public void Run()
        {
            PrepareNewResult();
-            CheckInputData();
+            if (CheckInputData() == false)
+            {
+                return;
+            }
            TraceInputData();
            try
            {
@@ -115,15 +109,17 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
            traceLogic.AddEntriesToTraceLogger(TraceLogger);
        }

-        private void CheckInputData()
+        private bool CheckInputData()
        {
-            checkInputDataLogic.InputData = InputData;
-            checkInputDataLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
-            if (checkInputDataLogic.Check() == false)
+            CheckInputDataLogic.Entity = InputData;
+            CheckInputDataLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
+            if (CheckInputDataLogic.Check() == false)
            {
                result.IsValid = false;
-                result.Description += checkInputDataLogic.CheckResult;
+                result.Description += CheckInputDataLogic.CheckResult;
+                return false;
            }
+            return true;
        }

        private void ProcessCalculations()