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

Add inclined rebar

Browse Source
This commit is contained in:
RedikultsevEvg
2025-07-07 00:06:54 +05:00
parent 0975dde696
commit 1bc7799d3c
37 changed files with 751 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
StructureHelperLogics/Models/BeamShears/IStirrupByInclinedRebar.cs Normal file
View File

@@ -0,0 +1,27 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
/// <summary>
/// Implements properies of stirrup by inclined rebar
/// </summary>
public interface IStirrupByInclinedRebar : IStirrup
{
/// <summary>
/// Coordinate of start point of inclination, m
/// </summary>
double StartCoordinate { get; set; }
/// <summary>
/// Distance beetwen start/end point and point where rebar work is started
/// </summary>
double OffSet { get; set; }
/// <summary>
/// Angle of inclination of rebar in degrees
/// </summary>
double AngleOfInclination { get; set; }
}
}

4
StructureHelperLogics/Models/BeamShears/IStirrupByRebar.cs
View File

@@ -17,6 +17,10 @@ namespace StructureHelperLogics.Models.BeamShears
/// </summary>
IReinforcementLibMaterial Material { get; set; }
/// <summary>
/// True if hoop is spiral one
/// </summary>
bool IsSpiral { get; set; }
/// <summary>
/// Count of legs of stirrup in specific cross-section
/// </summary>
double LegCount { get; set; }

3
StructureHelperLogics/Models/BeamShears/IStirrupGroup.cs
View File

@@ -6,8 +6,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public interface IStirrupGroup : IStirrup
public interface IStirrupGroup : IStirrup, IHasStirrups
{
List<IStirrup> Stirrups { get; }
}
}

2
StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarStrengthLogic.cs
View File

@@ -72,7 +72,7 @@ namespace StructureHelperLogics.Models.BeamShears
private void InitializeStrategies()
{
convertStrategy ??= new StirrupByRebarToDensityConvertStrategy(TraceLogger);
convertStrategy ??= new StirrupByRebarToDensityConvertStrategy(TraceLogger, inclinedSection);
IStirrupByDensity stirrupByDensity = convertStrategy.Convert(stirrupByRebar);
stirrupDensityStrengthLogic ??= new(stirrupEffectiveness, stirrupByDensity, inclinedSection, TraceLogger);
}

33
StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarToDensityConvertStrategy.cs
View File

@@ -1,4 +1,5 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
@@ -8,13 +9,15 @@ namespace StructureHelperLogics.Models.BeamShears
{
private const double stirrupStrengthFactor = 0.8d;
private const double maxStirrupStrength = 3e8;
private IInclinedSection inclinedSection;
private IUpdateStrategy<IStirrup> updateStrategy;
public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; }
public IShiftTraceLogger TraceLogger { get; set; }
public StirrupByRebarToDensityConvertStrategy(IShiftTraceLogger traceLogger)
public StirrupByRebarToDensityConvertStrategy(IShiftTraceLogger traceLogger, IInclinedSection inclinedSection)
{
TraceLogger = traceLogger;
this.inclinedSection = inclinedSection;
}
public StirrupByRebarToDensityConvertStrategy(IUpdateStrategy<IStirrup> updateStrategy, IShiftTraceLogger traceLogger)
@@ -42,9 +45,33 @@ namespace StructureHelperLogics.Models.BeamShears
TraceLogger?.AddMessage($"Strength of rebar Rsw = {stirrupStrengthFactor} * {materialStrength} = {stirrupStrength}(Pa)");
double minimizedStrength = Math.Min(stirrupStrength, maxStirrupStrength);
TraceLogger?.AddMessage($"Strength of rebar Rsw = Min({stirrupStrength}, {maxStirrupStrength})= {minimizedStrength}(Pa)");
double density = minimizedStrength * area * source.LegCount / source.Spacing;
TraceLogger?.AddMessage($"Density of stirrups = {minimizedStrength} * {area} * {source.LegCount} / {source.Spacing} = {density}(N/m)");
double spiralEffectiveness = 1;
if (source.IsSpiral = true)
{
spiralEffectiveness = GetSpiralEffectiveness(source);
}
double density = minimizedStrength * area * source.LegCount / source.Spacing * spiralEffectiveness;
TraceLogger?.AddMessage($"Density of stirrups = {minimizedStrength} * {area} * {source.LegCount} / {source.Spacing} * {spiralEffectiveness} = {density}(N/m)");
return density;
}
private double GetSpiralEffectiveness(IStirrupByRebar source)
{
if (inclinedSection is null)
{
string errorString = ErrorStrings.ParameterIsNull + ": Inclined Section";
TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
double spiralHeight = inclinedSection.EffectiveDepth - (inclinedSection.FullDepth - inclinedSection.EffectiveDepth);
TraceLogger?.AddMessage($"Spiral height = {spiralHeight}(m)");
double spiralSpacing = source.Spacing;
TraceLogger?.AddMessage($"Spiral spacing = {spiralSpacing}(m)");
double spiralAng = Math.Atan2(spiralHeight, spiralSpacing);
double spriralEffectiveness = Math.Sin(spiralAng);
double spiralAngInDegrees = 180 / (Math.PI) * spiralAng;
TraceLogger?.AddMessage($"Spiral effectiveness factor = sin({spiralAngInDegrees}(deg)) = {spriralEffectiveness}");
return spriralEffectiveness;
}
}
}

