Добавил тест для прямоугольника

2022-06-21 22:07:42 +05:00
parent 068b865a89
commit 6d0f2136e3
24 changed files with 389 additions and 11 deletions
--- a/StructureHelperLogics/NdmCalculations/Triangulations/Triangulation.cs
+++ b/StructureHelperLogics/NdmCalculations/Triangulations/Triangulation.cs
@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using LoaderCalculator.Data.Materials;
+using LoaderCalculator.Data.Materials.MaterialBuilders;
+using LoaderCalculator.Data.Ndms;
+using StructureHelperLogics.Data.Shapes;
+using StructureHelperLogics.NdmCalculations.Entities;
+using StructureHelperLogics.NdmCalculations.Materials;
+
+namespace StructureHelperLogics.NdmCalculations.Triangulations
+{
+    public static class Triangulation
+    {
+        public static IEnumerable<INdm> GetNdms(IEnumerable<INdmPrimitive> ndmPrimitives, ITriangulationOptions options)
+        {
+            List<INdm> ndms = new List<INdm>();
+            Dictionary<string, IPrimitiveMaterial> primitiveMaterials = GetPrimitiveMaterials(ndmPrimitives);
+            Dictionary<string, IMaterial> materials = GetMaterials(primitiveMaterials, options);
+            foreach (var ndmPrimitive in ndmPrimitives)
+            {
+                IPrimitiveMaterial primitiveMaterial = ndmPrimitive.PrimitiveMaterial;
+                IMaterial material;
+                if (materials.TryGetValue(primitiveMaterial.Id, out material) == false) { throw new Exception("Material dictionary is not valid"); }
+                IEnumerable<INdm> localNdms = GetNdmsByPrimitive(ndmPrimitive, material);
+                ndms.AddRange(localNdms);
+            }
+            return ndms;
+        }
+
+        private static Dictionary<string, IPrimitiveMaterial> GetPrimitiveMaterials(IEnumerable<INdmPrimitive> ndmPrimitives)
+        {
+            Dictionary<string, IPrimitiveMaterial> primitiveMaterials = new Dictionary<string, IPrimitiveMaterial>();
+            foreach (var ndmPrimitive in ndmPrimitives)
+            {
+                IPrimitiveMaterial material = ndmPrimitive.PrimitiveMaterial;
+                if (!primitiveMaterials.ContainsKey(material.Id)) { primitiveMaterials.Add(material.Id, material); }
+            }
+            return primitiveMaterials;
+        }
+
+        private static Dictionary<string, IMaterial> GetMaterials(Dictionary<string, IPrimitiveMaterial> PrimitiveMaterials, ITriangulationOptions options)
+        {
+            Dictionary<string, IMaterial> materials = new Dictionary<string, IMaterial>();
+            IEnumerable<string> keyCollection = PrimitiveMaterials.Keys;
+            IMaterial material;
+            foreach (string id in keyCollection)
+            {
+                IPrimitiveMaterial primitiveMaterial;
+                if (PrimitiveMaterials.TryGetValue(id, out primitiveMaterial) == false) { throw new Exception("Material dictionary is not valid"); }
+                material = GetMaterial(primitiveMaterial, options);
+                materials.Add(id, material);
+            }
+            return materials;
+        }
+
+        private static IEnumerable<INdm> GetNdmsByPrimitive(INdmPrimitive primitive, IMaterial material)
+        {
+            List<INdm> ndms = new List<INdm>();
+            ITriangulationLogicOptions options;
+            ICenter center = primitive.Center;
+            IShape shape = primitive.Shape;
+            if (shape is IRectangle)
+            {
+                IRectangle rectangle = shape as IRectangle;
+                options = new RectangleTriangulationOptions(primitive);
+                IRectangleTriangulationLogic logic = new RectangleTriangulationLogic(options);
+                ndms.AddRange(logic.GetNdmCollection(material));
+            }
+            else { throw new Exception("Primitive type is not valid"); }
+            return ndms;
+        }
+
+        private static IMaterial GetMaterial(IPrimitiveMaterial primitiveMaterial, ITriangulationOptions options)
+        {
+            IMaterial material;
+            if (primitiveMaterial.MaterialType == MaterialTypes.Concrete) { material = GetConcreteMaterial(primitiveMaterial, options); }
+            else if (primitiveMaterial.MaterialType == MaterialTypes.Reinforcement) { material = GetReinforcementMaterial(primitiveMaterial, options); }
+            else { throw new Exception("Material type is invalid"); }
+            return material;
+        }
+
+        private static IMaterial GetConcreteMaterial(IPrimitiveMaterial primitiveMaterial, ITriangulationOptions options)
+        {
+            IMaterialOptions materialOptions = new ConcreteOptions();
+            SetMaterialOptions(materialOptions, primitiveMaterial, options);
+            IMaterialBuilder builder = new ConcreteBuilder(materialOptions);
+            IBuilderDirector director = new BuilderDirector(builder);
+            return director.BuildMaterial();
+        }
+
+        private static IMaterial GetReinforcementMaterial(IPrimitiveMaterial primitiveMaterial, ITriangulationOptions options)
+        {
+            IMaterialOptions materialOptions = new ReinforcementOptions();
+            SetMaterialOptions(materialOptions, primitiveMaterial, options);
+            IMaterialBuilder builder = new ReinforcementBuilder(materialOptions);
+            IBuilderDirector director = new BuilderDirector(builder);
+            return director.BuildMaterial();
+        }
+
+        private static void SetMaterialOptions(IMaterialOptions materialOptions, IPrimitiveMaterial primitiveMaterial, ITriangulationOptions options)
+        {
+            materialOptions.Strength = primitiveMaterial.Strength;
+            materialOptions.CodesType = CodesType.EC2_1990;
+            if (options.LimiteState == Infrastructures.CommonEnums.LimitStates.Collapse) { materialOptions.LimitState = LimitStates.Collapse; }
+            else if (options.LimiteState == Infrastructures.CommonEnums.LimitStates.ServiceAbility) { materialOptions.LimitState = LimitStates.ServiceAbility; }
+            else if (options.LimiteState == Infrastructures.CommonEnums.LimitStates.Special) { materialOptions.LimitState = LimitStates.Special; }
+            else { throw new Exception("LimitStateType is not valid"); }
+            if (options.CalcTerm == Infrastructures.CommonEnums.CalcTerms.ShortTerm) { materialOptions.IsShortTerm = true; }
+            else if (options.CalcTerm == Infrastructures.CommonEnums.CalcTerms.LongTerm) { materialOptions.IsShortTerm = false; }
+            else { throw new Exception("Calculation term is not valid"); }
+        }
+    }
+}