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

Anchoring isofields has been added

Browse Source
This commit is contained in:
Evgeny Redikultsev
2023-03-25 19:38:40 +05:00
parent a88fa40f29
commit 3d22c3440e
23 changed files with 599 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs
View File

@@ -2,15 +2,15 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Strings;
using StructureHelperCommon.Models.Materials.Libraries;
using LCM = LoaderCalculator.Data.Materials;
using LCMB = LoaderCalculator.Data.Materials.MaterialBuilders;
using LoaderMaterials = LoaderCalculator.Data.Materials;
using LoaderMaterialBuilders = LoaderCalculator.Data.Materials.MaterialBuilders;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using StructureHelperCommon.Infrastructures.Settings;
using LCMBML = LoaderCalculator.Data.Materials.MaterialBuilders.MaterialLogics;
using LoaderMaterialLogic = LoaderCalculator.Data.Materials.MaterialBuilders.MaterialLogics;
namespace StructureHelperLogics.Models.Materials
{
@@ -22,13 +22,13 @@ namespace StructureHelperLogics.Models.Materials
public bool TensionForSLS { get; set; }
private IMaterialOptionLogic optionLogic;
private LCMBML.ITrueStrengthLogic strengthLogic;
private LoaderMaterialLogic.ITrueStrengthLogic strengthLogic;
public ConcreteLibMaterial()
{
SafetyFactors = new List<IMaterialSafetyFactor>();
SafetyFactors.AddRange(PartialCoefficientFactory.GetDefaultConcreteSafetyFactors(ProgramSetting.CodeType));
optionLogic = new MaterialOptionLogic(new LCMB.ConcreteOptions());
optionLogic = new MaterialOptionLogic(new LoaderMaterialBuilders.ConcreteOptions());
TensionForULS = false;
TensionForSLS = true;
}
@@ -38,9 +38,9 @@ namespace StructureHelperLogics.Models.Materials
return new ConcreteLibMaterial() { MaterialEntity = MaterialEntity, TensionForULS = TensionForULS, TensionForSLS = TensionForSLS };
}
public LCM.IMaterial GetLoaderMaterial(LimitStates limitState, CalcTerms calcTerm)
public LoaderMaterials.IMaterial GetLoaderMaterial(LimitStates limitState, CalcTerms calcTerm)
{
var materialOptions = optionLogic.SetMaterialOptions(MaterialEntity, limitState, calcTerm) as LCMB.ConcreteOptions;
var materialOptions = optionLogic.SetMaterialOptions(MaterialEntity, limitState, calcTerm) as LoaderMaterialBuilders.ConcreteOptions;
materialOptions.WorkInTension = false;
if (limitState == LimitStates.ULS & TensionForULS == true)
{
@@ -53,8 +53,8 @@ namespace StructureHelperLogics.Models.Materials
var strength = GetStrengthFactors(limitState, calcTerm);
materialOptions.ExternalFactor.Compressive = strength.Compressive;
materialOptions.ExternalFactor.Tensile = strength.Tensile;
LCMB.IMaterialBuilder builder = new LCMB.ConcreteBuilder(materialOptions);
LCMB.IBuilderDirector director = new LCMB.BuilderDirector(builder);
LoaderMaterialBuilders.IMaterialBuilder builder = new LoaderMaterialBuilders.ConcreteBuilder(materialOptions);
LoaderMaterialBuilders.IBuilderDirector director = new LoaderMaterialBuilders.BuilderDirector(builder);
return director.BuildMaterial();
}
@@ -72,9 +72,19 @@ namespace StructureHelperLogics.Models.Materials
public (double Compressive, double Tensile) GetStrength(LimitStates limitState, CalcTerms calcTerm)
{
strengthLogic = new LCMBML.TrueStrengthConcreteLogicSP63_2018(MaterialEntity.MainStrength);
strengthLogic = new LoaderMaterialLogic.TrueStrengthConcreteLogicSP63_2018(MaterialEntity.MainStrength);
var strength = strengthLogic.GetTrueStrength();
return (strength.Comressive, strength.Tensile);
double compressionFactor = 1d;
double tensionFactor = 1d;
if (limitState == LimitStates.ULS)
{
compressionFactor /= 1.3d;
tensionFactor /= 1.5d;
var factors = GetStrengthFactors(limitState, calcTerm);
compressionFactor *= factors.Compressive;
tensionFactor *= factors.Tensile;
}
return (strength.Comressive * compressionFactor, strength.Tensile * tensionFactor);
}
}
}

12
StructureHelperLogics/Models/Materials/Factories/HeadMaterialFactory.cs
View File

