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

CrackedCalculator and TriangulationLogic were changed

Browse Source
This commit is contained in:
Evgeny Redikultsev
2024-05-05 16:39:02 +05:00
parent f158ba3336
commit e75521dc20
34 changed files with 645 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs
View File

@@ -1,6 +1,7 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Cracking;
namespace StructureHelperLogics.Models.Templates.CrossSections
{
@@ -8,14 +9,19 @@ namespace StructureHelperLogics.Models.Templates.CrossSections
{
public IEnumerable<ICalculator> GetNdmCalculators()
{
var calculators = new List<ICalculator>
var calculators = new List<ICalculator>();
var forceCalculator = new ForceCalculator()
{
new ForceCalculator()
{
Name = "New Force Calculator",
TraceLogger = new ShiftTraceLogger()
}
Name = "New Force Calculator",
TraceLogger = new ShiftTraceLogger()
};
calculators.Add(forceCalculator);
var crackCalculator = new CrackCalculator(new CrackInputData())
{
Name = "New Crack Calculator",
TraceLogger = new ShiftTraceLogger()
};
calculators.Add(crackCalculator);
return calculators;
}
}

9
StructureHelperLogics/Models/Templates/CrossSections/RCs/SectionTemplate.cs
View File

@@ -4,6 +4,7 @@ using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.Models.CrossSections;
using StructureHelperLogics.Models.Templates.RCs;
using StructureHelperLogics.NdmCalculations.Analyses;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
@@ -62,6 +63,10 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs
var forceCalculator = calculator as IHasForceCombinations;
forceCalculator.ForceActions.AddRange(combinations);
}
if (calculator is CrackCalculator crackCalculator)
{
crackCalculator.InputData.ForceActions.AddRange(combinations);
}
}
}
private void AddAllPrimitivesToCalculator()
@@ -73,6 +78,10 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs
var primitiveCalculator = calculator as IHasPrimitives;
primitiveCalculator.Primitives.AddRange(primitives);
}
if (calculator is CrackCalculator crackCalculator)
{
crackCalculator.InputData.Primitives.AddRange(primitives);
}
}
}
}

20
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs
View File

@@ -1,6 +1,5 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
@@ -8,12 +7,10 @@ using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models.Sections;
using StructureHelperCommon.Models.Sections.Logics;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
using StructureHelperLogics.NdmCalculations.Buckling;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.Services.NdmPrimitives;
using System;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
@@ -24,6 +21,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
private ForcesResults result;
private IProcessorLogic<IForceTuple> eccentricityLogic;
private ForceTupleBucklingLogic bucklingLogic;
private ITriangulatePrimitiveLogic triangulateLogic;
public string Name { get; set; }
public List<LimitStates> LimitStatesList { get; private set; }
@@ -99,7 +98,14 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
IForcesTupleResult tupleResult;
LimitStates limitState = tuple.LimitState;
CalcTerms calcTerm = tuple.CalcTerm;
var ndms = NdmPrimitivesService.GetNdms(Primitives, limitState, calcTerm);
triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = Primitives,
LimitState = limitState,
CalcTerm = calcTerm,
TraceLogger = TraceLogger
};
var ndms = triangulateLogic.GetNdms();
IPoint2D point2D;
IProcessorLogic<IForceTuple> forcelogic = new ForceTupleCopier(tuple.ForceTuple);
if (combination.SetInGravityCenter == true)
@@ -196,7 +202,11 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
string result = "";
try
{
NdmPrimitivesService.CheckPrimitives(Primitives);
triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = Primitives
};
triangulateLogic.CheckPrimitives(Primitives);
}
catch (Exception ex)
{

11
StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculator.cs
View File

@@ -15,6 +15,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
private LimitCurvesResult result;
private int curvesIterationCount;
private ITriangulatePrimitiveLogic triangulateLogic;
private LimitCurvesCalculatorUpdateStrategy updateStrategy => new();
public Guid Id { get; }
@@ -78,7 +80,14 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
foreach (var calcTerm in InputData.CalcTerms)
{
var ndms = NdmPrimitivesService.GetNdms(primitiveSeries.Collection, limitState, calcTerm);
triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = primitiveSeries.Collection,
LimitState = limitState,
CalcTerm = calcTerm,
TraceLogger = TraceLogger
};
var ndms = triangulateLogic.GetNdms();
TraceLogger?.AddMessage($"Number of elementary parts N={ndms.Count()} were obtainded succesfully");
TraceLogger?.AddMessage($"Summary area of elementary parts Asum={ndms.Sum(x=>x.Area * x.StressScale)}", TraceLogStatuses.Debug);
foreach (var predicateEntry in InputData.PredicateEntries)

10
StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs
View File

@@ -2,6 +2,7 @@
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Logics;
using LoaderCalculator.Logics.Geometry;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
@@ -24,6 +25,7 @@ namespace StructureHelperLogics.NdmCalculations.Buckling
private List<INdm> concreteNdms;
private List<INdm> otherNdms;
IForcesTupleResult forcesResults;
private ITriangulatePrimitiveLogic triangulateLogic;
public string Name { get; set; }
@@ -52,7 +54,13 @@ namespace StructureHelperLogics.NdmCalculations.Buckling
Accuracy = accuracy;
var allPrimitives = options.Primitives;
ndmCollection = NdmPrimitivesService.GetNdms(allPrimitives, options.LimitState, options.CalcTerm);
triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = allPrimitives,
LimitState = options.LimitState,
CalcTerm = options.CalcTerm
};
ndmCollection = triangulateLogic.GetNdms();
concreteNdms = ndmCollection.Where(x => x.Material is ICrackMaterial).ToList();
otherNdms = ndmCollection.Except(concreteNdms).ToList();
}

