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

Tuple crack calculator was changed

Browse Source
This commit is contained in:
Evgeny Redikultsev
2024-05-10 20:27:57 +05:00
parent e75521dc20
commit 871355e07b
29 changed files with 745 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
StructureHelperLogics/Services/NdmPrimitives/CheckPrimitivesForMeshingLogic.cs Normal file
View File

@@ -0,0 +1,47 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
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.Services.NdmPrimitives
{
public class CheckPrimitivesForMeshingLogic : ICheckPrimitivesForMeshingLogic
{
public IEnumerable<INdmPrimitive> Primitives { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public bool Check()
{
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
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;
}
}
}

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

@@ -0,0 +1,16 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Services.NdmPrimitives
{
public interface ICheckPrimitivesForMeshingLogic : ILogic
{
IEnumerable<INdmPrimitive> Primitives { get; set; }
bool Check();
}
}

18
StructureHelperLogics/Services/NdmPrimitives/IMeshHasDivisionLogic.cs Normal file
View File

@@ -0,0 +1,18 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Services.NdmPrimitives
{
public interface IMeshHasDivisionLogic : ILogic
{
List<INdm> NdmCollection { get; set; }
IHasDivisionSize Primitive { get; set; }
void MeshHasDivision();
}
}

19
StructureHelperLogics/Services/NdmPrimitives/IMeshPrimitiveLogic.cs Normal file
View File

@@ -0,0 +1,19 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Services.NdmPrimitives
{
public interface IMeshPrimitiveLogic : ILogic
{
INdmPrimitive Primitive { get; set; }
ITriangulationOptions TriangulationOptions { get; set; }
List<INdm> MeshPrimitive();
}
}

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

@@ -11,6 +11,5 @@ namespace StructureHelperLogics.Services.NdmPrimitives
LimitStates LimitState { get; set; }
CalcTerms CalcTerm { get; set; }
List<INdm> GetNdms();
bool CheckPrimitives(IEnumerable<INdmPrimitive> primitives);
}
}

98
StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs Normal file
View File

