diff --git a/StructureHelper/App.xaml b/StructureHelper/App.xaml index 04fc9ba..70db8cc 100644 --- a/StructureHelper/App.xaml +++ b/StructureHelper/App.xaml @@ -19,6 +19,7 @@ + diff --git a/StructureHelper/Infrastructure/UI/Resources/Cracks.xaml b/StructureHelper/Infrastructure/UI/Resources/Cracks.xaml new file mode 100644 index 0000000..0e11fa7 --- /dev/null +++ b/StructureHelper/Infrastructure/UI/Resources/Cracks.xaml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/StructureHelper/Infrastructure/UI/Resources/ServiceColors.xaml b/StructureHelper/Infrastructure/UI/Resources/ServiceColors.xaml new file mode 100644 index 0000000..782b8b2 --- /dev/null +++ b/StructureHelper/Infrastructure/UI/Resources/ServiceColors.xaml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/StructureHelper/Libraries/LoaderCalculator.dll b/StructureHelper/Libraries/LoaderCalculator.dll index 53f5bf2..09353ee 100644 Binary files a/StructureHelper/Libraries/LoaderCalculator.dll and b/StructureHelper/Libraries/LoaderCalculator.dll differ diff --git a/StructureHelper/Services/ResultViewers/CrackResultFunc.cs b/StructureHelper/Services/ResultViewers/CrackResultFunc.cs new file mode 100644 index 0000000..b66aa96 --- /dev/null +++ b/StructureHelper/Services/ResultViewers/CrackResultFunc.cs @@ -0,0 +1,20 @@ +using StructureHelperLogics.NdmCalculations.Cracking; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelper.Services.ResultViewers +{ + public class CrackResultFunc : IResultFunc> + { + public string Name { get; set; } + + public Func ResultFunction { get; set; } + + public string UnitName { get; set; } + + public double UnitFactor { get; set; } + } +} diff --git a/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs b/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs new file mode 100644 index 0000000..9b3fbab --- /dev/null +++ b/StructureHelper/Services/ResultViewers/CrackResultFuncFactory.cs @@ -0,0 +1,82 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Services.Units; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelper.Services.ResultViewers +{ + + public static class CrackResultFuncFactory + { + static IUnit unitStress = CommonOperation.GetUnit(UnitTypes.Stress); + static IUnit unitLength = CommonOperation.GetUnit(UnitTypes.Length, "mm"); + + public static List GetResultFuncs() + { + List results = new() + { + new() + { + Name = "Long crack width", + ResultFunction = (RebarCrackResult rebar) => rebar.LongTermResult.CrackWidth, + UnitFactor = unitLength.Multiplyer, + UnitName = unitLength.Name + }, + new() + { + Name = "Short crack width", + ResultFunction = (RebarCrackResult rebar) => rebar.ShortTermResult.CrackWidth, + UnitFactor = unitLength.Multiplyer, + UnitName = unitLength.Name + }, + new() + { + Name = "Long rebar stress", + ResultFunction = (RebarCrackResult rebar) => rebar.LongTermResult.RebarStressResult.RebarStress, + UnitFactor = unitStress.Multiplyer, + UnitName = unitStress.Name + }, + new() + { + Name = "Short rebar stress", + ResultFunction = (RebarCrackResult rebar) => rebar.ShortTermResult.RebarStressResult.RebarStress, + UnitFactor = unitStress.Multiplyer, + UnitName = unitStress.Name + }, + new() + { + Name = "Long rebar strain", + ResultFunction = (RebarCrackResult rebar) => rebar.LongTermResult.RebarStressResult.RebarStrain, + UnitFactor = 1d, + UnitName = string.Empty + }, + new() + { + Name = "Short rebar strain", + ResultFunction = (RebarCrackResult rebar) => rebar.ShortTermResult.RebarStressResult.RebarStrain, + UnitFactor = 1d, + UnitName = string.Empty + }, + new() + { + Name = "Long concrete strain", + ResultFunction = (RebarCrackResult rebar) => rebar.LongTermResult.RebarStressResult.ConcreteStrain, + UnitFactor = 1d, + UnitName = string.Empty + }, + new() + { + Name = "Short concrete strain", + ResultFunction = (RebarCrackResult rebar) => rebar.ShortTermResult.RebarStressResult.ConcreteStrain, + UnitFactor = 1d, + UnitName = string.Empty + } + }; + return results; + } + } +} diff --git a/StructureHelper/Services/ResultViewers/ResultFunc.cs b/StructureHelper/Services/ResultViewers/ForceResultFunc.cs similarity index 81% rename from StructureHelper/Services/ResultViewers/ResultFunc.cs rename to StructureHelper/Services/ResultViewers/ForceResultFunc.cs index 129e705..724374f 100644 --- a/StructureHelper/Services/ResultViewers/ResultFunc.cs +++ b/StructureHelper/Services/ResultViewers/ForceResultFunc.cs @@ -8,14 +8,14 @@ using System.Threading.Tasks; namespace StructureHelper.Services.ResultViewers { - public class ResultFunc : IResultFunc + public class ForceResultFunc : IResultFunc> { public string Name { get; set; } public Func ResultFunction { get; set; } public string UnitName { get; set; } public double UnitFactor { get; set; } - public ResultFunc() + public ForceResultFunc() { UnitFactor = 1d; } diff --git a/StructureHelper/Services/ResultViewers/ForceResultFuncFactory.cs b/StructureHelper/Services/ResultViewers/ForceResultFuncFactory.cs new file mode 100644 index 0000000..3935460 --- /dev/null +++ b/StructureHelper/Services/ResultViewers/ForceResultFuncFactory.cs @@ -0,0 +1,83 @@ +using LoaderCalculator.Logics; +using StructureHelper.Infrastructure.UI.Converters.Units; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Services.Units; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelper.Services.ResultViewers +{ + public enum FuncsTypes + { + Strain, + Stress, + Forces, + Full, + } + public static class ForceResultFuncFactory + { + static IUnit unitForce = CommonOperation.GetUnit(UnitTypes.Force); + static IUnit unitStress = CommonOperation.GetUnit(UnitTypes.Stress); + static IUnit unitMoment = CommonOperation.GetUnit(UnitTypes.Moment); + static IUnit unitCurvature = CommonOperation.GetUnit(UnitTypes.Curvature); + + static readonly IStressLogic stressLogic = new StressLogic(); + public static List GetResultFuncs(FuncsTypes funcsType = FuncsTypes.Full) + { + List results = new(); + if (funcsType == FuncsTypes.Strain) + { + results.AddRange(GetStrainResultFuncs()); + } + else if (funcsType == FuncsTypes.Stress) + { + results.AddRange(GetStressResultFuncs()); + } + else if (funcsType == FuncsTypes.Forces) + { + results.AddRange(GetForcesResultFuncs()); + } + else if (funcsType == FuncsTypes.Full) + { + results.AddRange(GetStrainResultFuncs()); + results.AddRange(GetStressResultFuncs()); + results.AddRange(GetForcesResultFuncs()); + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(funcsType)); + } + return results; + } + private static List GetStrainResultFuncs() + { + List resultFuncs = new (); + resultFuncs.Add(new ForceResultFunc() { Name = "Section Strain", ResultFunction = stressLogic.GetSectionStrain }); + resultFuncs.Add(new ForceResultFunc() { Name = "Total Strain", ResultFunction = stressLogic.GetTotalStrainWithPrestrain }); + resultFuncs.Add(new ForceResultFunc() { Name = "Prestrain", ResultFunction = stressLogic.GetPrestrain }); + resultFuncs.Add(new ForceResultFunc() { Name = "Elastic Strain", ResultFunction = stressLogic.GetElasticStrain }); + resultFuncs.Add(new ForceResultFunc() { Name = "Plastic Strain", ResultFunction = stressLogic.GetPlasticStrain }); + return resultFuncs; + } + private static List GetStressResultFuncs() + { + List resultFuncs = new (); + resultFuncs.Add(new ForceResultFunc() { Name = "Stress", ResultFunction = stressLogic.GetStress, UnitFactor = unitStress.Multiplyer, UnitName = unitStress.Name }); + resultFuncs.Add(new ForceResultFunc() { Name = "Secant modulus", ResultFunction = stressLogic.GetSecantModulus, UnitFactor = unitStress.Multiplyer, UnitName = unitStress.Name }); + resultFuncs.Add(new ForceResultFunc() { Name = "Modulus degradation", ResultFunction = stressLogic.GetModulusDegradation }); + return resultFuncs; + } + private static List GetForcesResultFuncs() + { + List resultFuncs = new (); + resultFuncs.Add(new ForceResultFunc() { Name = "Force", ResultFunction = stressLogic.GetForce, UnitFactor = unitForce.Multiplyer, UnitName = unitForce.Name }); + resultFuncs.Add(new ForceResultFunc() { Name = "Moment X", ResultFunction = stressLogic.GetMomentX, UnitFactor = unitMoment.Multiplyer, UnitName = unitMoment.Name }); + resultFuncs.Add(new ForceResultFunc() { Name = "Moment Y", ResultFunction = stressLogic.GetMomentY, UnitFactor = unitMoment.Multiplyer, UnitName = unitMoment.Name }); + return resultFuncs; + } + } +} diff --git a/StructureHelper/Services/ResultViewers/IResultFunc.cs b/StructureHelper/Services/ResultViewers/IResultFunc.cs index f90acc1..6ab3b7a 100644 --- a/StructureHelper/Services/ResultViewers/IResultFunc.cs +++ b/StructureHelper/Services/ResultViewers/IResultFunc.cs @@ -8,10 +8,10 @@ using System.Threading.Tasks; namespace StructureHelper.Services.ResultViewers { - public interface IResultFunc + public interface IResultFunc { string Name { get; } - Func ResultFunction { get; } + T ResultFunction { get; } string UnitName { get; set; } double UnitFactor { get; } } diff --git a/StructureHelper/Services/ResultViewers/ResultFuncFactory.cs b/StructureHelper/Services/ResultViewers/ResultFuncFactory.cs deleted file mode 100644 index 3064412..0000000 --- a/StructureHelper/Services/ResultViewers/ResultFuncFactory.cs +++ /dev/null @@ -1,82 +0,0 @@ -using LoaderCalculator.Logics; -using StructureHelper.Infrastructure.UI.Converters.Units; -using StructureHelperCommon.Infrastructures.Enums; -using StructureHelperCommon.Infrastructures.Exceptions; -using StructureHelperCommon.Services.Units; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelper.Services.ResultViewers -{ - public enum FuncsTypes - { - Strain, - Stress, - Forces, - Full, - } - public static class ResultFuncFactory - { - static IUnit unitForce = CommonOperation.GetUnit(UnitTypes.Force); - static IUnit unitStress = CommonOperation.GetUnit(UnitTypes.Stress); - static IUnit unitMoment = CommonOperation.GetUnit(UnitTypes.Moment); - static IUnit unitCurvature = CommonOperation.GetUnit(UnitTypes.Curvature); - - static readonly IStressLogic stressLogic = new StressLogic(); - public static List GetResultFuncs(FuncsTypes funcsType = FuncsTypes.Full) - { - List results = new(); - if (funcsType == FuncsTypes.Strain) - { - results.AddRange(GetStrainResultFuncs()); - } - else if (funcsType == FuncsTypes.Stress) - { - results.AddRange(GetStressResultFuncs()); - } - else if (funcsType == FuncsTypes.Forces) - { - results.AddRange(GetForcesResultFuncs()); - } - else if (funcsType == FuncsTypes.Full) - { - results.AddRange(GetStrainResultFuncs()); - results.AddRange(GetStressResultFuncs()); - results.AddRange(GetForcesResultFuncs()); - } - else - { - throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(funcsType)); - } - return results; - } - private static List GetStrainResultFuncs() - { - List resultFuncs = new List(); - resultFuncs.Add(new ResultFunc() { Name = "Total Strain", ResultFunction = stressLogic.GetTotalStrain }); - resultFuncs.Add(new ResultFunc() { Name = "Total Strain with prestrain", ResultFunction = stressLogic.GetTotalStrainWithPrestrain }); - resultFuncs.Add(new ResultFunc() { Name = "Elastic Strain", ResultFunction = stressLogic.GetElasticStrain }); - resultFuncs.Add(new ResultFunc() { Name = "Plastic Strain", ResultFunction = stressLogic.GetPlasticStrain }); - return resultFuncs; - } - private static List GetStressResultFuncs() - { - List resultFuncs = new List(); - resultFuncs.Add(new ResultFunc() { Name = "Stress", ResultFunction = stressLogic.GetStress, UnitFactor = unitStress.Multiplyer, UnitName = unitStress.Name }); - resultFuncs.Add(new ResultFunc() { Name = "Secant modulus", ResultFunction = stressLogic.GetSecantModulus, UnitFactor = unitStress.Multiplyer, UnitName = unitStress.Name }); - resultFuncs.Add(new ResultFunc() { Name = "Modulus degradation", ResultFunction = stressLogic.GetModulusDegradation }); - return resultFuncs; - } - private static List GetForcesResultFuncs() - { - List resultFuncs = new List(); - resultFuncs.Add(new ResultFunc() { Name = "Force", ResultFunction = stressLogic.GetForce, UnitFactor = unitForce.Multiplyer, UnitName = unitForce.Name }); - resultFuncs.Add(new ResultFunc() { Name = "Moment X", ResultFunction = stressLogic.GetMomentX, UnitFactor = unitMoment.Multiplyer, UnitName = unitMoment.Name }); - resultFuncs.Add(new ResultFunc() { Name = "Moment Y", ResultFunction = stressLogic.GetMomentY, UnitFactor = unitMoment.Multiplyer, UnitName = unitMoment.Name }); - return resultFuncs; - } - } -} diff --git a/StructureHelper/Services/ResultViewers/ShowIsoFieldResult.cs b/StructureHelper/Services/ResultViewers/ShowIsoFieldResult.cs index 035fc76..67f3170 100644 --- a/StructureHelper/Services/ResultViewers/ShowIsoFieldResult.cs +++ b/StructureHelper/Services/ResultViewers/ShowIsoFieldResult.cs @@ -4,6 +4,9 @@ using LoaderCalculator.Data.Matrix; using LoaderCalculator.Data.Ndms; using LoaderCalculator.Data.ResultData; using LoaderCalculator.Logics; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperLogics.NdmCalculations.Cracking; +using StructureHelperLogics.NdmCalculations.Triangulations; using System; using System.Collections.Generic; using System.Linq; @@ -14,13 +17,13 @@ namespace StructureHelper.Services.ResultViewers { public static class ShowIsoFieldResult { - public static void ShowResult(IStrainMatrix strainMatrix, IEnumerable ndms, IEnumerable resultFuncs) + public static void ShowResult(IStrainMatrix strainMatrix, IEnumerable ndms, IEnumerable resultFuncs) { var primitiveSets = GetPrimitiveSets(strainMatrix, ndms, resultFuncs); FieldViewerOperation.ShowViewer(primitiveSets); } - public static List GetPrimitiveSets(IStrainMatrix strainMatrix, IEnumerable ndms, IEnumerable resultFuncs) + public static List GetPrimitiveSets(IStrainMatrix strainMatrix, IEnumerable ndms, IEnumerable resultFuncs) { List primitiveSets = new List(); foreach (var valDelegate in resultFuncs) @@ -29,23 +32,81 @@ namespace StructureHelper.Services.ResultViewers List primitives = new List(); foreach (INdm ndm in ndms) { - double val = valDelegate.ResultFunction.Invoke(strainMatrix, ndm) * valDelegate.UnitFactor; - IValuePrimitive valuePrimitive; - if (ndm is IRectangleNdm) - { - var shapeNdm = ndm as IRectangleNdm; - valuePrimitive = new RectanglePrimitive() { CenterX = ndm.CenterX, CenterY = ndm.CenterY, Height = shapeNdm.Height, Width = shapeNdm.Width, Value = val }; - } - else - { - valuePrimitive = new CirclePrimitive() { CenterX = ndm.CenterX, CenterY = ndm.CenterY, Diameter = Math.Sqrt(ndm.Area / Math.PI) * 2, Value = val }; - } - primitives.Add(valuePrimitive); + primitives.Add(ProcessNdm(strainMatrix, valDelegate, ndm)); } primitiveSet.ValuePrimitives = primitives; primitiveSets.Add(primitiveSet); } return primitiveSets; } + + public static List GetPrimitiveSets(IEnumerable rebarResults, IEnumerable resultFuncs) + { + List primitiveSets = new List(); + foreach (var valDelegate in resultFuncs) + { + PrimitiveSet primitiveSet = new PrimitiveSet() { Name = valDelegate.Name }; + List primitives = new List(); + foreach (var rebarResult in rebarResults) + { + primitives.Add(ProcessNdm(valDelegate, rebarResult)); + } + primitiveSet.ValuePrimitives = primitives; + primitiveSets.Add(primitiveSet); + } + return primitiveSets; + } + + private static IValuePrimitive ProcessNdm(CrackResultFunc valDelegate, RebarCrackResult rebarResult) + { + var val = valDelegate.ResultFunction.Invoke(rebarResult) * valDelegate.UnitFactor; + IValuePrimitive valuePrimitive; + var rebarNdm = rebarResult.RebarPrimitive.GetRebarNdm(new TriangulationOptions() + { + LimiteState = LimitStates.SLS, + CalcTerm = CalcTerms.ShortTerm + } + ); + valuePrimitive = ProcessCircle(rebarNdm, val); + return valuePrimitive; + } + + private static IValuePrimitive ProcessNdm(IStrainMatrix strainMatrix, ForceResultFunc valDelegate, INdm ndm) + { + double val = valDelegate.ResultFunction.Invoke(strainMatrix, ndm) * valDelegate.UnitFactor; + IValuePrimitive valuePrimitive; + if (ndm is IRectangleNdm shapeNdm) + { + valuePrimitive = ProcessRectangle(shapeNdm, val); + } + else + { + valuePrimitive = ProcessCircle(ndm, val); + } + return valuePrimitive; + } + + private static IValuePrimitive ProcessRectangle(IRectangleNdm shapeNdm, double val) + { + return new RectanglePrimitive() + { + CenterX = shapeNdm.CenterX, + CenterY = shapeNdm.CenterY, + Height = shapeNdm.Height, + Width = shapeNdm.Width, + Value = val + }; + } + + private static IValuePrimitive ProcessCircle(INdm ndm, double val) + { + return new CirclePrimitive() + { + CenterX = ndm.CenterX, + CenterY = ndm.CenterY, + Diameter = Math.Sqrt(ndm.Area / Math.PI) * 2, + Value = val + }; + } } } diff --git a/StructureHelper/StructureHelper.csproj.user b/StructureHelper/StructureHelper.csproj.user index a12f03f..c2ddce4 100644 --- a/StructureHelper/StructureHelper.csproj.user +++ b/StructureHelper/StructureHelper.csproj.user @@ -77,6 +77,9 @@ + + Designer + Designer @@ -92,6 +95,9 @@ Designer + + Designer + Designer @@ -101,6 +107,9 @@ Designer + + Designer + Designer diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackResultView.xaml b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackResultView.xaml index 1577c78..c4abe14 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackResultView.xaml +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackResultView.xaml @@ -6,11 +6,18 @@ xmlns:local="clr-namespace:StructureHelper.Windows.CalculationWindows.CalculatorsViews" d:DataContext="{d:DesignInstance local:CrackResultViewModel}" mc:Ignorable="d" - Title="Result of calculations of crack" Height="450" Width="800" MinHeight="300" MinWidth="600" MaxHeight="800" MaxWidth="1000"> + Title="Result of calculations of crack" Height="450" Width="800" MinHeight="300" MinWidth="600" MaxHeight="800" MaxWidth="1000" WindowStartupLocation="CenterScreen"> + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml.cs index d3d78a9..042665c 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultView.xaml.cs @@ -1,4 +1,5 @@ -using System; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; using System.Collections.Generic; using System.Linq; using System.Text; @@ -19,9 +20,16 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews /// public partial class TupleCrackResultView : Window { - public TupleCrackResultView() + TupleCrackResultViewModel viewModel; + public TupleCrackResultView(TupleCrackResultViewModel viewModel) { InitializeComponent(); + this.viewModel = viewModel; + DataContext = this.viewModel; + } + public TupleCrackResultView(TupleCrackResult crackResult) : this(new TupleCrackResultViewModel(crackResult)) + { + } } } diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs index 8d6bef2..cbb3f51 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/TupleCrackResultViewModel.cs @@ -1,12 +1,45 @@ -using System; +using LoaderCalculator.Data.Matrix; +using LoaderCalculator.Data.Ndms; +using StructureHelper.Infrastructure; +using StructureHelper.Services.Reports.CalculationReports; +using StructureHelper.Services.ResultViewers; +using StructureHelper.Windows.Errors; +using StructureHelper.Windows.ViewModels.Errors; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; using System.Collections.Generic; +using System.ComponentModel; using System.Linq; +using System.Runtime.CompilerServices; using System.Text; using System.Threading.Tasks; +using System.Windows.Input; namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews { - public class TupleCrackResultViewModel + public class TupleCrackResultViewModel : ViewModelBase { + IShowCrackIsoFieldsLogic showCrackIsoFieldsLogic => new ShowCrackIsoFieldsLogic(); + private TupleCrackResult crackResult; + private RelayCommand showIsoFieldCommand; + private IsoFieldReport isoFieldReport; + + public TupleCrackResult CrackResult => crackResult; + public List RebarResults => crackResult.RebarResults; + public RebarCrackResult SelectedResult { get; set; } + public ICommand ShowIsoFieldCommand + { + get + { + return showIsoFieldCommand ??= new RelayCommand(o => + { + showCrackIsoFieldsLogic.ShowIsoField(crackResult.RebarResults); + }); + } + } + public TupleCrackResultViewModel(TupleCrackResult crackResult) + { + this.crackResult = crackResult; + } } } diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs index 19c324a..54eccf4 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackWidthLogic.cs @@ -24,7 +24,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu //LimitState = LimitState, //CalcTerm = CalcTerm, LongTermTuple = ForceTuple, - NdmPrimitives = ndmPrimitives + Primitives = ndmPrimitives }; var calculator = new TupleCrackCalculator() { InputData = inputData }; calculator.Run(); diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs index 950c5b5..b08bb5c 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs @@ -22,7 +22,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu private List<(INamedAreaPoint areaPoint, INdmPrimitive ndmPrimitive)> pointCollection; private List validTuplesList; private ArrayParameter arrayOfValuesByPoint; - private IEnumerable selectedDelegates; + private IEnumerable selectedDelegates; private string exceptionMessage; public IEnumerable TupleList { get; set; } @@ -154,7 +154,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu + userPrestrain.Nz + autoPrestrain.Nz; return ndm; } - private List GetValueLabels(IEnumerable selectedDelegates) + private List GetValueLabels(IEnumerable selectedDelegates) { List strings = new(); foreach (var valuePoint in pointCollection) diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs index 1264d96..1191a0a 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs @@ -416,7 +416,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu try { IStrainMatrix strainMatrix = SelectedResult.LoaderResults.ForceStrainPair.StrainMatrix; - var primitiveSets = ShowIsoFieldResult.GetPrimitiveSets(strainMatrix, ndms, ResultFuncFactory.GetResultFuncs()); + var primitiveSets = ShowIsoFieldResult.GetPrimitiveSets(strainMatrix, ndms, ForceResultFuncFactory.GetResultFuncs()); isoFieldReport = new IsoFieldReport(primitiveSets); isoFieldReport.Show(); } @@ -429,7 +429,6 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu }; new ErrorMessage(vm).ShowDialog(); } - } private void GetNdms() { diff --git a/StructureHelper/Windows/Forces/ValueDelegatesLogic.cs b/StructureHelper/Windows/Forces/ValueDelegatesLogic.cs index 0307821..d85b6f0 100644 --- a/StructureHelper/Windows/Forces/ValueDelegatesLogic.cs +++ b/StructureHelper/Windows/Forces/ValueDelegatesLogic.cs @@ -11,13 +11,13 @@ namespace StructureHelper.Windows.Forces { public class ValueDelegatesLogic : ViewModelBase { - private readonly List resultFuncs; - public SelectItemsVM ResultFuncs { get; } + private readonly List resultFuncs; + public SelectItemsVM ResultFuncs { get; } public ValueDelegatesLogic() { - resultFuncs = new List(); - resultFuncs.AddRange(ResultFuncFactory.GetResultFuncs(FuncsTypes.Full)); - ResultFuncs = new SelectItemsVM(resultFuncs) + resultFuncs = new List(); + resultFuncs.AddRange(ForceResultFuncFactory.GetResultFuncs(FuncsTypes.Full)); + ResultFuncs = new SelectItemsVM(resultFuncs) { ShowButtons = true }; diff --git a/StructureHelper/Windows/ViewModels/Calculations/CalculationResult/CalculationResultViewModel.cs b/StructureHelper/Windows/ViewModels/Calculations/CalculationResult/CalculationResultViewModel.cs index 1145ff7..5bafcf7 100644 --- a/StructureHelper/Windows/ViewModels/Calculations/CalculationResult/CalculationResultViewModel.cs +++ b/StructureHelper/Windows/ViewModels/Calculations/CalculationResult/CalculationResultViewModel.cs @@ -55,7 +55,7 @@ namespace StructureHelper.Windows.ViewModels.Calculations.CalculationResult private void ShowIsoField() { IStrainMatrix strainMatrix = SelectedResult.LoaderResults.ForceStrainPair.StrainMatrix; - var primitiveSets = ShowIsoFieldResult.GetPrimitiveSets(strainMatrix, ndms, ResultFuncFactory.GetResultFuncs()); + var primitiveSets = ShowIsoFieldResult.GetPrimitiveSets(strainMatrix, ndms, ForceResultFuncFactory.GetResultFuncs()); isoFieldReport = new IsoFieldReport(primitiveSets); isoFieldReport.Show(); } diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs index cb8e637..b4c206f 100644 --- a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs +++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs @@ -184,7 +184,6 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections } if (SelectedItem is LimitCurvesCalculator calculator) { - var inputData = calculator.InputData; ShowInteractionDiagramByInputData(calculator); } else @@ -193,7 +192,13 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections var result = SelectedItem.Result; if (result.IsValid == false) { - MessageBox.Show(result.Description, "Check data for analisys", MessageBoxButtons.OK, MessageBoxIcon.Warning); + var vm = new ErrorProcessor() + { + ShortText = "Errors apearred during calculations, see detailed information", + DetailText = SelectedItem.Result.Description + }; + new ErrorMessage(vm).ShowDialog(); + return; } else { diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ICheckInputDataLogic.cs b/StructureHelperCommon/Infrastructures/Interfaces/ICheckInputDataLogic.cs new file mode 100644 index 0000000..5cf6ab5 --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/ICheckInputDataLogic.cs @@ -0,0 +1,14 @@ +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public interface ICheckInputDataLogic : ICheckLogic + { + IInputData InputData { get; set; } + } +} diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs b/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs new file mode 100644 index 0000000..dbefc5f --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public interface ICheckLogic : ILogic + { + string CheckResult { get; } + bool Check(); + } +} diff --git a/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs b/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs index fc07e65..8031064 100644 --- a/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs +++ b/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs @@ -33,8 +33,16 @@ namespace StructureHelperCommon.Models.Materials { GetLoaderOptions(); IBuilderDirector director = GetMaterialDirector(); - var material = director.BuildMaterial(); - return material; + try + { + var material = director.BuildMaterial(); + return material; + } + catch (System.Exception) + { + + throw; + } } private IBuilderDirector GetMaterialDirector() diff --git a/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs b/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs index f66f3aa..ac246ee 100644 --- a/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs +++ b/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs @@ -30,8 +30,17 @@ namespace StructureHelperCommon.Models.Materials { GetLoaderOptions(); IBuilderDirector director = GetMaterialDirector(); - var material = director.BuildMaterial(); - return material; + try + { + var material = director.BuildMaterial(); + return material; + } + catch (System.Exception) + { + + throw; + } + } private IBuilderDirector GetMaterialDirector() @@ -45,7 +54,7 @@ namespace StructureHelperCommon.Models.Materials { materialOptions = new ReinforcementOptions() { - DiagramType = DiagramType + DiagramType = DiagramType, }; optionLogic = new MaterialCommonOptionLogic(options); optionLogic.SetMaterialOptions(materialOptions); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs index e160803..b463e6d 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs @@ -60,14 +60,16 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private void MultiThreadProc(IEnumerable points) { Task[] tasks = new Task[points.Count()]; - for (int i = 0; i < points.Count(); i++) + int pointCount = points.Count(); + List PointList = points.ToList(); + for (int i = 0; i < pointCount; i++) { - var point = points.ToList()[i]; + var point = PointList[i]; tasks[i] = new Task(() => FindResultPoint(point)); tasks[i].Start(); } Task.WaitAll(tasks); - for (int j = 0; j < points.Count(); j++) + for (int j = 0; j < pointCount; j++) { var taskResult = tasks[j].Result; resultList.Add(taskResult); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleTraceResultLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleTraceResultLogic.cs index 0a412a5..63295aa 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleTraceResultLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleTraceResultLogic.cs @@ -50,7 +50,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces Point2D minPoint = new(), maxPoint = new(); foreach (var item in ndmCollection) { - var strain = stressLogic.GetTotalStrain(strainMatrix, item); + var strain = stressLogic.GetSectionStrain(strainMatrix, item); if (strain < minStrain) { minStrain = strain; diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs index 8f0a361..88884c6 100644 --- a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs @@ -205,7 +205,7 @@ namespace StructureHelperLogics.NdmCalculations.Buckling var stressLogic = new StressLogic(); foreach (var item in ndmCollection) { - var strain = stressLogic.GetTotalStrain(strains, item); + var strain = stressLogic.GetSectionStrain(strains, item); if (strain > maxStrain) { maxStrain = strain; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs new file mode 100644 index 0000000..676ed3e --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs @@ -0,0 +1,119 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.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.Cracking +{ + /// + /// Logic of checking of input data for crack calcultor + /// + public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic + { + private string checkResult; + private CrackInputData inputData; + private bool result; + + public IInputData InputData + { + get => inputData; + set + { + if (value is CrackInputData data) + { + inputData = data; + } + else + { + throw new StructureHelperException(ErrorStrings.ExpectedWas(typeof(CrackInputData), value)); + } + } + } + + public string CheckResult => checkResult; + + public IShiftTraceLogger? TraceLogger { get; set; } + public CheckCrackCalculatorInputDataLogic(CrackInputData inputData) + { + this.inputData = inputData; + } + public bool Check() + { + TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Debug); + result = true; + checkResult = string.Empty; + CheckPrimitives(); + CheckActions(); + return result; + } + + private void CheckActions() + { + if (inputData.ForceActions is null || (!inputData.ForceActions.Any())) + { + result = false; + string message = "Calculator does not contain any actions\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + }; + } + + private void CheckPrimitives() + { + if (inputData.Primitives is null || (!inputData.Primitives.Any())) + { + result = false; + string message = "Calculator does not contain any primitives\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + else + { + foreach (var primitive in inputData.Primitives) + { + if (primitive is RebarPrimitive rebar) + { + CheckRebar(rebar); + } + } + } + } + + private void CheckRebar(RebarPrimitive rebar) + { + if (rebar.HostPrimitive is null) + { + result = false; + string message = $"Primitive {rebar.Name} does not have a host\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + else + { + bool isPrimitivesContainRebarHost = inputData.Primitives.Contains(rebar.HostPrimitive); + if (isPrimitivesContainRebarHost == false) + { + result = false; + string message = $"Host {rebar.Name}({rebar.HostPrimitive.Name}) is not included in primitives\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + } + if (rebar.HostPrimitive.HeadMaterial.HelperMaterial is not ICrackedMaterial) + { + result = false; + string message = $"Material of host of {rebar.Name} does not support cracking\n"; + checkResult += message; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + } + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs index a024b92..b1d416f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs @@ -23,6 +23,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private CrackResult result; private IGetTupleInputDatasLogic datasLogic; private CrackCalculatorUpdateStrategy updateStrategy = new(); + private ICheckInputDataLogic checkInputDataLogic; public string Name { get; set; } public CrackInputData InputData { get; set; } @@ -44,6 +45,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public void Run() { PrepareNewResult(); + CheckInputData(); TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); try { @@ -58,6 +60,19 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } } + private void CheckInputData() + { + checkInputDataLogic = new CheckCrackCalculatorInputDataLogic(InputData) + { + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + if (checkInputDataLogic.Check() == false) + { + result.IsValid = false; + result.Description += checkInputDataLogic.CheckResult; + } + } + private void ProcessCalculations() { datasLogic = new GetTupleInputDatasLogic(InputData.Primitives, InputData.ForceActions, InputData.UserCrackInputData) diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs index 5052ce0..3e00cb6 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthLogicSP63.cs @@ -35,7 +35,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage($"Rebar elongation Epsilon = {inputData.RebarStrain} - {inputData.ConcreteStrain} = {rebarElongation}(dimensionless)"); double width = rebarElongation * inputData.Length; width *= inputData.TermFactor * inputData.BondFactor * inputData.StressStateFactor * inputData.PsiSFactor; - TraceLogger?.AddMessage($"Width of crack a,crc = {width}(m)"); + TraceLogger?.AddMessage($"Width of crack a,crc = {inputData.TermFactor} * {inputData.BondFactor} * {inputData.StressStateFactor} * {inputData.PsiSFactor} * {rebarElongation} * {inputData.Length}(m) = {width}(m)"); return width; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs index 097ad9b..82c15a2 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs @@ -52,9 +52,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking resultList.Add(new TupleCrackInputData() { IsValid = true, + TupleName = action.Name, LongTermTuple = tuple.LongTuple, ShortTermTuple = tuple.ShortTuple, - NdmPrimitives = Primitives, + Primitives = Primitives, UserCrackInputData = UserCrackInputData }); } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs index 7404778..19cdf81 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs @@ -2,6 +2,9 @@ { public interface ICrackWidthTupleResult { + /// + /// Calculated crack width + /// double CrackWidth { get; set; } bool IsCrackLessThanUltimate { get; } double UltimateCrackWidth { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs index 34c5bf5..99d185f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/LengthBetweenCracksLogicSP63.cs @@ -106,7 +106,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private double GetAverageDiameter(IEnumerable rebars) { var tesileRebars = rebars - .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d); + .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d); diameterLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50); diameterLogic.Rebars = tesileRebars; var rebarDiameter = diameterLogic.GetAverageDiameter(); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs index c3eb9bc..74a6548 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs @@ -8,12 +8,26 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { + /// + /// Result of calculation of crack for specific result + /// public class RebarCrackResult : IResult { + /// public bool IsValid { get; set; } + /// public string Description { get; set; } + /// + /// Specific rebar primitive + /// public RebarPrimitive RebarPrimitive { get; set; } + /// + /// Result of calculation of crack for long term + /// public CrackWidthRebarTupleResult LongTermResult { get; set; } + /// + /// Result of calculation of crack for short term + /// public CrackWidthRebarTupleResult ShortTermResult { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs index 86dc758..aca6206 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs @@ -62,7 +62,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public void Run() { - GetNdms(); + GetNdmCollectionFromPrimitives(); result = new RebarStressResult() { IsValid = true, @@ -71,13 +71,13 @@ namespace StructureHelperLogics.NdmCalculations.Cracking var strainTuple = GetStrainTuple(); result.StrainTuple = strainTuple; var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple); - result.RebarStrain = stressLogic.GetTotalStrain(strainMatrix, rebarNdm); + result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm); result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm); result.ConcreteStrain = concreteNdm.Prestrain; } - private void GetNdms() + private void GetNdmCollectionFromPrimitives() { var options = new TriangulationOptions() { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs index a6aaf44..c24bac3 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs @@ -10,7 +10,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class RebarStressResult : IResult { + /// public bool IsValid { get; set; } + /// public string? Description { get; set; } public StrainTuple StrainTuple { get; set; } public double RebarStress { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs b/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs index 8436f83..f5a6533 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TensileConcreteAreaLogicSP63.cs @@ -29,7 +29,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); var rebarCollection = NdmCollection - .Where(x => x is RebarNdm & stressLogic.GetTotalStrain(StrainMatrix, x) > 0d); + .Where(x => x is RebarNdm & stressLogic.GetSectionStrain(StrainMatrix, x) > 0d); var rebarArea = rebarCollection. Sum(x => x.Area * x.StressScale); TraceLogger?.AddMessage($"Summary rebar area As = {rebarArea}"); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs index 134c75d..8303141 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaByStrainLogic.cs @@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); TraceLogger?.AddMessage("Method of obtaining of summary area of rebars in tension based on areas which are proportional by maximum strain"); var rebars = Rebars - .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d); + .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d); if (!rebars.Any()) { string errorString = ErrorStrings.DataIsInCorrect + ": Collection of rebars does not contain any tensile rebars"; @@ -40,7 +40,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking throw new StructureHelperException(errorString); } var maxStrain = rebars - .Select(x => stressLogic.GetTotalStrain(StrainMatrix, x)) + .Select(x => stressLogic.GetSectionStrain(StrainMatrix, x)) .Max(); TraceLogger?.AddMessage($"Maximum strain maxStrain = {maxStrain}"); if (TraceLogger is not null) @@ -51,7 +51,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking foreach (var rebar in rebars) { double area = rebar.Area * rebar.StressScale; - double strain = stressLogic.GetTotalStrain(StrainMatrix, rebar); + double strain = stressLogic.GetSectionStrain(StrainMatrix, rebar); TraceLogger?.AddMessage($"Rebar area = {area}(m^2)"); TraceLogger?.AddMessage($"Rebar strain = {strain}"); var reducedArea = area * strain / maxStrain; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs index a9abe5b..d446c3a 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TensionRebarAreaSimpleSumLogic.cs @@ -11,6 +11,9 @@ using System.Linq; using System.Text; using System.Threading.Tasks; +//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + namespace StructureHelperLogics.NdmCalculations.Cracking { public class TensionRebarAreaSimpleSumLogic : ITensionRebarAreaLogic @@ -32,7 +35,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); TraceLogger?.AddMessage("Method of obtaining of summary area of rebars in tension based on ordinary summarizing of areas"); var rebars = Rebars - .Where(x => stressLogic.GetTotalStrain(StrainMatrix, x) > 0d); + .Where(x => stressLogic.GetSectionStrain(StrainMatrix, x) > 0d); if (!rebars.Any()) { string errorString = ErrorStrings.DataIsInCorrect + ": Collection of rebars does not contain any tensile rebars"; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs index 81d44b3..2563d2a 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs @@ -1,4 +1,5 @@ using LoaderCalculator.Data.Ndms; +using StructureHelper.Models.Materials; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Models; @@ -26,6 +27,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private StrainTuple shortDefaultStrainTuple; private double longLength; private double shortLength; + private object locker = new(); public string Name { get; set; } public TupleCrackInputData InputData { get; set; } @@ -68,6 +70,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { CheckInputData(); Triangulate(); + longDefaultStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, crackableNdms); shortDefaultStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, crackableNdms); var longElasticStrainTuple = CalcStrainMatrix(InputData.LongTermTuple as ForceTuple, elasticNdms); @@ -85,17 +88,28 @@ namespace StructureHelperLogics.NdmCalculations.Cracking shortLength = GetLengthBetweenCracks(shortElasticStrainTuple); } CalcCrackForce(); - foreach (var rebar in rebarPrimitives) - { - RebarCrackCalculatorInputData rebarCalculatorData = GetRebarCalculatorInputData(rebar); - var calculator = new RebarCrackCalculator + //for (int j = 0; j < 100000; j++) + //{ + result.RebarResults.Clear(); + int rebarCount = rebarPrimitives.Count; + Task[] tasks = new Task[rebarCount]; + for (int i = 0; i < rebarCount; i++) { - InputData = rebarCalculatorData, - TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) - }; - calculator.Run(); - var rebarResult = calculator.Result as RebarCrackResult; - result.RebarResults.Add(rebarResult); + var rebar = rebarPrimitives[i]; + tasks[i] = new Task(() => ProcessRebar(rebar)); + tasks[i].Start(); + } + Task.WaitAll(tasks); + for (int i = 0; i < rebarCount; i++) + { + result.RebarResults.Add(tasks[i].Result); + } + //} + + if (result.RebarResults.Any(x => x.IsValid == false)) + { + result.IsValid = false; + return; } result.LongTermResult = new() { @@ -109,25 +123,50 @@ namespace StructureHelperLogics.NdmCalculations.Cracking }; } + private RebarCrackResult ProcessRebar(RebarPrimitive rebar) + { + RebarCrackCalculatorInputData rebarCalculatorData = GetRebarCalculatorInputData(rebar); + var calculator = new RebarCrackCalculator + { + InputData = rebarCalculatorData, + TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) + }; + calculator.Run(); + var rebarResult = calculator.Result as RebarCrackResult; + return rebarResult; + } + private RebarCrackCalculatorInputData GetRebarCalculatorInputData(RebarPrimitive rebar) { + IEnumerable crackableNdmsLoc = null; + IEnumerable crackedNdmsLoc = null; + RebarPrimitive rebarCopy = null; + lock (locker) + { + rebarCopy = rebar.Clone() as RebarPrimitive; + rebarCopy.HeadMaterial = rebarCopy.HeadMaterial.Clone() as IHeadMaterial; + var triangulationLogicLoc = new CrackedSectionTriangulationLogic(InputData.Primitives); + crackableNdmsLoc = triangulationLogicLoc.GetNdmCollection(); + crackedNdmsLoc = triangulationLogicLoc.GetCrackedNdmCollection(); + } + var longRebarData = new RebarCrackInputData() { - CrackableNdmCollection = crackableNdms, - CrackedNdmCollection = crackedNdms, - ForceTuple = InputData.LongTermTuple as ForceTuple, + CrackableNdmCollection = crackableNdmsLoc, + CrackedNdmCollection = crackedNdmsLoc, + ForceTuple = InputData.LongTermTuple.Clone() as ForceTuple, Length = longLength }; var shortRebarData = new RebarCrackInputData() { CrackableNdmCollection = crackableNdms, CrackedNdmCollection = crackedNdms, - ForceTuple = InputData.ShortTermTuple as ForceTuple, + ForceTuple = InputData.ShortTermTuple.Clone() as ForceTuple, Length = shortLength }; var rebarCalculatorData = new RebarCrackCalculatorInputData() { - RebarPrimitive = rebar, + RebarPrimitive = rebarCopy, LongRebarData = longRebarData, ShortRebarData = shortRebarData, UserCrackInputData = InputData.UserCrackInputData @@ -153,6 +192,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { result.IsValid = false; result.Description += forceResult.Description; + TraceLogger?.AddMessage("Bearing capacity of cross-section is not enough for action", TraceLogStatuses.Error); + return null; } var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix); return strain; @@ -171,7 +212,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private void Triangulate() { - triangulationLogic = new CrackedSectionTriangulationLogic(InputData.NdmPrimitives) + triangulationLogic = new CrackedSectionTriangulationLogic(InputData.Primitives) { //TraceLogger = TraceLogger?.GetSimilarTraceLogger(50) }; @@ -192,7 +233,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private void CheckInputData() { - if (InputData.NdmPrimitives is null || InputData.NdmPrimitives.Count == 0) + if (InputData.Primitives is null || InputData.Primitives.Count == 0) { throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": input data doesn't have any primitives"); } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs index 9e26612..851987f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs @@ -8,14 +8,32 @@ using System.Linq; using System.Text; using System.Threading.Tasks; +//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + namespace StructureHelperLogics.NdmCalculations.Cracking { - public class TupleCrackInputData : IInputData + /// + /// Input data for calculation of crack for specific force tuple + /// + public class TupleCrackInputData : IInputData, IHasPrimitives { + /// public bool IsValid { get; set; } + public string TupleName { get; set; } + /// + /// Force tuple for long term calculations + /// public IForceTuple? LongTermTuple { get; set; } + /// + /// Force tuple for short term calculations + /// public IForceTuple? ShortTermTuple { get; set; } - public List? NdmPrimitives {get;set;} + /// + public List? Primitives { get; set;} + /// + /// Settings ajusted by user + /// public UserCrackInputData UserCrackInputData { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs index 89e3b0b..6e3ca8b 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackResult.cs @@ -6,21 +6,25 @@ using System.Linq; using System.Text; using System.Threading.Tasks; +//Copyright (c) 2024 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + namespace StructureHelperLogics.NdmCalculations.Cracking { + /// + /// Result of crack calculation for specific force tuple + /// public class TupleCrackResult : IResult { + /// public bool IsValid { get; set; } + /// public string Description { get; set; } public TupleCrackInputData InputData { get; set; } public bool IsCracked { get; set; } public List RebarResults { get; private set; } public CrackWidthRebarTupleResult LongTermResult { get; set; } public CrackWidthRebarTupleResult ShortTermResult { get; set; } - //public double MaxLongTermCrackWidth => RebarResults.Select(x => x.LongTermResult.CrackWidth).Max(); - //public double MaxShortTermCrackWidth => RebarResults.Select(x => x.ShortTermResult.CrackWidth).Max(); - //public bool IsLongCrackLessThanUltimate => MaxLongTermCrackWidth <= InputData.UserCrackInputData.UltimateLongCrackWidth; - //public bool IsShortCrackLessThanUltimate => MaxShortTermCrackWidth <= InputData.UserCrackInputData.UltimateShortCrackWidth; public TupleCrackResult() { diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs index 1ecb6ed..8b41179 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionREbarAreaSumLogicTest.cs @@ -26,11 +26,11 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks }; // Setup the mock to return positive strains - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 1.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 1.0))) .Returns(0.5); - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 2.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 2.0))) .Returns(1.0); - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 3.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 3.0))) .Returns(1.5); var logic = new TensionRebarAreaSimpleSumLogic(mockStressLogic.Object) @@ -64,7 +64,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks }; // Setup the mock to return non-positive strain - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.IsAny())) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.IsAny())) .Returns(0.0); var logic = new TensionRebarAreaSimpleSumLogic(mockStressLogic.Object) diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs index 736ebf8..ea12e1d 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/TensionRebarAreaByStrainLogicTest.cs @@ -29,11 +29,11 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks }; // Setup the mock to return positive strains - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 1.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 1.0))) .Returns(0.5); - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 2.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 2.0))) .Returns(1.0); - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.Is(r => r.Area == 3.0))) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.Is(r => r.Area == 3.0))) .Returns(1.5); var logic = new TensionRebarAreaByStrainLogic(mockStressLogic.Object) @@ -69,7 +69,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks }; // Setup the mock to return non-positive strain - mockStressLogic.Setup(s => s.GetTotalStrain(It.IsAny(), It.IsAny())) + mockStressLogic.Setup(s => s.GetSectionStrain(It.IsAny(), It.IsAny())) .Returns(0.0); var logic = new TensionRebarAreaByStrainLogic(mockStressLogic.Object)