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

Icons were added

Browse Source
This commit is contained in:
Evgeny Redikultsev
2023-08-12 14:53:38 +05:00
parent ce97586d2b
commit 80302525b3
103 changed files with 1133 additions and 449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogic.cs
View File

@@ -12,16 +12,14 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
internal class CircleTriangulationLogic : ITriangulationLogic
{
CircleTriangulationLogicOptions options;
public ITriangulationLogicOptions Options { get; private set; }
private readonly CircleTriangulationLogicOptions options;
public CircleTriangulationLogic(ITriangulationLogicOptions options)
{
ValidateOptions(options);
this.options = options as CircleTriangulationLogicOptions;
Options = options;
}
public IEnumerable<INdm> GetNdmCollection(IMaterial material)
public IEnumerable<INdm> GetNdmCollection()
{
double diameter = options.Circle.Diameter;
@@ -29,7 +27,10 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
int ndmMinDivision = options.NdmMinDivision;
var logicOptions = new LoaderCalculator.Triangulations.CircleTriangulationLogicOptions(diameter, ndmMaxSize, ndmMinDivision);
var logic = LoaderCalculator.Triangulations.Triangulation.GetLogicInstance(logicOptions);
var ndmCollection = logic.GetNdmCollection(new LoaderCalculator.Data.Planes.CirclePlane { Material = material });
var ndmCollection = logic.GetNdmCollection(new LoaderCalculator.Data.Planes.CirclePlane
{
Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm)
});
TriangulationService.CommonTransform(ndmCollection, options);
TriangulationService.SetPrestrain(ndmCollection, options.Prestrain);
return ndmCollection;
@@ -37,9 +38,9 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
public void ValidateOptions(ITriangulationLogicOptions options)
{
if (options is not ICircleTriangulationLogicOptions )
if (options is not CircleTriangulationLogicOptions )
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $"\n Expected: {nameof(ICircleTriangulationLogicOptions)}, But was: {nameof(options)}");
throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(CircleTriangulationLogicOptions), options.GetType()));
}
}
}

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

@@ -1,5 +1,7 @@
using StructureHelperCommon.Models.Forces;
using StructureHelper.Models.Materials;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
@@ -9,7 +11,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class CircleTriangulationLogicOptions : ICircleTriangulationLogicOptions
public class CircleTriangulationLogicOptions : IShapeTriangulationLogicOptions
{
public ICircleShape Circle { get; }
@@ -20,19 +22,17 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
public int NdmMinDivision { get; }
public StrainTuple Prestrain { get; set; }
public ITriangulationOptions triangulationOptions { get; set; }
public IHeadMaterial HeadMaterial { get; set; }
public CircleTriangulationLogicOptions(ICirclePrimitive primitive)
{
Center = new Point2D() { X = primitive.Center.X, Y = primitive.Center.Y };
Center = primitive.Center.Clone() as Point2D;
Circle = primitive;
NdmMaxSize = primitive.NdmMaxSize;
NdmMinDivision = primitive.NdmMinDivision;
Prestrain = new StrainTuple
{
Mx = primitive.UsersPrestrain.Mx + primitive.AutoPrestrain.Mx,
My = primitive.UsersPrestrain.My + primitive.AutoPrestrain.My,
Nz = primitive.UsersPrestrain.Nz + primitive.AutoPrestrain.Nz
};
HeadMaterial = primitive.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.UsersPrestrain, primitive.AutoPrestrain) as StrainTuple;
}
}
}

18
StructureHelperLogics/NdmCalculations/Triangulations/ICircleTriangulationLogicOptions.cs
View File

@@ -1,18 +0,0 @@
using StructureHelperCommon.Models.Shapes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
internal interface ICircleTriangulationLogicOptions : IShapeTriangulationLogicOptions
{
/// <summary>
/// Shape
/// </summary>
ICircleShape Circle { get; }
}
}

6
StructureHelperLogics/NdmCalculations/Triangulations/IPointTriangulationLogic.cs
View File

@@ -1,6 +0,0 @@
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
interface IPointTriangulationLogic : ITriangulationLogic
{
}
}

10
StructureHelperLogics/NdmCalculations/Triangulations/IPointTriangulationLogicOptions.cs
View File

@@ -1,10 +0,0 @@
using StructureHelperCommon.Models.Shapes;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public interface IPointTriangulationLogicOptions : ITriangulationLogicOptions
{
IPoint2D Center { get; }
double Area { get; }
}
}

6
StructureHelperLogics/NdmCalculations/Triangulations/IRectangleTriangulationLogic.cs
View File

