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

Change curvature calculator

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-11-29 21:43:00 +05:00
parent 5daa32a954
commit f381229a63
73 changed files with 1361 additions and 406 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs
View File

@@ -1,9 +1,6 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
@@ -41,6 +38,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
public void Run()
{
TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
PrepareNewResult();
if (CheckInputData() == false) {return;}
GetResultByLogic();

53
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculator.cs
View File

@@ -10,6 +10,13 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
public class CurvatureForceCalculator : ICurvatureForceCalculator
{
private CurvatureForceCalculatorResult result;
private ICurvatureTermCalculator calculator;
public CurvatureForceCalculator(IShiftTraceLogger? traceLogger)
{
TraceLogger = traceLogger;
}
public ICurvatureForceCalculatorInputData InputData { get; set; }
public IResult Result => result;
@@ -25,39 +32,36 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
public void Run()
{
TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
PrepareResult();
if (CheckForCracks(InputData.ShortTermTuple, CalcTerms.ShortTerm) || CheckForCracks(InputData.ShortTermTuple, CalcTerms.ShortTerm))
try
{
ProcessCrackedSection();
if (CheckForCracks(InputData.ForcePair.FullForceTuple, CalcTerms.ShortTerm) || CheckForCracks(InputData.ForcePair.LongForceTuple, CalcTerms.ShortTerm))
{
TraceLogger?.AddMessage($"Section is cracked");
calculator = new CurvatureTermCrackedCalculator(TraceLogger) { InputData = InputData };
}
else
{
TraceLogger?.AddMessage($"Section is not cracked");
calculator = new CurvatureTermUncrackedCalculator(TraceLogger) { InputData = InputData };
}
}
else
catch (Exception ex)
{
ProcessUncrackedSection();
result.IsValid = false;
result.Description += ex.Message;
result.Description += $"\n Check bearing capacity for action {InputData.ForcePair.Name}, probably section has been collapsed";
return;
}
}
private void ProcessCrackedSection()
{
throw new NotImplementedException();
}
private void ProcessUncrackedSection()
{
CurvatureTermCalculatorInputData inputData = new()
{
Primitives = InputData.Primitives,
DeflectionFactor = InputData.DeflectionFactor
};
var calculator = new CurvatureTermUncrackedCalculator() { InputData = inputData };
inputData.ForceTuple = InputData.LongTermTuple;
inputData.CalculationTerm = CalcTerms.LongTerm;
calculator.Run();
var calcResult = calculator.Result as CurvatureTermCalculatorResult;
var calcResult = calculator.Result as ICurvatureSectionResult;
if (calcResult.IsValid == false)
{
result.IsValid = false;
}
result.LongTermResult = calcResult;
result.SectionResult = calcResult;
}
private bool CheckForCracks(IForceTuple forceTuple, CalcTerms calcTerm)
@@ -81,7 +85,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
private void PrepareResult()
{
result = new();
result = new()
{
InputData = InputData,
};
}
}
}

3
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorInputData.cs
View File

@@ -5,8 +5,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureForceCalculatorInputData : ICurvatureForceCalculatorInputData
{
public IForceTuple LongTermTuple { get; set; }
public IForceTuple ShortTermTuple { get; set; }
public IDesignForcePair ForcePair { get; set; }
public List<INdmPrimitive> Primitives { get; set; } = [];
public IDeflectionFactor DeflectionFactor { get; set; }
}

3
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorResult.cs
View File

@@ -7,8 +7,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
public class CurvatureForceCalculatorResult : ICurvatureForceCalculatorResult
{
public ICurvatureForceCalculatorInputData InputData { get; set; }
public ICurvatureTermCalculatorResult LongTermResult { get; set; }
public ICurvatureTermCalculatorResult ShortTermResult { get; set; }
public ICurvatureSectionResult SectionResult { get; set; }
public bool IsValid { get; set; } = true;
public string? Description { get; set; } = string.Empty;
}