@@ -0,0 +1,98 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models.Materials;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.Models.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Services.NdmPrimitives
{
internal class MeshCrackedConcreteLogic : IMeshPrimitiveLogic
{
private IMeshPrimitiveLogic regularMeshLogic;
public List<INdm> NdmCollection { get; set; }
public INdmPrimitive Primitive { get; set; }
public ITriangulationOptions TriangulationOptions { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
List<INdm> IMeshPrimitiveLogic.MeshPrimitive()
{
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
CheckPrimitive();
List<INdm> ndmCollection = new();
if (Primitive.HeadMaterial.HelperMaterial is ICrackedMaterial)
{
TraceLogger?.AddMessage($"Primitive {Primitive.Name} is crackable primitive", TraceLogStatuses.Service);
var newPrimititve = Primitive.Clone() as INdmPrimitive;
SetNewMaterial(newPrimititve);
List<INdm> ndms = GetNdms(newPrimititve);
ndmCollection.AddRange(ndms);
}
else if (Primitive is RebarPrimitive rebar)
{
TraceLogger?.AddMessage($"Primitive {Primitive.Name} is rebar primitive", TraceLogStatuses.Service);
var newPrimititve = rebar.Clone() as RebarPrimitive;
var newHostPrimitive = rebar.HostPrimitive.Clone() as INdmPrimitive;
SetNewMaterial(newHostPrimitive);
newPrimititve.HostPrimitive = newHostPrimitive;
List<INdm> ndms = GetNdms(newPrimititve);
ndmCollection.AddRange(ndms);
}
else
{
TraceLogger?.AddMessage($"Primitive {Primitive.Name} is non-crackable primitive", TraceLogStatuses.Service);
List<INdm> ndms = GetNdms(Primitive);
ndmCollection.AddRange(ndms);
}
return ndmCollection;
}
private void SetNewMaterial(INdmPrimitive? newPrimititve)
{
TraceLogger?.AddMessage($"Process material {newPrimititve.HeadMaterial.Name} has started");
var newMaterial = newPrimititve.HeadMaterial.HelperMaterial.Clone() as ICrackedMaterial;
TraceLogger?.AddMessage($"Set work in tension zone for material {newPrimititve.HeadMaterial.Name}");
newMaterial.TensionForSLS = false;
newPrimititve.HeadMaterial.HelperMaterial = newMaterial as IHelperMaterial;
}
private List<INdm> GetNdms(INdmPrimitive primitive)
{
TraceLogger?.AddMessage($"Triangulation primitive has started");
regularMeshLogic = new MeshPrimitiveLogic()
{
Primitive = primitive,
TriangulationOptions = TriangulationOptions,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
List<INdm> ndms = regularMeshLogic.MeshPrimitive();
return ndms;
}
private void CheckPrimitive()
{
if (TriangulationOptions.LimiteState is not LimitStates.SLS)
{
string errorMessage = string.Intern(ErrorStrings.DataIsInCorrect + $": Limit state for cracking must correspondent limit state of serviceability");
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");
}
}
}

41
StructureHelperLogics/Services/NdmPrimitives/MeshHasDivisionLogic.cs Normal file
View File

@@ -0,0 +1,41 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.Models.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Services.NdmPrimitives
{
public class MeshHasDivisionLogic : IMeshHasDivisionLogic
{
public List<INdm> NdmCollection { get; set; }
public IHasDivisionSize Primitive { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public void MeshHasDivision()
{
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
if (Primitive 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);
}
}
}
}
}

34
StructureHelperLogics/Services/NdmPrimitives/MeshPrimitiveLogic.cs Normal file
View File

@@ -0,0 +1,34 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models.Materials;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.Models.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Services.NdmPrimitives
{
public class MeshPrimitiveLogic : IMeshPrimitiveLogic
{
public INdmPrimitive Primitive { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public ITriangulationOptions TriangulationOptions { get; set; }
public List<INdm> MeshPrimitive()
{
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
List<INdm> ndmCollection = new();
var itemNdms = Primitive.GetNdms(TriangulationOptions);
ndmCollection.AddRange(itemNdms);
TraceLogger?.AddMessage($"Triangulation of primitive {Primitive.Name} has finished, {itemNdms.Count()} part(s) were obtained", TraceLogStatuses.Service);
return ndmCollection;
}
}
}

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

@@ -2,7 +2,10 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models.Materials;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
@@ -10,49 +13,85 @@ namespace StructureHelperLogics.Services.NdmPrimitives
{
public class TriangulatePrimitiveLogic : ITriangulatePrimitiveLogic
{
private IMeshHasDivisionLogic divisionLogic;
private IMeshPrimitiveLogic meshLogic;
private List<INdm> ndmCollection;
private ICheckPrimitivesForMeshingLogic checkLogic;
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()
public TriangulatePrimitiveLogic(IMeshPrimitiveLogic meshPrimitiveLogic)
{
ConsiderCracking = false;
meshLogic = meshPrimitiveLogic;
}
public TriangulatePrimitiveLogic() : this (new MeshPrimitiveLogic()) { }
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);
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
CheckPrimitives();
ndmCollection = new List<INdm>();
foreach (var item in orderedNdmPrimitives)
SetLogics();
TraceInitialSettings();
TriangulatePrimitives();
return ndmCollection;
}
private void TriangulatePrimitives()
{
var orderedNdmPrimitives = Primitives.OrderBy(x => x.VisualProperty.ZIndex);
foreach (var primitive in orderedNdmPrimitives)
{
TraceLogger?.AddMessage($"Triangulation of primitive {item.Name} has started", TraceLogStatuses.Service);
ProcessHasDivision(item);
TriangulatePrimitive(item);
TriangulatePrimitive(primitive);
}
if (TraceLogger is not null)
{
TraceService.TraceNdmCollection(TraceLogger, ndmCollection);
}
return ndmCollection;
TraceLogger?.AddMessage($"Triangulation of primitives has finished, {ndmCollection.Count} part(s) were obtained", TraceLogStatuses.Service);
}
private void TriangulatePrimitive(INdmPrimitive item)
private void TraceInitialSettings()
{
if (item.Triangulate == true)
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);
}
private void SetLogics()
{
divisionLogic = new MeshHasDivisionLogic()
{
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);
NdmCollection = ndmCollection,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
var triangulationOptions = new TriangulationOptions()
{
LimiteState = LimitState,
CalcTerm = CalcTerm
};
meshLogic.TriangulationOptions = triangulationOptions;
meshLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
}
private void TriangulatePrimitive(INdmPrimitive primitive)
{
TraceLogger?.AddMessage($"Triangulation of primitive {primitive.Name} has started", TraceLogStatuses.Service);
if (primitive is IHasDivisionSize hasDivision)
{
divisionLogic.Primitive = hasDivision;
divisionLogic.MeshHasDivision();
}
if (primitive.Triangulate == true)
{
meshLogic.Primitive = primitive;
var ndms = meshLogic.MeshPrimitive();
ndmCollection.AddRange(ndms);
}
else
{
@@ -60,45 +99,14 @@ namespace StructureHelperLogics.Services.NdmPrimitives
}
}
private void ProcessHasDivision(INdmPrimitive? item)
private bool CheckPrimitives()
{
if (item is IHasDivisionSize hasDivision)
checkLogic = new CheckPrimitivesForMeshingLogic()
{
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);
}
}
Primitives = Primitives,
TraceLogger = TraceLogger?.GetSimilarTraceLogger(50)
};
checkLogic.Check();
return true;
}
}