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

Change curvature calculator

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

8
StructureHelperLogics/Models/BeamShears/Logics/GetDirectShearForceLogic.cs
View File

@@ -20,6 +20,8 @@ namespace StructureHelperLogics.Models.BeamShears
private IDirectShearForceLogicInputData inputData;
private ISumForceByShearLoadLogic summaryForceLogic;
private ICheckInputDataLogic<IDirectShearForceLogicInputData> checkInputDataLogic;
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
/// <inheritdoc/>
public IShiftTraceLogger? TraceLogger { get; set; }
@@ -38,7 +40,7 @@ namespace StructureHelperLogics.Models.BeamShears
Check();
IForceTuple externalTuple = CalculateExternalForceTuple();
IForceTuple internalTuple = CalculateInternalForceTuple();
IForceTuple totalTuple = ForceTupleService.SumTuples(internalTuple, externalTuple);
IForceTuple totalTuple = ForceTupleServiceLogic.SumTuples(internalTuple, externalTuple);
TraceLogger?.AddMessage($"Total longitudinal force = {totalTuple.Nz}(N)");
TraceLogger?.AddMessage($"Total shear force = {totalTuple.Qy}(N)");
return totalTuple;
@@ -83,7 +85,7 @@ namespace StructureHelperLogics.Models.BeamShears
TraceLogger?.AddMessage($"End of inclined section a,end = {inputData.InclinedSection.EndCoord}(m)");
ForceTuple summarySpanShearForce = GetSummarySpanShearForce(beamShearAxisAction.ShearLoads);
TraceLogger?.AddMessage($"Summary span shear force deltaQ = {summarySpanShearForce.Qy}(N)");
IForceTuple shearForce = ForceTupleService.SumTuples(supportShearForce, summarySpanShearForce);
IForceTuple shearForce = ForceTupleServiceLogic.SumTuples(supportShearForce, summarySpanShearForce);
TraceLogger?.AddMessage($"Summary shear force at the end of inclined section Q = {shearForce.Qy}(N)");
return shearForce;
}
@@ -94,7 +96,7 @@ namespace StructureHelperLogics.Models.BeamShears
foreach (var spanLoad in spanLoads)
{
IForceTuple summarySpanLoad = summaryForceLogic.GetSumShearForce(spanLoad, inputData.InclinedSection.StartCoord, inputData.InclinedSection.EndCoord);
ForceTupleService.SumTupleToTarget(summarySpanLoad, summarySpanShearForce);
ForceTupleServiceLogic.SumTupleToTarget(summarySpanLoad, summarySpanShearForce);
}
return summarySpanShearForce;
}

6
StructureHelperLogics/Models/BeamShears/Logics/ShearForceLogic.cs
View File

@@ -10,7 +10,9 @@ namespace StructureHelperLogics.Models.BeamShears
{
private IGetLoadFactor getFactorLogic;
private IGetDirectShearForceLogic getDirectShearForceLogic;
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public IShearForceLogicInputData InputData { get;}
public IShiftTraceLogger? TraceLogger { get; set; }
@@ -38,7 +40,7 @@ namespace StructureHelperLogics.Models.BeamShears
InitializeStrategies();
double factor = getFactorLogic.GetFactor();
IForceTuple directShearForce = getDirectShearForceLogic.CalculateShearForceTuple();
IForceTuple shearForce = ForceTupleService.MultiplyTupleByFactor(directShearForce,factor);
IForceTuple shearForce = ForceTupleServiceLogic.MultiplyTupleByFactor(directShearForce,factor);
return shearForce;
}

4
StructureHelperLogics/Models/BeamShears/Logics/SumConcentratedForceLogic.cs
View File