1
StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs
View File

@@ -24,6 +24,7 @@ namespace StructureHelperLogics.Models.BeamShears
targetObject.Diameter = sourceObject.Diameter;
targetObject.LegCount = sourceObject.LegCount;
targetObject.Spacing = sourceObject.Spacing;
targetObject.IsSpiral = sourceObject.IsSpiral;
}
}
}

55
StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs
View File

@@ -13,49 +13,74 @@ namespace StructureHelperLogics.Models.BeamShears.Logics
{
private IUpdateStrategy<IStirrupByDensity> densityUpdateStrategy;
private IUpdateStrategy<IStirrupByRebar> uniformUpdateStrategy;
private IUpdateStrategy<IStirrupGroup> groupUpdateStrategy;
private IUpdateStrategy<IStirrupByInclinedRebar> inclinedUpdateStrategy;
public void Update(IStirrup targetObject, IStirrup sourceObject)
{
CheckObject.IsNull(targetObject);
CheckObject.IsNull(sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
if (sourceObject is IStirrupByDensity density)
if (sourceObject is IStirrupGroup group)
{
UpdateByDensity(targetObject, density);
UpdateGroup(targetObject, group);
}
else if (sourceObject is IStirrupByRebar stirrupByUniformRebar)
{
UpdateByUniformRebar(targetObject, stirrupByUniformRebar);
}
else if (sourceObject is IStirrupByDensity density)
{
UpdateByDensity(targetObject, density);
}
else if (sourceObject is IStirrupByInclinedRebar inclinedRebar)
{
UpdateByInclinedRebar(targetObject, inclinedRebar);
}
else
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(sourceObject));
}
}
private void UpdateByUniformRebar(IStirrup targetObject, IStirrupByRebar stirrupByUniformRebar)
private void UpdateByInclinedRebar(IStirrup targetObject, IStirrupByInclinedRebar surceInclinedRebar)
{
uniformUpdateStrategy ??= new StirrupByRebarUpdateStrategy();
if (targetObject is IStirrupByRebar targetUniformRebar)
{
uniformUpdateStrategy.Update(targetUniformRebar, stirrupByUniformRebar);
}
else
if (targetObject is not IStirrupByInclinedRebar targetInclinedRebar)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject));
}
inclinedUpdateStrategy ??= new StirrupByInclinedRebarUpdateStrategy();
inclinedUpdateStrategy.Update(targetInclinedRebar, surceInclinedRebar);
}
private void UpdateGroup(IStirrup targetObject, IStirrupGroup sourceGroup)
{
if (targetObject is not IStirrupGroup targetGroup)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject));
}
groupUpdateStrategy ??= new StirrupGroupUpdateStrategy();
groupUpdateStrategy.Update(targetGroup, sourceGroup);
}
private void UpdateByUniformRebar(IStirrup targetObject, IStirrupByRebar stirrupByUniformRebar)
{
if (targetObject is not IStirrupByRebar targetUniformRebar)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject));
}
uniformUpdateStrategy ??= new StirrupByRebarUpdateStrategy();
uniformUpdateStrategy.Update(targetUniformRebar, stirrupByUniformRebar);
}
private void UpdateByDensity(IStirrup targetObject, IStirrupByDensity density)
{
densityUpdateStrategy ??= new StirrupByDensityUpdateStrategy();
if (targetObject is IStirrupByDensity targetDensity)
{
densityUpdateStrategy.Update(targetDensity, density);
}
else
if (targetObject is not IStirrupByDensity targetDensity)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject));
}
densityUpdateStrategy ??= new StirrupByDensityUpdateStrategy();
densityUpdateStrategy.Update(targetDensity, density);
}
}
}