@@ -16,6 +16,7 @@ namespace StructureHelperLogics.Models.Materials
{
Concrete40,
Reinforecement400,
Reinforecement500,
Elastic200
}
@@ -30,10 +31,21 @@ namespace StructureHelperLogics.Models.Materials
codeType = code;
if (type == HeadmaterialType.Concrete40) { return GetConcrete40(); }
if (type == HeadmaterialType.Reinforecement400) { return GetReinforcement400(); }
if (type == HeadmaterialType.Reinforecement500) { return GetReinforcement500(); }
if (type == HeadmaterialType.Elastic200) { return GetElastic200(); }
else throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknown + nameof(type));
}
private static IHeadMaterial GetReinforcement500()
{
var material = new HeadMaterial() { Name = "New reinforcement" };
var libMaterial = LibReinforcementMaterials.Where(x => x.Name.Contains("500")).First();
var libMat = new ReinforcementLibMaterial();
libMat.MaterialEntity = libMaterial;
material.HelperMaterial = libMat;
return material;
}
private static IHeadMaterial GetElastic200()
{
var material = new HeadMaterial();

43
StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs
View File

@@ -5,9 +5,9 @@ using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using LCM = LoaderCalculator.Data.Materials;
using LCMB = LoaderCalculator.Data.Materials.MaterialBuilders;
using LCMBML = LoaderCalculator.Data.Materials.MaterialBuilders.MaterialLogics;
using Loadermaterials = LoaderCalculator.Data.Materials;
using LoaderMaterialBuilders = LoaderCalculator.Data.Materials.MaterialBuilders;
using LoaderMaterialLogics = LoaderCalculator.Data.Materials.MaterialBuilders.MaterialLogics;
namespace StructureHelperLogics.Models.Materials
{
@@ -17,12 +17,12 @@ namespace StructureHelperLogics.Models.Materials
public List<IMaterialSafetyFactor> SafetyFactors { get; }
private IMaterialOptionLogic optionLogic;
private LCMBML.ITrueStrengthLogic strengthLogic;
private LoaderMaterialLogics.ITrueStrengthLogic strengthLogic;
public ReinforcementLibMaterial()
{
SafetyFactors = new List<IMaterialSafetyFactor>();
optionLogic = new MaterialOptionLogic(new LCMB.ReinforcementOptions());
optionLogic = new MaterialOptionLogic(new LoaderMaterialBuilders.ReinforcementOptions());
}
public object Clone()
@@ -30,14 +30,14 @@ namespace StructureHelperLogics.Models.Materials
return new ReinforcementLibMaterial() { MaterialEntity = MaterialEntity};
}
public LCM.IMaterial GetLoaderMaterial(LimitStates limitState, CalcTerms calcTerm)
public Loadermaterials.IMaterial GetLoaderMaterial(LimitStates limitState, CalcTerms calcTerm)
{
var materialOptions = optionLogic.SetMaterialOptions(MaterialEntity, limitState, calcTerm);
var strength = GetStrengthFactors(limitState, calcTerm);
materialOptions.ExternalFactor.Compressive = strength.Compressive;
materialOptions.ExternalFactor.Tensile = strength.Tensile;
LCMB.IMaterialBuilder builder = new LCMB.ReinforcementBuilder(materialOptions);
LCMB.IBuilderDirector director = new LCMB.BuilderDirector(builder);
LoaderMaterialBuilders.IMaterialBuilder builder = new LoaderMaterialBuilders.ReinforcementBuilder(materialOptions);
LoaderMaterialBuilders.IBuilderDirector director = new LoaderMaterialBuilders.BuilderDirector(builder);
return director.BuildMaterial();
}
@@ -55,9 +55,32 @@ namespace StructureHelperLogics.Models.Materials
public (double Compressive, double Tensile) GetStrength(LimitStates limitState, CalcTerms calcTerm)
{
strengthLogic = new LCMBML.TrueStrengthReinforcementLogic(MaterialEntity.MainStrength);
strengthLogic = new LoaderMaterialLogics.TrueStrengthReinforcementLogic(MaterialEntity.MainStrength);
var strength = strengthLogic.GetTrueStrength();
return (strength.Comressive, strength.Tensile);
double compressionFactor = 1d;
double tensionFactor = 1d;
if (limitState == LimitStates.ULS)
{
compressionFactor /= 1.15d;
tensionFactor /= 1.15d;
}
var factors = GetStrengthFactors(limitState, calcTerm);
compressionFactor *= factors.Compressive;
tensionFactor *= factors.Tensile;
var compressiveStrength = strength.Comressive * compressionFactor;
if (limitState == LimitStates.ULS)
{
if (calcTerm == CalcTerms.ShortTerm)
{
compressiveStrength = Math.Min(4e8, compressiveStrength);
}
else
{
compressiveStrength = Math.Min(5e8, compressiveStrength);
}
}
var tensileStrength = strength.Tensile * tensionFactor;
return (compressiveStrength, tensileStrength);
}
}
}

