diff --git a/StructureHelperCommon/Infrastructures/Enums/SectionStressStates.cs b/StructureHelperCommon/Infrastructures/Enums/SectionStressStates.cs new file mode 100644 index 0000000..19d2324 --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Enums/SectionStressStates.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Enums +{ + public enum SectionStressStates + { + Tension, + Compressed, + Combined + } +} diff --git a/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs b/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs index a4d0c0f..22cfff2 100644 --- a/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs +++ b/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs @@ -21,5 +21,6 @@ public static string ResultIsNotValid => "#0016: Result is not valid"; public static string ErrorOfExuting => "#0017: Error of executing"; public static string ExpectedWas(System.Type expected, System.Type was) => $"{DataIsInCorrect}: Expected {expected}, but was {was}"; + public static string ExpectedWas(System.Type expected, object obj) => ExpectedWas(expected, obj.GetType()); } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs index 720f540..fa54613 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs @@ -37,7 +37,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces var tuple = InputData.Tuple; var accuracy = InputData.Accuracy; - var mx = tuple.Mx; var my = tuple.My; var nz = tuple.Nz; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs new file mode 100644 index 0000000..4b8cd2e --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs @@ -0,0 +1,26 @@ +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public class CrackWidthCalculator : ICalculator + { + CrackWidthCalculatorResult result; + public string Name { get; set; } + public ICrackWidthCalculatorInputData InputData { get; set; } + public IResult Result => result; + + public void Run() + { + throw new NotImplementedException(); + } + public object Clone() + { + throw new NotImplementedException(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorResult.cs new file mode 100644 index 0000000..fd0204b --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorResult.cs @@ -0,0 +1,16 @@ +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public class CrackWidthCalculatorResult : IResult + { + public bool IsValid { get; set; } + public string Description { get; set; } + IEnumerable RebarResults { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicInputDataSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicInputDataSP63.cs new file mode 100644 index 0000000..7536a3a --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicInputDataSP63.cs @@ -0,0 +1,19 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public class CrackWidthLogicInputDataSP63 : ICrackWidthLogicInputData + { + public double RebarStrain { get; set; } + public double ConcreteStrain { get; set; } + public double Length { get; set; } + public double TermFactor { get; set; } + public double BondFactor { get; set; } + public double StressStateFactor { get; set; } + public double PsiSFactor { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs index 8a57d41..3a9637f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs @@ -9,44 +9,45 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class CrackWidthLogicSP63 : ICrackWidthLogic { - public double RebarStrain { get; set; } - public double ConcreteStrain { get; set; } - public double Length { get; set; } - public double TermFactor { get; set; } - public double BondFactor { get; set; } - public double StressStateFactor { get; set; } - public double PsiSFactor { get; set; } + CrackWidthLogicInputDataSP63 inputData; + public ICrackWidthLogicInputData InputData {get;set;} + public double GetCrackWidth() { CheckOptions(); //check if strain of concrete greater than strain of rebar - if (ConcreteStrain > RebarStrain) { return 0d; } - double width = (RebarStrain - ConcreteStrain) * Length; - width *= TermFactor * BondFactor * StressStateFactor * PsiSFactor; + if (inputData.ConcreteStrain > inputData.RebarStrain) { return 0d; } + double width = (inputData.RebarStrain - inputData.ConcreteStrain) * inputData.Length; + width *= inputData.TermFactor * inputData.BondFactor * inputData.StressStateFactor * inputData.PsiSFactor; return width; } private void CheckOptions() { - if (Length <=0d) + if (InputData is not CrackWidthLogicInputDataSP63) { - throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": length between cracks L={Length} must be greate than zero"); + throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(CrackWidthLogicInputDataSP63), InputData.GetType())); } - if (TermFactor <= 0d) + inputData = InputData as CrackWidthLogicInputDataSP63; + if (inputData.Length <=0d) { - throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Term factor {TermFactor} must be greate than zero"); + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": length between cracks L={inputData.Length} must be greate than zero"); } - if (BondFactor <= 0d) + if (inputData.TermFactor <= 0d) { - throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Bond factor {BondFactor} must be greate than zero"); + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Term factor {inputData.TermFactor} must be greate than zero"); } - if (StressStateFactor <= 0d) + if (inputData.BondFactor <= 0d) { - throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Bond factor {StressStateFactor} must be greate than zero"); + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Bond factor {inputData.BondFactor} must be greate than zero"); } - if (PsiSFactor <= 0d) + if (inputData.StressStateFactor <= 0d) { - throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": PsiS factor {PsiSFactor} must be greate than zero"); + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Bond factor {inputData.StressStateFactor} must be greate than zero"); + } + if (inputData.PsiSFactor <= 0d) + { + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": PsiS factor {inputData.PsiSFactor} must be greate than zero"); } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs new file mode 100644 index 0000000..dc7687d --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs @@ -0,0 +1,45 @@ +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public class CrackWidthSimpleCalculator : ICalculator + { + ICrackWidthLogic crackWidthLogic = new CrackWidthLogicSP63(); + CrackWidthSimpleCalculatorResult result; + public string Name { get; set; } + public ICrackWidthSimpleCalculatorInputData InputData { get; set; } + public IResult Result => result; + + + public void Run() + { + result = new() { IsValid = true}; + var crackWidthLogicType = CrackWidthLogicType.SP63; + var logicInputData = CrackWidthLogicInputDataFactory.GetCrackWidthLogicInputData(crackWidthLogicType, InputData); + crackWidthLogic.InputData = logicInputData; + double crackWidth = 0d; + try + { + crackWidth = crackWidthLogic.GetCrackWidth(); + } + catch (Exception ex) + { + result.IsValid = false; + result.Description += "\n" + ex; + } + result.RebarPrimitive = InputData.RebarPrimitive; + result.CrackWidth = crackWidth; + result.RebarStrain = logicInputData.RebarStrain; + result.ConcreteStrain = logicInputData.ConcreteStrain; + } + public object Clone() + { + throw new NotImplementedException(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorResult.cs new file mode 100644 index 0000000..c0e0461 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorResult.cs @@ -0,0 +1,20 @@ +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public class CrackWidthSimpleCalculatorResult : IResult + { + public bool IsValid { get; set; } + public string Description { get; set; } + public RebarPrimitive RebarPrimitive { get; set; } + public double CrackWidth { get; set; } + public double RebarStrain { get; set; } + public double ConcreteStrain { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs new file mode 100644 index 0000000..079e63f --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs @@ -0,0 +1,52 @@ +using LoaderCalculator.Logics; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Services.Forces; +using StructureHelperLogics.NdmCalculations.Triangulations; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + internal enum CrackWidthLogicType + { + SP63 + } + internal static class CrackWidthLogicInputDataFactory + { + static IStressLogic stressLogic => new StressLogic(); + public static ICrackWidthLogicInputData GetCrackWidthLogicInputData(CrackWidthLogicType logicType, ICrackWidthSimpleCalculatorInputData inputData) + { + if (logicType == CrackWidthLogicType.SP63) + { + CrackWidthLogicInputDataSP63 data = new(); + ProcessBaseProps(inputData, data); + if (inputData.CalcTerm == CalcTerms.LongTerm) { data.TermFactor = 1.4d; } + else { data.TermFactor = 1d; } + data.PsiSFactor = inputData.PsiSFactor; + data.StressStateFactor = inputData.StressState is SectionStressStates.Tension ? 1.2d : 1.0d; + return data; + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknown); + } + + } + + private static void ProcessBaseProps(ICrackWidthSimpleCalculatorInputData inputData, ICrackWidthLogicInputData data) + { + var strainMatrix = StrainTupleService.ConvertToLoaderStrainMatrix(inputData.StrainTuple); + var triangulationOptions = new TriangulationOptions { LimiteState = inputData.LimitState, CalcTerm = inputData.CalcTerm }; + var ndms = inputData.RebarPrimitive.GetNdms(triangulationOptions).ToArray(); + var concreteNdm = ndms[0]; + var rebarNdm = ndms[1]; + data.ConcreteStrain = stressLogic.GetTotalStrainWithPresrain(strainMatrix, concreteNdm); + data.RebarStrain = stressLogic.GetTotalStrainWithPresrain(strainMatrix, rebarNdm); + data.Length = inputData.Length; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculatorInputData.cs new file mode 100644 index 0000000..72fbf78 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculatorInputData.cs @@ -0,0 +1,19 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public interface ICrackWidthCalculatorInputData + { + LimitStates LimitState { get; set; } + CalcTerms CalcTerm { get; set; } + StrainTuple StrainTuple { get; set; } + IEnumerable NdmPrimitives {get;set;} + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogic.cs index ed741b3..532995f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogic.cs @@ -11,18 +11,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// public interface ICrackWidthLogic { - /// - /// strain of rebar, dimensionless - /// - double RebarStrain { get; set; } - /// - /// strain of concrete, dimensionless - /// - double ConcreteStrain { get; set; } - /// - /// Length between cracks in meters - /// - double Length { get; set; } + ICrackWidthLogicInputData InputData { get; set; } /// /// return width of crack in meters /// diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogicInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogicInputData.cs new file mode 100644 index 0000000..1ba88db --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogicInputData.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public interface ICrackWidthLogicInputData + { + /// + /// strain of rebar, dimensionless + /// + double RebarStrain { get; set; } + /// + /// strain of concrete, dimensionless + /// + double ConcreteStrain { get; set; } + /// + /// Length between cracks in meters + /// + double Length { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthSimpleCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthSimpleCalculatorInputData.cs new file mode 100644 index 0000000..739e4a4 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthSimpleCalculatorInputData.cs @@ -0,0 +1,25 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public interface ICrackWidthSimpleCalculatorInputData + { + LimitStates LimitState { get; set; } + CalcTerms CalcTerm { get; set; } + StrainTuple StrainTuple { get; set; } + double PsiSFactor { get; set; } + /// + /// Length between cracks in meters + /// + double Length { get; set; } + SectionStressStates StressState { get; set; } + RebarPrimitive RebarPrimitive { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs index a03399a..851db78 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs @@ -39,7 +39,6 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm) }; List ndmCollection = new() { concreteNdm, rebarNdm}; - //List ndmCollection = new() { rebarNdm }; NdmTransform.SetPrestrain(ndmCollection, StrainTupleService.ConvertToLoaderStrainMatrix(options.Prestrain)); return ndmCollection; }