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

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

@@ -69,7 +69,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
private void CheckPrimitives()
{
checkPrimitiveCollectionLogic ??= new CheckPrimitiveCollectionLogic(
checkPrimitiveCollectionLogic ??= new HasPrimitivesCheckLogic(
TraceLogger,
new CheckRebarPrimitiveLogic()
{

9
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs
View File

@@ -12,12 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
/// <inheritdoc/>
public IForceTuple ForceTuple { get; set; }
/// <inheritdoc/>
public IAccuracy Accuracy { get; set; }
public bool CheckStrainLimit { get; set; }
public ForceTupleInputData()
{
Accuracy ??= new Accuracy() { IterationAccuracy = 0.01d, MaxIterationCount = 1000 };
}
public IAccuracy Accuracy { get; set; } = new Accuracy() { IterationAccuracy = 0.01d, MaxIterationCount = 1000 };
public bool CheckStrainLimit { get; set; } = true;
}
}

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs
View File

@@ -91,7 +91,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
Mx = point3D.X,
My = point3D.Y
};
logic.Tuple = tuple;
logic.ForceTuple = tuple;
logic.SectionNdmCollection = Ndms;
try
{

7
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CalculatorCloningStrategyContainer.cs
View File

@@ -1,5 +1,6 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
using System;
@@ -11,7 +12,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
public class CalculatorCloningStrategyContainer : ICalculatorCloningStrategyContainer
{
private ICloningStrategy cloningStrategy;
private IUpdateStrategy<IValueDiagramCalculator> valueDiagramCalculatorStrategy;
private IUpdateStrategy<ICurvatureCalculator> curvatureCalculatorStrategy;
public IUpdateStrategy<IForceCalculator> ForceCalculatorStrategy => new ForceCalculatorUpdateCloningStrategy(cloningStrategy);
@@ -19,7 +21,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
public IUpdateStrategy<ILimitCurvesCalculator> LimitCurvesCalculatorStrategy => new LimitCurvesCalculatorUpdateCloningStrategy(cloningStrategy);
public IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy => new ValueDiagramCalculatorUpdateCloningStrategy(cloningStrategy);
public IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy => valueDiagramCalculatorStrategy ??= new ValueDiagramCalculatorUpdateCloningStrategy(cloningStrategy);
public IUpdateStrategy<ICurvatureCalculator> CurvatureCalculatorStrategy => curvatureCalculatorStrategy ??= new CurvatureCalculatorUpdateCloningStrategy(cloningStrategy);
public CalculatorCloningStrategyContainer(ICloningStrategy cloningStrategy)
{
this.cloningStrategy = cloningStrategy;

5
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs
View File

@@ -6,6 +6,7 @@ using StructureHelperCommon.Models.Parameters;
using StructureHelperCommon.Services;
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;
@@ -65,6 +66,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
cloningStrategyContainer.ValueDiagramCalculatorStrategy.Update(newCalculator as IValueDiagramCalculator, valueDiagramCalculator);
}
else if (calculator is ICurvatureCalculator curvatureCalculator)
{
cloningStrategyContainer.CurvatureCalculatorStrategy.Update(newCalculator as ICurvatureCalculator, curvatureCalculator);
}
else
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(calculator));

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

@@ -1,4 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
@@ -10,5 +11,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
IUpdateStrategy<ICrackCalculator> CrackCalculatorStrategy { get; }
IUpdateStrategy<ILimitCurvesCalculator> LimitCurvesCalculatorStrategy { get; }
IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy { get; }
IUpdateStrategy<ICurvatureCalculator> CurvatureCalculatorStrategy { get; }
}
}

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

@@ -27,7 +27,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
TraceLogger?.AddMessage($"Logic of analisys based on calculating sum of secant stifness of elementary parts EA,i = A,i * Esec,i");
TraceLogger?.AddMessage($"Calculating geometry properties for strains");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(StrainTuple));
var loaderStainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(StrainTuple);
var loaderStainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(StrainTuple);
var (MxFactor, MyFactor, NzFactor) = GeometryOperations.GetSofteningsFactors(NdmCollection, loaderStainMatrix);
TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.SndAxisName}-plane: EIx_cracked / EIx_uncracked = {MxFactor}");
TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.FstAxisName}-plane: EIy_cracked / EIy_uncracked = {MyFactor}");

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

1
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs
View File

@@ -61,7 +61,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
var newTuple = forcelogic.GetValue();
GetForceTupleResult(forceAction, newTuple);
}
}
}

15
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs
View File

