From 783d5e059144abe83c798124f29206d7eba2142f Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Thu, 1 Feb 2024 23:01:50 +0500 Subject: [PATCH] Trace logging for sorce of cracking was added --- .../ForceResultLogic/ShowCrackResultLogic.cs | 22 ++++++- .../ForcesResultsViewModel.cs | 2 - .../ProgressViews/TraceDocumentVM.cs | 4 +- .../Windows/Forces/InterpolateTuplesView.xaml | 2 +- .../Calculators/FindParameterCalculator.cs | 4 +- .../Loggers/Factories/TraceTablesFactory.cs | 29 ++++++--- .../Models/Loggers/ShiftTraceLogger.cs | 2 +- .../Analyses/ByForces/ForceTupleCalculator.cs | 46 +++++++++++--- .../ByForces/Logics/SofteningFactorLogic.cs | 24 +++++-- .../Cracking/CrackForceCalculator.cs | 62 ++++++++++++++----- .../NdmCalculations/Cracking/CrackedLogic.cs | 10 ++- .../Cracking/ExpSofteningLogic.cs | 24 +++++-- .../Cracking/HoleSectionCrackedLogic.cs | 29 ++++++++- .../Cracking/ICrackSofteningLogic.cs | 5 +- .../NdmCalculations/Cracking/ICrackedLogic.cs | 3 +- .../Cracking/ISectionCrackedLogic.cs | 3 +- 16 files changed, 212 insertions(+), 59 deletions(-) diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs index d1c2a27..280dd22 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs @@ -1,8 +1,11 @@ -using StructureHelper.Windows.Errors; +using LoaderCalculator; +using StructureHelper.Windows.CalculationWindows.ProgressViews; +using StructureHelper.Windows.Errors; using StructureHelper.Windows.Forces; using StructureHelper.Windows.ViewModels.Errors; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Settings; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperLogics.NdmCalculations.Cracking; using StructureHelperLogics.NdmCalculations.Primitives; @@ -14,6 +17,8 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu { internal class ShowCrackResultLogic { + private CrackForceCalculator calculator; + public static GeometryNames GeometryNames => ProgramSetting.GeometryNames; public LimitStates LimitState { get; set; } public CalcTerms CalcTerm { get; set; } @@ -33,7 +38,8 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu private void FindCrackFactor(IForceTuple finishDesignTuple, IForceTuple startDesignTuple) { - var calculator = new CrackForceCalculator(); + calculator = new CrackForceCalculator(); + calculator.TraceLogger = new ShiftTraceLogger(); calculator.StartTuple = startDesignTuple; calculator.EndTuple = finishDesignTuple; calculator.NdmCollection = NdmPrimitivesService.GetNdms(ndmPrimitives, LimitState, CalcTerm); @@ -41,7 +47,8 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu var result = (CrackForceResult)calculator.Result; if (result.IsValid) { - ShowResult(result); + ShowTraceResult(); + //ShowResult(result); } else { @@ -80,5 +87,14 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu MessageBoxButtons.OK, MessageBoxIcon.Information); } + + private void ShowTraceResult() + { + if (calculator.TraceLogger is not null) + { + var wnd = new TraceDocumentView(calculator.TraceLogger.TraceLoggerEntries); + wnd.ShowDialog(); + } + } } } diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs index 5062bfe..a2b438e 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs @@ -12,7 +12,6 @@ using StructureHelper.Windows.Forces; using StructureHelper.Windows.PrimitivePropertiesWindow; using StructureHelper.Windows.ViewModels.Calculations.Calculators; using StructureHelper.Windows.ViewModels.Errors; -using StructureHelper.Windows.ViewModels.PrimitiveProperties; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; @@ -22,7 +21,6 @@ using StructureHelperCommon.Models.Shapes; using StructureHelperCommon.Services.Forces; using StructureHelperLogics.NdmCalculations.Analyses; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; -using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve; using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics; using StructureHelperLogics.NdmCalculations.Analyses.Geometry; using StructureHelperLogics.NdmCalculations.Primitives; diff --git a/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs index cc6c3ce..7fa11e6 100644 --- a/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs +++ b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs @@ -16,7 +16,7 @@ namespace StructureHelper.Windows.CalculationWindows.ProgressViews { public class TraceDocumentVM : ViewModelBase { - const int tabFactor = 500; + const double tabFactor = 500d; private readonly IEnumerable loggerEntries; private IEnumerable selectedLoggerEntries; private FlowDocument document; @@ -110,13 +110,13 @@ namespace StructureHelper.Windows.CalculationWindows.ProgressViews { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(traceEntry)); } + block.Margin = new Thickness(traceEntry.Priority / tabFactor * tabGap, 7, 0, 7); return block; } private Block GetBlockByStringEntry(StringLogEntry stringEntry) { var paragraph = new Paragraph(new Run(stringEntry.Message)); - paragraph.Margin = new Thickness(stringEntry.Priority / tabFactor * tabGap, 7, 0, 7); if (stringEntry.Priority <= LoggerService.GetPriorityByStatus(TraceLogStatuses.Fatal)) { paragraph.FontSize = 14; diff --git a/StructureHelper/Windows/Forces/InterpolateTuplesView.xaml b/StructureHelper/Windows/Forces/InterpolateTuplesView.xaml index 5823dfc..5fa2abe 100644 --- a/StructureHelper/Windows/Forces/InterpolateTuplesView.xaml +++ b/StructureHelper/Windows/Forces/InterpolateTuplesView.xaml @@ -101,7 +101,7 @@ - + diff --git a/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs b/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs index 88b543d..fbfa38d 100644 --- a/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs +++ b/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs @@ -58,7 +58,7 @@ namespace StructureHelperCommon.Models.Calculators double precision = Accuracy.IterationAccuracy; int maxIterationCount = Accuracy.MaxIterationCount; double current = start; - double step = (end - start) / 2; + double step = (end - start) / 2d; int iterationNum = 0; while (step > precision) { @@ -73,8 +73,8 @@ namespace StructureHelperCommon.Models.Calculators TraceLogger?.AddMessage($"Predicate value in {current} is false", TraceLogStatuses.Debug, 50); start = current; } - TraceLogger?.AddMessage($"New current value Cur=({start}+{end})/2={current}", TraceLogStatuses.Debug); current = (start + end) / 2d; + TraceLogger?.AddMessage($"New current value Cur=({start}+{end})/2={current}", TraceLogStatuses.Debug); step = (end - start) / 2d; TraceLogger?.AddMessage($"New step S={current}", TraceLogStatuses.Debug, 50); iterationNum++; diff --git a/StructureHelperCommon/Models/Loggers/Factories/TraceTablesFactory.cs b/StructureHelperCommon/Models/Loggers/Factories/TraceTablesFactory.cs index aded8a1..d101094 100644 --- a/StructureHelperCommon/Models/Loggers/Factories/TraceTablesFactory.cs +++ b/StructureHelperCommon/Models/Loggers/Factories/TraceTablesFactory.cs @@ -37,7 +37,7 @@ namespace StructureHelperCommon.Models { var table = new TableLogEntry(6); table.Priority = Priority; - table.Table.AddRow(GetForceTupleHeaderRow()); + table.Table.AddRow(GetForceTupleHeaderRow(forceTuple)); table.Table.AddRow(GetForceTupleRow(forceTuple)); return table; } @@ -66,7 +66,7 @@ namespace StructureHelperCommon.Models { var table = new TableLogEntry(6); table.Priority = Priority; - table.Table.AddRow(GetForceTupleHeaderRow()); + table.Table.AddRow(GetForceTupleHeaderRow(new ForceTuple())); foreach (var forceTuple in forceTuples) { table.Table.AddRow(GetForceTupleRow(forceTuple)); @@ -81,43 +81,54 @@ namespace StructureHelperCommon.Models { Priority = LoggerService.GetPriorityByStatus(status); } - private ShTableRow GetForceTupleHeaderRow() + private ShTableRow GetForceTupleHeaderRow(IForceTuple forceTuple) { + const CellRole cellRole = CellRole.Header; + string[] ColumnList = new string[] { "Mx", "My", "Nz", "Qx", "Qy", "Mz" }; + if (forceTuple is StrainTuple) + { + ColumnList = new string[] { "Kx", "Ky", "EpsZ", "GammaX", "GammaY", "Kz" }; + } + var forceTupleRow = new ShTableRow(6); + foreach (var item in forceTupleRow.Elements) + { + item.Role = cellRole; + } forceTupleRow.Elements[0].Value = new StringLogEntry() { - Message = "Mx", + Message = ColumnList[0], Priority = Priority }; forceTupleRow.Elements[1].Value = new StringLogEntry() { - Message = "My", + Message = ColumnList[1], Priority = Priority }; forceTupleRow.Elements[2].Value = new StringLogEntry() { - Message = "Nz", + Message = ColumnList[2], Priority = Priority }; forceTupleRow.Elements[3].Value = new StringLogEntry() { - Message = "Qx", + Message = ColumnList[3], Priority = Priority }; forceTupleRow.Elements[4].Value = new StringLogEntry() { - Message = "Qy", + Message = ColumnList[4], Priority = Priority }; forceTupleRow.Elements[5].Value = new StringLogEntry() { - Message = "Mz", + Message = ColumnList[5], Priority = Priority }; diff --git a/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs b/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs index 8638ae0..a6ea08e 100644 --- a/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs +++ b/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs @@ -41,7 +41,7 @@ namespace StructureHelperCommon.Models { var newLogger = new ShiftTraceLogger(Logger) { - ShiftPriority = shiftPriority + ShiftPriority = ShiftPriority + shiftPriority }; return newLogger; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs index 0d25c9f..fcb7545 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs @@ -14,7 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public IResult Result { get; private set; } public Action ActionToOutputResults { get; set; } - public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } + public IShiftTraceLogger? TraceLogger { get; set; } public ForceTupleCalculator(IForceTupleInputData inputData) { @@ -31,14 +31,24 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private IForcesTupleResult CalculateResult() { + TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"Calculator logic based on calculating strain in plain section by elementary parts of finished size"); var ndmCollection = InputData.NdmCollection; + TraceLogger?.AddMessage($"Collection of elementary parts contains {ndmCollection.Count()} parts"); + TraceLogger?.AddMessage($"Summary area of elementary part collection = {ndmCollection.Sum(x => x.Area * x.StressScale)}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"Minimum x = {ndmCollection.Min(x => x.CenterX)}", TraceLogStatuses.Debug); + TraceLogger?.AddMessage($"Maximum x = {ndmCollection.Max(x => x.CenterX)}", TraceLogStatuses.Debug); + TraceLogger?.AddMessage($"Minimum y = {ndmCollection.Min(x => x.CenterY)}", TraceLogStatuses.Debug); + TraceLogger?.AddMessage($"Maximum y = {ndmCollection.Max(x => x.CenterY)}", TraceLogStatuses.Debug); var tuple = InputData.Tuple; var accuracy = InputData.Accuracy; - + TraceLogger?.AddMessage($"Input force combination"); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tuple)); var mx = tuple.Mx; var my = tuple.My; var nz = tuple.Nz; - + TraceLogger?.AddMessage($"Required accuracy rate {accuracy.IterationAccuracy}"); + TraceLogger?.AddMessage($"Maximum iteration count {accuracy.MaxIterationCount}"); try { var loaderData = new LoaderOptions @@ -53,23 +63,45 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces NdmCollection = ndmCollection }; var calculator = new Calculator(); + TraceLogger?.AddMessage($"Calculation is started", TraceLogStatuses.Debug); calculator.Run(loaderData, new CancellationToken()); + TraceLogger?.AddMessage($"Calculation result is obtained", TraceLogStatuses.Debug); var calcResult = calculator.Result; if (calcResult.AccuracyRate <= accuracy.IterationAccuracy) { - return new ForcesTupleResult() { IsValid = true, Description = "Analysis is done succsefully", LoaderResults = calcResult }; + TraceLogger?.AddMessage($"Analisis is done succsesfully"); + TraceLogger?.AddMessage($"Current accuracy {calcResult.AccuracyRate}, {calcResult.IterationCounter} iteration has done", TraceLogStatuses.Debug); + return new ForcesTupleResult() + { + IsValid = true, + Description = "Analysis is done succsefully", + LoaderResults = calcResult + }; } else { + TraceLogger?.AddMessage($"Required accuracy rate has not achived", TraceLogStatuses.Error); + TraceLogger?.AddMessage($"Current accuracy {calcResult.AccuracyRate}, {calcResult.IterationCounter} iteration has done", TraceLogStatuses.Warning); return new ForcesTupleResult() { IsValid = false, Description = "Required accuracy rate has not achived", LoaderResults = calcResult }; } } catch (Exception ex) { - var result = new ForcesTupleResult() { IsValid = false }; - if (ex.Message == "Calculation result is not valid: stiffness matrix is equal to zero") { result.Description = "Stiffness matrix is equal to zero \nProbably section was collapsed"; } - else { result.Description = $"Error is appeared due to analysis. Error: {ex}"; } + TraceLogger?.AddMessage($"Critical error ocured during calculation\n{ex}", TraceLogStatuses.Error); + var result = new ForcesTupleResult() + { + IsValid = false + }; + if (ex.Message == "Calculation result is not valid: stiffness matrix is equal to zero") + { + TraceLogger?.AddMessage($"Stiffness matrix is equal to zero\nProbably section was collapsed", TraceLogStatuses.Error); + result.Description = "Stiffness matrix is equal to zero\nProbably section was collapsed"; + } + else + { + result.Description = $"Error is appeared due to analysis. Error: {ex}"; + } return result; } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs index 03fa77b..0b9477f 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs @@ -1,6 +1,9 @@ using LoaderCalculator.Data.Ndms; using LoaderCalculator.Logics; using LoaderCalculator.Logics.Geometry; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Infrastructures.Settings; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Services.Forces; using System; @@ -11,19 +14,30 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics { - internal class SofteningFactorLogic + internal class SofteningFactorLogic : ILogic { public static IStressLogic stressLogic = new StressLogic(); public IEnumerable NdmCollection { get; set; } public StrainTuple StrainTuple { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public StrainTuple GetSofteningFactors() { - var strainTuple = new StrainTuple(); + TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"Logic of analisys based on calculating sum of secant stifness of elementary parts EA,i = A,i * Esec,i"); + TraceLogger?.AddMessage($"Calculating geometry properies for strains"); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(StrainTuple)); var loaderStainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(StrainTuple); var (MxFactor, MyFactor, NzFactor) = GeometryOperations.GetSofteningsFactors(NdmCollection, loaderStainMatrix); - strainTuple.Mx = MxFactor; - strainTuple.My = MyFactor; - strainTuple.Nz = NzFactor; + TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.SndAxisName}-plane: EIx_cracked / EIx_uncracked = {MxFactor}"); + TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.FstAxisName}-plane: EIy_cracked / EIy_uncracked = {MyFactor}"); + TraceLogger?.AddMessage($"Reducing of along {ProgramSetting.GeometryNames.TrdAxisName}-axis: EA_cracked / EA_uncracked = {NzFactor}"); + var strainTuple = new StrainTuple + { + Mx = MxFactor, + My = MyFactor, + Nz = NzFactor + }; return strainTuple; } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs index 462a56d..f015b52 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs @@ -1,5 +1,6 @@ using LoaderCalculator.Data.Ndms; using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Settings; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; @@ -13,11 +14,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public class CrackForceCalculator : ICalculator { static readonly CrackedLogic crackedLogic = new(); - static readonly ExpSofteningLogic softeningLogic = new(); + ExpSofteningLogic softeningLogic = new(); static readonly CrackStrainLogic crackStrainLogic = new(); static readonly SofteningFactorLogic softeningFactorLogic = new(); IForceTupleCalculator forceTupleCalculator; private CrackForceResult result; + private FindParameterCalculator parameterCalculator; public string Name { get; set; } public IForceTuple StartTuple { get; set; } @@ -26,7 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public Accuracy Accuracy {get;set; } public IResult Result => result; - public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } + public IShiftTraceLogger? TraceLogger { get; set; } public CrackForceCalculator(IForceTupleCalculator forceTupleCalculator) { @@ -40,7 +42,23 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } public void Run() { + parameterCalculator = new FindParameterCalculator() + { + Accuracy = Accuracy, + Predicate = crackedLogic.IsSectionCracked + }; + if (TraceLogger is not null) + { + forceTupleCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(100); + parameterCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + crackedLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(150); + } + TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service); result = new CrackForceResult(); + TraceLogger?.AddMessage($"Start force combination"); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(StartTuple)); + TraceLogger?.AddMessage($"Actual (end) force combination"); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(EndTuple)); crackedLogic.StartTuple = StartTuple; crackedLogic.EndTuple = EndTuple; crackedLogic.NdmCollection = NdmCollection; @@ -56,19 +74,17 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } if (crackedLogic.IsSectionCracked(0d) == true) { + TraceLogger?.AddMessage($"Crack is appeared in start corce combination", TraceLogStatuses.Warning); SectionCrackedAtStart(); return; } if (crackedLogic.IsSectionCracked(1d) == false) { + TraceLogger?.AddMessage($"Crack is not appeared from actual (end) force combination", TraceLogStatuses.Warning); SectionIsNotCracked(); return; } - var parameterCalculator = new FindParameterCalculator() - { - Accuracy = Accuracy, - Predicate = crackedLogic.IsSectionCracked - }; + parameterCalculator.Run(); var paramResult = parameterCalculator.Result as FindParameterResult; if (paramResult.IsValid == true) @@ -79,24 +95,42 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { result.IsValid = false; result.Description += paramResult.Description; + TraceLogger?.AddMessage($"Result of calculation is not valid\n{result.Description}", TraceLogStatuses.Error); } } private void SectionIsCrackedBetween(FindParameterResult? paramResult) { var factorOfCrackAppearance = paramResult.Parameter; + softeningLogic = new ExpSofteningLogic(); + if (TraceLogger is not null) + { + softeningLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + softeningFactorLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + } softeningLogic.ForceRatio = factorOfCrackAppearance; var psiS = softeningLogic.GetSofteningFactor(); + var tupleOfCrackApeearence = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance); + TraceLogger?.AddMessage($"Crack is appeared in force combination"); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tupleOfCrackApeearence)); + var reducedStrainTuple = GetReducedStrainTuple(factorOfCrackAppearance, psiS); + var crackedStrainTuple = GetStrainTuple(EndTuple); + TraceLogger?.AddMessage($"Strains in cracked section from actual (end) force"); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(crackedStrainTuple)); + TraceLogger?.AddMessage($"Average curvatures of cracked part of element"); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(reducedStrainTuple)); + TraceLogger?.AddMessage($"Calculating factors of reducing of stifness"); + result.FactorOfCrackAppearance = factorOfCrackAppearance; result.IsValid = true; result.IsSectionCracked = true; result.Description += paramResult.Description; - result.FactorOfCrackAppearance = factorOfCrackAppearance; - result.TupleOfCrackAppearance = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance); - var reducedStrainTuple = GetReducedStrainTuple(factorOfCrackAppearance, psiS); - result.CrackedStrainTuple = GetStrainTuple(EndTuple); + var softeningFactors = GetSofteningFactors(reducedStrainTuple); + result.TupleOfCrackAppearance = tupleOfCrackApeearence; + result.CrackedStrainTuple = crackedStrainTuple; result.ReducedStrainTuple = reducedStrainTuple; - result.SofteningFactors=GetSofteningFactors(reducedStrainTuple); + result.SofteningFactors= softeningFactors; result.PsiS = psiS; + TraceLogger?.AddMessage($"Valid result was obtained", TraceLogStatuses.Debug); } private StrainTuple GetSofteningFactors(StrainTuple reducedStrainTuple) @@ -108,8 +142,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private StrainTuple GetReducedStrainTuple(double factorOfCrackAppearance, double softeningFactor) { - const double notCrackedFactor = 0.99d; - var notCrackedForceTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance * notCrackedFactor) as ForceTuple; + const double notCrackedForceFactor = 0.99d; + var notCrackedForceTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple; var crackAppearanceStrainTuple = GetStrainTuple(notCrackedForceTuple); var actualStrainTuple = GetStrainTuple(EndTuple); crackStrainLogic.BeforeCrackingTuple = crackAppearanceStrainTuple; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackedLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackedLogic.cs index cea21c5..8ca8d87 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackedLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackedLogic.cs @@ -1,4 +1,6 @@ -using LoaderCalculator.Data.Ndms; +using LoaderCalculator; +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Services.Forces; using System; @@ -15,6 +17,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public IForceTuple StartTuple { get; set; } public IForceTuple EndTuple { get; set; } public IEnumerable NdmCollection { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public CrackedLogic(ISectionCrackedLogic sectionLogic) { sectionCrackedLogic = sectionLogic; @@ -25,6 +29,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } public bool IsSectionCracked(double factor) { + if (TraceLogger is not null) + { + sectionCrackedLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + } var actualTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factor); sectionCrackedLogic.Tuple = actualTuple; sectionCrackedLogic.NdmCollection = NdmCollection; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ExpSofteningLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ExpSofteningLogic.cs index b572d66..48773f7 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ExpSofteningLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ExpSofteningLogic.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Models; using System; using System.Collections.Generic; using System.Linq; @@ -41,19 +42,30 @@ namespace StructureHelperLogics.NdmCalculations.Cracking forceRatio = value; } } - public double FiMin {get;set;} + public double PsiSMin {get;set;} + public IShiftTraceLogger? TraceLogger { get; set; } + public ExpSofteningLogic() { - FiMin = 0.2d; + PsiSMin = 0.2d; PowerFactor = 2d; BettaFactor = 0.8d; } public double GetSofteningFactor() { - double fi; - fi = 1 - BettaFactor * Math.Pow(ForceRatio, PowerFactor); - fi = Math.Max(fi, FiMin); - return fi; + TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"Logic of calculation of psi_s factor based on exponential softening model"); + TraceLogger?.AddMessage($"psi_s = 1 - BettaFactor * ForceRatio ^ PowerFactor"); + TraceLogger?.AddMessage($"But not less than psi_s_min = {PsiSMin}"); + TraceLogger?.AddMessage($"BettaFactor = {BettaFactor}"); + TraceLogger?.AddMessage($"ForceRatio = {ForceRatio}"); + TraceLogger?.AddMessage($"PowerFactor = {BettaFactor}"); + double psi; + psi = 1 - BettaFactor * Math.Pow(ForceRatio, PowerFactor); + TraceLogger?.AddMessage($"psi_s = 1 - BettaFactor * ForceRatio ^ PowerFactor = 1 - {BettaFactor} * {ForceRatio} ^ {PowerFactor} = {psi}"); + double psi_c = Math.Max(psi, PsiSMin); + TraceLogger?.AddMessage($"Since psi_s = {psi} and psi_s_min = {PsiSMin},\npsi_s = {psi_c}"); + return psi_c; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/HoleSectionCrackedLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/HoleSectionCrackedLogic.cs index 23e82a3..f20e04a 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/HoleSectionCrackedLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/HoleSectionCrackedLogic.cs @@ -1,6 +1,7 @@ using LoaderCalculator.Data.Ndms; using LoaderCalculator.Logics; using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; @@ -18,15 +19,25 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public IForceTuple Tuple { get; set; } public IEnumerable NdmCollection { get; set; } public Accuracy Accuracy { get; set; } + public IShiftTraceLogger? TraceLogger { get; set; } + public HoleSectionCrackedLogic() { if (Accuracy is null) { - Accuracy = new Accuracy() { IterationAccuracy = 0.001d, MaxIterationCount = 10000 }; + Accuracy = new Accuracy() + { + IterationAccuracy = 0.001d, + MaxIterationCount = 10000 + }; } } public bool IsSectionCracked() { + TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service); + TraceLogger?.AddMessage($"It is assumed, that cracks appearence if: cross-section has elementary parts of concrete and strain of concrete greater than limit value"); + TraceLogger?.AddMessage($"Force combination for cracking check"); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(Tuple)); var inputData = new ForceTupleInputData() { Accuracy = Accuracy, @@ -34,14 +45,28 @@ namespace StructureHelperLogics.NdmCalculations.Cracking NdmCollection = NdmCollection }; var calculator = new ForceTupleCalculator(inputData); + if (TraceLogger is not null) + { + calculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); + } calculator.Run(); var calcResult = calculator.Result as ForcesTupleResult; if (calcResult.IsValid == false) { + TraceLogger?.AddMessage($"Result of calculation is not valid {calcResult.Description}", TraceLogStatuses.Error); throw new StructureHelperException(ErrorStrings.ResultIsNotValid + ": Result of Section Calculation is not valid"); } var strainMatrix = calcResult.LoaderResults.ForceStrainPair.StrainMatrix; - return stressLogic.IsSectionCracked(strainMatrix, NdmCollection); + var isSectionCracked = stressLogic.IsSectionCracked(strainMatrix, NdmCollection); + if (isSectionCracked == true) + { + TraceLogger?.AddMessage($"Cracks are appeared in cross-section for current force combination"); + } + else + { + TraceLogger?.AddMessage($"Cracks are not appeared in cross-section for current force combination"); + } + return isSectionCracked; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackSofteningLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackSofteningLogic.cs index b14b3a4..2f0feaa 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackSofteningLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackSofteningLogic.cs @@ -1,4 +1,5 @@ -using System; +using StructureHelperCommon.Infrastructures.Interfaces; +using System; using System.Collections.Generic; using System.Linq; using System.Text; @@ -6,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - public interface ICrackSofteningLogic + public interface ICrackSofteningLogic : ILogic { double GetSofteningFactor(); } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackedLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackedLogic.cs index 0561c57..b7d1190 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackedLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackedLogic.cs @@ -1,4 +1,5 @@ using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Forces; using System; using System.Collections.Generic; @@ -8,7 +9,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - internal interface ICrackedLogic + internal interface ICrackedLogic : ILogic { IForceTuple StartTuple { get; set; } IForceTuple EndTuple { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ISectionCrackedLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ISectionCrackedLogic.cs index a73498a..3fbbc1f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ISectionCrackedLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ISectionCrackedLogic.cs @@ -1,4 +1,5 @@ using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Forces; using System; using System.Collections.Generic; @@ -8,7 +9,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { - internal interface ISectionCrackedLogic + internal interface ISectionCrackedLogic : ILogic { IForceTuple Tuple { get; set; } IEnumerable NdmCollection { get; set; }