Add steel Material

StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs

@@ -7,11 +7,12 @@ namespace StructureHelperLogics.Models.Materials
     public class ConcreteLibUpdateStrategy : IUpdateStrategy<IConcreteLibMaterial>
     {
         private IUpdateStrategy<ILibMaterial> libUpdateStrategy;
+        private IUpdateStrategy<ILibMaterial> LibUpdateStrategy => libUpdateStrategy ??= new LibMaterialUpdateStrategy();
         public ConcreteLibUpdateStrategy(IUpdateStrategy<ILibMaterial> libUpdateStrategy)
         {
             this.libUpdateStrategy = libUpdateStrategy;
         }
-        public ConcreteLibUpdateStrategy() : this(new LibMaterialUpdateStrategy())
+        public ConcreteLibUpdateStrategy()
         {
             
         }
@@ -20,7 +21,7 @@ namespace StructureHelperLogics.Models.Materials
             CheckObject.ThrowIfNull(sourceObject);
             CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            libUpdateStrategy.Update(targetObject, sourceObject);
+            LibUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.TensionForULS = sourceObject.TensionForULS;
             targetObject.TensionForSLS = sourceObject.TensionForSLS;
             targetObject.RelativeHumidity = sourceObject.RelativeHumidity;

StructureHelperLogics/Models/Materials/Logics/GetSteelLoaderMaterialLogic.cs

@@ -0,0 +1,63 @@
+using LoaderCalculator.Data.Materials;
+using LoaderCalculator.Data.Materials.DiagramTemplates;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Materials.Libraries;
+using System;
+using System.Collections.Generic;
+using System.Security.Policy;
+using System.Text;
+using System.Windows.Media.TextFormatting;
+
+namespace StructureHelperLogics.Models.Materials.Logics
+{
+    public class GetSteelLoaderMaterialLogic
+    {
+        IObjectConvertStrategy<ISteelDiagramAbsoluteProperty, ISteelDiagramRelativeProperty> convertStrategy;
+
+        public double InitialModulus { get; set; }
+        public double CompressionStrength { get; set; }
+        public double TensionStrength { get; internal set; }
+        public double MaxPlasticStrainRatio { get; set; }
+        public ISteelDiagramRelativeProperty DiagramProperty { get; set; }
+
+        public IMaterial GetMaterial()
+        {
+            double elasticCompressionStrain = CompressionStrength / InitialModulus;
+            double fullCompressionStrain = elasticCompressionStrain * (1 + MaxPlasticStrainRatio);
+
+            Material material = new()
+            {
+                Diagram = GetDiagram(),
+                LimitPositiveStrain = fullCompressionStrain,
+                LimitNegativeStrain = - fullCompressionStrain,
+            };
+            return material;
+        }
+
+        private Func<double, double> GetDiagram()
+        {
+            MultiLinearStressStrainDiagram compressionDiagram = GetMultiLinearDiagram(CompressionStrength);
+            MultiLinearStressStrainDiagram tensionDiagram = GetMultiLinearDiagram(TensionStrength);
+            var posNegDiagram = new PosNegDigramDecorator(tensionDiagram, compressionDiagram);
+            return posNegDiagram.GetStressByStrain;
+        }
+
+        private MultiLinearStressStrainDiagram GetMultiLinearDiagram(double strength)
+        {
+            convertStrategy ??= new SteelRelativeToAbsoluteDiagramConvertLogic(InitialModulus, strength);
+            var absoluteProperty = convertStrategy.Convert(DiagramProperty);
+            List<IStressStrainPair> stressStrainPairs = new()
+            {
+                new StressStrainPair() { Stress = 0, Strain = 0},
+                new StressStrainPair() { Stress = absoluteProperty.StressOfProportionality, Strain = absoluteProperty.StrainOfProportionality},
+                new StressStrainPair() { Stress = absoluteProperty.BaseStrength, Strain = absoluteProperty.StrainOfStartOfYielding},
+                new StressStrainPair() { Stress = absoluteProperty.BaseStrength, Strain = absoluteProperty.StrainOfEndOfYielding},
+                new StressStrainPair() { Stress = absoluteProperty.StressOfUltimateStrength, Strain = absoluteProperty.StrainOfUltimateStrength},
+                new StressStrainPair() { Stress = absoluteProperty.StressOfFracture, Strain = absoluteProperty.StrainOfFracture},
+
+            };
+            var multiDiagram = new MultiLinearStressStrainDiagram(stressStrainPairs);
+            return multiDiagram;
+        }
+    }
+}

StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs

@@ -14,10 +14,16 @@ namespace StructureHelperLogics.Models.Materials
 {
     public class HelperMaterialUpdateStrategy : IUpdateStrategy<IHelperMaterial>
     {
-        private IUpdateStrategy<IElasticMaterial> elasticStrategy;
-        private IUpdateStrategy<IFRMaterial> frStrategy;
-        private IUpdateStrategy<IConcreteLibMaterial> concreteStrategy;
-        private IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy;
+        private IUpdateStrategy<IElasticMaterial> elasticUpdateStrategy;
+        private IUpdateStrategy<IFRMaterial> frUpdateStrategy;
+        private IUpdateStrategy<IConcreteLibMaterial> concreteUpdateStrategy;
+        private IUpdateStrategy<IReinforcementLibMaterial> reinforcementUpdateStrategy;
+        private IUpdateStrategy<ISteelLibMaterial> steelUpdateStrategy;
+        private IUpdateStrategy<IElasticMaterial> ElasticUpdateStrategy => elasticUpdateStrategy ??= new ElasticUpdateStrategy();
+        private IUpdateStrategy<IFRMaterial> FrUpdateStrategy => frUpdateStrategy ??= new FRUpdateStrategy();
+        private IUpdateStrategy<IConcreteLibMaterial> ConcreteUpdateStrategy => concreteUpdateStrategy ??= new ConcreteLibUpdateStrategy();
+        private IUpdateStrategy<IReinforcementLibMaterial> ReinforcementUpdateStrategy => reinforcementUpdateStrategy ??= new ReinforcementLibUpdateStrategy();
+        private IUpdateStrategy<ISteelLibMaterial> SteelUpdateStrategy => steelUpdateStrategy ??= new SteelLibMaterialUpdateStrategy();
         private IUpdateStrategy<IHelperMaterial> safetyFactorUpdateStrategy = new HelpermaterialSafetyFactorsUpdateStrategy();
         public HelperMaterialUpdateStrategy(IUpdateStrategy<IElasticMaterial> elasticStrategy,
             IUpdateStrategy<IFRMaterial> frStrategy,
@@ -25,17 +31,12 @@ namespace StructureHelperLogics.Models.Materials
             IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy
             )
         {
-            this.elasticStrategy = elasticStrategy;
-            this.frStrategy = frStrategy;
-            this.concreteStrategy = concreteStrategy;
-            this.reinforcementStrategy = reinforcementStrategy;
+            this.elasticUpdateStrategy = elasticStrategy;
+            this.frUpdateStrategy = frStrategy;
+            this.concreteUpdateStrategy = concreteStrategy;
+            this.reinforcementUpdateStrategy = reinforcementStrategy;
         }
-        public HelperMaterialUpdateStrategy() : this(
-            new ElasticUpdateStrategy(),
-            new FRUpdateStrategy(),
-            new ConcreteLibUpdateStrategy(),
-            new ReinforcementLibUpdateStrategy()
-        )
+        public HelperMaterialUpdateStrategy()
         { }
 
         public void Update(IHelperMaterial targetObject, IHelperMaterial sourceObject)
@@ -50,11 +51,11 @@ namespace StructureHelperLogics.Models.Materials
             }
             else if (sourceObject is IElasticMaterial)
             {
-                elasticStrategy.Update(targetObject as IElasticMaterial, sourceObject as IElasticMaterial);
+                ElasticUpdateStrategy.Update(targetObject as IElasticMaterial, sourceObject as IElasticMaterial);
             }
             else if (sourceObject is IFRMaterial)
             {
-                frStrategy.Update(targetObject as IFRMaterial, sourceObject as IFRMaterial);
+                FrUpdateStrategy.Update(targetObject as IFRMaterial, sourceObject as IFRMaterial);
             }
             else
             {
@@ -66,11 +67,15 @@ namespace StructureHelperLogics.Models.Materials
         {
             if (sourceObject is IConcreteLibMaterial concreteLibMaterial)
             {
-                concreteStrategy.Update(targetObject as IConcreteLibMaterial, concreteLibMaterial);
+                concreteUpdateStrategy.Update(targetObject as IConcreteLibMaterial, concreteLibMaterial);
             }
             else if (sourceObject is IReinforcementLibMaterial reinforcementLibMaterial)
             {
-                reinforcementStrategy.Update(targetObject as IReinforcementLibMaterial, reinforcementLibMaterial);
+                ReinforcementUpdateStrategy.Update(targetObject as IReinforcementLibMaterial, reinforcementLibMaterial);
+            }
+            else if (sourceObject is ISteelLibMaterial steelLibMaterial)
+            {
+                SteelUpdateStrategy.Update(targetObject as ISteelLibMaterial, steelLibMaterial);
             }
             else
             {

StructureHelperLogics/Models/Materials/Logics/SteelLibMaterialUpdateStrategy.cs

@@ -0,0 +1,34 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Materials;
+using StructureHelperCommon.Services;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.Models.Materials
+{
+    public class SteelLibMaterialUpdateStrategy : IUpdateStrategy<ISteelLibMaterial>
+    {
+        private IUpdateStrategy<ILibMaterial> libUpdateStrategy;
+        private IUpdateStrategy<ILibMaterial> LibUpdateStrategy => libUpdateStrategy ??= new LibMaterialUpdateStrategy();
+
+        public SteelLibMaterialUpdateStrategy(IUpdateStrategy<ILibMaterial> libUpdateStrategy)
+        {
+            this.libUpdateStrategy = libUpdateStrategy;
+        }
+
+        public SteelLibMaterialUpdateStrategy()
+        {
+            
+        }
+
+        public void Update(ISteelLibMaterial targetObject, ISteelLibMaterial sourceObject)
+        {
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            LibUpdateStrategy.Update(targetObject, sourceObject);
+            targetObject.MaxPlasticStrainRatio = sourceObject.MaxPlasticStrainRatio;
+        }
+    }
+}