@@ -1,6 +0,0 @@
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public interface IRectangleTriangulationLogic : ITriangulationLogic
{
}
}

16
StructureHelperLogics/NdmCalculations/Triangulations/IRectangleTriangulationLogicOptions.cs
View File

@@ -1,16 +0,0 @@
using StructureHelperCommon.Models.Shapes;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
/// <summary>
/// Parameter of triangulation of rectangle part of section
/// Параметры триангуляции прямоугольного участка сечения
/// </summary>
public interface IRectangleTriangulationLogicOptions : IShapeTriangulationLogicOptions
{
/// <summary>
///
/// </summary>
IRectangleShape Rectangle { get; }
}
}

3
StructureHelperLogics/NdmCalculations/Triangulations/ITriangulationLogic.cs
View File

@@ -6,8 +6,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public interface ITriangulationLogic
{
ITriangulationLogicOptions Options { get; }
IEnumerable<INdm> GetNdmCollection(IMaterial material);
IEnumerable<INdm> GetNdmCollection();
void ValidateOptions(ITriangulationLogicOptions options);
}
}

6
StructureHelperLogics/NdmCalculations/Triangulations/ITriangulationLogicOptions.cs
View File

@@ -1,9 +1,13 @@
using StructureHelperCommon.Models.Forces;
using StructureHelper.Models.Materials;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models.Forces;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public interface ITriangulationLogicOptions
{
ITriangulationOptions triangulationOptions { get; set; }
StrainTuple Prestrain { get; set; }
IHeadMaterial HeadMaterial { get; set; }
}
}

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

@@ -1,37 +1,40 @@
using LoaderCalculator.Data.Materials;
using LoaderCalculator.Data.Ndms;
using System;
using System.Collections.Generic;
using StructureHelperCommon.Models.Shapes;
using LoaderCalculator.Data.Matrix;
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Data.Ndms.Transformations;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Services.Forces;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class PointTriangulationLogic : IPointTriangulationLogic
public class PointTriangulationLogic : ITriangulationLogic
{
public ITriangulationLogicOptions Options { get; }
private readonly PointTriangulationLogicOptions options;
public PointTriangulationLogic(ITriangulationLogicOptions options)
{
Options = options;
ValidateOptions(options);
this.options = options as PointTriangulationLogicOptions;
}
public IEnumerable<INdm> GetNdmCollection(IMaterial material)
public IEnumerable<INdm> GetNdmCollection()
{
IPointTriangulationLogicOptions options = Options as IPointTriangulationLogicOptions;
IPoint2D center = options.Center;
double area = options.Area;
List<INdm> ndmCollection = new List<INdm>();
INdm ndm = new Ndm { CenterX = center.X, CenterY = center.Y, Area = area, Material = material };
ndmCollection.Add(ndm);
NdmTransform.SetPrestrain(ndmCollection, new StrainMatrix() { Kx = options.Prestrain.Mx, Ky = options.Prestrain.My, EpsZ = options.Prestrain.Nz });
var ndm = new Ndm
{
CenterX = options.Center.X,
CenterY = options.Center.Y,
Area = options.Area,
Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm)
};
List<INdm> ndmCollection = new () { ndm};
NdmTransform.SetPrestrain(ndmCollection, StrainTupleService.ConvertToLoaderStrainMatrix(options.Prestrain));
return ndmCollection;
}
public void ValidateOptions(ITriangulationLogicOptions options)
{
throw new NotImplementedException();
if (options is not PointTriangulationLogicOptions)
{
throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(PointTriangulationLogicOptions), options.GetType()));
}
}
}
}

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

@@ -1,5 +1,8 @@
using StructureHelperCommon.Models.Forces;
using LoaderCalculator.Data.Materials;
using StructureHelper.Models.Materials;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Triangulations
@@ -7,8 +10,9 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
/// <summary>
///
/// </summary>
public class PointTriangulationLogicOptions : IPointTriangulationLogicOptions
public class PointTriangulationLogicOptions : ITriangulationLogicOptions
{
public ITriangulationOptions triangulationOptions { get; set; }
/// <summary>
///
/// </summary>
@@ -16,26 +20,16 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
/// <inheritdoc />
public double Area { get; }
public StrainTuple Prestrain { get; set; }
public IHeadMaterial HeadMaterial { get; set; }
/// <inheritdoc />
public PointTriangulationLogicOptions(IPoint2D center, double area)
{
Center = center;
Area = area;
Prestrain = new StrainTuple();
}
public PointTriangulationLogicOptions(IPointPrimitive primitive)
{
Center = new Point2D() { X = primitive.Center.X, Y = primitive.Center.Y };
Center = primitive.Center.Clone() as Point2D;
Area = primitive.Area;
Prestrain = new StrainTuple
{
Mx = primitive.UsersPrestrain.Mx + primitive.AutoPrestrain.Mx,
My = primitive.UsersPrestrain.My + primitive.AutoPrestrain.My,
Nz = primitive.UsersPrestrain.Nz + primitive.AutoPrestrain.Nz
};
HeadMaterial = primitive.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.UsersPrestrain, primitive.AutoPrestrain) as StrainTuple;
}
}
}

