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

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

@@ -55,7 +55,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
if (combination.SetInGravityCenter == true)
{
var loaderPoint = LoaderCalculator.Logics.Geometry.GeometryOperations.GetGravityCenter(ndms);
point2D = new Point2D() { X = loaderPoint.CenterX, Y = loaderPoint.CenterY };
point2D = new Point2D() { X = loaderPoint.Cx, Y = loaderPoint.Cy };
}
else point2D = combination.ForcePoint;
var newTuple = ForceTupleService.MoveTupleIntoPoint(tuple.ForceTuple, point2D) as ForceTuple;

5
StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs
View File

@@ -4,6 +4,7 @@ using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -28,8 +29,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": main material is incorrect or null");
}
var material = ndmPrimitive.HeadMaterial.GetLoaderMaterial(limitState, calcTerm);
var ndm = ndmPrimitive.GetNdms(material).Single();
var triangulationOptions = new TriangulationOptions() { LimiteState = limitState, CalcTerm = calcTerm };
var ndm = ndmPrimitive.GetNdms(triangulationOptions).Single();
if (strainMatrix is not null)
{
inputData.ReinforcementStress = stressLogic.GetStress(strainMatrix, ndm);

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

@@ -81,10 +81,10 @@ namespace StructureHelperLogics.NdmCalculations.Buckling
var otherInertia = GeometryOperations.GetReducedMomentsOfInertia(otherNdms, gravityCenter);
var stiffnessX = stiffnessLogicX.GetStiffnessCoeffitients();
var dX = stiffnessX.Kc * concreteInertia.MomentX + stiffnessX.Ks * otherInertia.MomentX;
var dX = stiffnessX.Kc * concreteInertia.EIx + stiffnessX.Ks * otherInertia.EIx;
var stiffnessY = stiffnessLogicY.GetStiffnessCoeffitients();
var dY = stiffnessY.Kc * concreteInertia.MomentY + stiffnessY.Ks * otherInertia.MomentY;
var dY = stiffnessY.Kc * concreteInertia.EIy + stiffnessY.Ks * otherInertia.EIy;
return (dX, dY);
}

33
StructureHelperLogics/NdmCalculations/Cracking/AverageDiameterLogic.cs Normal file
View File

@@ -0,0 +1,33 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Exceptions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class AverageDiameterLogic : IAverageDiameterLogic
{
public IEnumerable<RebarNdm> Rebars { get; set; }
public double GetAverageDiameter()
{
Check();
var rebarArea = Rebars
.Sum(x => x.Area);
var rebarCount = Rebars.Count();
var averageArea = rebarArea / rebarCount;
var diameter = Math.Sqrt(averageArea / Math.PI);
return diameter;
}
private void Check()
{
if (!Rebars.Any())
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": rebars count must be greater then zero");
}
}
}
}

53
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs Normal file
View File

@@ -0,0 +1,53 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackWidthLogicSP63 : ICrackWidthLogic
{
public double RebarStrain { get; set; }
public double ConcreteStrain { get; set; }
public double Length { get; set; }
public double TermFactor { get; set; }
public double BondFactor { get; set; }
public double StressStateFactor { get; set; }
public double PsiSFactor { get; set; }
public double GetCrackWidth()
{
CheckOptions();
//check if strain of concrete greater than strain of rebar
if (ConcreteStrain > RebarStrain) { return 0d; }
double width = (RebarStrain - ConcreteStrain) * Length;
width *= TermFactor * BondFactor * StressStateFactor * PsiSFactor;
return width;
}
private void CheckOptions()
{
if (Length <=0d)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": length between cracks L={Length} must be greate than zero");
}
if (TermFactor <= 0d)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Term factor {TermFactor} must be greate than zero");
}
if (BondFactor <= 0d)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Bond factor {BondFactor} must be greate than zero");
}
if (StressStateFactor <= 0d)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": Bond factor {StressStateFactor} must be greate than zero");
}
if (PsiSFactor <= 0d)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": PsiS factor {PsiSFactor} must be greate than zero");
}
}
}
}

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

@@ -0,0 +1,15 @@
using LoaderCalculator.Data.Ndms;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface IAverageDiameterLogic
{
IEnumerable<RebarNdm> Rebars { get; set; }
double GetAverageDiameter();
}
}

31
StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthLogic.cs Normal file
View File

