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

Add curvature calculator

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-11-22 21:17:39 +05:00
parent 215f631bb0
commit 7ab4909c67
42 changed files with 705 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs
View File

@@ -18,7 +18,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
{
public static IStressLogic stressLogic = new StressLogic();
public IEnumerable<INdm> NdmCollection { get; set; }
public StrainTuple StrainTuple { get; set; }
public IForceTuple StrainTuple { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public StrainTuple GetSofteningFactors()

40
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs Normal file
View File

@@ -0,0 +1,40 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculator : ICurvatureCalculator
{
private ICurvatureCalculatorResult result;
public Guid Id { get; }
public string Name { get; set; } = string.Empty;
public ICurvatureCalculatorInputData InputData { get; set; } = new CurvatureCalculatorInputData(Guid.NewGuid());
public bool ShowTraceData { get; set; } = false;
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public CurvatureCalculator(Guid id)
{
Id = id;
}
public object Clone()
{
var updateStrategy = new CurvatureCalculatorUpdateStrategy();
CurvatureCalculator newItem = new(Guid.NewGuid());
updateStrategy.Update(newItem, this);
return newItem;
}
public void Run()
{
throw new NotImplementedException();
}
}
}

20
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,20 @@
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorInputData : ICurvatureCalculatorInputData
{
public Guid Id { get; }
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 CurvatureCalculatorInputData(Guid id)
{
Id = id;
}
}
}

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

@@ -0,0 +1,35 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureTermCalcualtor : ICurvatureTermCalcualtor
{
private ICurvatureTermCalcualtorResult result;
public ICurvatureTermCalcualtorInputData 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();
}
}
}

14
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalcualtorLogic.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
{
internal interface ICurvatureCalcualtorLogic
{
ICurvatureCalculatorInputData InputData {get;set;}
IResult Result { get; }
void Run();
}
}

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

@@ -0,0 +1,12 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureCalculator : ICalculator
{
ICurvatureCalculatorInputData InputData { get; set; }
}
}

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

@@ -0,0 +1,15 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureCalculatorInputData : IInputData, ISaveable, IHasForceActions, IHasPrimitives
{
double DeflectionFactor { get; set; }
double SpanLength { get; set; }
}
}

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

@@ -0,0 +1,13 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureCalculatorResult : IResult
{
ICurvatureCalculatorInputData InputData { get; set; }
List<ICurvatureForceCalculatorResult> ForceCalculatorResults { get; }
}
}

11
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalcualtor.cs Normal file
View File

@@ -0,0 +1,11 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureForceCalcualtor : ILogicCalculator
{
}
}

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

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

11
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs Normal file
View File

@@ -0,0 +1,11 @@
using StructureHelperCommon.Models.Calculators;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureForceCalculatorResult : IResult
{
ICurvatureForceCalculatorInputData InputData { get; set; }
ICurvatureTermCalcualtorResult LongTermResult { get; set; }
ICurvatureTermCalcualtorResult ShortTermResult { get; set; }
}
}

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

@@ -0,0 +1,12 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureTermCalcualtor : ILogicCalculator
{
ICurvatureTermCalcualtorInputData InputData { get; set; }
}
}

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

@@ -0,0 +1,14 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public interface ICurvatureTermCalcualtorInputData : IInputData, IHasPrimitives
{
IForceTuple DesignForceTuple { get; set; }
CalcTerms LoadTerm { get; set; }
CalcTerms CalculationTerm { get; set; }
}
}

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

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

31
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,31 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorInputDataUpdateStrategy : IParentUpdateStrategy<ICurvatureCalculatorInputData>
{
public bool UpdateChildren { get; set; } = true;
public void Update(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject)
{
CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject));
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);
targetObject.Primitives.Clear();
targetObject.Primitives.AddRange(sourceObject.Primitives);
CheckObject.ThrowIfNull(sourceObject.ForceActions);
CheckObject.ThrowIfNull(targetObject.ForceActions);
targetObject.ForceActions.Clear();
targetObject.ForceActions.AddRange(sourceObject.ForceActions);
}
}
}
}

