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

Add curvature calculator DTOs

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-11-23 17:19:36 +05:00
parent 7ab4909c67
commit 5daa32a954
77 changed files with 1415 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,4 +1,5 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
@@ -8,7 +9,13 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculator : ICurvatureCalculator
{
private ICurvatureCalculatorResult result;
private CurvatureCalculatorResult result;
private ICheckEntityLogic<ICurvatureCalculatorInputData> inputDataCheckLogic;
private ICurvatureCalcualtorLogic calculatorLogic;
private ICurvatureCalcualtorLogic CalculatorLogic => calculatorLogic ??= new CurvatureCalculatorLogic() { InputData = InputData, TraceLogger = TraceLogger};
private ICheckEntityLogic<ICurvatureCalculatorInputData> InputDataCheckLogic => inputDataCheckLogic ??= new CurvatureCalculatorInputDataCheckLogic(TraceLogger) { Entity = InputData};
public Guid Id { get; }
public string Name { get; set; } = string.Empty;
public ICurvatureCalculatorInputData InputData { get; set; } = new CurvatureCalculatorInputData(Guid.NewGuid());
@@ -34,7 +41,43 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
public void Run()
{
throw new NotImplementedException();
PrepareNewResult();
if (CheckInputData() == false) {return;}
GetResultByLogic();
}
private void GetResultByLogic()
{
try
{
CalculatorLogic.Run();
result = CalculatorLogic.Result as CurvatureCalculatorResult;
}
catch (Exception ex)
{
result.IsValid = false;
result.Description += ex.Message;
}
}
private void PrepareNewResult()
{
result = new()
{
IsValid = true,
InputData = InputData,
};
}
private bool CheckInputData()
{
if (InputDataCheckLogic.Check() == false)
{
result.IsValid = false;
result.Description += inputDataCheckLogic.CheckResult;
return false;
}
return true;
}
}
}

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

@@ -9,8 +9,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
public List<IForceAction> ForceActions { get; } = [];
public List<INdmPrimitive> Primitives { get; } = [];
public double DeflectionFactor { get; set; } = 0.1042;
public double SpanLength { get; set; } = 6.0;
public IDeflectionFactor DeflectionFactor { get; set; } = new DeflectionFactor(Guid.NewGuid());
public CurvatureCalculatorInputData(Guid id)
{

12
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorResult.cs Normal file
View File

@@ -0,0 +1,12 @@
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorResult : ICurvatureCalculatorResult
{
public ICurvatureCalculatorInputData InputData { get; set; }
public List<ICurvatureForceCalculatorResult> ForceCalculatorResults { get; } = [];
public bool IsValid { get; set; } = true;
public string? Description { get; set; } = string.Empty;
}
}

87
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculator.cs Normal file
View File

@@ -0,0 +1,87 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.Services.NdmPrimitives;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureForceCalculator : ICurvatureForceCalculator
{
private CurvatureForceCalculatorResult result;
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()
{
PrepareResult();
if (CheckForCracks(InputData.ShortTermTuple, CalcTerms.ShortTerm) || CheckForCracks(InputData.ShortTermTuple, CalcTerms.ShortTerm))
{
ProcessCrackedSection();
}
else
{
ProcessUncrackedSection();
}
}
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;
if (calcResult.IsValid == false)
{
result.IsValid = false;
}
result.LongTermResult = calcResult;
}
private bool CheckForCracks(IForceTuple forceTuple, CalcTerms calcTerm)
{
var triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = InputData.Primitives,
LimitState = LimitStates.SLS,
CalcTerm = calcTerm,
TraceLogger = TraceLogger
};
var ndms = triangulateLogic.GetNdms();
var logic = new IsSectionCrackedByForceLogic()
{
ForceTuple = forceTuple,
CheckedNdmCollection = ndms,
SectionNdmCollection = ndms
};
return logic.IsSectionCracked();
}
private void PrepareResult()
{
result = new();
}
}
}

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

@@ -0,0 +1,13 @@
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureForceCalculatorInputData : ICurvatureForceCalculatorInputData
{
public IForceTuple LongTermTuple { get; set; }
public IForceTuple ShortTermTuple { get; set; }
public List<INdmPrimitive> Primitives { get; set; } = [];
public IDeflectionFactor DeflectionFactor { get; set; }
}
}

15
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorResult.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 CurvatureForceCalculatorResult : ICurvatureForceCalculatorResult
{
public ICurvatureForceCalculatorInputData InputData { get; set; }
public ICurvatureTermCalculatorResult LongTermResult { get; set; }
public ICurvatureTermCalculatorResult ShortTermResult { get; set; }
public bool IsValid { get; set; } = true;
public string? Description { get; set; } = string.Empty;
}
}

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