@@ -0,0 +1,31 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
/// <summary>
/// Logic for calculating width of crack
/// </summary>
public interface ICrackWidthLogic
{
/// <summary>
/// strain of rebar, dimensionless
/// </summary>
double RebarStrain { get; set; }
/// <summary>
/// strain of concrete, dimensionless
/// </summary>
double ConcreteStrain { get; set; }
/// <summary>
/// Length between cracks in meters
/// </summary>
double Length { get; set; }
/// <summary>
/// return width of crack in meters
/// </summary>
double GetCrackWidth();
}
}

17
StructureHelperLogics/NdmCalculations/Cracking/ILengthBetweenCracksLogic.cs Normal file
View File

@@ -0,0 +1,17 @@
using LoaderCalculator.Data.Matrix;
using LoaderCalculator.Data.Ndms;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface ILengthBetweenCracksLogic
{
IEnumerable<INdm> NdmCollection { get; set; }
IStrainMatrix StrainMatrix { get; set; }
double GetLength();
}
}

21
StructureHelperLogics/NdmCalculations/Cracking/ITensileAreaLogic.cs Normal file
View File

@@ -0,0 +1,21 @@
using LoaderCalculator.Data.Matrix;
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
{
/// <summary>
/// Logic fo calculating of tensile area of RC crosssection
/// </summary>
public interface ITensileAreaLogic
{
IEnumerable<INdm> NdmCollection { get; set; }
IStrainMatrix StrainMatrix { get; set; }
double GetTensileArea();
}
}

49
StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs Normal file
View File

@@ -0,0 +1,49 @@
using LoaderCalculator.Data.Matrix;
using LoaderCalculator.Data.Ndms;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class LengthBetweenCracksLogicSP63 : ILengthBetweenCracksLogic
{
const double minDiameterFactor = 10d;
const double maxDiameterFactor = 40d;
const double minLength = 0.1d;
const double maxLength = 0.4d;
readonly IAverageDiameterLogic diameterLogic;
readonly ITensileAreaLogic tensileAreaLogic;
public IEnumerable<INdm> NdmCollection { get; set; }
public IStrainMatrix StrainMatrix { get; set; }
public LengthBetweenCracksLogicSP63(IAverageDiameterLogic diameterLogic, ITensileAreaLogic tensileAreaLogic)
{
this.diameterLogic = diameterLogic;
this.tensileAreaLogic = tensileAreaLogic;
}
public LengthBetweenCracksLogicSP63() :
this
( new AverageDiameterLogic(),
new TensileAreaLogicSP63())
{ }
public double GetLength()
{
var rebars = NdmCollection
.Where(x => x is RebarNdm)
.Select(x => x as RebarNdm);
var rebarArea = rebars.Sum(x => x.Area * x.StressScale);
diameterLogic.Rebars = rebars;
var rebarDiameter = diameterLogic.GetAverageDiameter();
tensileAreaLogic.NdmCollection = NdmCollection;
tensileAreaLogic.StrainMatrix = StrainMatrix;
var concreteArea = tensileAreaLogic.GetTensileArea();
var length = concreteArea / rebarArea * rebarDiameter;
length = new List<double> { length, minDiameterFactor * rebarDiameter, minLength }.Max();
length = new List<double> { length, maxDiameterFactor * rebarDiameter, maxLength }.Min();
return length;
}
}
}

45
StructureHelperLogics/NdmCalculations/Cracking/TensileAreaLogicSP63.cs Normal file
View File

@@ -0,0 +1,45 @@
using LoaderCalculator.Data.Materials;
using LoaderCalculator.Data.Matrix;
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Logics;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Services.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class TensileAreaLogicSP63 : ITensileAreaLogic
{
const double maxConcreteFactor = 0.5d;
const double minConcreteFactor = 0.1d;
const double minRebarFactor = 3d;
private static IStressLogic stressLogic => new StressLogic();
public IEnumerable<INdm> NdmCollection { get; set; }
public IStrainMatrix StrainMatrix { get; set; }
public double GetTensileArea()
{
var rebarCollection = NdmCollection
.Where(x => x is RebarNdm);
var rebarArea = rebarCollection.
Sum(x => x.Area * x.StressScale);
var concreteCollection = NdmCollection
.Where(x => x.Material is ConcreteMaterial);
var concreteArea = concreteCollection
.Sum(x => x.Area * x.StressScale);
var concreteTensileArea = concreteCollection
.Where(x => stressLogic.GetTotalStrainWithPresrain(StrainMatrix, x) > 0d)
.Sum(x => x.Area * x.StressScale);
concreteTensileArea = Math.Max(concreteTensileArea, rebarArea * minRebarFactor);
concreteTensileArea = Math.Max(concreteTensileArea, concreteArea * minConcreteFactor);
concreteTensileArea = Math.Min(concreteTensileArea, concreteArea * maxConcreteFactor);
return concreteTensileArea;
}
}
}