15
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureSectionResult.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureSectionResult : ICurvatureSectionResult
{
public ICurvatureForceCalculatorResult InputData { get; set; }
public ICurvatureTermResult LongTermResult { get; set; }
public ICurvatureTermResult ShortTermResult { get; set; }
public bool IsValid { get; set; } = true;
public string? Description { get; set; } = string.Empty;
}
}

35
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalcualtor.cs
View File

@@ -1,35 +0,0 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureTermCalcualtor : ICurvatureTermCalculator
{
private ICurvatureTermCalculatorResult result;
public ICurvatureTermCalculatorInputData InputData { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public Guid Id { get; }
public CurvatureTermCalcualtor(Guid id)
{
Id = id;
}
public object Clone()
{
throw new NotImplementedException();
}
public void Run()
{
throw new NotImplementedException();
}
}
}

16
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorResult.cs
View File

@@ -1,16 +0,0 @@
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureTermCalculatorResult : ICurvatureTermCalculatorResult
{
public ICurvatureTermCalculatorInputData InputData { get; set; }
public IForceTuple CurvatureValues { get; set; }
public IForceTuple Deflections { get; set; }
public bool IsValid { get; set; } = true;
public string? Description { get; set; } = string.Empty;
}
}

96
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCrackedCalculator.cs Normal file
View File

@@ -0,0 +1,96 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Cracking;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureTermCrackedCalculator : ICurvatureTermCalculator
{
private CurvatureSectionResult result;
private IGetTermDeflectionLogic deflectionLogic;
private IGetTermDeflectionLogic DeflectionLogic => deflectionLogic ??= new GetTermDeflectionLogic(TraceLogger);
private ICrackedSectionTriangulationLogic triangulationLogic;
private List<INdm> crackableNdms;
public CurvatureTermCrackedCalculator(IShiftTraceLogger? traceLogger)
{
TraceLogger = traceLogger;
}
public ICurvatureForceCalculatorInputData InputData { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public Guid Id => throw new NotImplementedException();
public object Clone()
{
throw new NotImplementedException();
}
public void Run()
{
TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
DeflectionLogic.DeflectionFactor = InputData.DeflectionFactor;
PrepareNewResult();
TraceLogger?.AddMessage($"Long term calculation");
Triangulate(CalcTerms.LongTerm);
ICrackForceResult? longCalcResult = GetCrackedResult(InputData.ForcePair.LongForceTuple);
if (result.IsValid == false) { return; }
DeflectionLogic.LongCurvature = longCalcResult.ReducedStrainTuple;
result.LongTermResult = DeflectionLogic.GetLongResult();
TraceLogger?.AddMessage($"Short term calculation");
Triangulate(CalcTerms.ShortTerm);
ICrackForceResult? shortFullCalcResult = GetCrackedResult(InputData.ForcePair.FullForceTuple);
if (result.IsValid == false) { return; }
DeflectionLogic.ShortFullCurvature = shortFullCalcResult.ReducedStrainTuple;
ICrackForceResult? shortLongCalcResult = GetCrackedResult(InputData.ForcePair.LongForceTuple);
if (result.IsValid == false) { return; }
DeflectionLogic.ShortLongCurvature = shortLongCalcResult.ReducedStrainTuple;
result.ShortTermResult = DeflectionLogic.GetShortResult();
}
private ICrackForceResult GetCrackedResult(IForceTuple forceTuple)
{
CrackForceCalculatorInputData inputData = new()
{
EndTuple = forceTuple,
CheckedNdmCollection = crackableNdms,
SectionNdmCollection = crackableNdms,
};
CrackForceBynarySearchCalculator calculator = new()
{
InputData = inputData,
TraceLogger = TraceLogger
};
calculator.Run();
var longCalcResult = calculator.Result as ICrackForceResult;
if (longCalcResult.IsValid == false)
{
result.IsValid = false;
result.Description += longCalcResult.Description;
}
return longCalcResult;
}
private void Triangulate(CalcTerms calcTerm)
{
triangulationLogic = new CrackedSectionTriangulationLogic(InputData.Primitives, calcTerm)
{
//TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
crackableNdms = triangulationLogic.GetNdmCollection();
}
private void PrepareNewResult()
{
result = new();
}
}
}

16
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermResult.cs Normal file
View File

@@ -0,0 +1,16 @@
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureTermResult : ICurvatureTermResult
{
public bool IsValid { get; set; } = true;
public string? Description { get; set; } = string.Empty;
public IDeflectionResult DeflectionMx { get; set; } = new DeflectionResult();
public IDeflectionResult DeflectionMy { get; set; } = new DeflectionResult();
public IDeflectionResult DeflectionNz { get; set; } = new DeflectionResult();
}
}