93
StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs Normal file
View File

@@ -0,0 +1,93 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Infrastructures.Settings;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Loggers;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackCalculator : ICalculator
{
const LimitStates limitState = LimitStates.SLS;
const CalcTerms longTerm = CalcTerms.LongTerm;
const CalcTerms shortTerm = CalcTerms.ShortTerm;
private CrackResult result;
private IGetTupleInputDatasLogic datasLogic;
private CrackCalculatorUpdateStrategy updateStrategy = new();
public string Name { get; set; }
public CrackInputData InputData { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public CrackCalculator(CrackInputData inputData)
{
InputData = inputData;
}
public object Clone()
{
var newItem = new CrackCalculator(new CrackInputData());
updateStrategy.Update(newItem, this);
return newItem;
}
public void Run()
{
PrepareNewResult();
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
try
{
ProcessCalculations();
TraceLogger?.AddMessage(LoggerStrings.CalculationHasDone);
}
catch (Exception ex)
{
result.IsValid = false;
result.Description += ex;
TraceLogger?.AddMessage(LoggerStrings.CalculationError + ex, TraceLogStatuses.Error);
}
}
private void ProcessCalculations()
{
datasLogic = new GetTupleInputDatasLogic(InputData.Primitives, InputData.ForceActions)
{
LimitState = limitState,
LongTerm = longTerm,
ShortTerm = shortTerm,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
var datas = datasLogic.GetTupleInputDatas();
foreach (var data in datas)
{
var calculator = new TupleCrackCalculator()
{
InputData = data,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
calculator.Run();
var calcResult = calculator.Result as TupleCrackResult;
result.TupleResults.Add(calcResult);
}
}
private void PrepareNewResult()
{
result = new CrackResult
{
IsValid = true,
Description = string.Empty
};
}
}
}

24
StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,24 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackCalculatorUpdateStrategy : IUpdateStrategy<CrackCalculator>
{
private CrackInputDataUpdateStrategy inputDataUpdateStrategy => new();
public void Update(CrackCalculator targetObject, CrackCalculator sourceObject)
{
if (ReferenceEquals(targetObject, sourceObject)) { return; }
CheckObject.CompareTypes(targetObject, sourceObject);
targetObject.Name = sourceObject.Name;
targetObject.InputData ??= new();
inputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData);
}
}
}

25
StructureHelperLogics/NdmCalculations/Cracking/CrackInputData.cs Normal file
View File

@@ -0,0 +1,25 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackInputData : IInputData, IHasPrimitives, IHasForceCombinations
{
/// <inheritdoc/>
public List<INdmPrimitive> Primitives { get; private set; }
/// <inheritdoc/>
public List<IForceAction> ForceActions { get; private set; }
public CrackInputData()
{
Primitives = new();
ForceActions = new();
}
}
}