55
StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs Normal file
View File

@@ -0,0 +1,55 @@
using LoaderCalculator.Data.Materials;
using LoaderCalculator.Data.Matrix;
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Data.Ndms.Transformations;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
internal class RebarTriangulationLogic : ITriangulationLogic
{
private readonly RebarTriangulationLogicOptions options;
public RebarTriangulationLogic(ITriangulationLogicOptions options)
{
ValidateOptions(options);
this.options = options as RebarTriangulationLogicOptions;
}
public IEnumerable<INdm> GetNdmCollection()
{
var concreteNdm = new Ndm
{
CenterX = options.Center.X,
CenterY = options.Center.Y,
Area = options.Area,
Material = options.HostMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm),
StressScale = -1d
};
var rebarNdm = new RebarNdm
{
CenterX = options.Center.X,
CenterY = options.Center.Y,
Area = options.Area,
Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm)
};
List<INdm> ndmCollection = new() { concreteNdm, rebarNdm};
//List<INdm> ndmCollection = new() { rebarNdm };
NdmTransform.SetPrestrain(ndmCollection, StrainTupleService.ConvertToLoaderStrainMatrix(options.Prestrain));
return ndmCollection;
}
public void ValidateOptions(ITriangulationLogicOptions options)
{
if (options is not RebarTriangulationLogicOptions)
{
throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(RebarTriangulationLogicOptions), options.GetType()));
}
}
}
}

37
StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs Normal file
View File

@@ -0,0 +1,37 @@
using StructureHelper.Models.Materials;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class RebarTriangulationLogicOptions : ITriangulationLogicOptions
{
public ITriangulationOptions triangulationOptions { get; set; }
/// <summary>
///
/// </summary>
public IPoint2D Center { get; }
/// <inheritdoc />
public double Area { get; }
public StrainTuple Prestrain { get; set; }
public IHeadMaterial HeadMaterial { get; set; }
public IHeadMaterial HostMaterial { get; set; }
/// <inheritdoc />
public RebarTriangulationLogicOptions(RebarPrimitive primitive)
{
Center = primitive.Center.Clone() as Point2D;
Area = primitive.Area;
HeadMaterial = primitive.HeadMaterial;
HostMaterial = primitive.HostPrimitive.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.UsersPrestrain, primitive.AutoPrestrain) as StrainTuple;
}
}
}

34
StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogic.cs
View File

@@ -1,19 +1,18 @@
using LoaderCalculator.Data.Materials;
using LoaderCalculator.Data.Ndms;
using System;
using System.Collections.Generic;
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Data.Ndms.Transformations;
using LoaderCalculator.Data.Matrix;
using StructureHelperCommon.Infrastructures.Exceptions;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class RectangleTriangulationLogic : IRectangleTriangulationLogic
public class RectangleTriangulationLogic : ITriangulationLogic
{
IRectangleTriangulationLogicOptions options;
public ITriangulationLogicOptions Options { get; }
public IEnumerable<INdm> GetNdmCollection(IMaterial material)
private readonly RectangleTriangulationLogicOptions options;
public RectangleTriangulationLogic(ITriangulationLogicOptions options)
{
ValidateOptions(options);
this.options = options as RectangleTriangulationLogicOptions;
}
public IEnumerable<INdm> GetNdmCollection()
{
double width = options.Rectangle.Width;
double height = options.Rectangle.Height;
@@ -21,7 +20,10 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
int ndmMinDivision = options.NdmMinDivision;
LoaderCalculator.Triangulations.RectangleTriangulationLogicOptions logicOptions = new LoaderCalculator.Triangulations.RectangleTriangulationLogicOptions(width, height, ndmMaxSize, ndmMinDivision);
var logic = LoaderCalculator.Triangulations.Triangulation.GetLogicInstance(logicOptions);
var ndmCollection = logic.GetNdmCollection(new LoaderCalculator.Data.Planes.RectangularPlane { Material = material });
var ndmCollection = logic.GetNdmCollection(new LoaderCalculator.Data.Planes.RectangularPlane
{
Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm)
});
TriangulationService.CommonTransform(ndmCollection, options);
double angle = options.Rectangle.Angle;
NdmTransform.Rotate(ndmCollection, angle);
@@ -31,17 +33,11 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
public void ValidateOptions(ITriangulationLogicOptions options)
{
if (options is not IRectangleTriangulationLogicOptions)
if (options is not RectangleTriangulationLogicOptions)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $"\n Expected: {nameof(IRectangleTriangulationLogicOptions)}, But was: {nameof(options)}");
throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(RectangleTriangulationLogicOptions), options.GetType()));
}
}
public RectangleTriangulationLogic(ITriangulationLogicOptions options)
{
ValidateOptions(options);
this.options = options as IRectangleTriangulationLogicOptions;
Options = options;
}
}
}

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