@@ -6,10 +6,10 @@ using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureTermCalcualtor : ICurvatureTermCalcualtor
public class CurvatureTermCalcualtor : ICurvatureTermCalculator
{
private ICurvatureTermCalcualtorResult result;
public ICurvatureTermCalcualtorInputData InputData { get; set; }
private ICurvatureTermCalculatorResult result;
public ICurvatureTermCalculatorInputData InputData { get; set; }
public IResult Result => result;

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

@@ -0,0 +1,16 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureTermCalculatorInputData : ICurvatureTermCalculatorInputData
{
public IForceTuple ForceTuple { get; set; }
public CalcTerms LoadTerm { get; set; }
public CalcTerms CalculationTerm { get; set; }
public List<INdmPrimitive> Primitives { get; set; } = [];
public IDeflectionFactor DeflectionFactor { get; set; }
}
}

16
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorResult.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 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;
}
}

98
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermUncrackedCalculator.cs Normal file
View File

@@ -0,0 +1,98 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
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;
public ICurvatureTermCalculatorInputData 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()
{
PrepareNewResult();
TriangulatePrimitives();
Calculate();
}
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();
}
catch (Exception ex)
{
result.IsValid = false;
result.Description = ex.Message;
}
}
private void ConvertCurvaturesToDeflections()
{
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;
}
private void TriangulatePrimitives()
{
var triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = InputData.Primitives,
LimitState = LimitStates.SLS,
CalcTerm = InputData.CalculationTerm,
TraceLogger = TraceLogger
};
ndms = triangulateLogic.GetNdms();
}
private void PrepareNewResult()
{
result = new();
}
}
}

43
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/DeflectionFactor.cs Normal file
View File

@@ -0,0 +1,43 @@
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class DeflectionFactor : IDeflectionFactor
{
private const double bendCurveFactor = 0.1042;
private const double longitudinalFactor = 1.0;
private const double maxDeflection = 0.02;
public IForceTuple DeflectionFactors { get; set; }
public double SpanLength { get; set; } = 6.0;
public IForceTuple MaxDeflections { get; set; }
public Guid Id { get; }
public DeflectionFactor(Guid id)
{
Id = id;
DeflectionFactors = new ForceTuple()
{
Mx = bendCurveFactor,
My = bendCurveFactor,
Mz = longitudinalFactor,
Nz = longitudinalFactor,
Qx = longitudinalFactor,
Qy = longitudinalFactor
};
MaxDeflections = new ForceTuple()
{
Mx = maxDeflection,
My = maxDeflection,
Mz = maxDeflection,
Nz = maxDeflection,
Qx = maxDeflection,
Qy = maxDeflection,
};
}
}
}

10
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorInputData.cs
View File

@@ -1,15 +1,15 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
/// <summary>
/// Input data for calculator of curvature of cross-section
/// </summary>
public interface ICurvatureCalculatorInputData : IInputData, ISaveable, IHasForceActions, IHasPrimitives
{
double DeflectionFactor { get; set; }
double SpanLength { get; set; }
IDeflectionFactor DeflectionFactor { get; set; }
}
}

3
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalcualtor.cs → StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculator.cs
View File

@@ -5,7 +5,8 @@ using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureForceCalcualtor : ILogicCalculator
public interface ICurvatureForceCalculator : ILogicCalculator
{
ICurvatureForceCalculatorInputData InputData { get; set; }
}
}

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

@@ -1,14 +1,13 @@
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureForceCalculatorInputData : IInputData, IHasPrimitives
{
IDesignForceTuple DesignForceTuple { get; set; }
IForceTuple LongTermTuple { get; set; }
IForceTuple ShortTermTuple { get; set; }
IDeflectionFactor DeflectionFactor { get; set; }
}
}

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

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

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

@@ -1,13 +0,0 @@
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureTermCalcualtorResult : IResult
{
ICurvatureTermCalcualtorInputData InputData { get; set; }
IForceTuple CurvatureValue { get; set; }
IForceTuple Deflection { get; set; }
}
}

4
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtor.cs → StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculator.cs
View File

@@ -5,8 +5,8 @@ using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureTermCalcualtor : ILogicCalculator
public interface ICurvatureTermCalculator : ILogicCalculator
{
ICurvatureTermCalcualtorInputData InputData { get; set; }
ICurvatureTermCalculatorInputData InputData { get; set; }
}
}

5
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorInputData.cs → StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorInputData.cs
View File

@@ -5,10 +5,11 @@ using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureTermCalcualtorInputData : IInputData, IHasPrimitives
public interface ICurvatureTermCalculatorInputData : IInputData, IHasPrimitives
{
IForceTuple DesignForceTuple { get; set; }
IForceTuple ForceTuple { get; set; }
CalcTerms LoadTerm { get; set; }
CalcTerms CalculationTerm { get; set; }
IDeflectionFactor DeflectionFactor { get; set; }
}
}

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