95
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermUncrackedCalculator.cs
View File

@@ -6,18 +6,23 @@ using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.Services.NdmPrimitives;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureTermUncrackedCalculator : ICurvatureTermCalculator
{
private CurvatureTermCalculatorResult result;
private List<INdm> ndms;
private CurvatureSectionResult result;
private IGetTermDeflectionLogic deflectionLogic;
private IGetTermDeflectionLogic DeflectionLogic => deflectionLogic ??= new GetTermDeflectionLogic(TraceLogger);
private List<INdm> longTermNdms;
private List<INdm> shortTermNdms;
public ICurvatureTermCalculatorInputData InputData { get; set; }
public CurvatureTermUncrackedCalculator(IShiftTraceLogger? traceLogger)
{
TraceLogger = traceLogger;
}
public ICurvatureForceCalculatorInputData InputData { get; set; }
public IResult Result => result;
@@ -37,29 +42,30 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
Calculate();
}
private void TriangulatePrimitives()
{
longTermNdms = TriangulatePrimitives(CalcTerms.LongTerm);
shortTermNdms = TriangulatePrimitives(CalcTerms.ShortTerm);
}
private void Calculate()
{
try
{
var inputData = new ForceTupleInputData()
{
NdmCollection = ndms,
ForceTuple = InputData.ForceTuple
};
var calculator = new ForceTupleCalculator()
{
InputData = inputData,
};
calculator.Run();
var calcResult = calculator.Result as IForceTupleCalculatorResult;
if (calcResult.IsValid != true)
{
result.IsValid = false;
result.Description += calcResult.Description;
return;
}
result.CurvatureValues = ForceTupleConverter.ConvertToForceTuple(calcResult.LoaderResults.StrainMatrix);
ConvertCurvaturesToDeflections();
DeflectionLogic.DeflectionFactor = InputData.DeflectionFactor;
IForceTupleCalculatorResult? longCalcResult = GetCalculatorResult(longTermNdms, InputData.ForcePair.LongForceTuple);
if (CheckCalcResul(longCalcResult) == false) { return; }
DeflectionLogic.LongCurvature = ForceTupleConverter.ConvertToForceTuple(longCalcResult.LoaderResults.StrainMatrix);
result.LongTermResult = DeflectionLogic.GetLongResult();
IForceTupleCalculatorResult? shortFullCalcResult = GetCalculatorResult(shortTermNdms, InputData.ForcePair.FullForceTuple);
if (CheckCalcResul(shortFullCalcResult) == false) { return; }
DeflectionLogic.ShortFullCurvature = ForceTupleConverter.ConvertToForceTuple(shortFullCalcResult.LoaderResults.StrainMatrix);
IForceTupleCalculatorResult? shortLongCalcResult = GetCalculatorResult(shortTermNdms, InputData.ForcePair.LongForceTuple);
if (CheckCalcResul(shortLongCalcResult) == false) { return; }
DeflectionLogic.ShortLongCurvature = ForceTupleConverter.ConvertToForceTuple(shortLongCalcResult.LoaderResults.StrainMatrix);
result.ShortTermResult = DeflectionLogic.GetShortResult();
}
catch (Exception ex)
{
@@ -68,26 +74,45 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
}
}
private void ConvertCurvaturesToDeflections()
private bool CheckCalcResul(IForceTupleCalculatorResult? calcResult)
{
ForceTuple deflections = new();
double spanLength = InputData.DeflectionFactor.SpanLength;
deflections.Mx = InputData.DeflectionFactor.DeflectionFactors.Mx * result.CurvatureValues.Mx * spanLength * spanLength;
deflections.My = InputData.DeflectionFactor.DeflectionFactors.My * result.CurvatureValues.My * spanLength * spanLength;
deflections.Nz = InputData.DeflectionFactor.DeflectionFactors.Nz * result.CurvatureValues.Nz * spanLength;
result.Deflections = deflections;
if (calcResult.IsValid != true)
{
result.IsValid = false;
result.Description += calcResult.Description;
return false;
}
return true;
}
private void TriangulatePrimitives()
private IForceTupleCalculatorResult? GetCalculatorResult(List<INdm> ndms, IForceTuple forceTuple)
{
var inputData = new ForceTupleInputData()
{
NdmCollection = ndms,
ForceTuple = forceTuple
};
var calculator = new ForceTupleCalculator()
{
InputData = inputData,
};
calculator.Run();
var calcResult = calculator.Result as IForceTupleCalculatorResult;
return calcResult;
}
private List<INdm> TriangulatePrimitives(CalcTerms calcTerm)
{
var triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = InputData.Primitives,
LimitState = LimitStates.SLS,
CalcTerm = InputData.CalculationTerm,
CalcTerm = calcTerm,
TraceLogger = TraceLogger
};
ndms = triangulateLogic.GetNdms();
return triangulateLogic.GetNdms();
}
private void PrepareNewResult()