23
StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,23 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackInputDataUpdateStrategy : IUpdateStrategy<CrackInputData>
{
public void Update(CrackInputData targetObject, CrackInputData sourceObject)
{
if (ReferenceEquals(targetObject, sourceObject)) { return; }
CheckObject.CompareTypes(targetObject, sourceObject);
targetObject.ForceActions.Clear();
targetObject.ForceActions.AddRange(sourceObject.ForceActions);
targetObject.Primitives.Clear();
targetObject.Primitives.AddRange(sourceObject.Primitives);
}
}
}

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

@@ -0,0 +1,20 @@
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackResult : IResult
{
public bool IsValid { get; set; }
public string? Description { get; set; }
public List<TupleCrackResult> TupleResults {get;set;}
public CrackResult()
{
TupleResults = new();
}
}
}

101
StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs Normal file
View File

@@ -0,0 +1,101 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperCommon.Infrastructures.Interfaces;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class GetTupleInputDatasLogic : IGetTupleInputDatasLogic
{
public List<IForceAction> ForceActions { get; set; }
public List<INdmPrimitive> Primitives { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public LimitStates LimitState { get; set; }
public CalcTerms LongTerm { get; set; }
public CalcTerms ShortTerm { get; set; }
public GetTupleInputDatasLogic(List<INdmPrimitive> primitives, List<IForceAction> forceActions)
{
Primitives = primitives;
ForceActions = forceActions;
}
public List<TupleCrackInputData> GetTupleInputDatas()
{
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
List<TupleCrackInputData> resultList = new();
CheckInputData();
foreach (var action in ForceActions)
{
var tuple = GetTuplesByActions(action);
if (tuple.isValid == false)
{
resultList.Add(new TupleCrackInputData()
{
IsValid = false,
});
}
else
{
resultList.Add(new TupleCrackInputData()
{
IsValid = true,
LongTermTuple = tuple.LongTuple,
ShortTermTuple = tuple.ShortTuple,
NdmPrimitives = Primitives
});
}
}
TraceLogger?.AddMessage(LoggerStrings.CalculationHasDone);
return resultList;
}
private void CheckInputData()
{
if (ForceActions is null)
{
TraceLogger?.AddMessage("Force action is null", TraceLogStatuses.Error);
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": {nameof(ForceActions)} is null");
}
}
private (bool isValid, IForceTuple? LongTuple, IForceTuple? ShortTuple) GetTuplesByActions(IForceAction action)
{
IForceTuple longTuple, shortTuple;
var combinations = action.GetCombinations().DesignForces;
try
{
longTuple = GetTupleByCombination(combinations, LimitState, LongTerm);
TraceLogger?.AddMessage("Long term force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(longTuple));
shortTuple = GetTupleByCombination(combinations, LimitState, ShortTerm);
TraceLogger?.AddMessage("Short term force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(longTuple));
}
catch (Exception ex)
{
TraceLogger?.AddMessage("Force combination is not obtained: \n" + ex, TraceLogStatuses.Error);
return (false, null, null);
}
return (true, longTuple, shortTuple);
}
private static IForceTuple GetTupleByCombination(List<IDesignForceTuple> combinations, LimitStates limitState, CalcTerms calcTerm)
{
return combinations
.Where(x => x.LimitState == limitState & x.CalcTerm == calcTerm)
.Single()
.ForceTuple;
}
}
}

15
StructureHelperLogics/NdmCalculations/Cracking/IGetTupleInputDatasLogic.cs Normal file
View File

@@ -0,0 +1,15 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface IGetTupleInputDatasLogic : ILogic, IHasPrimitives, IHasForceCombinations
{
LimitStates LimitState { get; set; }
CalcTerms LongTerm { get; set; }
CalcTerms ShortTerm { get; set; }
List<TupleCrackInputData> GetTupleInputDatas();
}
}

4
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs → StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs
View File