@@ -8,13 +8,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
public class ValueDiagramCalculatorUpdateCloningStrategy : IUpdateStrategy<IValueDiagramCalculator>
{
private readonly ICloningStrategy cloningStrategy;
private readonly IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private readonly IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
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 ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
cloningStrategy,
new HasForceActionUpdateCloningStrategy(cloningStrategy),
new HasPrimitivesUpdateCloningStrategy(cloningStrategy))
public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy)
{
this.cloningStrategy = cloningStrategy;
}
@@ -37,8 +36,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
if (ReferenceEquals(targetObject, sourceObject)) { return; }
var sourceData = sourceObject.InputData;
var targetData = targetObject.InputData;
primitivesUpdateStrategy.Update(targetData, sourceData);
forcesUpdateStrategy.Update(targetData, sourceData);
PrimitivesUpdateStrategy.Update(targetData, sourceData);
ForcesUpdateStrategy.Update(targetData, sourceData);
}
}
}

3
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs
View File

@@ -6,11 +6,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics
public class ValueDiagramCheckLogic : CheckEntityLogic<IValueDiagram>
{
private const double minDistance = 1e-3;
private bool result;
public override bool Check()
{
result = true;
bool result = true;
if (Entity is null)
{
string errorString = ErrorStrings.ParameterIsNull + ": value diagram";

2
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs
View File

@@ -33,7 +33,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
CheckRebarHostMaterial = false,
CheckRebarPlacement = false
};
primitivesCheckLogic = new CheckPrimitiveCollectionLogic(TraceLogger, checkRebarPrimitiveLogic);
primitivesCheckLogic = new HasPrimitivesCheckLogic(TraceLogger, checkRebarPrimitiveLogic);
actionsCheckLogic = new CheckForceActionsLogic(TraceLogger);
}

2
StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
View File

@@ -28,7 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
this.checkPrimitiveCollectionLogic = checkPrimitiveCollectionLogic;
}
public CheckCrackCalculatorInputDataLogic() : this (new CheckPrimitiveCollectionLogic())
public CheckCrackCalculatorInputDataLogic() : this (new HasPrimitivesCheckLogic())
{
}

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

@@ -199,7 +199,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
forceTupleCalculator.Run();
var result = forceTupleCalculator.Result as IForceTupleCalculatorResult;
var loaderStrainMatrix = result.LoaderResults.ForceStrainPair.StrainMatrix;
StrainTuple strainTuple = TupleConverter.ConvertToStrainTuple(loaderStrainMatrix);
StrainTuple strainTuple = ForceTupleConverter.ConvertToStrainTuple(loaderStrainMatrix);
return strainTuple;
}
private bool CheckInputData()

2
StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs
View File

@@ -15,7 +15,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// <inheritdoc/>
public INdm ConcreteNdm { get; set; }
/// <inheritdoc/>
public IForceTuple Tuple { get; set; }
public IForceTuple ForceTuple { get; set; }
/// <inheritdoc/>
public IEnumerable<INdm> CheckedNdmCollection { get; set; }
/// <inheritdoc/>

13
StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCracked.cs Normal file
View File

@@ -0,0 +1,13 @@
using StructureHelperCommon.Infrastructures.Interfaces;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface IIsSectionCracked : ILogic
{
/// <summary>
/// Returns result of checking of cracks appearence
/// </summary>
/// <returns>True if Checked collectition contains cracked elements</returns>
bool IsSectionCracked();
}
}

15
StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs
View File

@@ -1,23 +1,17 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Interfaces;
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>
/// Logic for checking collection of ndms for appearance of crack
/// </summary>
public interface IIsSectionCrackedByForceLogic : ILogic
public interface IIsSectionCrackedByForceLogic : IIsSectionCracked
{
/// <summary>
/// Force tuple for checking of cracks appearence
/// </summary>
IForceTuple Tuple { get; set; }
IForceTuple ForceTuple { get; set; }
/// <summary>
/// Collection of ndms which is checking for cracking
/// </summary>
@@ -26,10 +20,5 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// Full ndms collection of cross-section
/// </summary>
IEnumerable<INdm> SectionNdmCollection { get; set; }
/// <summary>
/// Returns result of checking of cracks appearence
/// </summary>
/// <returns>True if Checked collectition contains cracked elements</returns>
bool IsSectionCracked();
}
}

2
StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs
View File

@@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
IsSectionCrackedByForceLogic.TraceLogger ??= TraceLogger?.GetSimilarTraceLogger(50);
var actualTuple = ForceTupleService.InterpolateTuples(StartTuple, EndTuple, factor);
IsSectionCrackedByForceLogic.Tuple = actualTuple;
IsSectionCrackedByForceLogic.ForceTuple = actualTuple;
return IsSectionCrackedByForceLogic.IsSectionCracked();
}
}

19
StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs
View File