9
StructureHelperLogics/NdmCalculations/Primitives/CirclePrimitive.cs
View File

@@ -52,12 +52,15 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
return primitive;
}
/// <inheritdoc/>
public IEnumerable<INdm> GetNdms(IMaterial material)
public IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions)
{
var ndms = new List<INdm>();
var options = new CircleTriangulationLogicOptions(this);
var options = new CircleTriangulationLogicOptions(this)
{
triangulationOptions = triangulationOptions
};
var logic = new CircleTriangulationLogic(options);
ndms.AddRange(logic.GetNdmCollection(material));
ndms.AddRange(logic.GetNdmCollection());
return ndms;
}
/// <inheritdoc/>

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

@@ -9,6 +9,7 @@ using StructureHelperCommon.Infrastructures.Interfaces;
using System;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.Models.CrossSections;
using StructureHelperLogics.NdmCalculations.Triangulations;
namespace StructureHelperLogics.NdmCalculations.Primitives
{
@@ -26,6 +27,6 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
StrainTuple AutoPrestrain { get; }
IVisualProperty VisualProperty {get; }
IEnumerable<INdm> GetNdms(IMaterial material);
IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions);
}
}

28
StructureHelperLogics/NdmCalculations/Primitives/PointPrimitive.cs
View File

@@ -1,16 +1,10 @@
using StructureHelperLogics.Models.Materials;
using StructureHelperCommon.Models.Shapes;
using LoaderCalculator.Data.Ndms;
using StructureHelper.Models.Materials;
using System.Collections.Generic;
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Data.Materials;
using StructureHelperCommon.Infrastructures.Interfaces;
using System;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.Models.CrossSections;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Triangulations;
using StructureHelperLogics.Services.NdmPrimitives;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.Models.CrossSections;
namespace StructureHelperLogics.Models.Primitives
{
@@ -47,18 +41,18 @@ namespace StructureHelperLogics.Models.Primitives
{}
public PointPrimitive(IHeadMaterial material) : this() { HeadMaterial = material; }
public IEnumerable<INdm> GetNdms(IMaterial material)
{
var options = new PointTriangulationLogicOptions(this);
IPointTriangulationLogic logic = new PointTriangulationLogic(options);
return logic.GetNdmCollection(material);
}
public object Clone()
{
var primitive = new PointPrimitive();
updateStrategy.Update(primitive, this);
return primitive;
}
public IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions)
{
var options = new PointTriangulationLogicOptions(this) { triangulationOptions = triangulationOptions};
var logic = new PointTriangulationLogic(options);
return logic.GetNdmCollection();
}
}
}

18
StructureHelperLogics/NdmCalculations/Primitives/RebarPrimitive.cs
View File

@@ -22,7 +22,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
public class RebarPrimitive : IPointPrimitive, IHasHostPrimitive
{
static readonly RebarUpdateStrategy updateStrategy = new();
IDataRepository<RebarPrimitive> repository;
/// <inheritdoc/>
public string Name { get; set; }
/// <inheritdoc/>
@@ -66,16 +66,14 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
return primitive;
}
public IEnumerable<INdm> GetNdms(IMaterial material)
public IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions)
{
var options = new PointTriangulationLogicOptions(this);
IPointTriangulationLogic logic = new PointTriangulationLogic(options);
return logic.GetNdmCollection(material);
}
public void Save()
{
repository.Create(this);
var options = new RebarTriangulationLogicOptions(this)
{
triangulationOptions = triangulationOptions
};
var logic = new RebarTriangulationLogic(options);
return logic.GetNdmCollection();
}
}
}

9
StructureHelperLogics/NdmCalculations/Primitives/RectanglePrimitive.cs
View File

@@ -55,12 +55,15 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
return primitive;
}
public IEnumerable<INdm> GetNdms(IMaterial material)
public IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions)
{
var ndms = new List<INdm>();
var options = new RectangleTriangulationLogicOptions(this);
var options = new RectangleTriangulationLogicOptions(this)
{
triangulationOptions = triangulationOptions
};
var logic = new RectangleTriangulationLogic(options);
ndms.AddRange(logic.GetNdmCollection(material));
ndms.AddRange(logic.GetNdmCollection());
return ndms;
}

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