15
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/DeflectionResult.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class DeflectionResult : IDeflectionResult
{
public double UltimateDeflection { get; set; } = 0.0;
public double Curvature { get; set; } = 0.0;
public double Deflection { get; set; } = 0.0;
public bool IsDeflectionLessThanUltimate => Math.Abs(Deflection) <= Math.Abs(UltimateDeflection);
}
}

3
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorInputData.cs
View File

@@ -6,8 +6,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureForceCalculatorInputData : IInputData, IHasPrimitives
{
IForceTuple LongTermTuple { get; set; }
IForceTuple ShortTermTuple { get; set; }
IDesignForcePair ForcePair {get;set;}
IDeflectionFactor DeflectionFactor { get; set; }
}
}

3
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs
View File

@@ -5,7 +5,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
public interface ICurvatureForceCalculatorResult : IResult
{
ICurvatureForceCalculatorInputData InputData { get; set; }
ICurvatureTermCalculatorResult LongTermResult { get; set; }
ICurvatureTermCalculatorResult ShortTermResult { get; set; }
ICurvatureSectionResult SectionResult { get; set; }
}
}

14
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureSectionResult.cs Normal file
View File

@@ -0,0 +1,14 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureSectionResult : IResult
{
ICurvatureForceCalculatorResult InputData { get; set; }
ICurvatureTermResult LongTermResult { get; set; }
ICurvatureTermResult ShortTermResult { get; set; }
}
}

2
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculator.cs
View File

@@ -7,6 +7,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureTermCalculator : ILogicCalculator
{
ICurvatureTermCalculatorInputData InputData { get; set; }
ICurvatureForceCalculatorInputData InputData { get; set; }
}
}

13
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorResult.cs
View File

@@ -1,13 +0,0 @@
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureTermCalculatorResult : IResult
{
ICurvatureTermCalculatorInputData InputData { get; set; }
IForceTuple CurvatureValues { get; set; }
IForceTuple Deflections { get; set; }
}
}