4
StructureHelperLogics/NdmCalculations/Analyses/RC/AnchorageCalculator.cs
View File

@@ -22,7 +22,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC
public double GetBaseDevLength()
{
return anchorage.GetBaseDevLength();
var val = anchorage.GetBaseDevLength();
return val;
}
public double GetDevLength()
@@ -40,6 +41,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC
var anchorageOptions = new AnchorageOptionsSP63();
anchorageOptions.ConcreteStrength = inputData.ConcreteStrength;
anchorageOptions.ReinforcementStrength = inputData.ReinforcementStrength;
anchorageOptions.FactorEta1 = inputData.FactorEta1;
anchorageOptions.ReinforcementStress = inputData.ReinforcementStress;
anchorageOptions.CrossSectionArea = inputData.CrossSectionArea;
anchorageOptions.CrossSectionPerimeter = inputData.CrossSectionPerimeter;

2
StructureHelperLogics/NdmCalculations/Analyses/RC/AnchorageInputData.cs
View File

@@ -14,5 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC
public double CrossSectionPerimeter { get; set; }
public double ReinforcementStress { get; set; }
public double LappedCountRate { get; set; }
public double FactorEta1 { get; set; }
public bool IsPrestressed { get; set; }
}
}

2
StructureHelperLogics/NdmCalculations/Analyses/RC/IAnchorageInputData.cs
View File

@@ -10,10 +10,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC
{
double ConcreteStrength { get; set; }
double ReinforcementStrength { get; set; }
double FactorEta1 { get; set; }
double CrossSectionArea { get; set; }
double CrossSectionPerimeter { get; set; }
double ReinforcementStress { get; set; }
double LappedCountRate { get; set; }
bool IsPrestressed { get; set; }
}
}

74
StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs Normal file
View File

@@ -0,0 +1,74 @@
using LoaderCalculator.Data.Matrix;
using LoaderCalculator.Logics;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Strings;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Analyses.RC
{
public static class InputDataFactory
{
private static IStressLogic stressLogic => new StressLogic();
public static IAnchorageInputData GetInputData(ReinforcementPrimitive ndmPrimitive, IStrainMatrix strainMatrix, LimitStates limitState, CalcTerms calcTerm, double lappedCountRate)
{
var inputData = new AnchorageInputData();
inputData.ConcreteStrength = GetConcreteStrength(limitState, calcTerm, ndmPrimitive);
inputData.ReinforcementStrength = GetReinforcementStrength(limitState, calcTerm, ndmPrimitive);
inputData.FactorEta1 = 2.5d;
inputData.CrossSectionArea = ndmPrimitive.Area;
var diameter = Math.Sqrt(ndmPrimitive.Area / Math.PI) * 2d;
inputData.CrossSectionPerimeter = Math.PI * diameter;
if (ndmPrimitive.HeadMaterial is null)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": main material is incorrect or null");
}
var material = ndmPrimitive.HeadMaterial.GetLoaderMaterial(limitState, calcTerm);
var ndm = ndmPrimitive.GetNdms(material).Single();
if (strainMatrix is not null)
{
inputData.ReinforcementStress = stressLogic.GetStress(strainMatrix, ndm);
}
else
{
inputData.ReinforcementStress = inputData.ReinforcementStrength;
}
inputData.IsPrestressed = ndm.Prestrain > 0.0005d ? true : false;
inputData.LappedCountRate = lappedCountRate;
return inputData;
}
private static double GetConcreteStrength(LimitStates limitState, CalcTerms calcTerm, ReinforcementPrimitive primitive)
{
if (primitive.HostPrimitive is not null)
{
var host = primitive.HostPrimitive;
var hostMaterial = host.HeadMaterial.HelperMaterial;
if (hostMaterial is IConcreteLibMaterial)
{
var concreteMaterial = hostMaterial as IConcreteLibMaterial;
var concreteStrength = concreteMaterial.GetStrength(limitState, calcTerm).Tensile;
return concreteStrength;
}
}
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": host material is incorrect or null");
}
private static double GetReinforcementStrength(LimitStates limitState, CalcTerms calcTerm, ReinforcementPrimitive primitive)
{
if (primitive.HeadMaterial.HelperMaterial is IReinforcementLibMaterial)
{
var material = primitive.HeadMaterial.HelperMaterial as IReinforcementLibMaterial;
var strength = material.GetStrength(limitState, calcTerm).Tensile;
return strength;
}
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": host's material is incorrect or null");
}
}
}