40
StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,40 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
{
public class CurvatureCalculatorUpdateStrategy : IParentUpdateStrategy<ICurvatureCalculator>
{
private IUpdateStrategy<ICurvatureCalculatorInputData> inputDataUpdateStrategy;
private IUpdateStrategy<ICurvatureCalculatorInputData> InputDataUpdateStrategy => inputDataUpdateStrategy ??= new CurvatureCalculatorInputDataUpdateStrategy();
public CurvatureCalculatorUpdateStrategy(IUpdateStrategy<ICurvatureCalculatorInputData> inputDataUpdateStrategy)
{
this.inputDataUpdateStrategy = inputDataUpdateStrategy ?? throw new StructureHelperNullReferenceException(ErrorStrings.NullReference + ": input data of curvature calculator can not be null");
}
public CurvatureCalculatorUpdateStrategy()
{
}
public bool UpdateChildren { get; set; } = true;
public void Update(ICurvatureCalculator targetObject, ICurvatureCalculator sourceObject)
{
CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject));
CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
if (ReferenceEquals(targetObject, sourceObject))
return;
targetObject.Name = sourceObject.Name;
targetObject.ShowTraceData = sourceObject.ShowTraceData;
if (UpdateChildren == true)
{
CheckObject.ThrowIfNull(sourceObject.InputData);
CheckObject.ThrowIfNull(targetObject.InputData);
InputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData);
}
}
}
}

7
StructureHelperLogics/NdmCalculations/Analyses/Logics/CalculatorUpdateStrategy.cs
View File

@@ -5,6 +5,7 @@ using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
@@ -38,9 +39,13 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Logics
{
new ValueDiagramCalculatorUpdateStrategy().Update(diagramCalculator, (IValueDiagramCalculator)sourceObject);
}
else if (targetObject is ICurvatureCalculator curvatureCalculator)
{
new CurvatureCalculatorUpdateStrategy().Update(curvatureCalculator, (ICurvatureCalculator)sourceObject);
}
else
{
ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(INdmPrimitive), sourceObject.GetType());
ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(ICalculator), sourceObject.GetType());
}
}
}

13
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs
View File