@@ -1,11 +1,13 @@
using StructureHelperCommon.Models.Forces;
using StructureHelper.Models.Materials;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
/// <inheritdoc />
public class RectangleTriangulationLogicOptions : IRectangleTriangulationLogicOptions
public class RectangleTriangulationLogicOptions : IShapeTriangulationLogicOptions
{
/// <inheritdoc />
public IPoint2D Center { get; }
@@ -17,6 +19,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
public int NdmMinDivision { get; }
/// <inheritdoc />
public StrainTuple Prestrain { get; set; }
public ITriangulationOptions triangulationOptions { get; set; }
public IHeadMaterial HeadMaterial { get; set; }
public RectangleTriangulationLogicOptions(IPoint2D center, IRectangleShape rectangle, double ndmMaxSize, int ndmMinDivision)
{
@@ -33,12 +37,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
Rectangle = primitive;
NdmMaxSize = primitive.NdmMaxSize;
NdmMinDivision = primitive.NdmMinDivision;
Prestrain = new StrainTuple
{
Mx = primitive.UsersPrestrain.Mx + primitive.AutoPrestrain.Mx,
My = primitive.UsersPrestrain.My + primitive.AutoPrestrain.My,
Nz = primitive.UsersPrestrain.Nz + primitive.AutoPrestrain.Nz
};
HeadMaterial = primitive.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.UsersPrestrain, primitive.AutoPrestrain) as StrainTuple;
}
}
}

31
StructureHelperLogics/NdmCalculations/Triangulations/Triangulation.cs
View File

@@ -6,22 +6,21 @@ using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public static class Triangulation
public static class Triangulation1
{
public static IEnumerable<INdm> GetNdms(IEnumerable<INdmPrimitive> ndmPrimitives, ITriangulationOptions options)
{
List<INdm> ndms = new List<INdm>();
var headMaterials = GetPrimitiveMaterials(ndmPrimitives);
Dictionary<Guid, IMaterial> materials = GetMaterials(headMaterials, options);
foreach (var ndmPrimitive in ndmPrimitives)
{
IHeadMaterial headMaterial = ndmPrimitive.HeadMaterial;
IMaterial material;
if (materials.TryGetValue(headMaterial.Id, out material) == false) { throw new Exception("Material dictionary is not valid"); }
IEnumerable<INdm> localNdms = GetNdmsByPrimitive(ndmPrimitive, material);
ndms.AddRange(localNdms);
}
return ndms;
return ndmPrimitives.SelectMany(x => x.GetNdms(options));
//var headMaterials = GetPrimitiveMaterials(ndmPrimitives);
//Dictionary<Guid, IMaterial> materials = GetMaterials(headMaterials, options);
//foreach (var ndmPrimitive in ndmPrimitives)
//{
// IHeadMaterial headMaterial = ndmPrimitive.HeadMaterial;
// IMaterial material;
// if (materials.TryGetValue(headMaterial.Id, out material) == false) { throw new Exception("Material dictionary is not valid"); }
// IEnumerable<INdm> localNdms = GetNdmsByPrimitive(ndmPrimitive, options);
// ndms.AddRange(localNdms);
//}
}
/// <summary>
/// Returns dictionary of unique materials by collection of primitives
@@ -60,10 +59,10 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
return materials;
}
private static IEnumerable<INdm> GetNdmsByPrimitive(INdmPrimitive primitive, IMaterial material)
private static IEnumerable<INdm> GetNdmsByPrimitive(INdmPrimitive primitive, ITriangulationOptions options)
{
List<INdm> ndms = new List<INdm>();
ndms.AddRange(primitive.GetNdms(material));
List<INdm> ndms = new ();
ndms.AddRange(primitive.GetNdms(options));
return ndms;
}
}