@@ -0,0 +1,13 @@
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; }
}
}

24
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/IDeflectionFactor.cs Normal file
View File

@@ -0,0 +1,24 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
/// <summary>
/// Implements properties for calculation deflections
/// </summary>
public interface IDeflectionFactor : ISaveable
{
/// <summary>
/// Factors for calculating deflections, dimensionless
/// </summary>
IForceTuple DeflectionFactors { get; set; }
/// <summary>
/// Maximum deflections, metres
/// </summary>
double SpanLength { get; set; }
IForceTuple MaxDeflections { get; set; }
}
}

78
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataCheckLogic.cs Normal file
View File

@@ -0,0 +1,78 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Forces.Logics;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorInputDataCheckLogic : CheckEntityLogic<ICurvatureCalculatorInputData>
{
private ICheckEntityLogic<IHasPrimitives> primitivesCheckLogic;
private ICheckEntityLogic<IEnumerable<IForceAction>> actionsCheckLogic;
private bool result;
private ICheckEntityLogic<IEnumerable<IForceAction>> ActionsCheckLogic => actionsCheckLogic ??= new CheckForceActionsLogic(TraceLogger);
private ICheckEntityLogic<IHasPrimitives> PrimitivesCheckLogic => primitivesCheckLogic ??= new HasPrimitivesCheckLogic();
public CurvatureCalculatorInputDataCheckLogic(IShiftTraceLogger traceLogger)
{
TraceLogger = traceLogger;
CheckRebarPrimitiveLogic checkRebarPrimitiveLogic = new()
{
CheckRebarHostMaterial = false,
CheckRebarPlacement = false
};
primitivesCheckLogic = new HasPrimitivesCheckLogic(TraceLogger, checkRebarPrimitiveLogic);
}
public override bool Check()
{
result = true;
if (Entity is null)
{
string errorString = ErrorStrings.ParameterIsNull + ": curvature calculator input data";
TraceMessage(errorString);
throw new StructureHelperException(errorString);
}
if (Entity.Primitives is null || !Entity.Primitives.Any())
{
TraceMessage("Calculator does not contain any primitives");
result = false;
}
if (Entity.ForceActions is null || !Entity.ForceActions.Any())
{
TraceMessage("Calculator does not contain any forces");
result = false;
}
CheckPrimitives();
CheckActions();
return result;
}
private void CheckPrimitives()
{
PrimitivesCheckLogic.Entity = Entity;
if (PrimitivesCheckLogic.Check() == false)
{
result = false;
}
TraceMessage(PrimitivesCheckLogic.CheckResult);
}
private void CheckActions()
{
ActionsCheckLogic.Entity = Entity.ForceActions;
if (ActionsCheckLogic.Check() == false)
{
result = false;
}
TraceMessage(ActionsCheckLogic.CheckResult);
}
}
}

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

@@ -5,6 +5,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorInputDataUpdateStrategy : IParentUpdateStrategy<ICurvatureCalculatorInputData>
{
private IUpdateStrategy<IDeflectionFactor> deflectionUpdateStrategy;
private IUpdateStrategy<IDeflectionFactor> DeflectionUpdateStrategy => deflectionUpdateStrategy ??= new DeflectionFactorUpdateStrategy();
public bool UpdateChildren { get; set; } = true;
public void Update(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject)
@@ -13,19 +16,23 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
if (ReferenceEquals(targetObject, sourceObject))
return;
targetObject.DeflectionFactor = sourceObject.DeflectionFactor;
targetObject.SpanLength = sourceObject.SpanLength;
if (UpdateChildren == true)
{
CheckObject.ThrowIfNull(sourceObject.Primitives);
CheckObject.ThrowIfNull(targetObject.Primitives);
CheckProperties(targetObject, sourceObject);
targetObject.Primitives.Clear();
targetObject.Primitives.AddRange(sourceObject.Primitives);
CheckObject.ThrowIfNull(sourceObject.ForceActions);
CheckObject.ThrowIfNull(targetObject.ForceActions);
targetObject.ForceActions.Clear();
targetObject.ForceActions.AddRange(sourceObject.ForceActions);
}
}
private static void CheckProperties(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject)
{
CheckObject.ThrowIfNull(sourceObject.Primitives);
CheckObject.ThrowIfNull(targetObject.Primitives);
CheckObject.ThrowIfNull(sourceObject.ForceActions);
CheckObject.ThrowIfNull(targetObject.ForceActions);
}
}
}

