avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ConcreteBucklingCalculator was added

Browse Source
This commit is contained in:
Evgeny Redikultsev
2023-01-29 20:45:42 +05:00
parent 6d1f9bae1b
commit f013ddae13
44 changed files with 924 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs
View File

@@ -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<INdmPrimitive> 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<IDesignForceTuple> 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<IForceCombinationList>();
Primitives = new List<INdmPrimitive>();
CompressedMember = new CompressedMember();
CompressedMember = new CompressedMember() { Buckling = false };
Accuracy = new Accuracy() { IterationAccuracy = 0.001d, MaxIterationCount = 1000 };
LimitStatesList = new List<LimitStates>() { LimitStates.ULS, LimitStates.SLS };
CalcTermsList = new List<CalcTerms>() { CalcTerms.ShortTerm, CalcTerms.LongTerm };
}
private ForcesResult GetPrimitiveStrainMatrix(IEnumerable<INdm> ndmCollection, IForceTuple tuple)
private IForcesTupleResult GetPrimitiveStrainMatrix(IEnumerable<INdm> 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()

82
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs Normal file
View File

@@ -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();
}
}
}

18
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs Normal file
View File

@@ -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<INdm> NdmCollection { get; set; }
public IForceTuple Tuple { get; set; }
public IAccuracy Accuracy { get; set; }
}
}

4
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResults.cs
View File

@@ -9,12 +9,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
public class ForcesResults : IForcesResults
{
public bool IsValid { get; set; }
public List<ForcesResult> ForcesResultList { get; }
public List<IForcesTupleResult> ForcesResultList { get; }
public string Desctription { get; set; }
public ForcesResults()
{
ForcesResultList = new List<ForcesResult>();
ForcesResultList = new List<IForcesTupleResult>();
}
}
}

4
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesResult.cs → StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForcesTupleResult.cs
View File

@@ -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
/// </summary>
public ILoaderResults LoaderResults { get; set; }
public ForcesResult()
public ForcesTupleResult()
{
DesignForceTuple = new DesignForceTuple();
}

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculator.cs
View File

@@ -14,6 +14,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
List<CalcTerms> CalcTermsList { get; }
List<LimitStates> LimitStatesList { get; }
ICompressedMember CompressedMember { get; }
IAccuracy Accuracy { get; }
IAccuracy Accuracy { get; set; }
}
}

13
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs Normal file
View File

@@ -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
{
}
}

18
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs Normal file
View File

@@ -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<INdm> NdmCollection { get; set; }
IForceTuple Tuple { get; set; }
IAccuracy Accuracy { get; set; }
}
}

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesResults.cs
View File

@@ -5,7 +5,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
public interface IForcesResults : INdmResult
{
string Desctription { get; set; }
List<ForcesResult> ForcesResultList { get; }
List<IForcesTupleResult> ForcesResultList { get; }
bool IsValid { get; set; }
}
}

11
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForcesTupleResult.cs Normal file
View File

@@ -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; }
}
}

177
StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs Normal file
View File

@@ -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<INdm> ndmCollection;
private List<INdm> concreteNdms;
private List<INdm> 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<INdmPrimitive> 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();
}
}
}

29
StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingOptions.cs Normal file
View File

@@ -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
{
/// <inheritdoc/>
internal class ConcreteBucklingOptions : IConcreteBucklingOptions
{
/// <inheritdoc/>
public IForceTuple LongTermTuple { get; set; }
/// <inheritdoc/>
public ICompressedMember CompressedMember { get; set; }
/// <inheritdoc/>
public LimitStates LimitState { get; set; }
/// <inheritdoc/>
public CalcTerms CalcTerm { get; set; }
/// <inheritdoc/>
public IEnumerable<INdmPrimitive> Primitives { get; set; }
/// <inheritdoc/>
public IForceTuple CalcForceTuple { get; set; }
}
}

21
StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingResult.cs Normal file
View File

@@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Buckling
{
/// <inheritdoc/>
public class ConcreteBucklingResult : IConcreteBucklingResult
{
/// <inheritdoc/>
public bool IsValid { get; set; }
/// <inheritdoc/>
public string Desctription { get; set; }
/// <inheritdoc/>
public double EtaFactorAlongX { get; set; }
/// <inheritdoc/>
public double EtaFactorAlongY { get; set; }
}
}

16
StructureHelperLogics/NdmCalculations/Buckling/ConstDeltaELogic.cs Normal file
View File

@@ -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;
}
}
}

16
StructureHelperLogics/NdmCalculations/Buckling/ConstPhiLLogic.cs Normal file
View File

@@ -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;
}
}
}

23
StructureHelperLogics/NdmCalculations/Buckling/CriticalForceSP63Logic.cs Normal file
View File

@@ -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();
}
}
}

36
StructureHelperLogics/NdmCalculations/Buckling/DeltaELogicSP63.cs Normal file
View File

@@ -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;
}
}
}

35
StructureHelperLogics/NdmCalculations/Buckling/EilerCriticalForceLogic.cs Normal file
View File

@@ -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;
}
}
}

21
StructureHelperLogics/NdmCalculations/Buckling/IBucklingOptions.cs Normal file
View File

@@ -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<INdmPrimitive> Primitives { get; }
IForceTuple CalcForceTuple { get; }
}
}

15
StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingCalculator.cs Normal file
View File

@@ -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; }
}
}

15
StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingOptions.cs Normal file
View File

@@ -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; }
}
}

24
StructureHelperLogics/NdmCalculations/Buckling/IConcreteBucklingResult.cs Normal file
View File

@@ -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
{
/// <summary>
/// Results of calculation of buckling of reinforced concrete section
/// </summary>
public interface IConcreteBucklingResult : INdmResult
{
/// <summary>
/// Factor of increasing of bending moment (p-delta effect) in the plain XOZ
/// </summary>
double EtaFactorAlongX { get; set; }
/// <summary>
/// Factor of increasing of bending moment (p-delta effect) in the plain YOZ
/// </summary>
double EtaFactorAlongY { get; set; }
}
}

13
StructureHelperLogics/NdmCalculations/Buckling/IConcreteDeltaELogic.cs Normal file
View File

@@ -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();
}
}

13
StructureHelperLogics/NdmCalculations/Buckling/IConcretePhiLLogic.cs Normal file
View File

@@ -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();
}
}

14
StructureHelperLogics/NdmCalculations/Buckling/ICriticalBucklingForceLogic.cs Normal file
View File

@@ -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();
}
}

16
StructureHelperLogics/NdmCalculations/Buckling/IEilerCriticalForceLogic.cs Normal file
View File

@@ -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; }
}
}

14
StructureHelperLogics/NdmCalculations/Buckling/IRCStiffnessLogic.cs Normal file
View File

@@ -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();
}
}

41
StructureHelperLogics/NdmCalculations/Buckling/PhiLogicSP63.cs Normal file
View File

@@ -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);
}
}
}

33
StructureHelperLogics/NdmCalculations/Buckling/RCStiffnessLogicSP63.cs Normal file
View File

@@ -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);
}
}
}