13
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermResult.cs Normal file
View File

@@ -0,0 +1,13 @@
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureTermResult : IResult
{
IDeflectionResult DeflectionMx { get; set; }
IDeflectionResult DeflectionMy { get; set; }
IDeflectionResult DeflectionNz { get; set; }
}
}

14
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/IDeflectionResult.cs Normal file
View File

@@ -0,0 +1,14 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface IDeflectionResult
{
double UltimateDeflection { get; set; }
double Curvature { get; set; }
double Deflection { get; set; }
bool IsDeflectionLessThanUltimate { get; }
}
}

8
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataCheckLogic.cs
View File

@@ -24,8 +24,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
TraceLogger = traceLogger;
CheckRebarPrimitiveLogic checkRebarPrimitiveLogic = new()
{
CheckRebarHostMaterial = false,
CheckRebarPlacement = false
CheckRebarHostMaterial = true,
CheckRebarPlacement = true
};
primitivesCheckLogic = new HasPrimitivesCheckLogic(TraceLogger, checkRebarPrimitiveLogic);
}
@@ -39,12 +39,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
TraceMessage(errorString);
throw new StructureHelperException(errorString);
}
if (Entity.Primitives is null || !Entity.Primitives.Any())
if (Entity.Primitives is null || Entity.Primitives.Count == 0)
{
TraceMessage("Calculator does not contain any primitives");
result = false;
}
if (Entity.ForceActions is null || !Entity.ForceActions.Any())
if (Entity.ForceActions is null || Entity.ForceActions.Count == 0)
{
TraceMessage("Calculator does not contain any forces");
result = false;

88
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs
View File

@@ -3,36 +3,88 @@ using StructureHelperCommon.Services;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorInputDataUpdateStrategy : IParentUpdateStrategy<ICurvatureCalculatorInputData>
/// <summary>
/// Provides an update strategy for <see cref="ICurvatureCalculatorInputData"/>,
/// allowing transfer of child collections and nested objects from a source
/// instance to a target instance.
/// </summary>
public class CurvatureCalculatorInputDataUpdateStrategy
: IParentUpdateStrategy<ICurvatureCalculatorInputData>
{
private IUpdateStrategy<IDeflectionFactor> deflectionUpdateStrategy;
private IUpdateStrategy<IDeflectionFactor> DeflectionUpdateStrategy => deflectionUpdateStrategy ??= new DeflectionFactorUpdateStrategy();
private IUpdateStrategy<IDeflectionFactor>? _deflectionUpdateStrategy;
/// <summary>
/// Gets the strategy used to update the <see cref="IDeflectionFactor"/> object.
/// Lazily initialized to <see cref="DeflectionFactorUpdateStrategy"/> if none supplied.
/// </summary>
private IUpdateStrategy<IDeflectionFactor> DeflectionUpdateStrategy =>
_deflectionUpdateStrategy ??= new DeflectionFactorUpdateStrategy();
/// <summary>
/// When true, the children's data (collections and nested objects)
/// will be updated from the source. Defaults to true.
/// </summary>
public bool UpdateChildren { get; set; } = true;
public void Update(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject)
/// <summary>
/// Creates a new instance of the update strategy.
/// </summary>
/// <param name="deflectionUpdateStrategy">
/// Optional custom update strategy for <see cref="IDeflectionFactor"/>.
/// </param>
public CurvatureCalculatorInputDataUpdateStrategy(
IUpdateStrategy<IDeflectionFactor>? deflectionUpdateStrategy = null)
{
CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject));
CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
if (ReferenceEquals(targetObject, sourceObject))
_deflectionUpdateStrategy = deflectionUpdateStrategy;
}
/// <inheritdoc />
public void Update(ICurvatureCalculatorInputData target, ICurvatureCalculatorInputData source)
{
CheckObject.ThrowIfNull(source, nameof(source));
CheckObject.ThrowIfNull(target, nameof(target));
if (ReferenceEquals(target, source))
return;
if (UpdateChildren == true)
if (UpdateChildren)
{
CheckProperties(targetObject, sourceObject);
targetObject.Primitives.Clear();
targetObject.Primitives.AddRange(sourceObject.Primitives);
targetObject.ForceActions.Clear();
targetObject.ForceActions.AddRange(sourceObject.ForceActions);
ValidateChildProperties(target, source);
UpdateCollections(target, source);
DeflectionUpdateStrategy.Update(target.DeflectionFactor, source.DeflectionFactor);
}
}
private static void CheckProperties(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject)
/// <summary>
/// Validates that all required child properties are not null.
/// </summary>
private static void ValidateChildProperties(
ICurvatureCalculatorInputData target,
ICurvatureCalculatorInputData source)
{
CheckObject.ThrowIfNull(sourceObject.Primitives);
CheckObject.ThrowIfNull(targetObject.Primitives);
CheckObject.ThrowIfNull(sourceObject.ForceActions);
CheckObject.ThrowIfNull(targetObject.ForceActions);
CheckObject.ThrowIfNull(source.Primitives, nameof(source.Primitives));
CheckObject.ThrowIfNull(target.Primitives, nameof(target.Primitives));
CheckObject.ThrowIfNull(source.ForceActions, nameof(source.ForceActions));
CheckObject.ThrowIfNull(target.ForceActions, nameof(target.ForceActions));
CheckObject.ThrowIfNull(source.DeflectionFactor, nameof(source.DeflectionFactor));
CheckObject.ThrowIfNull(target.DeflectionFactor, nameof(target.DeflectionFactor));
}
/// <summary>
/// Replaces the target collections with copies of the source collections.
/// </summary>
private static void UpdateCollections(
ICurvatureCalculatorInputData target,
ICurvatureCalculatorInputData source)
{
target.Primitives.Clear();
target.Primitives.AddRange(source.Primitives);
target.ForceActions.Clear();
target.ForceActions.AddRange(source.ForceActions);
}
}
}

