Trace logging for sorce of cracking was added

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();
+            }
+        }
     }
 }

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;

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<ITraceLoggerEntry> loggerEntries;
         private IEnumerable<ITraceLoggerEntry> 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;

StructureHelper/Windows/Forces/InterpolateTuplesView.xaml

@@ -101,7 +101,7 @@
                 <TextBox Grid.Row="4" Grid.Column="1" Text="{Binding StepCount, ValidatesOnExceptions=True}" Visibility="{Binding StepCountVisible, Converter={StaticResource BooleanToVisibilityConverter}}"/>
                 <uc:MultiplyDouble Grid.Column="4" Grid.Row="1" DoubleFactor="{Binding StartFactor}" ValueChanged="StartValueChanged"/>
                 <uc:MultiplyDouble Grid.Column="4" Grid.Row="3" DoubleFactor="{Binding FinishFactor}" ValueChanged="FinishValueChanged"/>
-                <uc:MultiplyDouble Grid.Column="4" Grid.Row="4" DoubleFactor="{Binding FinishFactor}" ValueChanged="StepCountValueChanged"/>
+                <uc:MultiplyDouble Grid.Column="4" Grid.Row="4" DoubleFactor="{Binding FinishFactor}" ValueChanged="StepCountValueChanged"  Visibility="{Binding StepCountVisible, Converter={StaticResource BooleanToVisibilityConverter}}"/>
             </Grid>
         </Grid>
 

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++;

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<ITraceLoggerEntry> GetForceTupleHeaderRow()
+        private ShTableRow<ITraceLoggerEntry> 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<ITraceLoggerEntry>(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
             };
 

StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs

@@ -41,7 +41,7 @@ namespace StructureHelperCommon.Models
         {
             var newLogger = new ShiftTraceLogger(Logger)
             {
-                ShiftPriority = shiftPriority
+                ShiftPriority = ShiftPriority + shiftPriority
             };
             return newLogger;
         }

StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs

@@ -14,7 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         public IResult Result { get; private set; }
 
         public Action<IResult> 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 };
+                TraceLogger?.AddMessage($"Critical error ocured during calculation\n{ex}", TraceLogStatuses.Error);
-                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"; }
+                var result = new ForcesTupleResult()
-                else { result.Description = $"Error is appeared due to analysis. Error: {ex}"; }
+                {
+                    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;
             }
         }

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<INdm> 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;
+            TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.SndAxisName}-plane: EIx_cracked / EIx_uncracked = {MxFactor}");
-            strainTuple.My = MyFactor;
+            TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.FstAxisName}-plane: EIy_cracked / EIy_uncracked = {MyFactor}");
-            strainTuple.Nz = NzFactor;
+            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;
         }
     }

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;
+            var softeningFactors = GetSofteningFactors(reducedStrainTuple);
-            result.TupleOfCrackAppearance = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance);
+            result.TupleOfCrackAppearance = tupleOfCrackApeearence;
-            var reducedStrainTuple = GetReducedStrainTuple(factorOfCrackAppearance, psiS);
+            result.CrackedStrainTuple = crackedStrainTuple;
-            result.CrackedStrainTuple = GetStrainTuple(EndTuple);
             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;
+            const double notCrackedForceFactor = 0.99d;
-            var notCrackedForceTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance * notCrackedFactor) as ForceTuple;
+            var notCrackedForceTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple;
             var crackAppearanceStrainTuple = GetStrainTuple(notCrackedForceTuple);
             var actualStrainTuple = GetStrainTuple(EndTuple);
             crackStrainLogic.BeforeCrackingTuple = crackAppearanceStrainTuple;

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<INdm> 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;

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;
+            TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
-            fi = 1 - BettaFactor * Math.Pow(ForceRatio, PowerFactor);
+            TraceLogger?.AddMessage($"Logic of calculation of psi_s factor based on exponential softening model");
-            fi = Math.Max(fi, FiMin);
+            TraceLogger?.AddMessage($"psi_s = 1 - BettaFactor * ForceRatio ^ PowerFactor");
-            return fi;
+            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;
         }
     }
 }

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<INdm> 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;
         }
     }
 }

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();
     }

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; }

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<INdm> NdmCollection { get; set; }