@@ -3,10 +3,10 @@ using StructureHelperCommon.Models.Calculators;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackWidthSimpleCalculator : ICalculator
public class RebarCrackCalculator : ICalculator
{
ICrackWidthLogic crackWidthLogic = new CrackWidthLogicSP63();
CrackWidthSimpleCalculatorResult result;
RebarCrackResult result;
public string Name { get; set; }
public ICrackWidthSimpleCalculatorInputData InputData { get; set; }
public IResult Result => result;

2
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorInputData.cs → StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs
View File

@@ -9,7 +9,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackWidthSimpleCalculatorInputData : ICrackWidthSimpleCalculatorInputData
public class RebarCrackInputData : ICrackWidthSimpleCalculatorInputData
{
public CalcTerms CalcTerm { get; set; }
public StrainTuple StrainTuple { get; set; }

2
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculatorResult.cs → StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs
View File

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackWidthSimpleCalculatorResult : IResult
public class RebarCrackResult : IResult
{
public bool IsValid { get; set; }
public string Description { get; set; }

55
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs → StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs
View File

@@ -4,6 +4,7 @@ using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Primitives;
@@ -11,37 +12,54 @@ using StructureHelperLogics.Services.NdmPrimitives;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackWidthCalculator : ICalculator
public class TupleCrackCalculator : ICalculator
{
private static readonly ILengthBetweenCracksLogic lengthLogic = new LengthBetweenCracksLogicSP63();
private CrackWidthCalculatorResult result;
private TupleCrackResult result;
private IEnumerable<INdmPrimitive> ndmPrimitives;
private List<RebarPrimitive>? rebarPrimitives;
private IEnumerable<INdm> ndmCollection;
private IEnumerable<INdm> defaultNdm;
private IEnumerable<INdm> fulyCrackedNdm;
private CrackForceResult crackForceResult;
private StrainTuple strainTuple;
private ITriangulatePrimitiveLogic triangulateLogic;
public string Name { get; set; }
public CrackWidthCalculatorInputData InputData { get; set; }
public TupleCrackInputData InputData { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public void Run()
{
result = new() { IsValid = true, Description = ""};
PrepareNewResult();
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
try
{
ProcessCalculations();
TraceLogger?.AddMessage(LoggerStrings.CalculationHasDone);
}
catch (Exception ex)
{
result.IsValid = false;
result.Description += ex;
TraceLogger?.AddMessage(LoggerStrings.CalculationError + ex, TraceLogStatuses.Error);
}
}
private void PrepareNewResult()
{
result = new()
{
IsValid = true,
Description = string.Empty
};
}
private void ProcessCalculations()
{
CheckInputData();
@@ -49,12 +67,16 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
CalcStrainMatrix();
CalcCrackForce();
var crackInputData = GetCrackInputData();
var calculator = new CrackWidthSimpleCalculator { InputData = crackInputData };
var calculator = new RebarCrackCalculator
{
InputData = crackInputData,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
foreach (var item in rebarPrimitives)
{
crackInputData.RebarPrimitive = item;
calculator.Run();
var rebarResult = calculator.Result as CrackWidthSimpleCalculatorResult;
var rebarResult = calculator.Result as RebarCrackResult;
//if (crackForceResult.IsSectionCracked == false)
//{
// rebarResult.CrackWidth = 0d;
@@ -65,19 +87,19 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private void CalcStrainMatrix()
{
IForceTupleInputData inputData = new ForceTupleInputData() { NdmCollection = ndmCollection, Tuple = InputData.LongTermTuple};
IForceTupleInputData inputData = new ForceTupleInputData() { NdmCollection = defaultNdm, Tuple = InputData.LongTermTuple};
IForceTupleCalculator calculator = new ForceTupleCalculator() { InputData = inputData };
calculator.Run();
var forceResult = calculator.Result as IForcesTupleResult;
strainTuple = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix);
}
private CrackWidthSimpleCalculatorInputData GetCrackInputData()
private RebarCrackInputData GetCrackInputData()
{
lengthLogic.NdmCollection = ndmCollection;
lengthLogic.NdmCollection = defaultNdm;
lengthLogic.StrainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple);
var length = lengthLogic.GetLength();
var crackInputData = new CrackWidthSimpleCalculatorInputData
var crackInputData = new RebarCrackInputData
{
PsiSFactor = crackForceResult.PsiS,
Length = length,
@@ -97,14 +119,21 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
rebarPrimitives.Add(item as RebarPrimitive);
}
}
ndmCollection = NdmPrimitivesService.GetNdms(ndmPrimitives, LimitStates.SLS, CalcTerms.ShortTerm);
triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = ndmPrimitives,
LimitState = LimitStates.SLS,
CalcTerm = CalcTerms.ShortTerm,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
defaultNdm = triangulateLogic.GetNdms();
}
private void CalcCrackForce()
{
var calculator = new CrackForceCalculator();
calculator.EndTuple = InputData.LongTermTuple;
calculator.NdmCollection = ndmCollection;
calculator.NdmCollection = defaultNdm;
calculator.Run();
crackForceResult = calculator.Result as CrackForceResult;
}

9
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorInputData.cs → StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs
View File

@@ -10,10 +10,11 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackWidthCalculatorInputData : IInputData
public class TupleCrackInputData : IInputData
{
public IForceTuple LongTermTuple { get; set; }
public IForceTuple ShortTermTuple { get; set; }
public List<INdmPrimitive> NdmPrimitives {get;set;}
public bool IsValid { get; set; }
public IForceTuple? LongTermTuple { get; set; }
public IForceTuple? ShortTermTuple { get; set; }
public List<INdmPrimitive>? NdmPrimitives {get;set;}
}
}

8
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculatorResult.cs → StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs
View File

@@ -8,20 +8,20 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackWidthCalculatorResult : IResult
public class TupleCrackResult : IResult
{
public bool IsValid { get; set; }
public string Description { get; set; }
public IForceTuple LongTermTuple { get; set; }
public IForceTuple ShortTermTuple { get; set; }
public bool IsCracked { get; set; }
public List<CrackWidthSimpleCalculatorResult> RebarResults { get; set; }
public List<RebarCrackResult> RebarResults { get; set; }
public double MaxLongTermCrackWidth => IsCracked? RebarResults.Select(x => x.LongTermResult.CrackWidth).Max() : 0d;
public double MaxShortTermCrackWidth => IsCracked? RebarResults.Select(x => x.ShortTermResult.CrackWidth).Max() : 0d;
public CrackWidthCalculatorResult()
public TupleCrackResult()
{
RebarResults = new List<CrackWidthSimpleCalculatorResult>();
RebarResults = new ();
}
}
}

3
StructureHelperLogics/NdmCalculations/Primitives/IHasPrimitives.cs
View File

@@ -4,6 +4,9 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
{
public interface IHasPrimitives
{
/// <summary>
/// Collection of NdmPrimitives
/// </summary>
List<INdmPrimitive> Primitives { get; }
}
}

9
StructureHelperLogics/Services/NdmCalculations/CalculationService.cs
View File

@@ -21,11 +21,18 @@ namespace StructureHelperLogics.Services.NdmCalculations
public class CalculationService
{
private ICalculationProperty calculationProperty;
private ITriangulatePrimitiveLogic triangulateLogic;
public IStrainMatrix GetPrimitiveStrainMatrix(INdmPrimitive[] ndmPrimitives, double mx, double my, double nz)
{
var ndmCollection = new List<INdm>();
ndmCollection.AddRange(NdmPrimitivesService.GetNdms(ndmPrimitives, calculationProperty.LimitState, calculationProperty.CalcTerm));
triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = ndmPrimitives,
LimitState = calculationProperty.LimitState,
CalcTerm = calculationProperty.CalcTerm
};
ndmCollection.AddRange(triangulateLogic.GetNdms());
var loaderData = new LoaderOptions
{
Preconditions = new Preconditions

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

@@ -0,0 +1,16 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.Services.NdmPrimitives
{
public interface ITriangulatePrimitiveLogic : ILogic
{
IEnumerable<INdmPrimitive> Primitives { get; set; }
LimitStates LimitState { get; set; }
CalcTerms CalcTerm { get; set; }
List<INdm> GetNdms();
bool CheckPrimitives(IEnumerable<INdmPrimitive> primitives);
}
}

56
StructureHelperLogics/Services/NdmPrimitives/NdmPrimitivesService.cs
View File

@@ -1,56 +0,0 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
namespace StructureHelperLogics.Services.NdmPrimitives
{
public static class NdmPrimitivesService
{
public static List<INdm> GetNdms(IEnumerable<INdmPrimitive> primitives, LimitStates limitState, CalcTerms calcTerm)
{
var orderedNdmPrimitives = primitives.OrderBy(x => x.VisualProperty.ZIndex);
var ndms = new List<INdm>();
var triangulationOptions = new TriangulationOptions() { LimiteState = limitState, CalcTerm = calcTerm };
foreach (var item in orderedNdmPrimitives)
{
if (item is IHasDivisionSize)
{
var hasDivision = item as IHasDivisionSize;
if (hasDivision.ClearUnderlying == true)
{
ndms.RemoveAll(x => hasDivision.IsPointInside(new Point2D() { X = x.CenterX, Y = x.CenterY }) == true);
}
}
if (item.Triangulate == true)
{
ndms.AddRange(item.GetNdms(triangulationOptions));
}
}
return ndms;
}
public static bool CheckPrimitives(IEnumerable<INdmPrimitive> primitives)
{
if (!primitives.Any())
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Count of primitive must be greater than zero");
}
if (!primitives.Any(x => x.Triangulate == true))
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": There are not primitives to triangulate");
}
foreach (var item in primitives)
{
if (item.Triangulate == true &
item.HeadMaterial is null)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Primitive: {item.Name} can't be triangulated since material is null");
}
}
return true;
}
}
}

105
StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs Normal file
View File

@@ -0,0 +1,105 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
namespace StructureHelperLogics.Services.NdmPrimitives
{
public class TriangulatePrimitiveLogic : ITriangulatePrimitiveLogic
{
private List<INdm> ndmCollection;
public IEnumerable<INdmPrimitive> Primitives { get; set; }
public LimitStates LimitState { get; set; }
public CalcTerms CalcTerm { get; set; }
public bool ConsiderCracking { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public TriangulatePrimitiveLogic()
{
ConsiderCracking = false;
}
public List<INdm> GetNdms()
{
TraceLogger?.AddMessage($"Total count of primitives n = {Primitives.Count()}", TraceLogStatuses.Service);
TraceLogger?.AddMessage($"Limit state is {LimitState}", TraceLogStatuses.Service);
TraceLogger?.AddMessage($"Calc term is {CalcTerm}", TraceLogStatuses.Service);
var orderedNdmPrimitives = Primitives.OrderBy(x => x.VisualProperty.ZIndex);
ndmCollection = new List<INdm>();
foreach (var item in orderedNdmPrimitives)
{
TraceLogger?.AddMessage($"Triangulation of primitive {item.Name} has started", TraceLogStatuses.Service);
ProcessHasDivision(item);
TriangulatePrimitive(item);
}
if (TraceLogger is not null)
{
TraceService.TraceNdmCollection(TraceLogger, ndmCollection);
}
return ndmCollection;
}
private void TriangulatePrimitive(INdmPrimitive item)
{
if (item.Triangulate == true)
{
var triangulationOptions = new TriangulationOptions()
{
LimiteState = LimitState,
CalcTerm = CalcTerm
};
var itemNdms = item.GetNdms(triangulationOptions);
ndmCollection.AddRange(itemNdms);
TraceLogger?.AddMessage($"Triangulation of primitive {item.Name} was finished, {itemNdms.Count()} part(s) were obtained", TraceLogStatuses.Service);
}
else
{
TraceLogger?.AddMessage($"Triangulation of primitive was skiped cause its settings", TraceLogStatuses.Service);
}
}
private void ProcessHasDivision(INdmPrimitive? item)
{
if (item is IHasDivisionSize hasDivision)
{
if (hasDivision.ClearUnderlying == true)
{
TraceLogger?.AddMessage("Removing of background part has started", TraceLogStatuses.Service);
ndmCollection
.RemoveAll(x =>
hasDivision
.IsPointInside(new Point2D() { X = x.CenterX, Y = x.CenterY }) == true);
}
}
}
public bool CheckPrimitives(IEnumerable<INdmPrimitive> primitives)
{
if (!primitives.Any())
{
string errorMessage = string.Intern(ErrorStrings.DataIsInCorrect + $": Count of primitive must be greater than zero");
TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error);
throw new StructureHelperException(errorMessage);
}
if (!primitives.Any(x => x.Triangulate == true))
{
string errorMessage = string.Intern(ErrorStrings.DataIsInCorrect + $": There are not primitives to triangulate");
TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error);
throw new StructureHelperException(errorMessage);
}
foreach (var item in primitives)
{
if (item.Triangulate == true &
item.HeadMaterial is null)
{
string errorMessage = string.Intern(ErrorStrings.DataIsInCorrect + $": Primitive: {item.Name} can't be triangulated since material is null");
TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error);
throw new StructureHelperException(errorMessage);
}
}
return true;
}
}
}