@@ -11,6 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears
public class SumConcentratedForceLogic : ISumForceByShearLoadLogic
{
private ICoordinateByLevelLogic coordinateByLevelLogic;
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public IShiftTraceLogger? TraceLogger { get; set; }
public LimitStates LimitState { get; set; }
public CalcTerms CalcTerm { get; set; }
@@ -70,7 +72,7 @@ namespace StructureHelperLogics.Models.BeamShears
{
double loadFactor = GetLoadFactor(concentratedForce);
double sumFactor = concentratedForce.LoadRatio * loadFactor;
totalLoad = ForceTupleService.MultiplyTupleByFactor(concentratedForce.ForceValue, sumFactor);
totalLoad = ForceTupleServiceLogic.MultiplyTupleByFactor(concentratedForce.ForceValue, sumFactor);
TraceLogger?.AddMessage($"Total load Q,tot = {concentratedForce.ForceValue.Qy}(N) * {concentratedForce.LoadRatio} * {loadFactor} = {totalLoad}(N)");
}
else

4
StructureHelperLogics/Models/BeamShears/Logics/SumDistributedLoadLogic.cs
View File

@@ -11,6 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears
public class SumDistributedLoadLogic : ISumForceByShearLoadLogic
{
private ICoordinateByLevelLogic coordinateByLevelLogic;
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public IShiftTraceLogger? TraceLogger { get; set; }
public LimitStates LimitState { get; set; }
public CalcTerms CalcTerm { get; set; }
@@ -61,7 +63,7 @@ namespace StructureHelperLogics.Models.BeamShears
TraceLogger?.AddMessage($"Total length L,tot = {loadEndCoord}(m) - {loadStartCoord}(m) = {loadLength}(m)");
double loadFactor = GetLoadFactor(distributedLoad);
double sumFactor = distributedLoad.LoadRatio * loadLength * loadFactor;
IForceTuple totalLoad = ForceTupleService.MultiplyTupleByFactor(distributedLoad.LoadValue, sumFactor);
IForceTuple totalLoad = ForceTupleServiceLogic.MultiplyTupleByFactor(distributedLoad.LoadValue, sumFactor);
TraceLogger?.AddMessage($"Total load Q,tot = {distributedLoad.LoadValue.Qy}(N/m) * {distributedLoad.LoadRatio} * {loadLength}(m) * {loadFactor} = {totalLoad.Qy}(N)");
return totalLoad;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -11,18 +11,24 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackForceBynarySearchCalculator : ICrackForceCalculator
{
private CrackForceResult result;
private IIsSectionCrackedByFactorLogic crackedByFactorLogic;
private ICheckInputDataLogic<ICrackForceCalculatorInputData> checkInputDataLogic;
ExpSofteningLogic softeningLogic = new();
static readonly CrackStrainLogic crackStrainLogic = new();
static readonly SofteningFactorLogic softeningFactorLogic = new();
IForceTupleCalculator forceTupleCalculator;
private CrackForceResult result;
private ExpSofteningLogic softeningLogic = new();
private readonly CrackStrainLogic crackStrainLogic = new();
private readonly SofteningFactorLogic softeningFactorLogic = new();
private IForceTupleCalculator forceTupleCalculator = new ForceTupleCalculator();
private FindParameterCalculator parameterCalculator;
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public string Name { get; set; }
public ICrackForceCalculatorInputData InputData { get; set; }
public Accuracy Accuracy { get; set; }
public Accuracy Accuracy { get; set; } = new Accuracy()
{
IterationAccuracy = 0.0001d,
MaxIterationCount = 10000
};
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
@@ -36,15 +42,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
this.crackedByFactorLogic = crackedByFactorLogic;
this.checkInputDataLogic = checkInputDataLogic;
Accuracy ??= new Accuracy()
{
IterationAccuracy = 0.0001d,
MaxIterationCount = 10000
};
forceTupleCalculator = new ForceTupleCalculator();
InputData = new CrackForceCalculatorInputData();
}
public CrackForceBynarySearchCalculator() : this(new IsSectionCrackedByFactorLogic(), new CheckCrackForceCalculatorInputDataLogic())
public CrackForceBynarySearchCalculator() : this(
new IsSectionCrackedByFactorLogic(),
new CheckCrackForceCalculatorInputDataLogic())
{
}
@@ -54,17 +56,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
if (CheckInputData() == false) { return; }
parameterCalculator = new FindParameterCalculator();
parameterCalculator.InputData.Predicate = crackedByFactorLogic.IsSectionCracked;
if (TraceLogger is not null)
{
forceTupleCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(100);
parameterCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(50);
crackedByFactorLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(150);
}
TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
TraceLogger?.AddMessage($"Start force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.StartTuple));
TraceLogger?.AddMessage($"Actual (end) force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.EndTuple));
SetCalculatorsTraceLoggers();
TraceInputData();
crackedByFactorLogic.IsSectionCrackedByForceLogic = new IsSectionCrackedByForceLogic()
{
CheckedNdmCollection = InputData.CheckedNdmCollection,
@@ -74,24 +67,34 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
crackedByFactorLogic.EndTuple = InputData.EndTuple;
try
{
CheckInputData();
bool IsSectionCrackedInZeroForce = crackedByFactorLogic.IsSectionCracked(0d);
if (IsSectionCrackedInZeroForce == true)
{
TraceLogger?.AddMessage($"Crack is appeared in start force combination", TraceLogStatuses.Warning);
SectionCrackedAtStart();
return;
}
}
catch (Exception ex)
{
result.IsValid = false;
result.Description += ex;
result.Description +="\n" + ex.Message;
return;
}
if (crackedByFactorLogic.IsSectionCracked(0d) == true)
try
{
TraceLogger?.AddMessage($"Crack is appeared in start force combination", TraceLogStatuses.Warning);
SectionCrackedAtStart();
return;
bool isSectionCrackedUndefFullForce = crackedByFactorLogic.IsSectionCracked(1d);
if (isSectionCrackedUndefFullForce == false)
{
TraceLogger?.AddMessage($"Crack is not appeared from actual (end) force combination", TraceLogStatuses.Warning);
SectionIsNotCracked();
return;
}
}
if (crackedByFactorLogic.IsSectionCracked(1d) == false)
catch (Exception ex)
{
TraceLogger?.AddMessage($"Crack is not appeared from actual (end) force combination", TraceLogStatuses.Warning);
SectionIsNotCracked();
result.IsValid = false;
result.Description += "\n" + ex.Message;
return;
}
@@ -109,6 +112,22 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
}
}
private void TraceInputData()
{
TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
TraceLogger?.AddMessage($"Start force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.StartTuple));
TraceLogger?.AddMessage($"Actual (end) force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.EndTuple));
}
private void SetCalculatorsTraceLoggers()
{
forceTupleCalculator.TraceLogger = TraceLogger?.GetSimilarTraceLogger(100);
parameterCalculator.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
crackedByFactorLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(150);
}
private void PrepareNewResult()
{
result = new CrackForceResult();
@@ -125,7 +144,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
}
softeningLogic.ForceRatio = factorOfCrackAppearance;
var psiS = softeningLogic.GetSofteningFactor();
var tupleOfCrackApeearence = ForceTupleService.InterpolateTuples(InputData.StartTuple, InputData.EndTuple, factorOfCrackAppearance);
var tupleOfCrackApeearence = ForceTupleServiceLogic.InterpolateTuples(InputData.StartTuple, InputData.EndTuple, factorOfCrackAppearance);
TraceLogger?.AddMessage($"Crack is appeared in force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tupleOfCrackApeearence));
var reducedStrainTuple = GetReducedStrainTuple(factorOfCrackAppearance, psiS);
@@ -158,7 +177,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private IForceTuple GetReducedStrainTuple(double factorOfCrackAppearance, double softeningFactor)
{
const double notCrackedForceFactor = 0.99d;
var notCrackedForceTuple = ForceTupleService.InterpolateTuples(InputData.StartTuple, InputData.EndTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple;
var notCrackedForceTuple = ForceTupleServiceLogic.InterpolateTuples(InputData.StartTuple, InputData.EndTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple;
var crackAppearanceStrainTuple = GetStrainTuple(notCrackedForceTuple);
var actualStrainTuple = GetStrainTuple(InputData.EndTuple);
crackStrainLogic.BeforeCrackingTuple = crackAppearanceStrainTuple;

20
StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculatorInputData.cs
View File

@@ -1,24 +1,18 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
/// <inheritdoc/>
public class CrackForceCalculatorInputData : ICrackForceCalculatorInputData
{
public IForceTuple StartTuple { get; set; }
public IForceTuple EndTuple { get; set; }
/// <inheritdoc/>
public IForceTuple StartTuple { get; set; } = new ForceTuple();
/// <inheritdoc/>
public IForceTuple EndTuple { get; set; } = new ForceTuple();
/// <inheritdoc/>
public IEnumerable<INdm> CheckedNdmCollection { get; set; }
/// <inheritdoc/>
public IEnumerable<INdm> SectionNdmCollection { get; set; }
public CrackForceCalculatorInputData()
{
StartTuple = new ForceTuple();
EndTuple = new ForceTuple();
}
}
}

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

@@ -10,13 +10,15 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
internal class CrackStrainLogic : ICrackStrainLogic
{
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public IForceTuple BeforeCrackingTuple { get; set; }
public IForceTuple AfterCrackingTuple { get; set; }
public double SofteningFactor { get; set; }
public IForceTuple GetCrackedStrainTuple()
{
var strainTuple = ForceTupleService.InterpolateTuples(BeforeCrackingTuple, AfterCrackingTuple, SofteningFactor) as StrainTuple;
var strainTuple = ForceTupleServiceLogic.InterpolateTuples(BeforeCrackingTuple, AfterCrackingTuple, SofteningFactor) as StrainTuple;
return strainTuple;
}
}

25
StructureHelperLogics/NdmCalculations/Cracking/CrackedSectionTriangulationLogic.cs
View File

@@ -2,14 +2,8 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Loggers;
using StructureHelperLogics.Models.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.Services.NdmPrimitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
@@ -17,29 +11,26 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
public class CrackedSectionTriangulationLogic : ICrackedSectionTriangulationLogic
{
const LimitStates limitState = LimitStates.SLS;
const CalcTerms shortTerm = CalcTerms.ShortTerm;
private ITriangulatePrimitiveLogic triangulateLogic;
private string ndmPrimitiveCountMessage;
public CalcTerms CalcTerm { get; set; }
public IEnumerable<INdmPrimitive> NdmPrimitives { get; private set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public CrackedSectionTriangulationLogic(IEnumerable<INdmPrimitive> ndmPrimitives)
public CrackedSectionTriangulationLogic(IEnumerable<INdmPrimitive> ndmPrimitives, CalcTerms calcTerm)
{
NdmPrimitives = ndmPrimitives;
CalcTerm = calcTerm;
ndmPrimitiveCountMessage = $"Source collection containes {NdmPrimitives.Count()} primitives";
triangulateLogic = new TriangulatePrimitiveLogic
{
Primitives = NdmPrimitives,
LimitState = limitState,
CalcTerm = shortTerm,
CalcTerm = CalcTerm,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
}
public CrackedSectionTriangulationLogic()
{
}
/// <inheritdoc/>
public List<INdm> GetNdmCollection()
{
@@ -48,7 +39,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
triangulateLogic = new TriangulatePrimitiveLogic()
{
LimitState = limitState,
CalcTerm = shortTerm,
CalcTerm = CalcTerm,
Primitives = NdmPrimitives,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
@@ -62,7 +53,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
triangulateLogic = new TriangulatePrimitiveLogic(new MeshCrackedConcreteLogic())
{
LimitState = limitState,
CalcTerm = shortTerm,
CalcTerm = CalcTerm,
Primitives = NdmPrimitives,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
@@ -95,7 +86,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
triangulateLogic = new TriangulatePrimitiveLogic(new MeshElasticLogic())
{
LimitState = limitState,
CalcTerm = shortTerm,
CalcTerm = CalcTerm,
Primitives = NdmPrimitives,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};

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

@@ -13,6 +13,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class IsSectionCrackedByFactorLogic : IIsSectionCrackedByFactorLogic
{
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public IIsSectionCrackedByForceLogic IsSectionCrackedByForceLogic { get; set; }
public IForceTuple StartTuple { get; set; }
public IForceTuple EndTuple { get; set; }
@@ -31,7 +33,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
public bool IsSectionCracked(double factor)
{
IsSectionCrackedByForceLogic.TraceLogger ??= TraceLogger?.GetSimilarTraceLogger(50);
var actualTuple = ForceTupleService.InterpolateTuples(StartTuple, EndTuple, factor);
var actualTuple = ForceTupleServiceLogic.InterpolateTuples(StartTuple, EndTuple, factor);
IsSectionCrackedByForceLogic.ForceTuple = actualTuple;
return IsSectionCrackedByForceLogic.IsSectionCracked();
}

16
StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs
View File

@@ -1,14 +1,8 @@
using LoaderCalculator.Data.Ndms;
using StructureHelper.Models.Materials;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
@@ -21,10 +15,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
this.triangulationLogicLoc = triangulationLogicLoc;
}
public RebarCrackInputDataFactory(TupleCrackInputData inputData) : this (new CrackedSectionTriangulationLogic(inputData.Primitives))
{
//public RebarCrackInputDataFactory(TupleCrackInputData inputData) : this (new CrackedSectionTriangulationLogic(inputData.Primitives))
//{
}
//}
public RebarCrackInputDataFactory()
{
@@ -45,7 +39,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
rebarCopy = Rebar.Clone() as RebarNdmPrimitive;
rebarCopy.NdmElement.HeadMaterial = rebarCopy.NdmElement.HeadMaterial.Clone() as IHeadMaterial;
triangulationLogicLoc = new CrackedSectionTriangulationLogic(InputData.Primitives);
triangulationLogicLoc = new CrackedSectionTriangulationLogic(InputData.Primitives, CalcTerms.ShortTerm);
crackableNdmsLoc = triangulationLogicLoc.GetNdmCollection();
crackedNdmsLoc = triangulationLogicLoc.GetCrackedNdmCollection();

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

@@ -18,10 +18,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
private const CalcTerms crackingTerm = CalcTerms.ShortTerm;
private const LimitStates crackingLimitState = LimitStates.SLS;
private ILengthBetweenCracksLogic lengthLogic;
private TupleCrackResult result;
private ICrackedSectionTriangulationLogic triangulationLogic;
private ITupleRebarsCrackSolver solver;
private List<IRebarNdmPrimitive>? rebarPrimitives;
private IEnumerable<INdm> crackableNdms;
private IEnumerable<INdm> crackedNdms;
@@ -32,6 +30,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private double longLength;
private double shortLength;
private ICheckInputDataLogic<TupleCrackInputData> checkInputDataLogic;
private ILengthBetweenCracksLogic lengthLogic;
private ITupleRebarsCrackSolver crackSolver;
private ICheckInputDataLogic<TupleCrackInputData> CheckInputDataLogic => checkInputDataLogic ??= new CheckTupleCalculatorInputDataLogic();
private ILengthBetweenCracksLogic LengthLogic => lengthLogic ??= new LengthBetweenCracksLogicSP63();
private ITupleRebarsCrackSolver CrackSolver => crackSolver ??= new TupleRebarsCrackSolver();
public TupleCrackInputData InputData { get; set; }
public IResult Result => result;
@@ -46,16 +49,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
this.checkInputDataLogic = checkInputDataLogic;
this.lengthLogic = lengthLogic;
this.triangulationLogic = triangulationLogic;
this.solver = solver;
this.crackSolver = solver;
}
public TupleCrackCalculator() : this (new CheckTupleCalculatorInputDataLogic(),
new LengthBetweenCracksLogicSP63(),
new CrackedSectionTriangulationLogic(),
new TupleRebarsCrackSolver())
{
}
public TupleCrackCalculator() { }
public void Run()
{
@@ -139,19 +136,19 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private void SolveRebarResult()
{
result.RebarResults.Clear();
solver.Rebars = rebarPrimitives;
solver.InputData = InputData;
solver.LongLength = longLength;
solver.ShortLength = shortLength;
solver.TraceLogger = TraceLogger?.GetSimilarTraceLogger(0);
solver.Run();
if (solver.IsResultValid == false)
CrackSolver.Rebars = rebarPrimitives;
CrackSolver.InputData = InputData;
CrackSolver.LongLength = longLength;
CrackSolver.ShortLength = shortLength;
CrackSolver.TraceLogger = TraceLogger?.GetSimilarTraceLogger(0);
CrackSolver.Run();
if (CrackSolver.IsResultValid == false)
{
result.IsValid = false;
result.Description += solver.Description;
result.Description += CrackSolver.Description;
return;
}
result.RebarResults.AddRange(solver.Result);
result.RebarResults.AddRange(CrackSolver.Result);
}
private StrainTuple CalcStrainMatrix(ForceTuple forceTuple, IEnumerable<INdm> ndms)
@@ -181,15 +178,15 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private double GetLengthBetweenCracks(StrainTuple strainTuple)
{
lengthLogic.NdmCollection = elasticNdms;
lengthLogic.TraceLogger = TraceLogger;
lengthLogic.StrainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
return lengthLogic.GetLength();
LengthLogic.NdmCollection = elasticNdms;
LengthLogic.TraceLogger = TraceLogger;
LengthLogic.StrainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
return LengthLogic.GetLength();
}
private void Triangulate()
{
triangulationLogic = new CrackedSectionTriangulationLogic(InputData.Primitives)
triangulationLogic = new CrackedSectionTriangulationLogic(InputData.Primitives, crackingTerm)
{
//TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
@@ -201,12 +198,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private bool CheckInputData()
{
checkInputDataLogic.InputData = InputData;
if (checkInputDataLogic.Check() == false)
CheckInputDataLogic.InputData = InputData;
if (CheckInputDataLogic.Check() == false)
{
result.IsValid = false;
result.Description += checkInputDataLogic.CheckResult;
TraceLogger?.AddMessage($"Input data is not correct: {checkInputDataLogic.CheckResult}", TraceLogStatuses.Error);
result.Description += CheckInputDataLogic.CheckResult;
TraceLogger?.AddMessage($"Input data is not correct: {CheckInputDataLogic.CheckResult}", TraceLogStatuses.Error);
return false;
};
return true;

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

@@ -4,17 +4,28 @@ using StructureHelperCommon.Models.Materials;
namespace StructureHelperLogics.NdmCalculations.Primitives
{
/// <summary>
/// Logic for checking of propertis of rebar
/// </summary>
public class CheckRebarPrimitiveLogic : ICheckEntityLogic<IRebarNdmPrimitive>
{
private string checkResult;
private bool result;
/// <summary>
/// True if checking of rebar placement inside its host is required
/// </summary>
public bool CheckRebarPlacement { get; set; } = true;
/// <summary>
/// True if rebar must has its host
/// </summary>
public bool CheckRebarHostMaterial { get; set; } = true;
/// <summary>
/// Rebar primitive
/// </summary>
public IRebarNdmPrimitive Entity { get; set; }
public string CheckResult => checkResult;
/// <inheritdoc/>
public IShiftTraceLogger? TraceLogger { get; set; }
public CheckRebarPrimitiveLogic(IShiftTraceLogger traceLogger)

5
StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesCheckLogic.cs
View File

@@ -33,6 +33,11 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
}
public HasPrimitivesCheckLogic(IShiftTraceLogger? traceLogger)
{
TraceLogger = traceLogger;
}
public bool Check()
{
result = true;

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

@@ -14,6 +14,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class CircleTriangulationLogicOptions : IShapeTriangulationLogicOptions
{
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public ICircleShape Circle { get;}
public IPoint2D Center { get; set; }
@@ -32,7 +34,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
Circle = new CircleShape() { Diameter = primitive.Width };
DivisionSize = primitive.DivisionSize;
HeadMaterial = primitive.NdmElement.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
Prestrain = ForceTupleServiceLogic.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
}
}
}

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

@@ -15,6 +15,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class LinePolygonTriangulationLogicOption : IShapeTriangulationLogicOptions
{
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public IPoint2D Center { get; set; }
public IDivisionSize DivisionSize { get; set; }
public ITriangulationOptions TriangulationOptions { get; set; }
@@ -29,7 +31,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
TriangulationOptions = triangulationOptions;
Shape = primitive.Shape;
HeadMaterial = primitive.NdmElement.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
Prestrain = ForceTupleServiceLogic.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
}
}
}

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

@@ -12,6 +12,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
/// </summary>
public class PointTriangulationLogicOptions : ITriangulationLogicOptions
{
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public ITriangulationOptions TriangulationOptions { get; set; }
/// <summary>
///
@@ -29,7 +31,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
Center = primitive.Center.Clone() as Point2D;
Area = primitive.Area;
HeadMaterial = primitive.NdmElement.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
Prestrain = ForceTupleServiceLogic.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
}
}
}

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

@@ -17,6 +17,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
internal class RebarTriangulationLogic : ITriangulationLogic
{
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
private readonly RebarTriangulationLogicOptions options;
public RebarTriangulationLogic(ITriangulationLogicOptions options)
{
@@ -60,7 +62,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
.HeadMaterial
.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm);
var prestrain = ForceTupleService.SumTuples(hostPrimitive.NdmElement.UsersPrestrain,
var prestrain = ForceTupleServiceLogic.SumTuples(hostPrimitive.NdmElement.UsersPrestrain,
hostPrimitive.NdmElement.AutoPrestrain)
as StrainTuple;

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

@@ -13,6 +13,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class RebarTriangulationLogicOptions : ITriangulationLogicOptions
{
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public ITriangulationOptions TriangulationOptions { get; set; }
/// <summary>
///
@@ -32,7 +34,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
Area = primitive.Area;
HeadMaterial = primitive.NdmElement.HeadMaterial;
HostPrimitive = primitive.HostPrimitive;
Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
Prestrain = ForceTupleServiceLogic.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
}
}
}

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

@@ -10,6 +10,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
/// <inheritdoc />
public class RectangleTriangulationLogicOptions : IShapeTriangulationLogicOptions
{
private IForceTupleServiceLogic forceTupleServiceLogic;
private IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
/// <inheritdoc />
public IPoint2D Center { get; set; }
/// <inheritdoc />
@@ -41,7 +43,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
DivisionSize.NdmMaxSize = primitive.DivisionSize.NdmMaxSize;
DivisionSize.NdmMinDivision = primitive.DivisionSize.NdmMinDivision;
HeadMaterial = primitive.NdmElement.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
Prestrain = ForceTupleServiceLogic.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
}
}
}

4
StructureHelperLogics/Services/NdmCalculations/InterpolateService.cs
View File

@@ -9,6 +9,8 @@ namespace StructureHelperLogics.Services.NdmCalculations
public static class InterpolateService
{
static readonly CompressedMemberUpdateStrategy compressedMemberUpdateStrategy = new();
private static IForceTupleServiceLogic forceTupleServiceLogic;
private static IForceTupleServiceLogic ForceTupleServiceLogic => forceTupleServiceLogic ??= new ForceTupleServiceLogic();
public static ForceCalculator InterpolateForceCalculator(IForceCalculator source, IStateCalcTermPair stateCalcTermPair, InterpolateTuplesResult interpolateTuplesResult)
{
ForceCalculator calculator = new ForceCalculator();
@@ -21,7 +23,7 @@ namespace StructureHelperLogics.Services.NdmCalculations
calculator.InputData.Primitives.AddRange(source.InputData.Primitives);
calculator.InputData.ForceActions.Clear();
calculator.InputData.CheckStrainLimit = source.InputData.CheckStrainLimit;
var forceTuples = ForceTupleService.InterpolateTuples(interpolateTuplesResult.StartTuple, interpolateTuplesResult.FinishTuple, interpolateTuplesResult.StepCount);
var forceTuples = ForceTupleServiceLogic.InterpolateTuples(interpolateTuplesResult.StartTuple, interpolateTuplesResult.FinishTuple, interpolateTuplesResult.StepCount);
foreach (var forceTuple in forceTuples)
{
var combination = new ForceCombinationList()

12
StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs
View File

@@ -104,12 +104,12 @@ namespace StructureHelperLogics.Services.NdmPrimitives
TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error);
throw new StructureHelperException(errorMessage);
}
if (TriangulationOptions.CalcTerm is not CalcTerms.ShortTerm)
{
string errorMessage = string.Intern(ErrorStrings.DataIsInCorrect + $": Calc term for cracked concrete must correspondent short term");
TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error);
throw new StructureHelperException(errorMessage);
}
//if (TriangulationOptions.CalcTerm is not CalcTerms.ShortTerm)
//{
// string errorMessage = string.Intern(ErrorStrings.DataIsInCorrect + $": Calc term for cracked concrete must correspondent short term");
// TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error);
// throw new StructureHelperException(errorMessage);
//}
TraceLogger?.AddMessage($"Primitive check is ok");
}
}