51
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorLogic.cs
View File

@@ -6,6 +6,7 @@ using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Sections;
using StructureHelperCommon.Models.Sections.Logics;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.Services.NdmPrimitives;
using System;
@@ -16,7 +17,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
private const LimitStates limitState = LimitStates.SLS;
private CurvatureCalculatorResult result;
private ICurvatureForceCalculator forceCalculator;
private ICurvatureForceCalculator ForceCalculator => forceCalculator ??= new CurvatureForceCalculator();
private ICurvatureForceCalculator ForceCalculator => forceCalculator ??= new CurvatureForceCalculator(TraceLogger);
private IPoint2D gravityCenter;
public ICurvatureCalculatorInputData InputData { get; set; }
@@ -27,6 +28,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
public void Run()
{
TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
TraceLogger?.AddMessage($"Bending deflection is calculated by expression delta = S * k * L ^ 2");
TraceLogger?.AddMessage($"Longitudinal deflection is calculated by expression delta = S * k * L");
PrepareNewResult();
SetGravityCenter();
try
@@ -44,30 +48,37 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
foreach (var action in InputData.ForceActions)
{
TraceLogger?.AddMessage($"Calculation for action {action.Name} has been started");
var combinationList = action.GetCombinations();
foreach (var combination in combinationList)
{
var longTuple = combination.DesignForces.Single(x => x.LimitState == limitState && x.CalcTerm == CalcTerms.LongTerm).ForceTuple;
var shortTuple = combination.DesignForces.Single(x => x.LimitState == limitState && x.CalcTerm == CalcTerms.ShortTerm).ForceTuple;
if (action.SetInGravityCenter == true)
TraceLogger?.AddMessage($"Totally {combination.DesignForces.Count} combinations has been extracted successfully");
var pairList = ForceActionService.ConvertCombinationToPairs(combination).Where(x => x.LimitState == limitState).ToList();
foreach (var pair in pairList)
{
IProcessorLogic<IForceTuple> forceLogic = new ForceTupleCopier(longTuple);
forceLogic = new ForceTupleMoveToPointDecorator(forceLogic) { Point2D = gravityCenter };
longTuple = forceLogic.GetValue();
forceLogic = new ForceTupleCopier(shortTuple);
forceLogic = new ForceTupleMoveToPointDecorator(forceLogic) { Point2D = gravityCenter };
shortTuple = forceLogic.GetValue();
pair.Name = action.Name;
TraceLogger?.AddMessage($"Calculation for combination of force {pair.Name} has been started");
if (action.SetInGravityCenter == true)
{
IProcessorLogic<IForceTuple> forceLogic = new ForceTupleCopier(pair.LongForceTuple);
forceLogic = new ForceTupleMoveToPointDecorator(forceLogic) { Point2D = gravityCenter };
pair.LongForceTuple = forceLogic.GetValue();
forceLogic = new ForceTupleCopier(pair.FullForceTuple);
forceLogic = new ForceTupleMoveToPointDecorator(forceLogic) { Point2D = gravityCenter };
pair.FullForceTuple = forceLogic.GetValue();
}
CurvatureForceCalculatorInputData forceInputData = new()
{
ForcePair = pair,
Primitives = InputData.Primitives,
DeflectionFactor = InputData.DeflectionFactor
};
ForceCalculator.InputData = forceInputData;
ForceCalculator.Run();
ICurvatureForceCalculatorResult forceResult = (ICurvatureForceCalculatorResult)ForceCalculator.Result;
result.ForceCalculatorResults.Add(forceResult);
}
CurvatureForceCalculatorInputData forceInputData = new()
{
LongTermTuple = longTuple,
ShortTermTuple = shortTuple,
Primitives = InputData.Primitives,
DeflectionFactor = InputData.DeflectionFactor
};
ForceCalculator.InputData = forceInputData;
ForceCalculator.Run();
result.ForceCalculatorResults.Add((ICurvatureForceCalculatorResult)ForceCalculator.Result);
}
}
}