23
StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,23 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.Models.BeamShears
{
public class StirrupByInclinedRebarUpdateStrategy : IUpdateStrategy<IStirrupByInclinedRebar>
{
private IUpdateStrategy<IStirrup>? baseUpdateStrategy;
public void Update(IStirrupByInclinedRebar targetObject, IStirrupByInclinedRebar sourceObject)
{
CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
baseUpdateStrategy ??= new StirrupBaseUpdateStrategy();
baseUpdateStrategy.Update(targetObject, sourceObject);
targetObject.StartCoordinate = sourceObject.StartCoordinate;
targetObject.OffSet = sourceObject.OffSet;
targetObject.AngleOfInclination = sourceObject.AngleOfInclination;
}
}
}

29
StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,29 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.Models.BeamShears
{
public class StirrupGroupUpdateStrategy : IUpdateStrategy<IStirrupGroup>
{
private StirrupBaseUpdateStrategy baseUpdateStrategy;
public void Update(IStirrupGroup targetObject, IStirrupGroup sourceObject)
{
CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
baseUpdateStrategy ??= new StirrupBaseUpdateStrategy();
baseUpdateStrategy.Update(targetObject, sourceObject);
CheckObject.IsNull(sourceObject.Stirrups);
CheckObject.IsNull(targetObject.Stirrups);
targetObject.Stirrups.Clear();
foreach (var item in sourceObject.Stirrups)
{
IStirrup? newItem = item.Clone() as IStirrup;
targetObject.Stirrups.Add(newItem);
}
}
}
}

76
StructureHelperLogics/Models/BeamShears/StirrupByInclinedRebar.cs Normal file
View File

@@ -0,0 +1,76 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.BeamShears
{
public class StirrupByInclinedRebar : IStirrupByInclinedRebar
{
private const int minInclinationAngle = 10;
private const int maxInclinationAngle = 80;
private double angleOfInclination = 45;
private double startCoordinate = 0.05;
private double compressedGap = 0.05;
/// <inheritdoc>
public Guid Id { get; }
public string? Name { get; set; } = string.Empty;
/// <inheritdoc>
public double CompressedGap
{
get => compressedGap;
set
{
if (value < 0)
{
throw new StructureHelperException(ErrorStrings.IncorrectValue + $": distance from compressed edge must be positive");
}
compressedGap = value;
}
}
/// <inheritdoc>
public double StartCoordinate
{
get => startCoordinate;
set
{
if (value < 0)
{
throw new StructureHelperException(ErrorStrings.IncorrectValue + $": start coordinate must be positive");
}
startCoordinate = value;
}
}
/// <inheritdoc>
public double OffSet { get; set; } = 0.05;
/// <inheritdoc>
public double AngleOfInclination
{
get => angleOfInclination;
set
{
if (value < minInclinationAngle || value > maxInclinationAngle)
{
throw new StructureHelperException(ErrorStrings.IncorrectValue + $": angle of inclination of rebar must be beetwen {minInclinationAngle} and {maxInclinationAngle} degrees");
}
angleOfInclination = value;
}
}
public StirrupByInclinedRebar(Guid id)
{
Id = id;
}
public object Clone()
{
var logic = new StirrupByInclinedRebarUpdateStrategy();
StirrupByInclinedRebar newItem = new(Guid.NewGuid());
logic.Update(newItem, this);
return newItem;
}
}
}

11
StructureHelperLogics/Models/BeamShears/StirrupByRebar.cs
View File

