diff --git a/Libraries/LoaderCalculator.dll b/Libraries/LoaderCalculator.dll index f87555f..c410bbe 100644 Binary files a/Libraries/LoaderCalculator.dll and b/Libraries/LoaderCalculator.dll differ diff --git a/StructureHelperCommon/Infrastructures/Enums/Directions.cs b/StructureHelperCommon/Infrastructures/Enums/Directions.cs new file mode 100644 index 0000000..f210380 --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Enums/Directions.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 Directions + { + X, + Y, + Z + } +} diff --git a/StructureHelperCommon/Infrastructures/Strings/ErrorString.cs b/StructureHelperCommon/Infrastructures/Strings/ErrorString.cs index 1b5ba2a..227527f 100644 --- a/StructureHelperCommon/Infrastructures/Strings/ErrorString.cs +++ b/StructureHelperCommon/Infrastructures/Strings/ErrorString.cs @@ -20,5 +20,8 @@ namespace StructureHelperCommon.Infrastructures.Strings public static string FileCantBeSaved => "#0009: File can't be saved"; public static string VisualPropertyIsNotRight => "#0010: VisualPropertyIsNotRight"; public static string FactorMustBeGraterThanZero => "#0011: Partial factor must not be less than zero"; + public static string LongitudinalForceMustBeLessThanZero => "#0012: Longitudinal force must be less than zero"; + public static string LongitudinalForceMustBeLessThanCriticalForce => "#0013: Absolute value of longitudinal force must be greater than critical force"; + public static string SizeMustBeGreaterThanZero => "#0014: Size must be greater than zero"; } } diff --git a/StructureHelperCommon/StructureHelperCommon.csproj b/StructureHelperCommon/StructureHelperCommon.csproj index 5faf8c6..d5e146a 100644 --- a/StructureHelperCommon/StructureHelperCommon.csproj +++ b/StructureHelperCommon/StructureHelperCommon.csproj @@ -51,6 +51,7 @@ + diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs index 6a47239..3451fac 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs @@ -10,10 +10,12 @@ using StructureHelperCommon.Models.Shapes; using StructureHelperCommon.Services.Calculations; using StructureHelperCommon.Services.Forces; using StructureHelperCommon.Services.Sections; +using StructureHelperLogics.NdmCalculations.Buckling; using StructureHelperLogics.NdmCalculations.Primitives; using StructureHelperLogics.Services.NdmPrimitives; using System; using System.Collections.Generic; +using System.Linq; using System.Threading; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces @@ -27,7 +29,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public List Primitives { get; } public INdmResult Result { get; private set; } public ICompressedMember CompressedMember { get; } - public IAccuracy Accuracy { get; } + public IAccuracy Accuracy { get; set; } public void Run() { @@ -56,11 +58,42 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces if (combination.SetInGravityCenter == true) { var loaderPoint = LoaderCalculator.Logics.Geometry.GeometryOperations.GetGravityCenter(ndms); - point2D = new Point2D() { X = loaderPoint[0], Y = loaderPoint[1] }; + point2D = new Point2D() { X = loaderPoint.CenterX, Y = loaderPoint.CenterY }; } else point2D = combination.ForcePoint; var newTuple = ForceTupleService.MoveTupleIntoPoint(tuple.ForceTuple, point2D); var result = GetPrimitiveStrainMatrix(ndms, newTuple); + if (CompressedMember.Buckling == true) + { + IForceTuple longTuple; + if (calcTerm == CalcTerms.LongTerm) + { + longTuple = newTuple; + } + else + { + longTuple = GetLongTuple(combination.DesignForces, limitState); + } + var bucklingCalculator = GetBucklingCalculator(CompressedMember, limitState, calcTerm, newTuple, longTuple); + try + { + bucklingCalculator.Run(); + var bucklingResult = bucklingCalculator.Result as IConcreteBucklingResult; + if (bucklingResult.IsValid != true) + { + result.IsValid = false; + result.Desctription += $"Buckling result:\n{bucklingResult.Desctription}\n"; + } + newTuple = CalculateBuckling(newTuple, bucklingResult); + } + catch (Exception ex) + { + result.IsValid = false; + result.Desctription = $"Buckling error:\n{ex}\n"; + } + + } + result.DesignForceTuple.LimitState = limitState; result.DesignForceTuple.CalcTerm = calcTerm; result.DesignForceTuple.ForceTuple = newTuple; @@ -71,6 +104,42 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces Result = ndmResult; } + private IForceTuple GetLongTuple(List designForces, LimitStates limitState) + { + IForceTuple longTuple; + try + { + longTuple = designForces.Where(x => x.LimitState == limitState & x.CalcTerm == CalcTerms.LongTerm).First().ForceTuple; + } + catch (Exception) + { + longTuple = new ForceTuple(); + } + return longTuple; + } + + private IConcreteBucklingCalculator GetBucklingCalculator(ICompressedMember compressedMember, LimitStates limitStates, CalcTerms calcTerms, IForceTuple calcTuple, IForceTuple longTuple) + { + IConcreteBucklingOptions options = new ConcreteBucklingOptions() + { CompressedMember = compressedMember, + LimitState = limitStates, + CalcTerm = calcTerms, + CalcForceTuple = calcTuple, + LongTermTuple = longTuple, + Primitives = Primitives }; + IConcreteBucklingCalculator bucklingCalculator = new ConcreteBucklingCalculator(options, Accuracy); + return bucklingCalculator; + } + + private IForceTuple CalculateBuckling(IForceTuple calcTuple, IConcreteBucklingResult bucklingResult) + { + var newTuple = calcTuple.Clone() as IForceTuple; + newTuple.Mx *= bucklingResult.EtaFactorAlongY; + newTuple.My *= bucklingResult.EtaFactorAlongX; + return newTuple; + } + + private string CheckInputData() { string result = ""; @@ -85,51 +154,18 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { ForceCombinationLists = new List(); Primitives = new List(); - CompressedMember = new CompressedMember(); + CompressedMember = new CompressedMember() { Buckling = false }; Accuracy = new Accuracy() { IterationAccuracy = 0.001d, MaxIterationCount = 1000 }; LimitStatesList = new List() { LimitStates.ULS, LimitStates.SLS }; CalcTermsList = new List() { CalcTerms.ShortTerm, CalcTerms.LongTerm }; } - private ForcesResult GetPrimitiveStrainMatrix(IEnumerable ndmCollection, IForceTuple tuple) + private IForcesTupleResult GetPrimitiveStrainMatrix(IEnumerable ndmCollection, IForceTuple tuple) { - var mx = tuple.Mx; - var my = tuple.My; - var nz = tuple.Nz; - - try - { - var loaderData = new LoaderOptions - { - Preconditions = new Preconditions - { - ConditionRate = Accuracy.IterationAccuracy, - MaxIterationCount = Accuracy.MaxIterationCount, - StartForceMatrix = new ForceMatrix { Mx = mx, My = my, Nz = nz } - }, - NdmCollection = ndmCollection - }; - var calculator = new Calculator(); - calculator.Run(loaderData, new CancellationToken()); - var calcResult = calculator.Result; - if (calcResult.AccuracyRate <= Accuracy.IterationAccuracy) - { - return new ForcesResult() { IsValid = true, Desctription = "Analysis is done succsefully", LoaderResults = calcResult }; - } - else - { - return new ForcesResult() { IsValid = false, Desctription = "Required accuracy rate has not achived", LoaderResults = calcResult }; - } - - } - catch (Exception ex) - { - var result = new ForcesResult() { IsValid = false }; - if (ex.Message == "Calculation result is not valid: stiffness matrix is equal to zero") { result.Desctription = "Stiffness matrix is equal to zero \nProbably section was collapsed"; } - else { result.Desctription = $"Error is appeared due to analysis. Error: {ex}"; } - return result; - } - + IForceTupleInputData inputData = new ForceTupleInputData() { NdmCollection = ndmCollection, Tuple = tuple, Accuracy = Accuracy }; + IForceTupleCalculator calculator = new ForceTupleCalculator(inputData); + calculator.Run(); + return calculator.Result as IForcesTupleResult; } public object Clone() diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs new file mode 100644 index 0000000..47988e8 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs @@ -0,0 +1,82 @@ +using LoaderCalculator.Data.Matrix; +using LoaderCalculator.Data.SourceData; +using LoaderCalculator; +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public class ForceTupleCalculator : IForceTupleCalculator + { + public string Name { get; set; } + public INdmResult Result { get; private set; } + + private IForceTupleInputData inputData; + + public ForceTupleCalculator(IForceTupleInputData inputData) + { + this.inputData = inputData; + } + + public void Run() + { + Result = CalculateResult(); + } + + private IForcesTupleResult CalculateResult() + { + var ndmCollection = inputData.NdmCollection; + var tuple = inputData.Tuple; + var accuracy = inputData.Accuracy; + + + var mx = tuple.Mx; + var my = tuple.My; + var nz = tuple.Nz; + + try + { + var loaderData = new LoaderOptions + { + Preconditions = new Preconditions + { + ConditionRate = accuracy.IterationAccuracy, + MaxIterationCount = accuracy.MaxIterationCount, + StartForceMatrix = new ForceMatrix { Mx = mx, My = my, Nz = nz } + }, + NdmCollection = ndmCollection + }; + var calculator = new Calculator(); + calculator.Run(loaderData, new CancellationToken()); + var calcResult = calculator.Result; + if (calcResult.AccuracyRate <= accuracy.IterationAccuracy) + { + return new ForcesTupleResult() { IsValid = true, Desctription = "Analysis is done succsefully", LoaderResults = calcResult }; + } + else + { + return new ForcesTupleResult() { IsValid = false, Desctription = "Required accuracy rate has not achived", LoaderResults = calcResult }; + } + + } + catch (Exception ex) + { + var result = new ForcesTupleResult() { IsValid = false }; + if (ex.Message == "Calculation result is not valid: stiffness matrix is equal to zero") { result.Desctription = "Stiffness matrix is equal to zero \nProbably section was collapsed"; } + else { result.Desctription = $"Error is appeared due to analysis. Error: {ex}"; } + return result; + } + } + + public object Clone() + { + throw new NotImplementedException(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs new file mode 100644 index 0000000..241e76d --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs @@ -0,0 +1,18 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public class ForceTupleInputData : IForceTupleInputData + { + public IEnumerable NdmCollection { get; set; } + public IForceTuple Tuple { get; set; } + public IAccuracy Accuracy { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResults.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResults.cs index e2ce7d3..75fd467 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResults.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResults.cs @@ -9,12 +9,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public class ForcesResults : IForcesResults { public bool IsValid { get; set; } - public List ForcesResultList { get; } + public List ForcesResultList { get; } public string Desctription { get; set; } public ForcesResults() { - ForcesResultList = new List(); + ForcesResultList = new List(); } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResult.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesTupleResult.cs similarity index 89% rename from StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResult.cs rename to StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesTupleResult.cs index 10bb070..7de59dc 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResult.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesTupleResult.cs @@ -9,7 +9,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - public class ForcesResult : INdmResult + public class ForcesTupleResult : IForcesTupleResult { public bool IsValid { get; set; } public IDesignForceTuple DesignForceTuple { get; set; } @@ -22,7 +22,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces /// public ILoaderResults LoaderResults { get; set; } - public ForcesResult() + public ForcesTupleResult() { DesignForceTuple = new DesignForceTuple(); } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculator.cs index ebf5d12..25d9723 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculator.cs @@ -14,6 +14,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces List CalcTermsList { get; } List LimitStatesList { get; } ICompressedMember CompressedMember { get; } - IAccuracy Accuracy { get; } + IAccuracy Accuracy { get; set; } } } \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs new file mode 100644 index 0000000..07a411a --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs @@ -0,0 +1,13 @@ +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public interface IForceTupleCalculator : INdmCalculator + { + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs new file mode 100644 index 0000000..c151d6f --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs @@ -0,0 +1,18 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public interface IForceTupleInputData + { + IEnumerable NdmCollection { get; set; } + IForceTuple Tuple { get; set; } + IAccuracy Accuracy { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesResults.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesResults.cs index 9c8fd39..e0f5ddd 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesResults.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesResults.cs @@ -5,7 +5,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public interface IForcesResults : INdmResult { string Desctription { get; set; } - List ForcesResultList { get; } + List ForcesResultList { get; } bool IsValid { get; set; } } } \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesTupleResult.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesTupleResult.cs new file mode 100644 index 0000000..4a108fc --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesTupleResult.cs @@ -0,0 +1,11 @@ +using LoaderCalculator.Data.ResultData; +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public interface IForcesTupleResult : INdmResult + { + IDesignForceTuple DesignForceTuple { get; set; } + ILoaderResults LoaderResults { get; set; } + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs new file mode 100644 index 0000000..0738077 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs @@ -0,0 +1,177 @@ +using LoaderCalculator.Data.Materials.MaterialBuilders; +using LoaderCalculator.Data.Ndms; +using LoaderCalculator.Logics; +using LoaderCalculator.Logics.Geometry; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Shapes; +using StructureHelperCommon.Services.Forces; +using StructureHelperLogics.Models.Materials; +using StructureHelperLogics.NdmCalculations.Analyses; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperLogics.Services.NdmPrimitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public class ConcreteBucklingCalculator : IConcreteBucklingCalculator + { + private IConcreteBucklingOptions options; + private IEilerCriticalForceLogic criticalForceLogic; + private IRCStiffnessLogic stiffnessLogicX, stiffnessLogicY; + private List ndmCollection; + private List concreteNdms; + private List otherNdms; + IForcesTupleResult forcesResults; + + public string Name { get; set; } + + public INdmResult Result { get; private set; } + + public IAccuracy Accuracy { get; set; } + + private (double EtaAlongX, double EtaAlongY) GetBucklingCoefficients() + { + var stiffness = GetStiffness(); + criticalForceLogic.LongForce = options.CalcForceTuple.Nz; + criticalForceLogic.StiffnessEI = stiffness.DX; + criticalForceLogic.DesignLength = options.CompressedMember.GeometryLength * options.CompressedMember.LengthFactorY; + var etaAlongY = criticalForceLogic.GetEtaFactor(); + criticalForceLogic.StiffnessEI = stiffness.DY; + criticalForceLogic.DesignLength = options.CompressedMember.GeometryLength * options.CompressedMember.LengthFactorX; + var etaAlongX = criticalForceLogic.GetEtaFactor(); + return (etaAlongX, etaAlongY); + } + + public ConcreteBucklingCalculator(IConcreteBucklingOptions options, IAccuracy accuracy) + { + this.options = options; + Accuracy = accuracy; + + var allPrimitives = options.Primitives; + var concretePrimitives = GetConcretePrimitives(); + var otherPrimitives = allPrimitives.Except(concretePrimitives); + ndmCollection = NdmPrimitivesService.GetNdms(allPrimitives, options.LimitState, options.CalcTerm); + concreteNdms = NdmPrimitivesService.GetNdms(concretePrimitives, options.LimitState, options.CalcTerm); + otherNdms = NdmPrimitivesService.GetNdms(otherPrimitives, options.LimitState, options.CalcTerm); + } + + private (IConcreteDeltaELogic DeltaLogicX, IConcreteDeltaELogic DeltaLogicY) GetDeltaLogics() + { + IForceTuple forceTuple = options.CalcForceTuple; + if (forceTuple.Nz >= 0) { return (new ConstDeltaELogic(), new ConstDeltaELogic()); } + var eccentricityAlongX = options.CalcForceTuple.My / forceTuple.Nz; + var eccentricityAlongY = options.CalcForceTuple.Mx / forceTuple.Nz; + var sizeAlongX = ndmCollection.Max(x => x.CenterX) - ndmCollection.Min(x => x.CenterX); + var sizeAlongY = ndmCollection.Max(x => x.CenterY) - ndmCollection.Min(x => x.CenterY); + var DeltaElogicAboutX = new DeltaELogicSP63(eccentricityAlongY, sizeAlongY); + var DeltaElogicAboutY = new DeltaELogicSP63(eccentricityAlongX, sizeAlongX); + return (DeltaElogicAboutX, DeltaElogicAboutY); + } + + private IEnumerable GetConcretePrimitives() + { + var primitives = options.Primitives.Where(x => x.HeadMaterial.HelperMaterial is IConcreteLibMaterial); + return primitives; + } + + private (double DX, double DY) GetStiffness() + { + var gravityCenter = GeometryOperations.GetGravityCenter(ndmCollection); + + var concreteInertia = GeometryOperations.GetMomentsOfInertiaMod(concreteNdms, gravityCenter); + var otherInertia = GeometryOperations.GetMomentsOfInertiaMod(otherNdms, gravityCenter); + + var stiffnessX = stiffnessLogicX.GetStiffnessCoeffitients(); + var dX = stiffnessX.Kc * concreteInertia.MomentX + stiffnessX.Ks * otherInertia.MomentX; + + var stiffnessY = stiffnessLogicY.GetStiffnessCoeffitients(); + var dY = stiffnessY.Kc * concreteInertia.MomentY + stiffnessY.Ks * otherInertia.MomentY; + + return (dX, dY); + } + + private IConcretePhiLLogic GetPhiLogic() + { + IPoint2D point = GetMostTensionedPoint(); + var phiLogic = new PhiLogicSP63(options.CalcForceTuple, options.LongTermTuple, point); + return phiLogic; + } + + private IPoint2D GetMostTensionedPoint() + { + var strains = forcesResults.LoaderResults.StrainMatrix; + double maxStrain = double.NegativeInfinity; + IPoint2D point = new Point2D(); + var stressLogic = new StressLogic(); + foreach (var item in ndmCollection) + { + var strain = stressLogic.GetTotalStrain(strains, item); + if (strain > maxStrain) + { + maxStrain = strain; + point = new Point2D() { X = item.CenterX, Y = item.CenterY }; + } + } + return point; + } + + private IForceTupleCalculator GetForceCalculator() + { + var tuple = options.CalcForceTuple; + IForceTupleInputData inputData = new ForceTupleInputData() { NdmCollection = ndmCollection, Tuple = tuple, Accuracy = Accuracy }; + IForceTupleCalculator calculator = new ForceTupleCalculator(inputData); + return calculator; + } + + public void Run() + { + var checkResult = CheckInputData(); + if (checkResult != "") + { + Result = new ConcreteBucklingResult() { IsValid = false, Desctription = checkResult }; + return; + } + else + { + IConcretePhiLLogic phiLLogic = GetPhiLogic(); + var (DeltaLogicAboutX, DeltaLogicAboutY) = GetDeltaLogics(); + stiffnessLogicX = new RCStiffnessLogicSP63(phiLLogic, DeltaLogicAboutX); + stiffnessLogicY = new RCStiffnessLogicSP63(phiLLogic, DeltaLogicAboutY); + criticalForceLogic = new EilerCriticalForceLogic(); + + var (EtaFactorX, EtaFactorY) = GetBucklingCoefficients(); + Result = new ConcreteBucklingResult() + { + IsValid = true, + EtaFactorAlongX = EtaFactorX, + EtaFactorAlongY = EtaFactorY + }; + } + } + + private string CheckInputData() + { + string result = ""; + IForceTupleCalculator calculator = GetForceCalculator(); + calculator.Run(); + forcesResults = calculator.Result as IForcesTupleResult; + if (forcesResults.IsValid != true) + { + result += "Bearind capacity of crosssection is not enough for initial forces\n"; + } + return result; + } + + public object Clone() + { + throw new NotImplementedException(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingOptions.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingOptions.cs new file mode 100644 index 0000000..820b7f2 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingOptions.cs @@ -0,0 +1,29 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Sections; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + /// + internal class ConcreteBucklingOptions : IConcreteBucklingOptions + { + /// + public IForceTuple LongTermTuple { get; set; } + /// + public ICompressedMember CompressedMember { get; set; } + /// + public LimitStates LimitState { get; set; } + /// + public CalcTerms CalcTerm { get; set; } + /// + public IEnumerable Primitives { get; set; } + /// + public IForceTuple CalcForceTuple { get; set; } +} +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingResult.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingResult.cs new file mode 100644 index 0000000..1d3e233 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingResult.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + /// + public class ConcreteBucklingResult : IConcreteBucklingResult + { + /// + public bool IsValid { get; set; } + /// + public string Desctription { get; set; } + /// + public double EtaFactorAlongX { get; set; } + /// + public double EtaFactorAlongY { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConstDeltaELogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConstDeltaELogic.cs new file mode 100644 index 0000000..ed60dd4 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConstDeltaELogic.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public class ConstDeltaELogic : IConcreteDeltaELogic + { + public double GetDeltaE() + { + return 1.5d; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConstPhiLLogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConstPhiLLogic.cs new file mode 100644 index 0000000..a9cdc03 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConstPhiLLogic.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + internal class ConstPhiLLogic : IConcretePhiLLogic + { + public double GetPhil() + { + return 2.0d; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/CriticalForceSP63Logic.cs b/StructureHelperLogics/NdmCalculations/Buckling/CriticalForceSP63Logic.cs new file mode 100644 index 0000000..6d14887 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/CriticalForceSP63Logic.cs @@ -0,0 +1,23 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + internal class CriticalForceSP63Logic : ICriticalBucklingForceLogic + { + double concreteFactor, reinforcementFactor; + + public double GetCriticalForce() + { + throw new NotImplementedException(); + } + + public double GetEtaFactor() + { + throw new NotImplementedException(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/DeltaELogicSP63.cs b/StructureHelperLogics/NdmCalculations/Buckling/DeltaELogicSP63.cs new file mode 100644 index 0000000..631aab6 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/DeltaELogicSP63.cs @@ -0,0 +1,36 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Strings; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public class DeltaELogicSP63 : IConcreteDeltaELogic + { + const double deltaEMin = 0.15d; + const double deltaEMax = 1.5d; + + readonly double eccentricity; + readonly double size; + public DeltaELogicSP63(double eccentricity, double size) + { + if (size <= 0 ) + { + throw new StructureHelperException(ErrorStrings.SizeMustBeGreaterThanZero + $", actual size: {size}"); + } + this.eccentricity = eccentricity; + this.size = size; + } + + public double GetDeltaE() + { + var deltaE = Math.Abs(eccentricity) / size; + deltaE = Math.Max(deltaE, deltaEMin); + deltaE = Math.Min(deltaE, deltaEMax); + return deltaE; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/EilerCriticalForceLogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/EilerCriticalForceLogic.cs new file mode 100644 index 0000000..9a76b38 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/EilerCriticalForceLogic.cs @@ -0,0 +1,35 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Strings; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + internal class EilerCriticalForceLogic : IEilerCriticalForceLogic + { + public double LongForce { get; set; } + public double StiffnessEI { get; set; } + public double DesignLength { get; set; } + + public double GetCriticalForce() + { + double Ncr = - Math.Pow(Math.PI, 2) * StiffnessEI / (Math.Pow(DesignLength, 2)); + return Ncr; + } + + public double GetEtaFactor() + { + if (LongForce >= 0d) return 1d; + var Ncr = GetCriticalForce(); + if (LongForce <= Ncr) + { + throw new StructureHelperException(ErrorStrings.LongitudinalForceMustBeLessThanCriticalForce); + } + double eta = 1 / (1 - LongForce / Ncr); + return eta; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IBucklingOptions.cs b/StructureHelperLogics/NdmCalculations/Buckling/IBucklingOptions.cs new file mode 100644 index 0000000..ecfc7c3 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IBucklingOptions.cs @@ -0,0 +1,21 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Sections; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public interface IBucklingOptions + { + ICompressedMember CompressedMember { get; } + LimitStates LimitState { get; } + CalcTerms CalcTerm { get; } + IEnumerable Primitives { get; } + IForceTuple CalcForceTuple { get; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingCalculator.cs b/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingCalculator.cs new file mode 100644 index 0000000..6555062 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingCalculator.cs @@ -0,0 +1,15 @@ +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Analyses; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + internal interface IConcreteBucklingCalculator : INdmCalculator + { + IAccuracy Accuracy { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingOptions.cs b/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingOptions.cs new file mode 100644 index 0000000..5ee4b4b --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingOptions.cs @@ -0,0 +1,15 @@ +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public interface IConcreteBucklingOptions : IBucklingOptions + { + IForceTuple LongTermTuple { get; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingResult.cs b/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingResult.cs new file mode 100644 index 0000000..635aa2b --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingResult.cs @@ -0,0 +1,24 @@ +using StructureHelperLogics.NdmCalculations.Analyses; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + /// + /// Results of calculation of buckling of reinforced concrete section + /// + public interface IConcreteBucklingResult : INdmResult + { + /// + /// Factor of increasing of bending moment (p-delta effect) in the plain XOZ + /// + double EtaFactorAlongX { get; set; } + /// + /// Factor of increasing of bending moment (p-delta effect) in the plain YOZ + /// + double EtaFactorAlongY { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IConcreteDeltaELogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/IConcreteDeltaELogic.cs new file mode 100644 index 0000000..5654179 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IConcreteDeltaELogic.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + internal interface IConcreteDeltaELogic + { + double GetDeltaE(); + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IConcretePhiLLogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/IConcretePhiLLogic.cs new file mode 100644 index 0000000..504e935 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IConcretePhiLLogic.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public interface IConcretePhiLLogic + { + double GetPhil(); + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ICriticalBucklingForceLogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/ICriticalBucklingForceLogic.cs new file mode 100644 index 0000000..1d14189 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/ICriticalBucklingForceLogic.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + internal interface ICriticalBucklingForceLogic + { + double GetCriticalForce(); + double GetEtaFactor(); + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IEilerCriticalForceLogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/IEilerCriticalForceLogic.cs new file mode 100644 index 0000000..c778b72 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IEilerCriticalForceLogic.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + internal interface IEilerCriticalForceLogic : ICriticalBucklingForceLogic + { + double LongForce { get; set; } + double StiffnessEI { get; set; } + double DesignLength { get; set; } + + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/IRCStiffnessLogic.cs b/StructureHelperLogics/NdmCalculations/Buckling/IRCStiffnessLogic.cs new file mode 100644 index 0000000..39cee43 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/IRCStiffnessLogic.cs @@ -0,0 +1,14 @@ +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public interface IRCStiffnessLogic + { + (double Kc, double Ks) GetStiffnessCoeffitients(); + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/PhiLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Buckling/PhiLogicSP63.cs new file mode 100644 index 0000000..cb02ffd --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/PhiLogicSP63.cs @@ -0,0 +1,41 @@ +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Shapes; +using StructureHelperCommon.Services.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + public class PhiLogicSP63 : IConcretePhiLLogic + { + readonly IForceTuple fullForceTuple; + readonly IForceTuple longForceTuple; + readonly IPoint2D point; + public PhiLogicSP63(IForceTuple fullForceTuple, IForceTuple longForceTuple, IPoint2D point) + { + this.fullForceTuple = fullForceTuple; + this.longForceTuple = longForceTuple; + this.point = point; + } + + public double GetPhil() + { + var distance = Math.Sqrt(point.X * point.X + point.Y * point.Y); + var fullMoment = GetMoment(fullForceTuple, distance); + var longMoment = GetMoment(longForceTuple, distance); + if (fullMoment == 0d) { return 2d; } + var phi = 1 + longMoment / fullMoment; + phi = Math.Max(1, phi); + phi = Math.Min(2, phi); + return phi; + } + + private double GetMoment(IForceTuple forceTuple, double distance) + { + return Math.Abs(forceTuple.Nz) * distance + Math.Abs(forceTuple.Mx) + Math.Abs(forceTuple.My); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Buckling/RCStiffnessLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Buckling/RCStiffnessLogicSP63.cs new file mode 100644 index 0000000..357a14b --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Buckling/RCStiffnessLogicSP63.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Buckling +{ + internal class RCStiffnessLogicSP63 : IRCStiffnessLogic + { + IConcretePhiLLogic phiLLogic { get; } + IConcreteDeltaELogic deltaELogic { get; } + + public RCStiffnessLogicSP63() : this(new ConstPhiLLogic(), new ConstDeltaELogic()) { } + + public RCStiffnessLogicSP63(IConcretePhiLLogic phiLLogic, IConcreteDeltaELogic deltaELogic) + { + this.phiLLogic = phiLLogic; + this.deltaELogic = deltaELogic; + } + + public (double Kc, double Ks) GetStiffnessCoeffitients() + { + const double initialKs = 0.7d; + const double initialKc = 0.15d; + const double deltaEAddition = 0.3d; + double phiL = phiLLogic.GetPhil(); + double deltaE = deltaELogic.GetDeltaE(); + double kc = initialKc / (phiL * (deltaEAddition + deltaE)); + return (kc, initialKs); + } + } +} diff --git a/StructureHelperLogics/Services/NdmCalculations/InterpolateService.cs b/StructureHelperLogics/Services/NdmCalculations/InterpolateService.cs index 11ced04..5d1cd4b 100644 --- a/StructureHelperLogics/Services/NdmCalculations/InterpolateService.cs +++ b/StructureHelperLogics/Services/NdmCalculations/InterpolateService.cs @@ -1,5 +1,6 @@ using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Services.Forces; +using StructureHelperCommon.Services.Sections; using StructureHelperLogics.Models.Primitives; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; using System; @@ -19,8 +20,8 @@ namespace StructureHelperLogics.Services.NdmCalculations calculator.LimitStatesList.Add(finishDesignForce.LimitState); calculator.CalcTermsList.Clear(); calculator.CalcTermsList.Add(finishDesignForce.CalcTerm); - calculator.Accuracy.IterationAccuracy = source.Accuracy.IterationAccuracy; - calculator.Accuracy.MaxIterationCount = source.Accuracy.MaxIterationCount; + CompressedMemberServices.CopyProperties(source.CompressedMember, calculator.CompressedMember); + calculator.Accuracy = source.Accuracy; calculator.Primitives.AddRange(source.Primitives); calculator.ForceCombinationLists.Clear(); var combination = new ForceCombinationList() diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs index 07c92a1..26c8f1d 100644 --- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs +++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs @@ -1,4 +1,5 @@ using LoaderCalculator.Tests.Infrastructures.Logics; +using Moq; using NUnit.Framework; using StructureHelperLogics.Models.Templates.CrossSections.RCs; using StructureHelperLogics.Models.Templates.RCs; @@ -8,15 +9,19 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT { public class RCSectionsTest { - [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, -0.00062544561815463693d, -0.0029292919541166911d, 0.00035383082501577246d)] - [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 3, 2, -0.00046762265275279838d, -0.0025101896869558888d, 0.00027185795017719519d)] - [TestCase(0.5d, 0.5d, 0.025d, 0.025d, 3, 3, -0.00080914991212906239d, -0.00080914991212906184d, 0.00011900072665826425d)] - public void Run_SouldPass(double width, double height, double topDiametr, double bottomDiametr, int widthCount, int heightCount, double expectedKx, double expectedKy, double expectedEpsZ) + [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, -0.00062544561815463693d, -0.0029292919541166911d, 0.00035383082501577246d)] + [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 3, 2, false, -0.00046762265275279838d, -0.0025101896869558888d, 0.00027185795017719519d)] + [TestCase(0.5d, 0.5d, 0.025d, 0.025d, 3, 3, false, -0.00080914991212906239d, -0.00080914991212906184d, 0.00011900072665826425d)] + [TestCase(0.5d, 0.5d, 0.025d, 0.025d, 3, 3, true, -0.0008126213321004612d, -0.00081262133210046055d, 0.00011963568117586145d)] + [TestCase(0.5d, 0.6d, 0.025d, 0.025d, 3, 3, true, -0.00047720148631058529d, -0.00077269031816753532d, 0.00010610472872420363d)] + [TestCase(0.6d, 0.5d, 0.025d, 0.025d, 3, 3, true, -0.00077269031816753478d, -0.00047720148631058437d, 0.00010610472872420363d)] + public void Run_ShouldPass(double width, double height, double topDiametr, double bottomDiametr, int widthCount, int heightCount, bool isBuckling, double expectedKx, double expectedKy, double expectedEpsZ) { //Arrange var template = new RectangleBeamTemplate(width, height) { TopDiameter = topDiametr, BottomDiameter = bottomDiametr, WidthCount = widthCount, HeightCount = heightCount}; var newSection = new SectionTemplate(new RectGeometryLogic(template)).GetCrossSection(); - var calculator = newSection.SectionRepository.CalculatorsList[0]; + var calculator = newSection.SectionRepository.CalculatorsList[0] as IForceCalculator; + calculator.CompressedMember.Buckling = isBuckling; //Act calculator.Run(); var result = calculator.Result as IForcesResults; @@ -32,15 +37,16 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT Assert.AreEqual(expectedEpsZ, epsz, ExpectedProcessor.GetAccuracyForExpectedValue(expectedEpsZ)); } - [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, true, true)] - [TestCase(1d, 0.2d, 0.012d, 0.012d, 5, 2, true, false)] - [TestCase(1d, 0.2d, 0.012d, 0.025d, 5, 2, true, true)] - public void Run_SouldPass_Result_IsNotValid(double width, double height, double topDiametr, double bottomDiametr, int widthCount, int heightCount, bool calcResult, bool firstForceResult) + [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, true, true)] + [TestCase(1d, 0.2d, 0.012d, 0.012d, 5, 2, false, true, false)] + [TestCase(1d, 0.2d, 0.012d, 0.025d, 5, 2, false, true, true)] + public void Run_ShouldPass_Result_IsNotValid(double width, double height, double topDiametr, double bottomDiametr, int widthCount, int heightCount,bool isBuckling, bool calcResult, bool firstForceResult) { //Arrange var template = new RectangleBeamTemplate(width, height) { TopDiameter = topDiametr, BottomDiameter = bottomDiametr, WidthCount = widthCount, HeightCount = heightCount }; var newSection = new SectionTemplate(new RectGeometryLogic(template)).GetCrossSection(); - var calculator = newSection.SectionRepository.CalculatorsList[0]; + var calculator = newSection.SectionRepository.CalculatorsList[0] as IForceCalculator; + calculator.CompressedMember.Buckling = isBuckling; //Act calculator.Run(); var result = calculator.Result as IForcesResults; diff --git a/StructureHelperTests/FunctionalTests/Ndms/RCSections/BucklingLogicTest.cs b/StructureHelperTests/FunctionalTests/Ndms/RCSections/BucklingLogicTest.cs new file mode 100644 index 0000000..56abd72 --- /dev/null +++ b/StructureHelperTests/FunctionalTests/Ndms/RCSections/BucklingLogicTest.cs @@ -0,0 +1,50 @@ +using LoaderCalculator.Tests.Infrastructures.Logics; +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.Models.Templates.CrossSections.RCs; +using StructureHelperLogics.Models.Templates.RCs; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Buckling; + +namespace StructureHelperTests.FunctionalTests.Ndms.RCSections +{ + public class BucklingLogicTest + { + [TestCase(0d, 0d, 0d, 0d, 0d, -100d, -0.15d, 0.15d, 1d)] + [TestCase(0d, 0d, -50d, 0d, 0d, -100d, -0.15d, 0.15d, 1.5d)] + [TestCase(0d, 0d, -100d, 0d, 0d, -100d, -0.15d, 0.15d, 2d)] + [TestCase(0d, 0d, 0d, -10d, 0d, -100d, -0.15d, 0.15d, 1d)] + [TestCase(-5d, 0d, -50d, -10d, 0d, -100d, -0.15d, 0.15d, 1.5d)] + [TestCase(-10d, 0d, -100d, -10d, 0d, -100d, -0.15d, 0.15d, 2d)] + [TestCase(0d, 0d, 0d, -10d, 10d, -100d, -0.15d, 0.15d, 1d)] + [TestCase(-5d, 5d, -50d, -10d, 10d, -100d, -0.15d, 0.15d, 1.5d)] + [TestCase(-10d, 10d, -100d, -10d, 10d, -100d, -0.15d, 0.15d, 2d)] + public void Run_ShoulPass_PhiLogicSP63(double longMx, double longMy, double longNz, double shortMx, double shortMy, double shortNz, double pointX, double pointY, double expectedPhi) + { + //Arrange + var fullTuple = new ForceTuple() { Mx = shortMx, My = shortMy, Nz = shortNz }; + var longTuple = new ForceTuple() { Mx = longMx, My = longMy, Nz = longNz }; + var point = new Point2D() { X = pointX, Y = pointY }; + //Act + var phiLogic = new PhiLogicSP63(fullTuple, longTuple, point); + var phiL = phiLogic.GetPhil(); + //Assert + Assert.AreEqual(expectedPhi, phiL, 0.01d); + } + + [TestCase(0d, 0.5d, 0.15d)] + [TestCase(0.1d, 0.5d, 0.2d)] + [TestCase(1d, 0.5d, 1.5d)] + public void Run_ShoulPass_DeltaELogicSP63(double eccentricity, double size, double expectedDeltaE) + { + //Arrange + //Act + var deltaELogic = new DeltaELogicSP63(eccentricity, size); + var deltaE = deltaELogic.GetDeltaE(); + //Assert + Assert.AreEqual(expectedDeltaE, deltaE, 0.01d); + } + } +} diff --git a/StructureHelperTests/StructureHelperTests.csproj b/StructureHelperTests/StructureHelperTests.csproj index 3c234b3..7b76be3 100644 --- a/StructureHelperTests/StructureHelperTests.csproj +++ b/StructureHelperTests/StructureHelperTests.csproj @@ -1,7 +1,7 @@  - + Debug AnyCPU @@ -44,6 +44,7 @@ + @@ -58,16 +59,14 @@ - ..\packages\Castle.Core.5.1.0\lib\net462\Castle.Core.dll - True + ..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll ..\Libraries\LoaderCalculator.dll True - ..\packages\Moq.4.18.2\lib\net462\Moq.dll - True + ..\packages\Moq.4.18.4\lib\net462\Moq.dll ..\packages\NUnit.3.13.3\lib\net45\nunit.framework.dll @@ -112,7 +111,7 @@ + - \ No newline at end of file diff --git a/StructureHelperTests/app.config b/StructureHelperTests/app.config index 0075fb7..5bd96bc 100644 --- a/StructureHelperTests/app.config +++ b/StructureHelperTests/app.config @@ -8,7 +8,19 @@ - + + + + + + + + + + + + + diff --git a/StructureHelperTests/packages.config b/StructureHelperTests/packages.config index 7c07542..a3a8821 100644 --- a/StructureHelperTests/packages.config +++ b/StructureHelperTests/packages.config @@ -1,9 +1,9 @@  - - + + - + \ No newline at end of file diff --git a/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceCalculatorView.xaml b/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceCalculatorView.xaml index 2363cdf..411ecb2 100644 --- a/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceCalculatorView.xaml +++ b/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceCalculatorView.xaml @@ -49,7 +49,7 @@ - + diff --git a/Windows/MainWindow/MainViewModel.cs b/Windows/MainWindow/MainViewModel.cs index 7feb8af..e7df72c 100644 --- a/Windows/MainWindow/MainViewModel.cs +++ b/Windows/MainWindow/MainViewModel.cs @@ -287,11 +287,11 @@ namespace StructureHelper.Windows.MainWindow { if (CheckMaterials() == false) { return;} var ndms = NdmPrimitivesService.GetNdms(repository.Primitives, LimitStates.SLS, CalcTerms.ShortTerm); - double[] center = GeometryOperations.GetGravityCenter(ndms); + var center = GeometryOperations.GetGravityCenter(ndms); foreach (var item in PrimitiveLogic.Items) { - item.CenterX -= center[0]; - item.CenterY -= center[1]; + item.CenterX -= center.CenterX; + item.CenterY -= center.CenterY; } }, o => repository.Primitives.Count() > 0 diff --git a/Windows/PrimitivePropertiesWindow/PrimitivePropertiesView.xaml b/Windows/PrimitivePropertiesWindow/PrimitivePropertiesView.xaml index b59edfe..173a83f 100644 --- a/Windows/PrimitivePropertiesWindow/PrimitivePropertiesView.xaml +++ b/Windows/PrimitivePropertiesWindow/PrimitivePropertiesView.xaml @@ -112,23 +112,24 @@ + + + - - - + - - + + - - - - - + + + + + diff --git a/Windows/ViewModels/Calculations/Calculators/ForcesResultsViewModel.cs b/Windows/ViewModels/Calculations/Calculators/ForcesResultsViewModel.cs index bbba5ac..de01491 100644 --- a/Windows/ViewModels/Calculations/Calculators/ForcesResultsViewModel.cs +++ b/Windows/ViewModels/Calculations/Calculators/ForcesResultsViewModel.cs @@ -41,7 +41,7 @@ namespace StructureHelper.Windows.ViewModels.Calculations.Calculators private IEnumerable ndms; private IReport isoFieldReport; - public ForcesResult SelectedResult { get; set; } + public ForcesTupleResult SelectedResult { get; set; } private RelayCommand showIsoFieldCommand; private RelayCommand exportToCSVCommand; private RelayCommand interpolateCommand; diff --git a/Windows/ViewModels/NdmCrossSections/SecondOrderViewModel.cs b/Windows/ViewModels/NdmCrossSections/SecondOrderViewModel.cs index fe267b0..3294617 100644 --- a/Windows/ViewModels/NdmCrossSections/SecondOrderViewModel.cs +++ b/Windows/ViewModels/NdmCrossSections/SecondOrderViewModel.cs @@ -37,7 +37,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections get => member.LengthFactorX; set { - member.GeometryLength = value; + member.LengthFactorX = value; OnPropertyChanged(nameof(LengthFactorX)); } } @@ -47,7 +47,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections get => member.LengthFactorY; set { - member.GeometryLength = value; + member.LengthFactorY= value; OnPropertyChanged(nameof(LengthFactorY)); } }