3
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/DeflectionFactorUpdateStrategy.cs
View File

@@ -1,9 +1,6 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{

81
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/GetDeflectionByCurvatureLogic.cs Normal file
View File

@@ -0,0 +1,81 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class GetDeflectionByCurvatureLogic : IGetDeflectionByCurvatureLogic
{
public GetDeflectionByCurvatureLogic(IShiftTraceLogger traceLogger)
{
TraceLogger = traceLogger;
}
public IShiftTraceLogger? TraceLogger { get; set; }
public ICurvatureTermResult GetDeflection(IForceTuple curvature, IDeflectionFactor factor)
{
double L = factor.SpanLength;
TraceLogger?.AddMessage($"Span length L = {L}(m)");
var result = new CurvatureTermResult();
result.DeflectionMx = ComputeDeflection(
axisName: "X",
curvature: curvature.Mx,
k: factor.DeflectionFactors.Mx,
ultimate: factor.MaxDeflections.Mx,
spanLength: L,
isQuadratic: true);
result.DeflectionMy = ComputeDeflection(
axisName: "Y",
curvature: curvature.My,
k: factor.DeflectionFactors.My,
ultimate: factor.MaxDeflections.My,
spanLength: L,
isQuadratic: true);
result.DeflectionNz = ComputeDeflection(
axisName: "Z",
curvature: curvature.Nz,
k: factor.DeflectionFactors.Nz,
ultimate: factor.MaxDeflections.Nz,
spanLength: L,
isQuadratic: false);
return result;
}
private DeflectionResult ComputeDeflection(
string axisName,
double curvature,
double k,
double ultimate,
double spanLength,
bool isQuadratic)
{
double deflection = isQuadratic
? k * curvature * spanLength * spanLength
: k * curvature * spanLength;
string formula = isQuadratic
? $"{k} * {curvature} * ({spanLength})^2"
: $"{k} * {curvature} * {spanLength}";
TraceLogger?.AddMessage(
$"Deflection along {axisName} axis = {formula} = {deflection}(m)");
return new DeflectionResult
{
Curvature = curvature,
UltimateDeflection = ultimate,
Deflection = deflection
};
}
}
}