99
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorLogic.cs Normal file
View File

@@ -0,0 +1,99 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Sections;
using StructureHelperCommon.Models.Sections.Logics;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.Services.NdmPrimitives;
using System;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorLogic : ICurvatureCalcualtorLogic
{
private const LimitStates limitState = LimitStates.SLS;
private CurvatureCalculatorResult result;
private ICurvatureForceCalculator forceCalculator;
private ICurvatureForceCalculator ForceCalculator => forceCalculator ??= new CurvatureForceCalculator();
private IPoint2D gravityCenter;
public ICurvatureCalculatorInputData InputData { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public void Run()
{
PrepareNewResult();
SetGravityCenter();
try
{
Calculate();
}
catch (Exception ex)
{
result.IsValid = false;
result.Description += ex.Message;
}
}
private void Calculate()
{
foreach (var action in InputData.ForceActions)
{
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)
{
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();
}
CurvatureForceCalculatorInputData forceInputData = new()
{
LongTermTuple = longTuple,
ShortTermTuple = shortTuple,
Primitives = InputData.Primitives,
DeflectionFactor = InputData.DeflectionFactor
};
ForceCalculator.InputData = forceInputData;
ForceCalculator.Run();
result.ForceCalculatorResults.Add((ICurvatureForceCalculatorResult)ForceCalculator.Result);
}
}
}
private void SetGravityCenter()
{
var triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = InputData.Primitives,
LimitState = LimitStates.ULS,
CalcTerm = CalcTerms.ShortTerm,
TraceLogger = TraceLogger
};
var ndms = triangulateLogic.GetNdms();
var (Cx, Cy) = LoaderCalculator.Logics.Geometry.GeometryOperations.GetGravityCenter(ndms);
gravityCenter = new Point2D() { X = Cx, Y = Cy };
}
private void PrepareNewResult()
{
result = new CurvatureCalculatorResult()
{
IsValid = true,
Description = string.Empty,
InputData = InputData
};
}
}
}

46
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,46 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorUpdateCloningStrategy : IUpdateStrategy<ICurvatureCalculator>
{
private readonly ICloningStrategy cloningStrategy;
private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
private IUpdateStrategy<IHasForceActions> ForcesUpdateStrategy => forcesUpdateStrategy ??= new HasForceActionUpdateCloningStrategy(cloningStrategy);
private IUpdateStrategy<IHasPrimitives> PrimitivesUpdateStrategy => primitivesUpdateStrategy ??= new HasPrimitivesUpdateCloningStrategy(cloningStrategy);
public CurvatureCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy)
{
this.cloningStrategy = cloningStrategy;
}
public CurvatureCalculatorUpdateCloningStrategy(
ICloningStrategy cloningStrategy,
IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.forcesUpdateStrategy = forcesUpdateStrategy;
this.primitivesUpdateStrategy = primitivesUpdateStrategy;
}
public void Update(ICurvatureCalculator targetObject, ICurvatureCalculator sourceObject)
{
CheckObject.ThrowIfNull(cloningStrategy);
CheckObject.ThrowIfNull(sourceObject);
CheckObject.ThrowIfNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
var sourceData = sourceObject.InputData;
var targetData = targetObject.InputData;
PrimitivesUpdateStrategy.Update(targetData, sourceData);
ForcesUpdateStrategy.Update(targetData, sourceData);
}
}
}

32
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/DeflectionFactorUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,32 @@
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
{
public class DeflectionFactorUpdateStrategy : IParentUpdateStrategy<IDeflectionFactor>
{
public bool UpdateChildren { get; set; } = true;
public void Update(IDeflectionFactor targetObject, IDeflectionFactor sourceObject)
{
CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject));
CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
if (ReferenceEquals(targetObject, sourceObject))
return;
targetObject.SpanLength = sourceObject.SpanLength;
if (UpdateChildren == true)
{
CheckObject.ThrowIfNull(sourceObject.DeflectionFactors);
CheckObject.ThrowIfNull(targetObject.DeflectionFactors);
CheckObject.ThrowIfNull(sourceObject.MaxDeflections);
CheckObject.ThrowIfNull(targetObject.MaxDeflections);
targetObject.DeflectionFactors = sourceObject.DeflectionFactors.Clone() as IForceTuple;
targetObject.MaxDeflections = sourceObject.MaxDeflections.Clone() as IForceTuple;
}
}
}
}

5
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalcualtorLogic.cs → StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/ICurvatureCalcualtorLogic.cs
View File

@@ -1,11 +1,12 @@
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
internal interface ICurvatureCalcualtorLogic
internal interface ICurvatureCalcualtorLogic : ILogic
{
ICurvatureCalculatorInputData InputData {get;set;}
IResult Result { get; }