diff --git a/StructureHelper/Libraries/LoaderCalculator.dll b/StructureHelper/Libraries/LoaderCalculator.dll index a080846..2f002eb 100644 Binary files a/StructureHelper/Libraries/LoaderCalculator.dll and b/StructureHelper/Libraries/LoaderCalculator.dll differ diff --git a/StructureHelper/Windows/ViewModels/Materials/ConcreteViewModel.cs b/StructureHelper/Windows/ViewModels/Materials/ConcreteViewModel.cs index f8dea99..f9d3f79 100644 --- a/StructureHelper/Windows/ViewModels/Materials/ConcreteViewModel.cs +++ b/StructureHelper/Windows/ViewModels/Materials/ConcreteViewModel.cs @@ -36,10 +36,10 @@ namespace StructureHelper.Windows.ViewModels.Materials } public double Humidity { - get => concreteMaterial.Humidity; + get => concreteMaterial.RelativeHumidity; set { - concreteMaterial.Humidity = value; + concreteMaterial.RelativeHumidity = value; OnPropertyChanged(nameof(Humidity)); } } diff --git a/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs b/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs index 22cfff2..6719810 100644 --- a/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs +++ b/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs @@ -4,6 +4,7 @@ { public static string UnknownError => "#0000: Unknown error"; public static string ObjectTypeIsUnknown => "#0001: Object type is unknown"; + public static string ObjectTypeIsUnknownObj(object obj) => $"{ObjectTypeIsUnknown}: {obj.GetType()}"; public static string MaterialTypeIsUnknown => "#0002: Material type is unknown"; public static string DataIsInCorrect => "#0003: Data is not correct"; public static string ShapeIsNotCorrect => "#0004: Shape is not valid"; diff --git a/StructureHelperLogics/Models/Materials/ConcreteCurveLogic.cs b/StructureHelperLogics/Models/Materials/ConcreteCurveLogic.cs new file mode 100644 index 0000000..db320ab --- /dev/null +++ b/StructureHelperLogics/Models/Materials/ConcreteCurveLogic.cs @@ -0,0 +1,55 @@ +using LoaderCalculator.Data.Materials; +using LoaderCalculator.Data.Materials.MaterialBuilders; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Models.Materials.Libraries; +using System.Windows.Media.Media3D; +using static System.Windows.Forms.Design.AxImporter; +using LMBuilders = LoaderCalculator.Data.Materials.MaterialBuilders; + +namespace StructureHelperLogics.Models.Materials +{ + public class ConcreteCurveLogic : IMaterialLogic + { + private ConcreteOptions concreteOptions; + private IMaterialOptionLogic optionLogic; + private ConcreteLogicOptions options; + + + public string Name { get; set; } + public IMaterialLogicOptions Options + { + get => options; + set + { + if (value is not ConcreteLogicOptions) + { + throw new StructureHelperException($"{ErrorStrings.ExpectedWas(typeof(ConcreteLogicOptions), value)}"); + } + options = (ConcreteLogicOptions)value; + } + } + + public IMaterial GetLoaderMaterial() + { + GetLoaderOptions(); + IBuilderDirector director = GetMaterialDirector(); + var material = director.BuildMaterial(); + return material; + } + + private IBuilderDirector GetMaterialDirector() + { + IMaterialBuilder builder = new ConcreteBuilder(concreteOptions); + IBuilderDirector director = new BuilderDirector(builder); + return director; + } + + private void GetLoaderOptions() + { + concreteOptions = new ConcreteOptions(); + optionLogic = new ConcreteMaterialOptionLogic(options); + optionLogic.SetMaterialOptions(concreteOptions); + } + } +} diff --git a/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs b/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs index 4133e1e..97f5f05 100644 --- a/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs +++ b/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs @@ -5,6 +5,7 @@ using LMBuilders = LoaderCalculator.Data.Materials.MaterialBuilders; using LMLogic = LoaderCalculator.Data.Materials.MaterialBuilders.MaterialLogics; using LM = LoaderCalculator.Data.Materials; using LoaderCalculator.Data.Materials; +using StructureHelperCommon.Infrastructures.Exceptions; namespace StructureHelperLogics.Models.Materials { @@ -14,21 +15,32 @@ namespace StructureHelperLogics.Models.Materials private IMaterialOptionLogic optionLogic; private IFactorLogic factorLogic => new FactorLogic(SafetyFactors); private LMLogic.ITrueStrengthLogic strengthLogic; + /// public ILibMaterialEntity MaterialEntity { get; set; } + /// public List SafetyFactors { get; } + /// public bool TensionForULS { get ; set; } + /// public bool TensionForSLS { get; set; } - public double Humidity { get; set; } - + /// + /// Humidity of concrete + /// + public double RelativeHumidity { get; set; } + /// + public IMaterialLogic MaterialLogic { get; set; } + /// + public List MaterialLogics { get; } public ConcreteLibMaterial() { + MaterialLogic = new ConcreteCurveLogic(); SafetyFactors = new List(); lmOptions = new LMBuilders.ConcreteOptions(); SafetyFactors.AddRange(PartialCoefficientFactory.GetDefaultConcreteSafetyFactors(ProgramSetting.CodeType)); TensionForULS = false; TensionForSLS = true; - Humidity = 0.55d; + RelativeHumidity = 0.55d; } public object Clone() @@ -39,30 +51,7 @@ namespace StructureHelperLogics.Models.Materials return newItem; } - public LM.IMaterial GetLoaderMaterial(LimitStates limitState, CalcTerms calcTerm) - { - GetOptions(limitState, calcTerm, false); - LMBuilders.IBuilderDirector director = GetMaterial(limitState, calcTerm); - return director.BuildMaterial(); - } - private LMBuilders.IBuilderDirector GetMaterial(LimitStates limitState, CalcTerms calcTerm) - { - var strength = factorLogic.GetTotalFactor(limitState, calcTerm); - lmOptions.ExternalFactor.Compressive = strength.Compressive; - lmOptions.ExternalFactor.Tensile = strength.Tensile; - LMBuilders.IMaterialBuilder builder = new LMBuilders.ConcreteBuilder(lmOptions); - LMBuilders.IBuilderDirector director = new LMBuilders.BuilderDirector(builder); - return director; - } - - private void GetOptions(LimitStates limitState, CalcTerms calcTerm, bool isSectionCracked) - { - optionLogic = new MaterialCommonOptionLogic(MaterialEntity, limitState, calcTerm); - optionLogic.SetMaterialOptions(lmOptions); - optionLogic = new ConcreteMaterialOptionLogic(this, limitState, isSectionCracked); - optionLogic.SetMaterialOptions(lmOptions); - } public (double Compressive, double Tensile) GetStrength(LimitStates limitState, CalcTerms calcTerm) { @@ -83,9 +72,56 @@ namespace StructureHelperLogics.Models.Materials public IMaterial GetCrackedLoaderMaterial(LimitStates limitState, CalcTerms calcTerm) { - GetOptions(limitState, calcTerm, true); - LMBuilders.IBuilderDirector director = GetMaterial(limitState, calcTerm); - return director.BuildMaterial(); + ConcreteLogicOptions options = SetOptions(limitState, calcTerm); + options.WorkInTension = false; + MaterialLogic.Options = options; + var material = MaterialLogic.GetLoaderMaterial(); + return material; + } + + public IMaterial GetLoaderMaterial(LimitStates limitState, CalcTerms calcTerm) + { + ConcreteLogicOptions options = SetOptions(limitState, calcTerm); + MaterialLogic.Options = options; + var material = MaterialLogic.GetLoaderMaterial(); + return material; + } + + private ConcreteLogicOptions SetOptions(LimitStates limitState, CalcTerms calcTerm) + { + var options = new ConcreteLogicOptions(); + options.SafetyFactors = SafetyFactors; + options.MaterialEntity = MaterialEntity; + options.LimitState = limitState; + options.CalcTerm = calcTerm; + if (limitState == LimitStates.ULS) + { + if (TensionForULS == true) + { + options.WorkInTension = true; + } + else + { + options.WorkInTension = false; + } + } + else if (limitState == LimitStates.SLS) + { + if (TensionForSLS == true) + { + options.WorkInTension = true; + } + else + { + options.WorkInTension = false; + } + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(limitState)); + } + options.RelativeHumidity = RelativeHumidity; + return options; } } } diff --git a/StructureHelperLogics/Models/Materials/ConcreteLogicOptions.cs b/StructureHelperLogics/Models/Materials/ConcreteLogicOptions.cs new file mode 100644 index 0000000..91110c2 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/ConcreteLogicOptions.cs @@ -0,0 +1,21 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Materials.Libraries; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.Materials +{ + public class ConcreteLogicOptions : IMaterialLogicOptions + { + public List SafetyFactors { get; set; } + public LimitStates LimitState { get; set; } + public CalcTerms CalcTerm { get; set; } + public ILibMaterialEntity MaterialEntity { get; set; } + public bool WorkInCompression { get; set; } + public bool WorkInTension { get; set; } + public double RelativeHumidity { get; set; } + } +} diff --git a/StructureHelperLogics/Models/Materials/IConcreteLibMaterial.cs b/StructureHelperLogics/Models/Materials/IConcreteLibMaterial.cs index 94b7c77..21a35c8 100644 --- a/StructureHelperLogics/Models/Materials/IConcreteLibMaterial.cs +++ b/StructureHelperLogics/Models/Materials/IConcreteLibMaterial.cs @@ -11,6 +11,6 @@ namespace StructureHelperLogics.Models.Materials { bool TensionForULS { get; set; } bool TensionForSLS { get; set; } - double Humidity { get; set; } + double RelativeHumidity { get; set; } } } diff --git a/StructureHelperLogics/Models/Materials/ILibMaterial.cs b/StructureHelperLogics/Models/Materials/ILibMaterial.cs index c9832ef..3e6dc40 100644 --- a/StructureHelperLogics/Models/Materials/ILibMaterial.cs +++ b/StructureHelperLogics/Models/Materials/ILibMaterial.cs @@ -11,6 +11,8 @@ namespace StructureHelperLogics.Models.Materials { ILibMaterialEntity MaterialEntity { get; set; } List SafetyFactors { get; } + IMaterialLogic MaterialLogic { get; set; } + List MaterialLogics { get; } (double Compressive, double Tensile) GetStrength(LimitStates limitState, CalcTerms calcTerm); } } diff --git a/StructureHelperLogics/Models/Materials/IMaterialLogic.cs b/StructureHelperLogics/Models/Materials/IMaterialLogic.cs new file mode 100644 index 0000000..7a2e626 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/IMaterialLogic.cs @@ -0,0 +1,17 @@ +using LoaderCalculator.Data.Materials; +using StructureHelperCommon.Infrastructures.Enums; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.Materials +{ + public interface IMaterialLogic + { + string Name { get; set; } + IMaterialLogicOptions Options { get; set; } + IMaterial GetLoaderMaterial(); + } +} diff --git a/StructureHelperLogics/Models/Materials/IMaterialLogicOptions.cs b/StructureHelperLogics/Models/Materials/IMaterialLogicOptions.cs new file mode 100644 index 0000000..a9be9c6 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/IMaterialLogicOptions.cs @@ -0,0 +1,20 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Materials.Libraries; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.Materials +{ + public interface IMaterialLogicOptions + { + public List SafetyFactors { get; set; } + public ILibMaterialEntity MaterialEntity { get; set; } + LimitStates LimitState { get; set; } + CalcTerms CalcTerm { get; set; } + bool WorkInCompression { get; set; } + bool WorkInTension { get; set; } + } +} diff --git a/StructureHelperLogics/Models/Materials/LibMaterial.cs b/StructureHelperLogics/Models/Materials/LibMaterial.cs index b41c421..a2aef5b 100644 --- a/StructureHelperLogics/Models/Materials/LibMaterial.cs +++ b/StructureHelperLogics/Models/Materials/LibMaterial.cs @@ -23,6 +23,9 @@ namespace StructureHelperLogics.Models.Materials public ILibMaterialEntity MaterialEntity { get; set; } public List SafetyFactors { get; } + public IMaterialLogic MaterialLogic { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } + + public List MaterialLogics => throw new NotImplementedException(); public LibMaterial(MaterialTypes materialType, CodeTypes codeType, string name, double mainStrength) { diff --git a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs index 2dd2e8d..88f0819 100644 --- a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs @@ -16,7 +16,8 @@ namespace StructureHelperLogics.Models.Materials libUpdateStrategy.Update(targetObject, sourceObject); targetObject.TensionForULS = sourceObject.TensionForULS; targetObject.TensionForSLS = sourceObject.TensionForSLS; - targetObject.Humidity = sourceObject.Humidity; + targetObject.RelativeHumidity = sourceObject.RelativeHumidity; + targetObject.MaterialLogic = sourceObject.MaterialLogic; } } } diff --git a/StructureHelperLogics/Models/Materials/Logics/ConcreteMaterialOptionLogic.cs b/StructureHelperLogics/Models/Materials/Logics/ConcreteMaterialOptionLogic.cs index fcd0035..172255b 100644 --- a/StructureHelperLogics/Models/Materials/Logics/ConcreteMaterialOptionLogic.cs +++ b/StructureHelperLogics/Models/Materials/Logics/ConcreteMaterialOptionLogic.cs @@ -7,50 +7,37 @@ using System.Linq; using System.Text; using System.Threading.Tasks; using static System.Windows.Forms.Design.AxImporter; +using LoaderCalculator.Data.Materials.MaterialBuilders; +using StructureHelperCommon.Models.Materials.Libraries; namespace StructureHelperLogics.Models.Materials { internal class ConcreteMaterialOptionLogic : IMaterialOptionLogic { - private IConcreteLibMaterial material; - private LimitStates limitState; - bool IsMaterialCracked; - public ConcreteMaterialOptionLogic(IConcreteLibMaterial material, LimitStates limitState, bool IsMaterialCracked) + private ConcreteLogicOptions options; + private MaterialCommonOptionLogic optionLogic; + private FactorLogic factorLogic; + + public ConcreteMaterialOptionLogic(ConcreteLogicOptions options) { - this.material = material; - this.limitState = limitState; - this.IsMaterialCracked = IsMaterialCracked; - } - public void SetMaterialOptions(LCMB.IMaterialOptions materialOptions) - { - Check(materialOptions); - var concreteOptions = materialOptions as LCMB.ConcreteOptions; - concreteOptions.WorkInTension = false; - if (IsMaterialCracked) - { - concreteOptions.WorkInTension = true; - return; - } - if (limitState == LimitStates.ULS & material.TensionForULS == true) - { - concreteOptions.WorkInTension = true; - } - if (limitState == LimitStates.SLS & material.TensionForSLS == true) - { - concreteOptions.WorkInTension = true; - } + this.options = options; } - private static void Check(LCMB.IMaterialOptions materialOptions) + public void SetMaterialOptions(IMaterialOptions materialOptions) { - if (materialOptions is null) + if (materialOptions is not ConcreteOptions) { - throw new StructureHelperException(ErrorStrings.ParameterIsNull + $": expected {typeof(LCMB.ConcreteOptions)}, but was null"); - } - if (materialOptions is not LCMB.ConcreteOptions) - { - throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknown + $": expected {typeof(LCMB.ConcreteOptions)}, but was {materialOptions.GetType()}"); + throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(ConcreteOptions), materialOptions.GetType())); } + var concreteOptions = materialOptions as ConcreteOptions; + optionLogic = new MaterialCommonOptionLogic(options); + optionLogic.SetMaterialOptions(concreteOptions); + factorLogic = new FactorLogic(options.SafetyFactors); + var strength = factorLogic.GetTotalFactor(options.LimitState, options.CalcTerm); + concreteOptions.ExternalFactor.Compressive = strength.Compressive; + concreteOptions.ExternalFactor.Tensile = strength.Tensile; + concreteOptions.WorkInTension = options.WorkInTension; + concreteOptions.RelativeHumidity = options.RelativeHumidity; } } } diff --git a/StructureHelperLogics/Models/Materials/MaterialCommonOptionLogic.cs b/StructureHelperLogics/Models/Materials/MaterialCommonOptionLogic.cs index 51f768d..0774ff7 100644 --- a/StructureHelperLogics/Models/Materials/MaterialCommonOptionLogic.cs +++ b/StructureHelperLogics/Models/Materials/MaterialCommonOptionLogic.cs @@ -1,46 +1,45 @@ using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; -using StructureHelperCommon.Models.Materials.Libraries; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; using LCMB = LoaderCalculator.Data.Materials.MaterialBuilders; namespace StructureHelperLogics.Models.Materials { public class MaterialCommonOptionLogic : IMaterialOptionLogic { - private ILibMaterialEntity materialEntity; - private LimitStates limitState; - private CalcTerms calcTerm; + private IMaterialLogicOptions options; - public MaterialCommonOptionLogic(ILibMaterialEntity materialEntity, LimitStates limitState, CalcTerms calcTerm) + public MaterialCommonOptionLogic(IMaterialLogicOptions options) { - this.materialEntity = materialEntity; - this.limitState = limitState; - this.calcTerm = calcTerm; + this.options = options; } public void SetMaterialOptions(LCMB.IMaterialOptions materialOptions) { - materialOptions.Strength = materialEntity.MainStrength; - if (materialEntity.CodeType == CodeTypes.EuroCode_2_1990) + materialOptions.Strength = options.MaterialEntity.MainStrength; + if (options.MaterialEntity.CodeType == CodeTypes.EuroCode_2_1990) { materialOptions.CodesType = LCMB.CodesType.EC2_1990; } - else if (materialEntity.CodeType == CodeTypes.SP63_2018) + else if (options.MaterialEntity.CodeType == CodeTypes.SP63_2018) { materialOptions.CodesType = LCMB.CodesType.SP63_2018; } else { throw new StructureHelperException($"{ErrorStrings.ObjectTypeIsUnknown} : {materialOptions.CodesType}"); } - if (limitState == LimitStates.ULS) { materialOptions.LimitState = LCMB.LimitStates.Collapse; } - else if (limitState == LimitStates.SLS) { materialOptions.LimitState = LCMB.LimitStates.ServiceAbility; } - else if (limitState == LimitStates.Special) { materialOptions.LimitState = LCMB.LimitStates.Special; } + if (options.LimitState == LimitStates.ULS) + { + materialOptions.LimitState = LCMB.LimitStates.Collapse; + } + else if (options.LimitState == LimitStates.SLS) + { + materialOptions.LimitState = LCMB.LimitStates.ServiceAbility; + } + else if (options.LimitState == LimitStates.Special) + { + materialOptions.LimitState = LCMB.LimitStates.Special; + } else { throw new StructureHelperException(ErrorStrings.LimitStatesIsNotValid); } - if (calcTerm == CalcTerms.ShortTerm) { materialOptions.IsShortTerm = true; } - else if (calcTerm == CalcTerms.LongTerm) { materialOptions.IsShortTerm = false; } + if (options.CalcTerm == CalcTerms.ShortTerm) { materialOptions.IsShortTerm = true; } + else if (options.CalcTerm == CalcTerms.LongTerm) { materialOptions.IsShortTerm = false; } else { throw new StructureHelperException(ErrorStrings.LoadTermIsNotValid); } } } diff --git a/StructureHelperLogics/Models/Materials/ReinforcementBiLinearLogic.cs b/StructureHelperLogics/Models/Materials/ReinforcementBiLinearLogic.cs new file mode 100644 index 0000000..cff02b9 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/ReinforcementBiLinearLogic.cs @@ -0,0 +1,58 @@ +using LoaderCalculator.Data.Materials; +using LoaderCalculator.Data.Materials.MaterialBuilders; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperLogics.Models.Templates.CrossSections.RCs; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using static System.Windows.Forms.Design.AxImporter; + +namespace StructureHelperLogics.Models.Materials +{ + public class ReinforcementBiLinearLogic : IMaterialLogic + { + private ReinforcementOptions materialOptions; + private IMaterialOptionLogic optionLogic; + private ReinforcementLogicOptions options; + private IMaterialLogicOptions options1; + + public string Name { get; set; } + public IMaterialLogicOptions Options + { + get => options; + set + { + if (value is not ReinforcementLogicOptions) + { + throw new StructureHelperException($"{ErrorStrings.ExpectedWas(typeof(ReinforcementLogicOptions), value)}"); + } + options = (ReinforcementLogicOptions)value; + } + } + + public IMaterial GetLoaderMaterial() + { + GetLoaderOptions(); + IBuilderDirector director = GetMaterialDirector(); + var material = director.BuildMaterial(); + return material; + } + + private IBuilderDirector GetMaterialDirector() + { + IMaterialBuilder builder = new ReinforcementBuilder(materialOptions); + IBuilderDirector director = new BuilderDirector(builder); + return director; + } + + private void GetLoaderOptions() + { + materialOptions = new ReinforcementOptions(); + optionLogic = new MaterialCommonOptionLogic(options); + optionLogic.SetMaterialOptions(materialOptions); + } + } +} diff --git a/StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs b/StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs index 9b75058..d1aceb0 100644 --- a/StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs +++ b/StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs @@ -20,10 +20,13 @@ namespace StructureHelperLogics.Models.Materials private LoaderMaterialLogics.ITrueStrengthLogic strengthLogic; public ILibMaterialEntity MaterialEntity { get; set; } public List SafetyFactors { get; } + public IMaterialLogic MaterialLogic { get; set; } + public List MaterialLogics { get; } public ReinforcementLibMaterial() { + MaterialLogic = new ReinforcementBiLinearLogic(); SafetyFactors = new List(); lmOptions = new LMBuilders.ReinforcementOptions(); } @@ -36,17 +39,24 @@ namespace StructureHelperLogics.Models.Materials return newItem; } - public Loadermaterials.IMaterial GetLoaderMaterial(LimitStates limitState, CalcTerms calcTerm) + public IMaterial GetLoaderMaterial(LimitStates limitState, CalcTerms calcTerm) { - optionLogic = new MaterialCommonOptionLogic(MaterialEntity, limitState, calcTerm); - optionLogic.SetMaterialOptions(lmOptions); - var factors = factorLogic.GetTotalFactor(limitState, calcTerm); - lmOptions.ExternalFactor.Compressive = factors.Compressive; - lmOptions.ExternalFactor.Tensile = factors.Tensile; - LMBuilders.IMaterialBuilder builder = new LMBuilders.ReinforcementBuilder(lmOptions); - LMBuilders.IBuilderDirector director = new LMBuilders.BuilderDirector(builder); - return director.BuildMaterial(); + ReinforcementLogicOptions options = SetOptions(limitState, calcTerm); + MaterialLogic.Options = options; + var material = MaterialLogic.GetLoaderMaterial(); + return material; } + + private ReinforcementLogicOptions SetOptions(LimitStates limitState, CalcTerms calcTerm) + { + var options = new ReinforcementLogicOptions(); + options.SafetyFactors = SafetyFactors; + options.MaterialEntity = MaterialEntity; + options.LimitState = limitState; + options.CalcTerm = calcTerm; + return options; + } + public (double Compressive, double Tensile) GetStrength(LimitStates limitState, CalcTerms calcTerm) { strengthLogic = new LoaderMaterialLogics.TrueStrengthReinforcementLogic(MaterialEntity.MainStrength); diff --git a/StructureHelperLogics/Models/Materials/ReinforcementLogicOptions.cs b/StructureHelperLogics/Models/Materials/ReinforcementLogicOptions.cs new file mode 100644 index 0000000..4b80b56 --- /dev/null +++ b/StructureHelperLogics/Models/Materials/ReinforcementLogicOptions.cs @@ -0,0 +1,20 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Materials.Libraries; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.Materials +{ + internal class ReinforcementLogicOptions : IMaterialLogicOptions + { + public List SafetyFactors { get; set; } + public ILibMaterialEntity MaterialEntity { get; set; } + public LimitStates LimitState { get; set; } + public CalcTerms CalcTerm { get; set; } + public bool WorkInCompression { get; set; } + public bool WorkInTension { get; set; } + } +}