59
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/GetTermDeflectionLogic.cs Normal file
View File

@@ -0,0 +1,59 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Services.Forces;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
/// <summary>
/// Provides logic for calculating long-term and short-term deflection terms
/// based on curvature values and deflection factors. Uses an underlying
/// <see cref="IGetDeflectionByCurvatureLogic"/> to compute the deflection
/// for a given curvature state.
/// </summary>
public class GetTermDeflectionLogic : IGetTermDeflectionLogic
{
private IGetDeflectionByCurvatureLogic deflectionLogic;
private IGetDeflectionByCurvatureLogic DeflectionLogic => deflectionLogic ??= new GetDeflectionByCurvatureLogic(TraceLogger);
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public IForceTuple LongCurvature { get; set; }
public IForceTuple ShortLongCurvature { get; set; }
public IForceTuple ShortFullCurvature { get; set; }
public IDeflectionFactor DeflectionFactor { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public GetTermDeflectionLogic(IShiftTraceLogger traceLogger)
{
TraceLogger = traceLogger;
}
public GetTermDeflectionLogic(IGetDeflectionByCurvatureLogic deflectionLogic, IForceTupleServiceLogic forceTupleServiceLogic, IShiftTraceLogger? traceLogger)
{
this.deflectionLogic = deflectionLogic;
this.forceTupleServiceLogic = forceTupleServiceLogic;
TraceLogger = traceLogger;
}
public ICurvatureTermResult GetLongResult()
{
TraceCurvature(LongCurvature);
ICurvatureTermResult longTermDeflection = DeflectionLogic.GetDeflection(LongCurvature, DeflectionFactor);
return longTermDeflection;
}
private void TraceCurvature(IForceTuple curvature)
{
TraceLogger?.AddMessage($"Curvature kx = {curvature.Mx}(1/m), ky = {curvature.My}(1/m), epsz = {curvature.Nz}(dimensionless)");
}
public ICurvatureTermResult GetShortResult()
{
var deltaShortCurvature = ForceTupleServiceLogic.SumTuples(ShortFullCurvature, ShortLongCurvature, -1);
var shortCurvature = ForceTupleServiceLogic.SumTuples(LongCurvature, deltaShortCurvature);
TraceCurvature(shortCurvature);
ICurvatureTermResult shortTermDeflection = DeflectionLogic.GetDeflection(shortCurvature, DeflectionFactor);
return shortTermDeflection;
}
}
}

13
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/IGetDeflectionByCurvatureLogic.cs Normal file
View File

@@ -0,0 +1,13 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface IGetDeflectionByCurvatureLogic : ILogic
{
ICurvatureTermResult GetDeflection(IForceTuple curvature, IDeflectionFactor DeflectionFactor);
}
}

27
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/IGetTermDeflectionLogic.cs Normal file
View File

@@ -0,0 +1,27 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface IGetTermDeflectionLogic : ILogic
{
IDeflectionFactor DeflectionFactor { get; set; }
/// <summary>
/// Curvature of cross-section form long term load with long term properties of material
/// </summary>
IForceTuple LongCurvature { get; set; }
/// <summary>
/// Curvature of cross-section form long term load with short term properties of material
/// </summary>
IForceTuple ShortLongCurvature { get; set; }
/// <summary>
/// Curvature of cross-section form short term load with short term properties of material
/// </summary>
IForceTuple ShortFullCurvature { get; set; }
ICurvatureTermResult GetLongResult();
ICurvatureTermResult GetShortResult();
}
}