@@ -14,33 +14,22 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
static readonly IStressLogic stressLogic = new StressLogic();
/// <inheritdoc/>
public IForceTuple Tuple { get; set; }
public IForceTuple ForceTuple { get; set; }
public IEnumerable<INdm> CheckedNdmCollection { get; set; }
public IEnumerable<INdm> SectionNdmCollection { get; set; }
public Accuracy Accuracy { get; set; }
public Accuracy Accuracy { get; set; } = new Accuracy() { IterationAccuracy = 0.001d, MaxIterationCount = 10000};
public IShiftTraceLogger? TraceLogger { get; set; }
public IsSectionCrackedByForceLogic()
{
if (Accuracy is null)
{
Accuracy = new Accuracy()
{
IterationAccuracy = 0.001d,
MaxIterationCount = 10000
};
}
}
public bool IsSectionCracked()
{
TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
TraceLogger?.AddMessage($"It is assumed, that cracks appearence if: cross-section has elementary parts of concrete and strain of concrete greater than limit value");
TraceLogger?.AddMessage($"Force combination for cracking check");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(Tuple));
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(ForceTuple));
var inputData = new ForceTupleInputData()
{
Accuracy = Accuracy,
ForceTuple = Tuple,
ForceTuple = ForceTuple,
NdmCollection = SectionNdmCollection
};
var calculator = new ForceTupleCalculator() { InputData = inputData };

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

@@ -60,7 +60,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
var strainTuple = GetStrainTuple();
result.StrainTuple = strainTuple;
var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
var strainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm);
result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm);
result.ConcreteStrain = -concreteNdm.PrestrainLogic.GetAll().Sum(x => x.PrestrainValue);
@@ -94,7 +94,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
//TraceLogger?.AddMessage(LoggerStrings.CalculationError + $": {forceResult.Description}", TraceLogStatuses.Error);
throw new StructureHelperException(ErrorStrings.CalculationError);
}
var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
var strain = ForceTupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
return strain;
}

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

@@ -175,7 +175,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
TraceLogger?.AddMessage("Bearing capacity of cross-section is not enough for action", TraceLogStatuses.Error);
return null;
}
var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
var strain = ForceTupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
return strain;
}
@@ -183,7 +183,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
lengthLogic.NdmCollection = elasticNdms;
lengthLogic.TraceLogger = TraceLogger;
lengthLogic.StrainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
lengthLogic.StrainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
return lengthLogic.GetLength();
}

8
StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs
View File

@@ -1,14 +1,8 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Materials;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
namespace StructureHelperLogics.NdmCalculations.Primitives
{
public class CheckRebarPrimitiveLogic : ICheckEntityLogic<IRebarNdmPrimitive>
{

9
StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs → StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesCheckLogic.cs
View File

@@ -1,10 +1,11 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
namespace StructureHelperLogics.NdmCalculations.Primitives
{
public class CheckPrimitiveCollectionLogic : ICheckEntityLogic<IHasPrimitives>
public class HasPrimitivesCheckLogic : ICheckEntityLogic<IHasPrimitives>
{
private const string collectionDoesntHaveAnyPrimitives = "Calculator does not contain any primitives\n";
private const string checkRebarLogic = ": check rebar logic";
@@ -19,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
public IShiftTraceLogger? TraceLogger { get; set; }
public CheckPrimitiveCollectionLogic(
public HasPrimitivesCheckLogic(
IShiftTraceLogger shiftTraceLogger,
ICheckEntityLogic<IRebarNdmPrimitive> checkRebarPrimitiveLogic)
{
@@ -27,7 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
this.checkRebarPrimitiveLogic = checkRebarPrimitiveLogic;
}
public CheckPrimitiveCollectionLogic() : this (new ShiftTraceLogger(), new CheckRebarPrimitiveLogic())
public HasPrimitivesCheckLogic() : this (new ShiftTraceLogger(), new CheckRebarPrimitiveLogic())
{
}

2
StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogic.cs
View File

@@ -25,7 +25,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm)
};
List<INdm> ndmCollection = new () { ndm};
NdmTransform.SetPrestrain(ndmCollection, TupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
NdmTransform.SetPrestrain(ndmCollection, ForceTupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
return ndmCollection;
}

4
StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs
View File

@@ -47,7 +47,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm)
};
;
NdmTransform.SetPrestrain(rebarNdm, TupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
NdmTransform.SetPrestrain(rebarNdm, ForceTupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
return rebarNdm;
}
@@ -74,7 +74,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
//StressScale = -1d
StressScale = 1d//-1d
};
NdmTransform.SetPrestrain(concreteNdm, TupleConverter.ConvertToLoaderStrainMatrix(prestrain));
NdmTransform.SetPrestrain(concreteNdm, ForceTupleConverter.ConvertToLoaderStrainMatrix(prestrain));
return concreteNdm;
}