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

Analisys manager window was added

Browse Source
This commit is contained in:
RedikultsevEvg
2024-08-20 20:38:01 +05:00
parent 45dbd7a1ca
commit c1b9f80a96
50 changed files with 1036 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -21,7 +21,7 @@ namespace StructureHelperLogics.Models.Materials
/// <inheritdoc/>
public ILibMaterialEntity MaterialEntity { get; set; }
/// <inheritdoc/>
public List<IMaterialSafetyFactor> SafetyFactors { get; }
public List<IMaterialSafetyFactor> SafetyFactors { get; set; }
/// <inheritdoc/>
public bool TensionForULS { get ; set; }
/// <inheritdoc/>

4
StructureHelperLogics/Models/Materials/FRMaterials/FRMaterial.cs
View File

@@ -1,5 +1,6 @@
using LoaderCalculator.Data.Materials;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Infrastructures.Settings;
using StructureHelperCommon.Models.Materials.Libraries;
using System;
@@ -14,6 +15,7 @@ namespace StructureHelperLogics.Models.Materials
{
private IElasticMaterialLogic elasticMaterialLogic => new ElasticMaterialLogic();
private MaterialTypes materialType;
IUpdateStrategy<IFRMaterial> fRUpdateStrategy = new FRUpdateStrategy();
public double Modulus{ get; set; }
public double CompressiveStrength { get; set; }
public double TensileStrength { get; set; }
@@ -49,7 +51,7 @@ namespace StructureHelperLogics.Models.Materials
public object Clone()
{
var newItem = new FRMaterial(this.materialType);
var updateStrategy = new FRUpdateStrategy();
var updateStrategy = fRUpdateStrategy;
updateStrategy.Update(newItem, this);
return newItem;
}

2
StructureHelperLogics/Models/Materials/ILibMaterial.cs
View File

@@ -11,7 +11,7 @@ namespace StructureHelperLogics.Models.Materials
public interface ILibMaterial : IHelperMaterial
{
ILibMaterialEntity MaterialEntity { get; set; }
List<IMaterialSafetyFactor> SafetyFactors { get; }
List<IMaterialSafetyFactor> SafetyFactors { get; set; }
IMaterialLogic MaterialLogic { get; set; }
List<IMaterialLogic> MaterialLogics { get; }
(double Compressive, double Tensile) GetStrength(LimitStates limitState, CalcTerms calcTerm);

2
StructureHelperLogics/Models/Materials/LibMaterial.cs
View File

@@ -23,7 +23,7 @@ namespace StructureHelperLogics.Models.Materials
public ILibMaterialEntity MaterialEntity { get; set; }
public List<IMaterialSafetyFactor> SafetyFactors { get; }
public List<IMaterialSafetyFactor> SafetyFactors { get; set; }
public IMaterialLogic MaterialLogic { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
public List<IMaterialLogic> MaterialLogics => throw new NotImplementedException();

14
StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs
View File

@@ -1,4 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -7,11 +8,20 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.Models.Materials
{
internal class ConcreteLibUpdateStrategy : IUpdateStrategy<IConcreteLibMaterial>
public class ConcreteLibUpdateStrategy : IUpdateStrategy<IConcreteLibMaterial>
{
LibMaterialUpdateStrategy libUpdateStrategy = new LibMaterialUpdateStrategy();
private IUpdateStrategy<ILibMaterial> libUpdateStrategy;
public ConcreteLibUpdateStrategy(IUpdateStrategy<ILibMaterial> libUpdateStrategy)
{
this.libUpdateStrategy = libUpdateStrategy;
}
public ConcreteLibUpdateStrategy() : this(new LibMaterialUpdateStrategy())
{
}
public void Update(IConcreteLibMaterial targetObject, IConcreteLibMaterial sourceObject)
{
CheckObject.CompareTypes(targetObject, sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
libUpdateStrategy.Update(targetObject, sourceObject);
targetObject.TensionForULS = sourceObject.TensionForULS;

6
StructureHelperLogics/Models/Materials/Logics/ElasticMaterialLogic.cs
View File

@@ -12,13 +12,15 @@ namespace StructureHelperLogics.Models.Materials
{
internal class ElasticMaterialLogic : IElasticMaterialLogic
{
private List<double> parameters;
public IMaterial GetLoaderMaterial(IElasticMaterial elasticMaterial, LimitStates limitState, CalcTerms calcTerm, double factor = 1d)
{
IMaterial material = new Material();
material.InitModulus = elasticMaterial.Modulus;
IFactorLogic factorLogic = new FactorLogic(elasticMaterial.SafetyFactors);
var factors = factorLogic.GetTotalFactor(limitState, calcTerm);
IEnumerable<double> parameters = new List<double>()
parameters = new List<double>()
{
elasticMaterial.Modulus,
elasticMaterial.CompressiveStrength * factors.Compressive * factor,
@@ -29,7 +31,7 @@ namespace StructureHelperLogics.Models.Materials
return material;
}
private double GetStressByStrain(IEnumerable<double> parameters, double strain)
private double GetStressByStrain(IEnumerable<double> parameters1, double strain)
{
double modulus = parameters.First();
double stress = modulus * strain;

2
StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs
View File

@@ -1,4 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -12,6 +13,7 @@ namespace StructureHelperLogics.Models.Materials
{
public void Update(IElasticMaterial targetObject, IElasticMaterial sourceObject)
{
CheckObject.CompareTypes(targetObject, sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.Modulus = sourceObject.Modulus;
targetObject.CompressiveStrength = sourceObject.CompressiveStrength;

8
StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs
View File

@@ -1,4 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -12,12 +13,13 @@ namespace StructureHelperLogics.Models.Materials
{
public void Update(IFRMaterial targetObject, IFRMaterial sourceObject)
{
CheckObject.ReferenceEquals(targetObject, sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.Modulus = sourceObject.Modulus;
targetObject.CompressiveStrength = sourceObject.CompressiveStrength;
targetObject.TensileStrength = targetObject.TensileStrength;
targetObject.ULSConcreteStrength = targetObject.ULSConcreteStrength;
targetObject.SumThickness = targetObject.SumThickness;
targetObject.TensileStrength = sourceObject.TensileStrength;
targetObject.ULSConcreteStrength = sourceObject.ULSConcreteStrength;
targetObject.SumThickness = sourceObject.SumThickness;
}
}
}

16
StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs
View File

@@ -1,5 +1,6 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Materials.Libraries;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -8,18 +9,23 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.Models.Materials
{
internal class LibMaterialUpdateStrategy : IUpdateStrategy<ILibMaterial>
public class LibMaterialUpdateStrategy : IUpdateStrategy<ILibMaterial>
{
public void Update(ILibMaterial targetObject, ILibMaterial sourceObject)
{
CheckObject.CompareTypes(targetObject, sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.MaterialEntity = sourceObject.MaterialEntity;
targetObject.SafetyFactors.Clear();
targetObject.MaterialLogic = sourceObject.MaterialLogic;
foreach (var item in sourceObject.SafetyFactors)
if (targetObject.SafetyFactors is not null & sourceObject.SafetyFactors is not null)
{
targetObject.SafetyFactors.Add(item.Clone() as IMaterialSafetyFactor);
targetObject.SafetyFactors.Clear();
foreach (var item in sourceObject.SafetyFactors)
{
targetObject.SafetyFactors.Add(item.Clone() as IMaterialSafetyFactor);
}
}
targetObject.MaterialLogic = sourceObject.MaterialLogic;
}
}
}

33
StructureHelperLogics/Models/Materials/Logics/MaterialUpdateStrategy.cs
View File

@@ -1,24 +1,37 @@
using StructureHelper.Models.Materials;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.Materials
{
public class MaterialUpdateStrategy : IUpdateStrategy<IHeadMaterial>
{
private readonly IUpdateStrategy<IElasticMaterial> elasticStrategy = new ElasticUpdateStrategy();
private readonly IUpdateStrategy<IFRMaterial> frStrategy = new FRUpdateStrategy();
private readonly IUpdateStrategy<IConcreteLibMaterial> concreteStrategy = new ConcreteLibUpdateStrategy();
private readonly IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy = new ReinforcementLibUpdateStrategy();
private IUpdateStrategy<IElasticMaterial> elasticStrategy;
private IUpdateStrategy<IFRMaterial> frStrategy;
private IUpdateStrategy<IConcreteLibMaterial> concreteStrategy;
private IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy;
public MaterialUpdateStrategy(IUpdateStrategy<IElasticMaterial> elasticStrategy,
IUpdateStrategy<IFRMaterial> frStrategy,
IUpdateStrategy<IConcreteLibMaterial> concreteStrategy,
IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy
)
{
this.elasticStrategy = elasticStrategy;
this.frStrategy = frStrategy;
this.concreteStrategy = concreteStrategy;
this.reinforcementStrategy= reinforcementStrategy;
}
public MaterialUpdateStrategy() : this(
new ElasticUpdateStrategy(),
new FRUpdateStrategy(),
new ConcreteLibUpdateStrategy(),
new ReinforcementLibUpdateStrategy()
) { }
public void Update(IHeadMaterial targetObject, IHeadMaterial sourceObject)
{
CheckObject.CompareTypes(targetObject, sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.Name = sourceObject.Name;
targetObject.Color = sourceObject.Color;

14
StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs
View File

@@ -1,4 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -7,11 +8,20 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.Models.Materials
{
internal class ReinforcementLibUpdateStrategy : IUpdateStrategy<IReinforcementLibMaterial>
public class ReinforcementLibUpdateStrategy : IUpdateStrategy<IReinforcementLibMaterial>
{
LibMaterialUpdateStrategy libUpdateStrategy = new LibMaterialUpdateStrategy();
private IUpdateStrategy<ILibMaterial> libUpdateStrategy;
public ReinforcementLibUpdateStrategy(IUpdateStrategy<ILibMaterial> libUpdateStrategy)
{
this.libUpdateStrategy = libUpdateStrategy;
}
public ReinforcementLibUpdateStrategy() : this(new LibMaterialUpdateStrategy())
{
}
public void Update(IReinforcementLibMaterial targetObject, IReinforcementLibMaterial sourceObject)
{
CheckObject.CompareTypes(targetObject, sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
libUpdateStrategy.Update(targetObject, sourceObject);
}

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

@@ -23,7 +23,7 @@ namespace StructureHelperLogics.Models.Materials
private readonly List<IMaterialLogic> materialLogics;
public ILibMaterialEntity MaterialEntity { get; set; }
public List<IMaterialSafetyFactor> SafetyFactors { get; }
public List<IMaterialSafetyFactor> SafetyFactors { get; set; }
public IMaterialLogic MaterialLogic { get; set; }
public List<IMaterialLogic> MaterialLogics => materialLogics;

6
StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs
View File

@@ -16,16 +16,18 @@ namespace StructureHelperLogics.Models.Templates.CrossSections
TraceLogger = new ShiftTraceLogger()
};
calculators.Add(forceCalculator);
CrackCalculatorInputData newInputData = new CrackCalculatorInputData();
var newInputData = new CrackCalculatorInputData();
var checkLogic = new CheckCrackCalculatorInputDataLogic
{
InputData = newInputData
};
var crackCalculator = new CrackCalculator(newInputData, checkLogic)
checkLogic.InputData = newInputData;
var crackCalculator = new CrackCalculator(checkLogic, new CrackCalculatorUpdateStrategy(), null)
{
Name = "New Crack Calculator",
TraceLogger = new ShiftTraceLogger()
};
crackCalculator.InputData = newInputData;
calculators.Add(crackCalculator);
return calculators;
}

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

@@ -18,12 +18,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// <summary>
/// Logic of checking of input data for crack calcultor
/// </summary>
public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<CrackCalculatorInputData>
public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<ICrackCalculatorInputData>
{
private bool result;
private ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic;
public CrackCalculatorInputData InputData { get; set; }
public ICrackCalculatorInputData InputData { get; set; }
public string CheckResult { get; private set; }

30
StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs
View File

@@ -14,7 +14,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackCalculator : ICalculator
public class CrackCalculator : ICrackCalculator
{
const LimitStates limitState = LimitStates.SLS;
const CalcTerms longTerm = CalcTerms.LongTerm;
@@ -22,26 +22,30 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private const double maxSizeOfCrossSection = 1d;
private CrackResult result;
private IGetTupleInputDatasLogic datasLogic;
private CrackCalculatorUpdateStrategy updateStrategy = new();
private ICheckInputDataLogic<CrackCalculatorInputData> checkInputDataLogic;
private IUpdateStrategy<ICrackCalculator> updateStrategy;
private ICheckInputDataLogic<ICrackCalculatorInputData> checkInputDataLogic;
public string Name { get; set; }
public CrackCalculatorInputData InputData { get; set; }
public ICrackCalculatorInputData InputData { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public CrackCalculator(CrackCalculatorInputData inputData, ICheckInputDataLogic<CrackCalculatorInputData> checkInputDataLogic)
public CrackCalculator(ICheckInputDataLogic<ICrackCalculatorInputData> checkInputDataLogic,
IUpdateStrategy<ICrackCalculator> updateStrategy,
IShiftTraceLogger traceLogger
)
{
InputData = inputData;
this.checkInputDataLogic = checkInputDataLogic;
this.updateStrategy = updateStrategy;
this.TraceLogger = traceLogger;
Name = string.Empty;
}
public CrackCalculator(CrackCalculatorInputData inputData)
: this(inputData,
new CheckCrackCalculatorInputDataLogic()
{ InputData = inputData}
) { }
public CrackCalculator()
: this(new CheckCrackCalculatorInputDataLogic(),
new CrackCalculatorUpdateStrategy(),
new ShiftTraceLogger())
{ }
public object Clone()
{
@@ -50,7 +54,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
InputData = InputData
};
var newItem = new CrackCalculator(crackInputData, checkDataLogic);
var newItem = new CrackCalculator(checkDataLogic, new CrackCalculatorUpdateStrategy(), new ShiftTraceLogger());
newItem.InputData = crackInputData;
updateStrategy.Update(newItem, this);
return newItem;
}
@@ -75,6 +80,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private void CheckInputData()
{
checkInputDataLogic.InputData = InputData;
checkInputDataLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
if (checkInputDataLogic.Check() == false)
{

6
StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs
View File

@@ -10,18 +10,18 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackCalculatorInputData : IInputData, IHasPrimitives, IHasForceCombinations
public class CrackCalculatorInputData : ICrackCalculatorInputData
{
/// <inheritdoc/>
public List<INdmPrimitive> Primitives { get; private set; }
/// <inheritdoc/>
public List<IForceAction> ForceActions { get; private set; }
public UserCrackInputData UserCrackInputData { get; set; }
public IUserCrackInputData UserCrackInputData { get; set; }
public CrackCalculatorInputData()
{
Primitives = new();
ForceActions = new();
UserCrackInputData = new()
UserCrackInputData = new UserCrackInputData()
{
SetSofteningFactor = true,
SofteningFactor = 1d,

12
StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
View File

@@ -8,22 +8,22 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackCalculatorUpdateStrategy : IUpdateStrategy<CrackCalculator>
public class CrackCalculatorUpdateStrategy : IUpdateStrategy<ICrackCalculator>
{
private IUpdateStrategy<CrackCalculatorInputData> inputDataUpdateStrategy;
private IUpdateStrategy<ICrackCalculatorInputData> inputDataUpdateStrategy;
public CrackCalculatorUpdateStrategy(IUpdateStrategy<CrackCalculatorInputData> inputDataUpdateStrategy)
public CrackCalculatorUpdateStrategy(IUpdateStrategy<ICrackCalculatorInputData> inputDataUpdateStrategy)
{
this.inputDataUpdateStrategy = inputDataUpdateStrategy;
}
public CrackCalculatorUpdateStrategy() : this(new CrackInputDataUpdateStrategy()) { }
public void Update(CrackCalculator targetObject, CrackCalculator sourceObject)
public void Update(ICrackCalculator targetObject, ICrackCalculator sourceObject)
{
if (ReferenceEquals(targetObject, sourceObject)) { return; }
CheckObject.CompareTypes(targetObject, sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.Name = sourceObject.Name;
targetObject.InputData ??= new();
targetObject.InputData ??= new CrackCalculatorInputData();
inputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData);
}
}

6
StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs
View File

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackInputDataUpdateStrategy : IUpdateStrategy<CrackCalculatorInputData>
public class CrackInputDataUpdateStrategy : IUpdateStrategy<ICrackCalculatorInputData>
{
private IUpdateStrategy<IUserCrackInputData> userCrackInputDataUpdateStrategy;
public CrackInputDataUpdateStrategy(IUpdateStrategy<IUserCrackInputData> userCrackInputDataUpdateStrategy)
@@ -20,10 +20,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
}
public void Update(CrackCalculatorInputData targetObject, CrackCalculatorInputData sourceObject)
public void Update(ICrackCalculatorInputData targetObject, ICrackCalculatorInputData sourceObject)
{
if (ReferenceEquals(targetObject, sourceObject)) { return; }
CheckObject.CompareTypes(targetObject, sourceObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.ForceActions.Clear();
targetObject.ForceActions.AddRange(sourceObject.ForceActions);
targetObject.Primitives.Clear();

31
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculationLogic.cs
View File

@@ -13,10 +13,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackWidthCalculationLogic : ICrackWidthCalculationLogic
{
private IRebarStressResultLogic rebarStressResultLogic;
private ICrackWidthLogic crackWidthLogic;
private RebarCrackResult result;
private ICrackSofteningLogic crackSofteningLogic;
private RebarStressResult rebarStressResult;
private IRebarStressResult rebarStressResult;
private ICrackWidthLogicInputData acrc2InputData;
private ICrackWidthLogicInputData acrc1InputData;
private ICrackWidthLogicInputData acrc3InputData;
@@ -39,14 +40,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
public IShiftTraceLogger? TraceLogger { get; set; }
public CrackWidthCalculationLogic(IRebarStressCalculator rebarStressCalculator, ICrackWidthLogic crackWidthLogic, IShiftTraceLogger? traceLogger)
public CrackWidthCalculationLogic(IRebarStressResultLogic rebarStressResultLogic, ICrackWidthLogic crackWidthLogic, IShiftTraceLogger? traceLogger)
{
this.rebarStressCalculator = rebarStressCalculator;
this.rebarStressResultLogic = rebarStressResultLogic;
this.crackWidthLogic = crackWidthLogic;
this.TraceLogger = traceLogger;
}
public CrackWidthCalculationLogic() : this (new RebarStressCalculator(), new CrackWidthLogicSP63(), null)
public CrackWidthCalculationLogic() : this (new RebarStressResultLogic(), new CrackWidthLogicSP63(), null)
{
}
@@ -74,7 +75,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
result.ShortTermResult = shortRebarResult;
}
public CrackWidthRebarTupleResult ProcessShortTermCalculations()
private CrackWidthRebarTupleResult ProcessShortTermCalculations()
{
crackSofteningLogic = GetSofteningLogic(InputData.ShortRebarData);
rebarStressResult = GetRebarStressResult(InputData.ShortRebarData);
@@ -98,7 +99,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
return shortRebarResult;
}
public CrackWidthRebarTupleResult ProcessLongTermCalculations()
private CrackWidthRebarTupleResult ProcessLongTermCalculations()
{
crackSofteningLogic = GetSofteningLogic(InputData.LongRebarData);
rebarStressResult = GetRebarStressResult(InputData.LongRebarData);
@@ -168,20 +169,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
return crackWidthInputData;
}
public RebarStressResult GetRebarStressResult(IRebarCrackInputData inputData)
private IRebarStressResult GetRebarStressResult(IRebarCrackInputData rebarCrackInputData)
{
rebarStressCalculator.InputData.ForceTuple = inputData.ForceTuple;
rebarStressCalculator.InputData.NdmCollection = inputData.CrackedNdmCollection;
rebarStressCalculator.InputData.RebarPrimitive = InputData.RebarPrimitive;
rebarStressCalculator.Run();
var result = rebarStressCalculator.Result as RebarStressResult;
if (result.IsValid == false)
{
string errorString = LoggerStrings.CalculationError + result.Description;
TraceLogger?.AddMessage($"Rebar name: {InputData.RebarPrimitive.Name}\n" + errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
return result;
rebarStressResultLogic.RebarCrackInputData = rebarCrackInputData;
rebarStressResultLogic.RebarPrimitive = InputData.RebarPrimitive;
rebarStressResultLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
return rebarStressResultLogic.GetRebarStressResult();
}
}

2
StructureHelperLogics/NdmCalculations/Cracking/CrackWidthRebarTupleResult.cs
View File

@@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
public double CrackWidth { get; set; }
public double UltimateCrackWidth { get; set; }
public bool IsCrackLessThanUltimate => CrackWidth <= UltimateCrackWidth;
public RebarStressResult RebarStressResult { get; set; }
public IRebarStressResult RebarStressResult { get; set; }
public double SofteningFactor { get; set; }
}
}

4
StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs
View File

@@ -22,9 +22,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
public LimitStates LimitState { get; set; }
public CalcTerms LongTerm { get; set; }
public CalcTerms ShortTerm { get; set; }
public UserCrackInputData UserCrackInputData { get; set; }
public IUserCrackInputData UserCrackInputData { get; set; }
public GetTupleInputDatasLogic(List<INdmPrimitive> primitives, List<IForceAction> forceActions, UserCrackInputData userCrackInputData)
public GetTupleInputDatasLogic(List<INdmPrimitive> primitives, List<IForceAction> forceActions, IUserCrackInputData userCrackInputData)
{
Primitives = primitives;
ForceActions = forceActions;

9
StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculator.cs Normal file
View File

@@ -0,0 +1,9 @@
using StructureHelperCommon.Models.Calculators;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface ICrackCalculator : ICalculator
{
ICrackCalculatorInputData InputData { get; set; }
}
}

14
StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,14 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface ICrackCalculatorInputData : IInputData, IHasPrimitives, IHasForceCombinations
{
List<IForceAction> ForceActions { get; }
List<INdmPrimitive> Primitives { get; }
IUserCrackInputData UserCrackInputData { get; set; }
}
}

3
StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculationLogic.cs
View File

@@ -8,8 +8,5 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
RebarCrackResult Result { get; }
void Run();
CrackWidthRebarTupleResult ProcessLongTermCalculations();
CrackWidthRebarTupleResult ProcessShortTermCalculations();
RebarStressResult GetRebarStressResult(IRebarCrackInputData inputData);
}
}

2
StructureHelperLogics/NdmCalculations/Cracking/IGetTupleInputDatasLogic.cs
View File

@@ -11,6 +11,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
CalcTerms LongTerm { get; set; }
CalcTerms ShortTerm { get; set; }
List<TupleCrackInputData> GetTupleInputDatas();
UserCrackInputData UserCrackInputData { get; set; }
IUserCrackInputData UserCrackInputData { get; set; }
}
}

25
StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResult.cs Normal file
View File

@@ -0,0 +1,25 @@
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface IRebarStressResult : IResult
{
/// <summary>
/// Strain tuple which stress and strain is obtained for
/// </summary>
StrainTuple StrainTuple { get; set; }
/// <summary>
/// Strain in fake concrete ndm-part which rounds rebas and locatade at axis of rebar (refrence strain in concrete)
/// </summary>
double ConcreteStrain { get; set; }
/// <summary>
/// Strain in rebar, dimensionless
/// </summary>
double RebarStrain { get; set; }
/// <summary>
/// Stress in rebar, Pa
/// </summary>
double RebarStress { get; set; }
}
}

13
StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs Normal file
View File

@@ -0,0 +1,13 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface IRebarStressResultLogic : ILogic
{
IRebarCrackInputData RebarCrackInputData { get; set; }
IRebarPrimitive RebarPrimitive { get; set; }
IRebarStressResult GetRebarStressResult();
}
}

20
StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs
View File

@@ -11,27 +11,19 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// <summary>
/// Result of calculation of stress and strain in rebar
/// </summary>
public class RebarStressResult : IResult
public class RebarStressResult : IRebarStressResult
{
/// <inheritdoc/>
public bool IsValid { get; set; }
/// <inheritdoc/>
public string? Description { get; set; }
/// <summary>
/// Strain tuple which stress and strain is obtained for
/// </summary>
public StrainTuple StrainTuple { get; set; }
/// <summary>
/// Stress in rebar, Pa
/// </summary>
public StrainTuple StrainTuple { get; set; }
public double RebarStress { get; set; }
/// <summary>
/// Strain in rebar, dimensionless
/// </summary>
public double RebarStrain { get; set; }
/// <summary>
/// Strain in fake concrete ndm-part which rounds rebas and locatade at axis of rebar (refrence strain in concrete)
/// </summary>
public double ConcreteStrain { get; set; }
}
}

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

@@ -0,0 +1,53 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperCommon.Infrastructures.Interfaces;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class RebarStressResultLogic : IRebarStressResultLogic
{
private IRebarStressCalculator rebarStressCalculator;
public IRebarPrimitive RebarPrimitive { get; set; }
public IRebarCrackInputData RebarCrackInputData { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public RebarStressResultLogic(IRebarStressCalculator rebarStressCalculator, IShiftTraceLogger? traceLogger)
{
this.rebarStressCalculator = rebarStressCalculator;
this.TraceLogger = traceLogger;
}
public RebarStressResultLogic() : this(new RebarStressCalculator(), null)
{
}
public IRebarStressResult GetRebarStressResult()
{
IRebarStressCalculatorInputData calculatorInputData = new RebarStressCalculatorInputData()
{
ForceTuple = RebarCrackInputData.ForceTuple,
NdmCollection = RebarCrackInputData.CrackedNdmCollection,
RebarPrimitive = RebarPrimitive,
};
rebarStressCalculator.InputData = calculatorInputData;
rebarStressCalculator.Run();
var result = rebarStressCalculator.Result as RebarStressResult;
if (result.IsValid == false)
{
string errorString = LoggerStrings.CalculationError + result.Description;
TraceLogger?.AddMessage($"Rebar name: {RebarPrimitive.Name}\n" + errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
return result;
}
}
}

2
StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs
View File

@@ -34,6 +34,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// <summary>
/// Settings ajusted by user
/// </summary>
public UserCrackInputData UserCrackInputData { get; set; }
public IUserCrackInputData UserCrackInputData { get; set; }
}
}