@@ -29,7 +29,8 @@ namespace StructureHelperLogics.Models.BeamShears
}
legCount = value;
}
} /// <inheritdoc/>
}
/// <inheritdoc/>
public double Diameter
{
get => diameter; set
@@ -44,7 +45,8 @@ namespace StructureHelperLogics.Models.BeamShears
}
diameter = value;
}
} /// <inheritdoc/>
}
/// <inheritdoc/>
public double Spacing
{
get => step; set
@@ -55,8 +57,11 @@ namespace StructureHelperLogics.Models.BeamShears
}
step = value;
}
} /// <inheritdoc/>
}
/// <inheritdoc/>
public double CompressedGap { get; set; } = 0;
/// <inheritdoc/>
public bool IsSpiral { get; set; } = false;
public StirrupByRebar(Guid id)
{

12
StructureHelperLogics/Models/BeamShears/StirrupGroup.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
@@ -9,18 +10,21 @@ namespace StructureHelperLogics.Models.BeamShears
public class StirrupGroup : IStirrupGroup
{
public Guid Id { get; }
public string Name { get; set; }
public string Name { get; set; } = string.Empty;
public List<IStirrup> Stirrups { get; } = new();
public double CompressedGap { get; set; }
public double GetShearBearingCapacity(IInclinedSection inclinedSection)
public StirrupGroup(Guid id)
{
throw new NotImplementedException();
Id = id;
}
public object Clone()
{
throw new NotImplementedException();
var updateStrategy = new StirrupGroupUpdateStrategy();
StirrupGroup newItem = new(Guid.NewGuid());
updateStrategy.Update(newItem, this);
return newItem;
}
}

32
StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs
View File

@@ -1,16 +1,10 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Infrastructures.Settings;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Forces.Logics;
using StructureHelperLogics.NdmCalculations.Cracking;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
@@ -19,6 +13,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
private bool result;
private string checkResult;
private ICheckEntityLogic<IAccuracy> checkAccuracyLogic;
private ICheckEntityLogic<IHasPrimitives> checkPrimitiveCollectionLogic;
public IForceCalculatorInputData InputData { get; set; }
@@ -66,11 +61,32 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
TraceMessage("Calculator does not contain any calc term");
result = false;
}
CheckPrimitives();
CheckAccuracy();
CheckActions();
return result;
}
private void CheckPrimitives()
{
checkPrimitiveCollectionLogic ??= new CheckPrimitiveCollectionLogic(
TraceLogger,
new CheckRebarPrimitiveLogic()
{
CheckRebarHostMaterial = false,
CheckRebarPlacement = false
})
{
Entity = InputData,
};
if (checkPrimitiveCollectionLogic.Check() == false)
{
result = false;
}
TraceMessage(checkPrimitiveCollectionLogic.CheckResult);
}
private void CheckActions()
{
var checkLogic = new CheckForceActionsLogic()

14
StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
View File

@@ -1,18 +1,10 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces.Logics;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models.Materials;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media.Animation;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
@@ -22,7 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<ICrackCalculatorInputData>
{
private bool result;
private ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic;
private ICheckEntityLogic<IHasPrimitives> checkPrimitiveCollectionLogic;
public ICrackCalculatorInputData InputData { get; set; }
@@ -31,7 +23,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
public IShiftTraceLogger? TraceLogger { get; set; }
public CheckCrackCalculatorInputDataLogic(ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic)
public CheckCrackCalculatorInputDataLogic(ICheckEntityLogic<IHasPrimitives> checkPrimitiveCollectionLogic)
{
this.checkPrimitiveCollectionLogic = checkPrimitiveCollectionLogic;
}
@@ -57,7 +49,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
throw new StructureHelperException(ErrorStrings.ParameterIsNull + ": check primitive logic");
}
checkPrimitiveCollectionLogic.HasPrimitives = InputData;
checkPrimitiveCollectionLogic.Entity = InputData;
checkPrimitiveCollectionLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger();
if (checkPrimitiveCollectionLogic.Check() == false)
{

18
StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs
View File

@@ -11,22 +11,24 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
{
public class CheckPrimitiveCollectionLogic : ICheckPrimitiveCollectionLogic
public class CheckPrimitiveCollectionLogic : ICheckEntityLogic<IHasPrimitives>
{
private const string collectionDoesntHaveAnyPrimitives = "Calculator does not contain any primitives\n";
private const string checkRebarLogic = ": check rebar logic";
private string checkResult;
private bool result;
private ICheckRebarPrimitiveLogic checkRebarPrimitiveLogic;
private ICheckEntityLogic<IRebarNdmPrimitive> checkRebarPrimitiveLogic;
public IHasPrimitives HasPrimitives { get; set; }
public IHasPrimitives Entity { get; set; }
public string CheckResult => checkResult;
public IShiftTraceLogger? TraceLogger { get; set; }
public CheckPrimitiveCollectionLogic(IShiftTraceLogger shiftTraceLogger, ICheckRebarPrimitiveLogic checkRebarPrimitiveLogic)
public CheckPrimitiveCollectionLogic(
IShiftTraceLogger shiftTraceLogger,
ICheckEntityLogic<IRebarNdmPrimitive> checkRebarPrimitiveLogic)
{
TraceLogger = shiftTraceLogger;
this.checkRebarPrimitiveLogic = checkRebarPrimitiveLogic;
@@ -47,7 +49,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
private void CheckPrimitives()
{
if (HasPrimitives.Primitives is null || (!HasPrimitives.Primitives.Any()))
if (Entity.Primitives is null || (!Entity.Primitives.Any()))
{
result = false;
checkResult += collectionDoesntHaveAnyPrimitives;
@@ -55,7 +57,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
}
else
{
foreach (var primitive in HasPrimitives.Primitives)
foreach (var primitive in Entity.Primitives)
{
if (primitive is IRebarNdmPrimitive rebar)
{
@@ -71,7 +73,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
{
throw new StructureHelperException(ErrorStrings.ParameterIsNull + checkRebarLogic);
}
checkRebarPrimitiveLogic.RebarPrimitive = rebar;
checkRebarPrimitiveLogic.Entity = rebar;
checkRebarPrimitiveLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger();
if (checkRebarPrimitiveLogic.Check() == false)
{
@@ -79,7 +81,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
checkResult += checkRebarPrimitiveLogic.CheckResult;
return;
}
bool isPrimitivesContainRebarHost = HasPrimitives.Primitives.Contains(rebar.HostPrimitive);
bool isPrimitivesContainRebarHost = Entity.Primitives.Contains(rebar.HostPrimitive);
if (isPrimitivesContainRebarHost == false)
{
result = false;

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

@@ -1,4 +1,5 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Materials;
using System;
@@ -9,12 +10,14 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
{
public class CheckRebarPrimitiveLogic : ICheckRebarPrimitiveLogic
public class CheckRebarPrimitiveLogic : ICheckEntityLogic<IRebarNdmPrimitive>
{
private string checkResult;
private bool result;
public IRebarNdmPrimitive RebarPrimitive { get; set; }
public bool CheckRebarPlacement { get; set; } = true;
public bool CheckRebarHostMaterial { get; set; } = true;
public IRebarNdmPrimitive Entity { get; set; }
public string CheckResult => checkResult;
@@ -40,33 +43,47 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
private void CheckRebar()
{
if (RebarPrimitive.HostPrimitive is null)
if (Entity.HostPrimitive is null)
{
result = false;
string message = $"Primitive {RebarPrimitive.Name} does not have a host\n";
string message = $"Primitive {Entity.Name} does not have a host\n";
checkResult += message;
TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
return;
}
if (RebarPrimitive.HostPrimitive is IHasDivisionSize division)
if (CheckRebarPlacement == true)
{
if (!division.IsPointInside(RebarPrimitive.Center))
{
result = false;
string message = $"Primitive of rebar {RebarPrimitive.Name} is out of its host {RebarPrimitive.HostPrimitive.Name}";
checkResult += message;
TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
}
CheckIfRebarInsideHostPrimitive();
}
if (CheckRebarHostMaterial == true)
{
CheckIfRemarMaterialIsCrackedMaterial();
}
}
if (RebarPrimitive.HostPrimitive.NdmElement.HeadMaterial.HelperMaterial is not ICrackedMaterial)
private void CheckIfRemarMaterialIsCrackedMaterial()
{
if (Entity.HostPrimitive.NdmElement.HeadMaterial.HelperMaterial is not ICrackedMaterial)
{
result = false;
string message = $"Material of host of {RebarPrimitive.Name} ({RebarPrimitive.HostPrimitive.NdmElement.HeadMaterial.Name}) does not support cracking\n";
string message = $"Material of host of {Entity.Name} ({Entity.HostPrimitive.NdmElement.HeadMaterial.Name}) does not support cracking\n";
checkResult += message;
TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
}
}
private void CheckIfRebarInsideHostPrimitive()
{
if (Entity.HostPrimitive is IHasDivisionSize division)
{
if (!division.IsPointInside(Entity.Center))
{
result = false;
string message = $"Primitive of rebar {Entity.Name} is out of its host {Entity.HostPrimitive.Name}";
checkResult += message;
TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
}
}
}
}
}

14
StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckPrimitiveCollectionLogic.cs
View File

@@ -1,14 +0,0 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
{
public interface ICheckPrimitiveCollectionLogic : ICheckLogic
{
IHasPrimitives HasPrimitives { get; set; }
}
}

14
StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckRebarPrimitiveLogic.cs
View File

@@ -1,14 +0,0 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
{
public interface ICheckRebarPrimitiveLogic : ICheckLogic
{
IRebarNdmPrimitive RebarPrimitive { get; set; }
}
}

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

@@ -53,6 +53,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
public Ndm GetConcreteNdm()
{
//#error //fix check rebar for host null
var hostPrimitive = options.HostPrimitive;
var material = hostPrimitive
.NdmElement