261 lines
12 KiB
C#
261 lines
12 KiB
C#
using LoaderCalculator.Data.Materials;
|
|
using LoaderCalculator.Data.Ndms;
|
|
using LoaderCalculator.Logics;
|
|
using LoaderCalculator.Logics.Geometry;
|
|
using StructureHelperCommon.Infrastructures.Enums;
|
|
using StructureHelperCommon.Models;
|
|
using StructureHelperCommon.Models.Calculators;
|
|
using StructureHelperCommon.Models.Forces;
|
|
using StructureHelperCommon.Models.Loggers;
|
|
using StructureHelperCommon.Models.Shapes;
|
|
using StructureHelperLogics.Models.Materials;
|
|
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
|
|
using StructureHelperLogics.NdmCalculations.Primitives;
|
|
using StructureHelperLogics.Services;
|
|
using StructureHelperLogics.Services.NdmPrimitives;
|
|
|
|
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;
|
|
private ITriangulatePrimitiveLogic triangulateLogic;
|
|
|
|
public string Name { get; set; }
|
|
|
|
public IResult Result { get; private set; }
|
|
|
|
public IAccuracy Accuracy { get; set; }
|
|
public Action<IResult> ActionToOutputResults { get; set; }
|
|
public IShiftTraceLogger? TraceLogger { get; set; }
|
|
|
|
private (double EtaAlongX, double EtaAlongY) GetBucklingCoefficients()
|
|
{
|
|
var (DX, DY) = GetStiffness();
|
|
criticalForceLogic.LongitudinalForce = options.CalcForceTuple.Nz;
|
|
criticalForceLogic.StiffnessEI = DX;
|
|
criticalForceLogic.DesignLength = options.CompressedMember.GeometryLength * options.CompressedMember.LengthFactorY;
|
|
var etaAlongY = criticalForceLogic.GetEtaFactor();
|
|
criticalForceLogic.StiffnessEI = 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;
|
|
triangulateLogic = new TriangulatePrimitiveLogic()
|
|
{
|
|
Primitives = allPrimitives,
|
|
LimitState = options.LimitState,
|
|
CalcTerm = options.CalcTerm
|
|
};
|
|
ndmCollection = triangulateLogic.GetNdms();
|
|
concreteNdms = ndmCollection.Where(x => x.Material is ICrackMaterial).ToList();
|
|
otherNdms = ndmCollection.Except(concreteNdms).ToList();
|
|
}
|
|
|
|
public void Run()
|
|
{
|
|
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
|
|
TraceLogger?.AddMessage(LoggerStrings.MethodBasedOn + "SP63.13330.2018");
|
|
var checkResult = CheckInputData();
|
|
if (checkResult != "")
|
|
{
|
|
ProcessFalseResult(checkResult);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
ProcessValidResult();
|
|
}
|
|
TraceLogger?.AddMessage(LoggerStrings.CalculationHasDone);
|
|
}
|
|
|
|
private void ProcessValidResult()
|
|
{
|
|
var phiLLogic = GetPhiLogic();
|
|
var (DeltaLogicAboutX, DeltaLogicAboutY) = GetDeltaLogics();
|
|
stiffnessLogicX = new RCStiffnessLogicSP63(phiLLogic, DeltaLogicAboutX);
|
|
stiffnessLogicY = new RCStiffnessLogicSP63(phiLLogic, DeltaLogicAboutY);
|
|
if (TraceLogger is not null)
|
|
{
|
|
stiffnessLogicX.TraceLogger = TraceLogger.GetSimilarTraceLogger(50);
|
|
stiffnessLogicY.TraceLogger = TraceLogger.GetSimilarTraceLogger(50);
|
|
}
|
|
criticalForceLogic = new EilerCriticalForceLogic();
|
|
if (TraceLogger is not null)
|
|
{
|
|
criticalForceLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(50);
|
|
}
|
|
|
|
var (EtaFactorX, EtaFactorY) = GetBucklingCoefficients();
|
|
var messageString = "Eta factor orbitrary {0} axis, Eta{0} = {1} (dimensionless)";
|
|
var messageStringX = string.Format(messageString, "X", EtaFactorX);
|
|
var messageStringY = string.Format(messageString, "Y", EtaFactorY);
|
|
TraceLogger?.AddMessage(messageStringX);
|
|
TraceLogger?.AddMessage(messageStringY);
|
|
Result = new ConcreteBucklingResult()
|
|
{
|
|
IsValid = true,
|
|
EtaFactorAlongX = EtaFactorX,
|
|
EtaFactorAlongY = EtaFactorY
|
|
};
|
|
}
|
|
|
|
private void ProcessFalseResult(string checkResult)
|
|
{
|
|
TraceLogger?.AddMessage(checkResult, TraceLogStatuses.Error);
|
|
Result = new ConcreteBucklingResult()
|
|
{
|
|
IsValid = false,
|
|
Description = checkResult,
|
|
EtaFactorAlongX = double.PositiveInfinity,
|
|
EtaFactorAlongY = double.PositiveInfinity
|
|
};
|
|
}
|
|
|
|
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;
|
|
const string eccMesssage = "Eccentricity along {0}-axis e{0} = {1}(N * m) / {2}(N) = {3}(m)";
|
|
TraceLogger?.AddMessage(string.Format(eccMesssage,
|
|
"x",
|
|
options.CalcForceTuple.My, forceTuple.Nz,
|
|
eccentricityAlongX));
|
|
TraceLogger?.AddMessage(string.Format(eccMesssage,
|
|
"y",
|
|
options.CalcForceTuple.Mx, forceTuple.Nz,
|
|
eccentricityAlongY));
|
|
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);
|
|
if (TraceLogger is not null)
|
|
{
|
|
DeltaElogicAboutX.TraceLogger = TraceLogger.GetSimilarTraceLogger(50);
|
|
DeltaElogicAboutY.TraceLogger = TraceLogger.GetSimilarTraceLogger(50);
|
|
}
|
|
return (DeltaElogicAboutX, DeltaElogicAboutY);
|
|
}
|
|
|
|
private (double DX, double DY) GetStiffness()
|
|
{
|
|
const string sumStif = "Summary stiffness";
|
|
var gravityCenter = GeometryOperations.GetGravityCenter(ndmCollection);
|
|
string message = string.Format("Gravity center, x = {0}(m), y = {1}(m)", gravityCenter.Cx, gravityCenter.Cy);
|
|
TraceLogger?.AddMessage(message);
|
|
if (TraceLogger is not null)
|
|
{
|
|
TraceLogger.AddMessage(string.Intern("Concrete elementary parts"));
|
|
TraceService.TraceNdmCollection(TraceLogger, concreteNdms);
|
|
TraceLogger.AddMessage(string.Intern("Nonconcrete elementary parts"));
|
|
TraceService.TraceNdmCollection(TraceLogger, otherNdms);
|
|
}
|
|
|
|
var (EIx, EIy) = GeometryOperations.GetReducedMomentsOfInertia(concreteNdms, gravityCenter);
|
|
TraceLogger?.AddMessage(string.Format("{0} of concrete parts EIx,c = {1}", sumStif, EIx));
|
|
TraceLogger?.AddMessage(string.Format("{0} of concrete parts EIy,c = {1}", sumStif, EIy));
|
|
var otherInertia = GeometryOperations.GetReducedMomentsOfInertia(otherNdms, gravityCenter);
|
|
TraceLogger?.AddMessage(string.Format("{0} of nonconcrete parts EIx,s = {1}", sumStif, otherInertia.EIx));
|
|
TraceLogger?.AddMessage(string.Format("{0} of nonconcrete parts EIy,s = {1}", sumStif, otherInertia.EIy));
|
|
|
|
var (Kc, Ks) = stiffnessLogicX.GetStiffnessCoeffitients();
|
|
var dX = Kc * EIx + Ks * otherInertia.EIx;
|
|
string mesDx = string.Format("{0} Dx = Kc * EIx,c + Ks * EIx,s = {1} * {2} + {3} * {4} = {5}",
|
|
sumStif, Kc, EIx, Ks, otherInertia.EIx, dX);
|
|
TraceLogger?.AddMessage(mesDx);
|
|
|
|
var stiffnessY = stiffnessLogicY.GetStiffnessCoeffitients();
|
|
var dY = stiffnessY.Kc * EIy + stiffnessY.Ks * otherInertia.EIy;
|
|
string mesDy = string.Format("{0} Dy = Kc * EIy,c + Ks * EIy,s = {1} * {2} + {3} * {4} = {5}",
|
|
sumStif, stiffnessY.Kc, EIy, stiffnessY.Ks, otherInertia.EIy, dY);
|
|
TraceLogger?.AddMessage(mesDy);
|
|
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 };
|
|
}
|
|
}
|
|
TraceLogger?.AddMessage(string.Format("Most tensioned (minimum compressed) point: x = {0}, y = {1}", point.X, point.Y));
|
|
TraceLogger?.AddMessage(string.Format("Strain: epsilon = {0}", maxStrain), TraceLogStatuses.Debug);
|
|
return point;
|
|
}
|
|
|
|
private IForceTupleCalculator GetForceCalculator()
|
|
{
|
|
var tuple = options.CalcForceTuple;
|
|
IForceTupleInputData inputData = new ForceTupleInputData()
|
|
{
|
|
NdmCollection = ndmCollection,
|
|
Tuple = tuple, Accuracy = Accuracy
|
|
};
|
|
IForceTupleCalculator calculator = new ForceTupleCalculator() { InputData = inputData };
|
|
return calculator;
|
|
}
|
|
|
|
|
|
|
|
private string CheckInputData()
|
|
{
|
|
string result = "";
|
|
var tuple = options.CalcForceTuple;
|
|
if (tuple.Nz >= 0d)
|
|
{
|
|
result += $"Force Nz = {tuple.Nz} must negative in compression";
|
|
return result;
|
|
}
|
|
IForceTupleCalculator calculator = GetForceCalculator();
|
|
calculator.Run();
|
|
forcesResults = calculator.Result as IForcesTupleResult;
|
|
if (forcesResults.IsValid != true)
|
|
{
|
|
result += "Bearind capacity of cross-section is not enough for initial forces\n";
|
|
TraceLogger?.AddMessage("Initial forces", TraceLogStatuses.Error);
|
|
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tuple));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public object Clone()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
}
|