@@ -5,18 +5,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
{
public class ValueDiagramCalculatorInputDataUpdateStrategy : IParentUpdateStrategy<IValueDiagramCalculatorInputData>
{
private IUpdateStrategy<IValueDiagramEntity> entityUpdateStrategy;
public ValueDiagramCalculatorInputDataUpdateStrategy(IUpdateStrategy<IValueDiagramEntity> entityUpdateStrategy)
{
this.entityUpdateStrategy = entityUpdateStrategy;
}
public ValueDiagramCalculatorInputDataUpdateStrategy()
{
}
public bool UpdateChildren { get; set; } = true;
public void Update(IValueDiagramCalculatorInputData targetObject, IValueDiagramCalculatorInputData sourceObject)
@@ -33,7 +21,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
targetObject.ForceActions.Clear();
targetObject.ForceActions.AddRange(sourceObject.ForceActions);
targetObject.Diagrams.Clear();
entityUpdateStrategy ??= new ValueDiagramEntityUpdateStrategy();
foreach (var entity in sourceObject.Diagrams)
{
var newItem = entity.Clone() as IValueDiagramEntity;

4
StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs
View File

@@ -148,14 +148,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
TraceLogger?.AddMessage($"Valid result was obtained", TraceLogStatuses.Debug);
}
private StrainTuple GetSofteningFactors(StrainTuple reducedStrainTuple)
private StrainTuple GetSofteningFactors(IForceTuple reducedStrainTuple)
{
softeningFactorLogic.NdmCollection = InputData.SectionNdmCollection;
softeningFactorLogic.StrainTuple = reducedStrainTuple;
return softeningFactorLogic.GetSofteningFactors();
}
private StrainTuple GetReducedStrainTuple(double factorOfCrackAppearance, double softeningFactor)
private IForceTuple GetReducedStrainTuple(double factorOfCrackAppearance, double softeningFactor)
{
const double notCrackedForceFactor = 0.99d;
var notCrackedForceTuple = ForceTupleService.InterpolateTuples(InputData.StartTuple, InputData.EndTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple;

10
StructureHelperLogics/NdmCalculations/Cracking/CrackForceResult.cs
View File

@@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// <summary>
/// Result of crack calculation
/// </summary>
public class CrackForceResult : IResult
public class CrackForceResult : ICrackForceResult
{
/// <inheritdoc/>
public bool IsValid { get; set; }
@@ -41,15 +41,15 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// <summary>
/// General curvature in cracked section
/// </summary>
public StrainTuple CrackedStrainTuple { get; set; }
public IForceTuple CrackedStrainTuple { get; set; }
/// <summary>
/// Average general curvature with considering of cracking
/// </summary>
public StrainTuple ReducedStrainTuple { get; set; }
public IForceTuple ReducedStrainTuple { get; set; }
/// <summary>
/// Factor of softening of stifness with considering of cracks
/// </summary>
public StrainTuple SofteningFactors { get; set; }
public IForceTuple SofteningFactors { get; set; }
/// <summary>
/// Collection of ndms which crack properties looking for
/// </summary>
@@ -58,6 +58,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// Common softening factor
/// </summary>
public double PsiS { get; set; }
}
}

6
StructureHelperLogics/NdmCalculations/Cracking/CrackStrainLogic.cs
View File

@@ -10,11 +10,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
internal class CrackStrainLogic : ICrackStrainLogic
{
public StrainTuple BeforeCrackingTuple { get; set; }
public StrainTuple AfterCrackingTuple { get; set; }
public IForceTuple BeforeCrackingTuple { get; set; }
public IForceTuple AfterCrackingTuple { get; set; }
public double SofteningFactor { get; set; }
public StrainTuple GetCrackedStrainTuple()
public IForceTuple GetCrackedStrainTuple()
{
var strainTuple = ForceTupleService.InterpolateTuples(BeforeCrackingTuple, AfterCrackingTuple, SofteningFactor) as StrainTuple;
return strainTuple;

21
StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculatorInputData.cs
View File

@@ -1,20 +1,29 @@
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.Cracking
{
/// <summary>
/// Implements input data for search of forces of crack appearance in some range of load
/// </summary>
public interface ICrackForceCalculatorInputData: IInputData
{
/// <summary>
/// Start tuple of range for search of forces of crack appearance
/// </summary>
IForceTuple StartTuple { get; set; }
/// <summary>
/// End tuple of range for search of forces of crack appearance
/// </summary>
IForceTuple EndTuple { get; set; }
/// <summary>
/// Collection of NdmElements for checking of crack appearance
/// </summary>
IEnumerable<INdm> CheckedNdmCollection { get; set; }
/// <summary>
/// Collection of initial NdmElements of cross-section
/// </summary>
IEnumerable<INdm> SectionNdmCollection { get; set; }
}
}

20
StructureHelperLogics/NdmCalculations/Cracking/ICrackForceResult.cs Normal file
View File

@@ -0,0 +1,20 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface ICrackForceResult : IResult
{
IForceTuple CrackedStrainTuple { get; set; }
IForceTuple EndTuple { get; set; }
double FactorOfCrackAppearance { get; set; }
bool IsSectionCracked { get; set; }
IEnumerable<INdm> NdmCollection { get; set; }
double PsiS { get; set; }
IForceTuple ReducedStrainTuple { get; set; }
IForceTuple SofteningFactors { get; set; }
IForceTuple StartTuple { get; set; }
IForceTuple TupleOfCrackAppearance { get; set; }
}
}

6
StructureHelperLogics/NdmCalculations/Cracking/ICrackStrainLogic.cs
View File

@@ -9,9 +9,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
internal interface ICrackStrainLogic
{
StrainTuple BeforeCrackingTuple { get; set; }
StrainTuple AfterCrackingTuple { get; set; }
IForceTuple BeforeCrackingTuple { get; set; }
IForceTuple AfterCrackingTuple { get; set; }
double SofteningFactor { get; set; }
StrainTuple GetCrackedStrainTuple();
IForceTuple GetCrackedStrainTuple();
}
}

16
StructureHelperLogics/Services/NdmPrimitives/ITriangulatePrimitiveLogic.cs
View File

@@ -5,11 +5,27 @@ using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.Services.NdmPrimitives
{
/// <summary>
/// Implements logic of meshing of StructureHelper NdmPrimitives to collection of Loader Indem parts
/// </summary>
public interface ITriangulatePrimitiveLogic : ILogic
{
/// <summary>
/// Collection of primitives which have to be meshed
/// </summary>
IEnumerable<INdmPrimitive> Primitives { get; set; }
/// <summary>
/// Limit state for meshing
/// </summary>
LimitStates LimitState { get; set; }
/// <summary>
/// Term (duration) of calculating for meshing
/// </summary>
CalcTerms CalcTerm { get; set; }
/// <summary>
/// Meshes collection of primitives
/// </summary>
/// <returns>List of Loader Ndm parts</returns>
List<INdm> GetNdms();
}
}

7
StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs
View File

@@ -1,16 +1,15 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models.Materials;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
namespace StructureHelperLogics.Services.NdmPrimitives
{
/// <summary>
/// Direct meshing logic
/// </summary>
public class TriangulatePrimitiveLogic : ITriangulatePrimitiveLogic
{
private IMeshHasDivisionLogic divisionLogic;