From a9ffd8b903c9924058e3930b09d85ba5261dc384 Mon Sep 17 00:00:00 2001
From: Evgeny Redikultsev <effect-project@yandex.ru>
Date: Sat, 27 Jan 2024 13:39:48 +0500
Subject: [PATCH] Table log Entry was added

---
 .../Calculators/LimitCurveVisualCalculator.cs |   2 +-
 StructureHelper/StructureHelper.csproj.user   |   6 +
 .../CalculatorsViews/CrackDiagramLogic.cs     |   2 +-
 .../InteractionDiagramLogic.cs                |   2 +-
 .../ForceResultLogic/ShowDiagramLogic.cs      |   2 +-
 .../LimitCurveCalculatorView.xaml             |   2 +-
 .../ProgressViews/TraceDocumentVM.cs          | 205 ++++++++++++++++++
 .../ProgressViews/TraceDocumentView.xaml      |  27 +++
 .../ProgressViews/TraceDocumentView.xaml.cs   |  34 +++
 .../NdmCrossSections/AnalysisVewModelLogic.cs |  14 +-
 .../Interfaces/ILongProcessLogic.cs           |   2 +-
 .../Calculators/FindParameterCalculator.cs    |  18 +-
 .../Models/Calculators/ICalculator.cs         |   2 +-
 .../TraceLoggerTableByPointsFactory.cs        |  62 ++++++
 .../Models/Loggers/IShiftTraceLogger.cs       |  16 ++
 .../Models/Loggers/ITraceLogger.cs            |   3 +-
 .../Models/Loggers/LoggerService.cs           |  33 +++
 .../Models/Loggers/ShiftTraceLogger.cs        |  55 +++++
 .../Models/Loggers/TableLoggerEntry.cs        |  27 +++
 .../Models/Loggers/TraceLogger.cs             |  31 +--
 .../Models/Soils/AnchorCalculator.cs          |   2 +-
 .../Models/Tables/IShTableRow.cs              |  10 +
 .../Models/Tables/ListTable.cs                |  77 +++++++
 .../Models/Tables/ShTableRow.cs               |  38 ++++
 .../Analyses/ByForces/ForceCalculator.cs      |   2 +-
 .../Analyses/ByForces/ForceTupleCalculator.cs |   2 +-
 .../ByForces/LimitCurve/ILimitCurveLogic.cs   |   2 +-
 .../LimitCurve/ILimitCurveParameterLogic.cs   |   2 +-
 .../LimitCurve/LimitCurveCalculator.cs        |  19 +-
 .../ByForces/LimitCurve/LimitCurveLogic.cs    |   7 +-
 .../LimitCurve/LimitCurveParameterLogic.cs    |  12 +-
 .../LimitCurve/LimitCurvesCalculator.cs       |   7 +-
 .../LimitCurve/StabLimitCurveLogic.cs         |   2 +-
 .../Logics/InterpolationProgressLogic.cs      |   2 +-
 .../Analyses/Geometry/GeometryCalculator.cs   |   2 +-
 .../Buckling/ConcreteBucklingCalculator.cs    |   2 +-
 .../Cracking/CrackForceCalculator.cs          |   2 +-
 .../Cracking/CrackWidthCalculator.cs          |   2 +-
 .../Cracking/CrackWidthSimpleCalculator.cs    |   2 +-
 39 files changed, 675 insertions(+), 64 deletions(-)
 create mode 100644 StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs
 create mode 100644 StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentView.xaml
 create mode 100644 StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentView.xaml.cs
 create mode 100644 StructureHelperCommon/Models/Loggers/Factories/TraceLoggerTableByPointsFactory.cs
 create mode 100644 StructureHelperCommon/Models/Loggers/IShiftTraceLogger.cs
 create mode 100644 StructureHelperCommon/Models/Loggers/LoggerService.cs
 create mode 100644 StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs
 create mode 100644 StructureHelperCommon/Models/Loggers/TableLoggerEntry.cs
 create mode 100644 StructureHelperCommon/Models/Tables/IShTableRow.cs
 create mode 100644 StructureHelperCommon/Models/Tables/ListTable.cs
 create mode 100644 StructureHelperCommon/Models/Tables/ShTableRow.cs

diff --git a/StructureHelper/Models/Calculators/LimitCurveVisualCalculator.cs b/StructureHelper/Models/Calculators/LimitCurveVisualCalculator.cs
index dc99558..0330cc8 100644
--- a/StructureHelper/Models/Calculators/LimitCurveVisualCalculator.cs
+++ b/StructureHelper/Models/Calculators/LimitCurveVisualCalculator.cs
@@ -19,7 +19,7 @@ namespace StructureHelper.Models.Calculators
 
         public IResult Result => result;
 
-        public ITraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         public void Run()
         {
diff --git a/StructureHelper/StructureHelper.csproj.user b/StructureHelper/StructureHelper.csproj.user
index dff02ba..6fee5a1 100644
--- a/StructureHelper/StructureHelper.csproj.user
+++ b/StructureHelper/StructureHelper.csproj.user
@@ -27,6 +27,9 @@
     <Compile Update="Windows\CalculationWindows\ProgressViews\ShowProgressView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Update="Windows\CalculationWindows\ProgressViews\TraceDocumentView.xaml.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Update="Windows\Errors\ErrorMessage.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
@@ -89,6 +92,9 @@
     <Page Update="Windows\CalculationWindows\ProgressViews\ShowProgressView.xaml">
       <SubType>Designer</SubType>
     </Page>
+    <Page Update="Windows\CalculationWindows\ProgressViews\TraceDocumentView.xaml">
+      <SubType>Designer</SubType>
+    </Page>
     <Page Update="Windows\Errors\ErrorMessage.xaml">
       <SubType>Designer</SubType>
     </Page>
diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs
index ab20ba8..c3025d0 100644
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs
+++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs
@@ -36,7 +36,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
 
         public int StepCount => ValidTupleList.Count();
 
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public CrackDiagramLogic(IEnumerable<IForcesTupleResult> tupleList, IEnumerable<INdmPrimitive> ndmPrimitives)
         {
diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/InteractionDiagramLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/InteractionDiagramLogic.cs
index e0279ce..a4e48d2 100644
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/InteractionDiagramLogic.cs
+++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/InteractionDiagramLogic.cs
@@ -41,7 +41,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu
 
         public Action<int> SetProgress { get; set; }
         public bool Result { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public InteractionDiagramLogic(LimitCurveInputData inputData)
         {
diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowDiagramLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowDiagramLogic.cs
index 0ea4440..89a6d65 100644
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowDiagramLogic.cs
+++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowDiagramLogic.cs
@@ -28,7 +28,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu
 
         public Action<int> SetProgress { get; set; }
         public bool Result { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public void WorkerDoWork(object sender, DoWorkEventArgs e)
         {
diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/LimitCurveCalculatorView.xaml b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/LimitCurveCalculatorView.xaml
index 90e622e..0adf251 100644
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/LimitCurveCalculatorView.xaml
+++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/LimitCurveCalculatorView.xaml
@@ -7,7 +7,7 @@
         xmlns:fc="clr-namespace:StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalculatorViews"
         d:DataContext ="{d:DesignInstance local:LimitCurveCalculatorViewModel}"
         mc:Ignorable="d"
-        Title="Limit Curve Calculator" Height="390" Width="400" MinHeight="300" MinWidth="400" ResizeMode="NoResize" WindowStartupLocation="CenterScreen">
+        Title="Interaction Diagram Calculator" Height="390" Width="400" MinHeight="300" MinWidth="400" ResizeMode="NoResize" WindowStartupLocation="CenterScreen">
     <Grid>
         <Grid.RowDefinitions>
             <RowDefinition/>
diff --git a/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs
new file mode 100644
index 0000000..1415c6f
--- /dev/null
+++ b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs
@@ -0,0 +1,205 @@
+using StructureHelper.Infrastructure;
+using StructureHelper.Windows.AddMaterialWindow;
+using StructureHelper.Windows.ViewModels.Errors;
+using StructureHelper.Windows.ViewModels.Materials;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Models.Loggers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.ConstrainedExecution;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace StructureHelper.Windows.CalculationWindows.ProgressViews
+{
+    public class TraceDocumentVM : ViewModelBase
+    {
+        IEnumerable<ITraceLoggerEntry> loggerEntries;
+        IEnumerable<ITraceLoggerEntry> selectedLoggerEntries;
+        FlowDocument document;
+        private ICommand rebuildCommand;
+        private ICommand printDocumentCommand;
+        private int maxPriority;
+        private int tabGap;
+
+        public FlowDocumentReader DocumentReader { get; set; }
+        public int MaxPriority
+        {
+            get => maxPriority; set
+            {
+                var oldValue = maxPriority;
+                try
+                {
+                    maxPriority = Math.Max(value, 0);
+                    OnPropertyChanged(nameof(MaxPriority));
+                }
+                catch (Exception)
+                {
+                    maxPriority = oldValue;
+                }
+            }
+        }
+        public int TabGap
+        {
+            get => tabGap; set
+            {
+                var oldValue = tabGap;
+                try
+                {
+                    tabGap = Math.Max(value, 0);
+                    OnPropertyChanged(nameof(TabGap));
+                }
+                catch (Exception)
+                {
+                    tabGap = oldValue;
+                }
+            }
+        }
+        public TraceDocumentVM(IEnumerable<ITraceLoggerEntry> loggerEntries)
+        {
+            this.loggerEntries = loggerEntries;
+            maxPriority = 350;
+            tabGap = 50;
+        }
+
+        public ICommand RebuildCommand =>
+            rebuildCommand ??= new RelayCommand(o =>
+            {
+                Show();
+            });
+
+        public ICommand PrintDocumentCommand =>
+            printDocumentCommand ??= new RelayCommand(o =>
+            {
+                SafetyProcessor.RunSafeProcess(DocumentReader.Print, "Error of printing document");
+            });
+
+        public void Show()
+        {
+            Prepare();
+            ShowPrepared();
+        }
+
+        public void Prepare()
+        {
+            document = new();
+            selectedLoggerEntries = loggerEntries.Where(x => x.Priority <= MaxPriority);
+            foreach (var item in selectedLoggerEntries)
+            {
+                ProcessLoggerEntries(item);
+            }
+        }
+
+        private void ProcessLoggerEntries(ITraceLoggerEntry item)
+        {
+            if (item is StringLoggerEntry stringEntry)
+            {
+                ProcessStringEntry(stringEntry);
+            }
+            else if (item is TableLoggerEntry tableEntry)
+            {
+                ProcessTableEntry(tableEntry);
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(item));
+            }
+        }
+
+        private void ProcessTableEntry(TableLoggerEntry tableEntry)
+        {
+            var rows = tableEntry.Table.GetAllRows();
+            int rowCount = rows.Count();
+            int columnCount = tableEntry.Table.RowSize;
+            var table = new Table();
+            for (int x = 0; x < columnCount; x++)
+            {
+                var tableColumn = new TableColumn();
+                tableColumn.Width = new GridLength(150);
+                table.Columns.Add(tableColumn);
+            }
+            foreach (var row in rows)
+            {
+                var newRow = new TableRow();
+                foreach (var cell in row.Elements)
+                {
+                    TableCell tableCell; 
+                    if (cell is null)
+                    {
+                        tableCell = new TableCell(new Paragraph(new Run(string.Empty)));
+                    }
+                    else
+                    {
+                        if (cell is StringLoggerEntry stringEntry)
+                        {
+                            tableCell = new TableCell(GetParagraphByStringEntry(stringEntry));
+                        }
+                        else
+                        {
+                            throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(cell));
+                        }
+                    }
+                    newRow.Cells.Add(tableCell);
+                }
+                table.RowGroups.Add(new TableRowGroup());
+                table.RowGroups[0].Rows.Add(newRow);
+            }
+            document.Blocks.Add(table);
+        }
+
+        private void ProcessStringEntry(StringLoggerEntry stringEntry)
+        {
+            var paragraph = GetParagraphByStringEntry(stringEntry);
+            document.Blocks.Add(paragraph);
+        }
+
+        private Paragraph GetParagraphByStringEntry(StringLoggerEntry stringEntry)
+        {
+            var paragraph = new Paragraph(new Run(stringEntry.Message));
+            paragraph.Margin = new Thickness(stringEntry.Priority / tabGap);
+            if (stringEntry.Priority <= LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Fatal))
+            {
+                paragraph.FontSize = 14;
+                paragraph.Background = Brushes.Red;
+                paragraph.Foreground = Brushes.Black;
+                paragraph.FontStyle = FontStyles.Italic;
+            }
+            else if (stringEntry.Priority <= LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Error))
+            {
+                paragraph.FontSize = 14;
+                paragraph.Background = Brushes.Pink;
+                paragraph.Foreground = Brushes.Black;
+            }
+            else if (stringEntry.Priority <= LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Warning))
+            {
+                paragraph.FontSize = 14;
+                paragraph.Background = Brushes.Yellow;
+                paragraph.Foreground = Brushes.Black;
+            }
+            else if (stringEntry.Priority <= LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Debug))
+            {
+                paragraph.FontSize = 12;
+                paragraph.Foreground = Brushes.Black;
+            }
+            else
+            {
+                paragraph.FontSize = 8;
+                paragraph.Foreground = Brushes.Gray;
+
+            }
+
+            return paragraph;
+        }
+
+        public void ShowPrepared()
+        {
+            DocumentReader.Document = document;
+        }
+    }
+}
diff --git a/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentView.xaml b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentView.xaml
new file mode 100644
index 0000000..c1c5a39
--- /dev/null
+++ b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentView.xaml
@@ -0,0 +1,27 @@
+<Window x:Class="StructureHelper.Windows.CalculationWindows.ProgressViews.TraceDocumentView"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:StructureHelper.Windows.CalculationWindows.ProgressViews"
+        d:DataContext="{d:DesignInstance local:TraceDocumentVM}"
+        mc:Ignorable="d"
+        Title="Trace Document Viewer" Height="450" Width="800" MinHeight="400" MinWidth="600" WindowStartupLocation="CenterScreen">
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="*"/>
+            <ColumnDefinition Width="90"/>
+        </Grid.ColumnDefinitions>
+        <FlowDocumentReader Name="DocumentReader" ViewingMode="Scroll"/>
+        <StackPanel Grid.Column="1">
+            <GroupBox Header="Tab gap">
+                <TextBox Text="{Binding TabGap, ValidatesOnExceptions=True}" />
+            </GroupBox>
+            <GroupBox Header="Max priority">
+                <TextBox Text="{Binding MaxPriority, ValidatesOnExceptions=True}" />
+            </GroupBox>
+            <Button Margin="3" Content="Rebuild" ToolTip="Rebuild document" Command="{Binding RebuildCommand}"/>
+            <Button Margin="3" Content="Print" ToolTip="Print document" Command="{Binding PrintDocumentCommand}"/>
+         </StackPanel>
+    </Grid>
+</Window>
diff --git a/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentView.xaml.cs b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentView.xaml.cs
new file mode 100644
index 0000000..497e819
--- /dev/null
+++ b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentView.xaml.cs
@@ -0,0 +1,34 @@
+using StructureHelperCommon.Models.Loggers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+
+namespace StructureHelper.Windows.CalculationWindows.ProgressViews
+{
+    /// <summary>
+    /// Логика взаимодействия для TraceDocumentView.xaml
+    /// </summary>
+    public partial class TraceDocumentView : Window
+    {
+        TraceDocumentVM viewModel;
+        public TraceDocumentView(TraceDocumentVM viewModel)
+        {
+            InitializeComponent();
+            this.viewModel = viewModel;
+            this.DataContext = this.viewModel;
+            this.viewModel.DocumentReader = this.DocumentReader;
+            this.viewModel.Show();
+        }
+        public TraceDocumentView(IEnumerable<ITraceLoggerEntry> loggerEntries) : this(new TraceDocumentVM(loggerEntries)) { }
+    }
+}
diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisVewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisVewModelLogic.cs
index 572355c..c333f63 100644
--- a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisVewModelLogic.cs
+++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisVewModelLogic.cs
@@ -2,6 +2,7 @@
 using StructureHelper.Infrastructure.Enums;
 using StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalculatorViews;
 using StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalculatorViews.ForceResultLogic;
+using StructureHelper.Windows.CalculationWindows.ProgressViews;
 using StructureHelper.Windows.ViewModels.Calculations.Calculators;
 using StructureHelper.Windows.ViewModels.Errors;
 using StructureHelperCommon.Infrastructures.Exceptions;
@@ -35,7 +36,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections
                 NewItem = new ForceCalculator()
                 {
                     Name = "New force calculator",
-                    TraceLogger = new TraceLogger(),
+                    TraceLogger = new ShiftTraceLogger(),
                 };
             }
             else if (parameterType == CalculatorTypes.LimitCurveCalculator)
@@ -45,7 +46,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections
                 {
                     Name = "New interaction diagram calculator",
                     InputData = inputData,
-                    TraceLogger = new TraceLogger(),
+                    TraceLogger = new ShiftTraceLogger(),
                 };
             }
             else
@@ -132,11 +133,16 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections
 
         private void RunCalculator()
         {
-            if (SelectedItem is LimitCurvesCalculator)
+            if (SelectedItem is LimitCurvesCalculator calculator)
             {
-                var calculator = SelectedItem as LimitCurvesCalculator;
+                if (calculator.TraceLogger is not null) { calculator.TraceLogger.TraceLoggerEntries.Clear(); }
                 var inputData = calculator.InputData;
                 ShowInteractionDiagramByInputData(calculator);
+                if (calculator.TraceLogger is not null)
+                {
+                    var wnd = new TraceDocumentView(calculator.TraceLogger.TraceLoggerEntries);
+                    wnd.ShowDialog();
+                }
             }
             else
             {
diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ILongProcessLogic.cs b/StructureHelperCommon/Infrastructures/Interfaces/ILongProcessLogic.cs
index 0cebe7b..0f9d74f 100644
--- a/StructureHelperCommon/Infrastructures/Interfaces/ILongProcessLogic.cs
+++ b/StructureHelperCommon/Infrastructures/Interfaces/ILongProcessLogic.cs
@@ -16,7 +16,7 @@ namespace StructureHelperCommon.Infrastructures.Interfaces
         Action<int> SetProgress { get; set; }
         bool Result { get; set; }
 
-        ITraceLogger? TraceLogger { get; set; }
+        IShiftTraceLogger? TraceLogger { get; set; }
 
         void WorkerDoWork(object sender, DoWorkEventArgs e);
         void WorkerProgressChanged(object sender, ProgressChangedEventArgs e);
diff --git a/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs b/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs
index f23db89..524d478 100644
--- a/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs
+++ b/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs
@@ -20,7 +20,7 @@ namespace StructureHelperCommon.Models.Calculators
         public IResult Result => result;
 
         public Action<IResult> ActionToOutputResults { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public FindParameterCalculator()
         {
@@ -48,10 +48,11 @@ namespace StructureHelperCommon.Models.Calculators
 
         private void FindMinimumValue(double start, double end, Predicate<double> predicate)
         {
+            TraceLogger?.AddMessage($"Calculating parameter by iterations is started,\nrequired precision {Accuracy.IterationAccuracy}");
             if (predicate(end) == false)
             {
+                TraceLogger?.AddMessage($"Predicate for end value must be true", TraceLoggerStatuses.Error);
                 throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": predicate for end value must be true");
-
             }
             double precision = Accuracy.IterationAccuracy;
             int maxIterationCount = Accuracy.MaxIterationCount;
@@ -60,18 +61,21 @@ namespace StructureHelperCommon.Models.Calculators
             int iterationNum = 0;
             while (step > precision)
             {
-                TraceLogger?.AddMessage($"Iteration number {iterationNum}", TraceLoggerStatuses.Debug);
+                TraceLogger?.AddMessage($"Iteration number {iterationNum} is started", TraceLoggerStatuses.Debug);
                 if (predicate(current) == true)
                 {
+                    TraceLogger?.AddMessage($"Predicate value in {current} is true", TraceLoggerStatuses.Debug, 50);
                     end = current;
                 }
                 else
                 {
+                    TraceLogger?.AddMessage($"Predicate value in {current} is false", TraceLoggerStatuses.Debug, 50);
                     start = current;
                 }
-                current = (start + end) / 2;
-                TraceLogger?.AddMessage($"Current value {current}", TraceLoggerStatuses.Debug);
-                step = (end - start) / 2;
+                TraceLogger?.AddMessage($"New current value Cur=({start}+{end})/2={current}", TraceLoggerStatuses.Debug);
+                current = (start + end) / 2d;
+                step = (end - start) / 2d;
+                TraceLogger?.AddMessage($"New step S={current}", TraceLoggerStatuses.Debug, 50);
                 iterationNum++;
 
                 result.IsValid = false;
@@ -86,7 +90,7 @@ namespace StructureHelperCommon.Models.Calculators
                     throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": violation of iteration count");
                 }
             }
-            TraceLogger?.AddMessage($"Parameter value {current} was obtained");
+            TraceLogger?.AddMessage($"Parameter value Cur={current} was found,\nCalculation has finished succefully");
             result.Parameter = current;
             result.Description = "Parameter was found succefully";
             result.IsValid = true;
diff --git a/StructureHelperCommon/Models/Calculators/ICalculator.cs b/StructureHelperCommon/Models/Calculators/ICalculator.cs
index 9376164..1a74a03 100644
--- a/StructureHelperCommon/Models/Calculators/ICalculator.cs
+++ b/StructureHelperCommon/Models/Calculators/ICalculator.cs
@@ -12,7 +12,7 @@ namespace StructureHelperCommon.Models.Calculators
 {
     public interface ICalculator : ICloneable
     {
-        ITraceLogger? TraceLogger { get; set; }
+        IShiftTraceLogger? TraceLogger { get; set; }
         string Name { get; set; }
         /// <summary>
         /// Method for calculating
diff --git a/StructureHelperCommon/Models/Loggers/Factories/TraceLoggerTableByPointsFactory.cs b/StructureHelperCommon/Models/Loggers/Factories/TraceLoggerTableByPointsFactory.cs
new file mode 100644
index 0000000..92e04a2
--- /dev/null
+++ b/StructureHelperCommon/Models/Loggers/Factories/TraceLoggerTableByPointsFactory.cs
@@ -0,0 +1,62 @@
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperCommon.Models.Tables;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Loggers
+{
+    public static class TraceLoggerTableByPointsFactory
+    {
+        public static TableLoggerEntry GetTableByPoint2D(IPoint2D point2D)
+        {
+            var table = new TableLoggerEntry(2);
+            table.Table.AddRow(GetHeaderRow());
+            table.Table.AddRow(GetPointRow(point2D));
+            return table;
+        }
+        public static TableLoggerEntry GetTableByPoint2D(IEnumerable<IPoint2D> points)
+        {
+            var table = new TableLoggerEntry(2);
+            table.Table.AddRow(GetHeaderRow());
+            foreach (var item in points)
+            {
+                table.Table.AddRow(GetPointRow(item));           
+            }
+            return table;
+        }
+
+        private static ShTableRow<ITraceLoggerEntry> GetHeaderRow()
+        {
+            var headerRow = new ShTableRow<ITraceLoggerEntry>(2);
+            headerRow.Elements[0] = new StringLoggerEntry()
+            {
+                Message = "X",
+                Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info)
+            };
+            headerRow.Elements[1] = new StringLoggerEntry()
+            {
+                Message = "Y",
+                Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info)
+            };
+            return headerRow;
+        }
+        private static ShTableRow<ITraceLoggerEntry> GetPointRow(IPoint2D point2D)
+        {
+            var pointRow = new ShTableRow<ITraceLoggerEntry>(2);
+            pointRow.Elements[0] = new StringLoggerEntry()
+            {
+                Message = Convert.ToString(point2D.X),
+                Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info)
+            };
+            pointRow.Elements[1] = new StringLoggerEntry()
+            {
+                Message = Convert.ToString(point2D.Y),
+                Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info)
+            };
+            return pointRow;
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Loggers/IShiftTraceLogger.cs b/StructureHelperCommon/Models/Loggers/IShiftTraceLogger.cs
new file mode 100644
index 0000000..91a0454
--- /dev/null
+++ b/StructureHelperCommon/Models/Loggers/IShiftTraceLogger.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Loggers
+{
+    public interface IShiftTraceLogger : ITraceLogger
+    {
+        ITraceLogger Logger { get; set; }
+        int ShiftPriority { get; set; }
+        void AddEntry(ITraceLoggerEntry loggerEntry);
+        IShiftTraceLogger GetSimilarTraceLogger(int shftPriority = 0);
+    }
+}
diff --git a/StructureHelperCommon/Models/Loggers/ITraceLogger.cs b/StructureHelperCommon/Models/Loggers/ITraceLogger.cs
index d54135d..36128c8 100644
--- a/StructureHelperCommon/Models/Loggers/ITraceLogger.cs
+++ b/StructureHelperCommon/Models/Loggers/ITraceLogger.cs
@@ -9,6 +9,7 @@ namespace StructureHelperCommon.Models.Loggers
     public interface ITraceLogger
     {
         List<ITraceLoggerEntry> TraceLoggerEntries { get; }
-        void AddMessage(string message, TraceLoggerStatuses status = TraceLoggerStatuses.Info);
+        void AddMessage(string message, TraceLoggerStatuses status = TraceLoggerStatuses.Info, int shiftPriority = 0);
+        void AddMessage(string message, int priority);
     }
 }
diff --git a/StructureHelperCommon/Models/Loggers/LoggerService.cs b/StructureHelperCommon/Models/Loggers/LoggerService.cs
new file mode 100644
index 0000000..9b02c22
--- /dev/null
+++ b/StructureHelperCommon/Models/Loggers/LoggerService.cs
@@ -0,0 +1,33 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Loggers
+{
+    public static class LoggerService
+    {
+        const int fatal = 0;
+        const int error = 100;
+        const int warning = 200;
+        const int info = 300;
+        const int service = 400;
+        const int debug = 500;
+        public static int GetPriorityByStatus(TraceLoggerStatuses status)
+        {
+            if (status == TraceLoggerStatuses.Fatal) { return fatal; }
+            else if (status == TraceLoggerStatuses.Error) { return error; }
+            else if (status == TraceLoggerStatuses.Warning) { return warning; }
+            else if (status == TraceLoggerStatuses.Info) { return info; }
+            else if (status == TraceLoggerStatuses.Service) { return service; }
+            else if (status == TraceLoggerStatuses.Debug) { return debug; }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(status));
+            }
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs b/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs
new file mode 100644
index 0000000..8270eed
--- /dev/null
+++ b/StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Loggers
+{
+    public class ShiftTraceLogger : IShiftTraceLogger
+    {
+        public ITraceLogger Logger { get; set; }
+        public int ShiftPriority { get; set; }
+
+        public List<ITraceLoggerEntry> TraceLoggerEntries => Logger.TraceLoggerEntries;
+        public ShiftTraceLogger(ITraceLogger logger)
+        {
+            Logger = logger;
+        }
+        public ShiftTraceLogger() : this(new TraceLogger())  {  }
+        public void AddMessage(string message, TraceLoggerStatuses status = TraceLoggerStatuses.Info, int shiftPrioriry = 0)
+        {
+            // if status in (fatal, error, warning) they must be kept as they are
+            if (status <= TraceLoggerStatuses.Warning)
+            {
+                Logger.AddMessage(message, status);
+            }
+            else
+            {
+                var priority = LoggerService.GetPriorityByStatus(status) + shiftPrioriry;
+                this.AddMessage(message, priority);
+            }
+        }
+
+        public void AddMessage(string message, int priority)
+        {
+            priority += ShiftPriority;
+            Logger.AddMessage(message, priority);
+        }
+
+        public IShiftTraceLogger GetSimilarTraceLogger(int shiftPriority = 0)
+        {
+            var newLogger = new ShiftTraceLogger(Logger)
+            {
+                ShiftPriority = shiftPriority
+            };
+            return newLogger;
+        }
+
+        public void AddEntry(ITraceLoggerEntry loggerEntry)
+        {
+            loggerEntry.Priority += ShiftPriority;
+            Logger.TraceLoggerEntries.Add(loggerEntry);
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Loggers/TableLoggerEntry.cs b/StructureHelperCommon/Models/Loggers/TableLoggerEntry.cs
new file mode 100644
index 0000000..d98b55b
--- /dev/null
+++ b/StructureHelperCommon/Models/Loggers/TableLoggerEntry.cs
@@ -0,0 +1,27 @@
+using StructureHelperCommon.Models.Tables;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Loggers
+{
+    public class TableLoggerEntry : ITraceLoggerEntry
+    {
+        private ListTable<ITraceLoggerEntry> table;
+        public ListTable<ITraceLoggerEntry> Table {get => table;}
+        public DateTime TimeStamp { get; }
+
+        public int Priority { get; set; }
+        public TableLoggerEntry(int rowSize)
+        {
+            if (rowSize <= 0)
+            {
+                throw new ArgumentException("Row size must be greater than 0.", nameof(rowSize));
+            }
+            table = new(rowSize);
+            TimeStamp = DateTime.Now;
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Loggers/TraceLogger.cs b/StructureHelperCommon/Models/Loggers/TraceLogger.cs
index 0bcb5f7..3e18d5f 100644
--- a/StructureHelperCommon/Models/Loggers/TraceLogger.cs
+++ b/StructureHelperCommon/Models/Loggers/TraceLogger.cs
@@ -4,18 +4,12 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Windows.Forms;
 
 namespace StructureHelperCommon.Models.Loggers
 {
     public class TraceLogger : ITraceLogger
-    {
-        const int fatal = 0;
-        const int error = 1000;
-        const int warning = 200;
-        const int info = 300;
-        const int service = 400;
-        const int debug = 500;
-        
+    {       
         public List<ITraceLoggerEntry> TraceLoggerEntries { get; }
 
         public TraceLogger()
@@ -23,12 +17,15 @@ namespace StructureHelperCommon.Models.Loggers
             TraceLoggerEntries = new();
         }
 
-        public void AddMessage(string message, TraceLoggerStatuses status = TraceLoggerStatuses.Info)
+        public void AddMessage(string message, TraceLoggerStatuses status = TraceLoggerStatuses.Info, int shiftPrioriry = 0)
         {
+            if (status == TraceLoggerStatuses.Fatal) { message = $"Fatal error! {message}"; }
+            if (status == TraceLoggerStatuses.Error) { message = $"Error! {message}"; }
+            if (status == TraceLoggerStatuses.Warning) { message = $"Warning! {message}"; }
             TraceLoggerEntries.Add(new StringLoggerEntry()
             {
                 Message = message,
-                Priority = GetPriorityByStatus(status)
+                Priority = LoggerService.GetPriorityByStatus(status)
             });
         }        
         public void AddMessage(string message, int priority)
@@ -39,19 +36,5 @@ namespace StructureHelperCommon.Models.Loggers
                 Priority = priority
             });
         }
-
-        public static int GetPriorityByStatus(TraceLoggerStatuses status)
-        {
-            if (status == TraceLoggerStatuses.Fatal) { return fatal; }
-            else if (status == TraceLoggerStatuses.Error) { return error; }
-            else if (status == TraceLoggerStatuses.Warning) { return warning; }
-            else if (status == TraceLoggerStatuses.Info) { return info; }
-            else if (status == TraceLoggerStatuses.Service) { return service; }
-            else if (status == TraceLoggerStatuses.Debug) { return debug; }
-            else
-            {
-                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(status));
-            }
-        }
     }
 }
diff --git a/StructureHelperCommon/Models/Soils/AnchorCalculator.cs b/StructureHelperCommon/Models/Soils/AnchorCalculator.cs
index 36d981d..aab8339 100644
--- a/StructureHelperCommon/Models/Soils/AnchorCalculator.cs
+++ b/StructureHelperCommon/Models/Soils/AnchorCalculator.cs
@@ -21,7 +21,7 @@ namespace StructureHelperCommon.Models.Soils
         public IResult Result => result;
 
         public Action<IResult> ActionToOutputResults { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public ITraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         public AnchorCalculator(SoilAnchor soilAnchor, IAnchorSoilProperties anchorSoilProperties)
         {
diff --git a/StructureHelperCommon/Models/Tables/IShTableRow.cs b/StructureHelperCommon/Models/Tables/IShTableRow.cs
new file mode 100644
index 0000000..7a4469d
--- /dev/null
+++ b/StructureHelperCommon/Models/Tables/IShTableRow.cs
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace StructureHelperCommon.Models.Tables
+{
+    public interface IShTableRow<T>
+    {
+        List<T> Elements { get; }
+        int RowSize { get; }
+    }
+}
\ No newline at end of file
diff --git a/StructureHelperCommon/Models/Tables/ListTable.cs b/StructureHelperCommon/Models/Tables/ListTable.cs
new file mode 100644
index 0000000..d83ece2
--- /dev/null
+++ b/StructureHelperCommon/Models/Tables/ListTable.cs
@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Tables
+{
+    public class ListTable<T>
+    {
+        private List<IShTableRow<T>> table;
+
+        public int RowSize { get; }
+
+        public ListTable(int rowSize)
+        {
+            if (rowSize <= 0)
+            {
+                throw new ArgumentException("Row size must be greater than 0.", nameof(rowSize));
+            }
+
+            RowSize = rowSize;
+            table = new List<IShTableRow<T>>();
+        }
+
+        // Add a new row to the table
+        public void AddRow(IShTableRow<T> tableRow)
+        {
+            table.Add(tableRow);
+        }
+        public void AddRow()
+        {
+            table.Add(new ShTableRow<T>(RowSize));
+        }
+
+        /// <summary>
+        /// Get all rows in the table
+        /// </summary>
+        /// <returns></returns>
+        public List<IShTableRow<T>> GetAllRows()
+        {
+            return table;
+        }
+
+        public List<T> GetElementsFromRow(int rowIndex)
+        {
+            if (rowIndex >= 0 && rowIndex < table.Count)
+            {
+                return table[rowIndex].Elements;
+            }
+            else
+            {
+                throw new IndexOutOfRangeException("Row index is out of range.");
+            }
+        }
+
+        /// <summary>
+        /// Set a value at the specified column and row index
+        /// </summary>
+        /// <param name="columnIndex"></param>
+        /// <param name="rowIndex"></param>
+        /// <param name="value"></param>
+        /// <exception cref="IndexOutOfRangeException"></exception>
+        public void SetValue(int columnIndex, int rowIndex, T value)
+        {
+            if (columnIndex >= 0 && columnIndex < RowSize &&
+                rowIndex >= 0 && rowIndex < table.Count)
+            {
+                table[rowIndex].Elements[columnIndex] = value;
+            }
+            else
+            {
+                throw new IndexOutOfRangeException("Column or row index is out of range.");
+            }
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Tables/ShTableRow.cs b/StructureHelperCommon/Models/Tables/ShTableRow.cs
new file mode 100644
index 0000000..fdacb4c
--- /dev/null
+++ b/StructureHelperCommon/Models/Tables/ShTableRow.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Tables
+{
+    public class ShTableRow<T> : IShTableRow<T>
+    {
+        private List<T> elements;
+
+        public int RowSize { get; }
+
+        public ShTableRow(int rowSize)
+        {
+            if (rowSize <= 0)
+            {
+                throw new ArgumentException("Row size must be greater than 0.", nameof(rowSize));
+            }
+
+            RowSize = rowSize;
+            elements = new List<T>(rowSize);
+            for (int i = 0; i < rowSize; i++)
+            {
+                elements.Add(default);
+            }
+        }
+
+        // Property to access elements in the row
+        public List<T> Elements => elements;
+
+        internal void Add(object value)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs
index 35df9b6..6c79543 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs
@@ -26,7 +26,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         public IAccuracy Accuracy { get; set; }
         public List<IForceCombinationList> ForceCombinationLists { get; private set; }
         public Action<IResult> ActionToOutputResults { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public void Run()
         {
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs
index 0a531c7..55cc646 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<IResult> ActionToOutputResults { get; set; }
-        public ITraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         public ForceTupleCalculator(IForceTupleInputData inputData)
         {
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurveLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurveLogic.cs
index 219f219..5c54dc4 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurveLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurveLogic.cs
@@ -23,6 +23,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         /// <param name="points"></param>
         /// <returns></returns>
         List<IPoint2D> GetPoints(IEnumerable<IPoint2D> points);
-        ITraceLogger? TraceLogger { get; set; }
+        IShiftTraceLogger? TraceLogger { get; set; }
     }
 }
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurveParameterLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurveParameterLogic.cs
index 6fbd306..8117539 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurveParameterLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurveParameterLogic.cs
@@ -17,6 +17,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         Predicate<Point2D> LimitPredicate { get; set; }
         IPoint2D CurrentPoint { get; set; }
         double GetParameter();
-        ITraceLogger? TraceLogger { get; set; }
+        IShiftTraceLogger? TraceLogger { get; set; }
     }
 }
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs
index 9daa629..aaa2a63 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs
@@ -26,7 +26,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         public IResult Result => result;
 
         public Action<IResult> ActionToOutputResults { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public LimitCurveCalculator(ILimitCurveLogic limitCurveLogic)
         {
@@ -47,7 +47,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
 
         public void Run()
         {
-            if (TraceLogger is not null) { limitCurveLogic.TraceLogger = TraceLogger; }
+            if (TraceLogger is not null) { limitCurveLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(50); }
             TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLoggerStatuses.Service);
             TraceLogger?.AddMessage($"Start solution in calculator {Name}");
             result = new LimitCurveResult();
@@ -58,11 +58,19 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
             TraceLogger?.AddMessage($"Point count {PointCount}");
             surroundList = SurroundProcLogic.GetPoints();
             TraceLogger?.AddMessage($"There are {surroundList.Count()} point prepared for calculation");
+            if (TraceLogger is not null)
+            {
+                AddTAbleToTraceLoggerByPoints(surroundList);
+            }
             try
             {
                 limitCurveLogic.ActionToOutputResults = GetCurrentStepNumber;
                 factoredList = limitCurveLogic.GetPoints(surroundList);
                 TraceLogger?.AddMessage($"Solution was successfully obtained for {factoredList.Count()} point");
+                if (TraceLogger is not null)
+                {
+                    AddTAbleToTraceLoggerByPoints(factoredList);
+                }
                 result.Points = factoredList;
             }
             catch (Exception ex)
@@ -73,6 +81,13 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
             }
         }
 
+        private void AddTAbleToTraceLoggerByPoints(IEnumerable<IPoint2D> pointList)
+        {
+            var table = TraceLoggerTableByPointsFactory.GetTableByPoint2D(pointList);
+            table.Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info) + TraceLogger.ShiftPriority;
+            TraceLogger.AddEntry(table);
+        }
+
         private void GetCurrentStepNumber(IResult calcResult)
         {
             if (calcResult is not FindParameterResult)
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs
index a73edfe..4f88302 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs
@@ -18,7 +18,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
 
         private object lockObject = new object();
         public Action<IResult> ActionToOutputResults { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public LimitCurveLogic(ILimitCurveParameterLogic parameterLogic)
         {
@@ -89,7 +89,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         {
             var localCurrentPoint = point.Clone() as IPoint2D;
             var logic = ParameterLogic.Clone() as ILimitCurveParameterLogic;
-            logic.TraceLogger = new TraceLogger();
+            logic.TraceLogger = new ShiftTraceLogger()
+            {
+                ShiftPriority=100
+            };
             logic.CurrentPoint = localCurrentPoint;
             logic.LimitPredicate = limitPredicate;
             double parameter;
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs
index 9b409ee..67f7202 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs
@@ -16,7 +16,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         public Predicate<Point2D> LimitPredicate { get; set; }
         public IPoint2D CurrentPoint { get; set; }
         public Action<IResult> ActionToOutputResults { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public LimitCurveParameterLogic()
         {
@@ -29,7 +29,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
             {
                 Predicate = GetFactorPredicate,
             };
-            if (TraceLogger is not null) { parameterCalculator.TraceLogger = TraceLogger; }
+            if (TraceLogger is not null)
+            {
+                parameterCalculator.TraceLogger = TraceLogger;
+            }
             parameterCalculator.Accuracy.IterationAccuracy = 0.001d;
             parameterCalculator.Run();
             if (parameterCalculator.Result.IsValid == false)
@@ -38,8 +41,11 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
             }
             result = parameterCalculator.Result as FindParameterResult;
             var parameter = result.Parameter;
-            if (parameter < 0.1d)
+            var limitparamValue = 0.1d;
+            if (parameter < limitparamValue)
             {
+                var newAccuracy = limitparamValue / 10d;
+                TraceLogger?.AddMessage($"Since current parameter value {parameter} has a low accuracy (less than {limitparamValue}) new parameter calculatin is started", TraceLoggerStatuses.Warning);
                 parameterCalculator.Accuracy.IterationAccuracy = 0.0001d;
                 parameterCalculator.Run();
                 result = parameterCalculator.Result as FindParameterResult;
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculator.cs
index 761c093..c3e4229 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculator.cs
@@ -30,7 +30,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
         public IResult Result => result;
 
         public Action<IResult> ActionToOutputResults { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public LimitCurvesCalculator()
         {
@@ -90,7 +90,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
                         {
                             string calcName = $"{primitiveSeries.Name}_{predicateEntry.Name}_{limitState}_{calcTerm}";
                             LimitCurveCalculator calculator = GetCalculator(ndms, predicateEntry.PredicateType, calcName);
-                            if (TraceLogger is not null) { calculator.TraceLogger = TraceLogger; }
+                            if (TraceLogger is not null)
+                            {
+                                calculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(50);
+                            }
                             calculators.Add(calculator);
                         }
                     }
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/StabLimitCurveLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/StabLimitCurveLogic.cs
index 1a6defe..ec64dba 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/StabLimitCurveLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/StabLimitCurveLogic.cs
@@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
     public class StabLimitCurveLogic : ILimitCurveLogic
     {
         public Action<IResult> ActionToOutputResults { get; set; }
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public List<IPoint2D> GetPoints(IEnumerable<IPoint2D> points)
         {
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/InterpolationProgressLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/InterpolationProgressLogic.cs
index 8313ace..ff1e8c0 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/InterpolationProgressLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/InterpolationProgressLogic.cs
@@ -24,7 +24,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
 
         public int StepCount => interpolateTuplesResult.StepCount + 1;
 
-        public ITraceLogger? TraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
 
         public void WorkerDoWork(object sender, DoWorkEventArgs e)
         {
diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Geometry/GeometryCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/Geometry/GeometryCalculator.cs
index d4bac37..6d6761e 100644
--- a/StructureHelperLogics/NdmCalculations/Analyses/Geometry/GeometryCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/Geometry/GeometryCalculator.cs
@@ -20,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Geometry
         public IResult Result => geometryResult;
 
         public Action<IResult> ActionToOutputResults { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public ITraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         public GeometryCalculator(IEnumerable<INdm> ndms, IStrainMatrix strainMatrix)
         {
diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs
index 46267a1..d824b1c 100644
--- a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs
@@ -29,7 +29,7 @@ namespace StructureHelperLogics.NdmCalculations.Buckling
 
         public IAccuracy Accuracy { get; set; }
         public Action<IResult> ActionToOutputResults { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public ITraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         private (double EtaAlongX, double EtaAlongY) GetBucklingCoefficients()
         {
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs
index b65ff4c..cdd22a8 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs
@@ -31,7 +31,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         public Accuracy Accuracy {get;set; }
         public IResult Result => result;
 
-        public ITraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         public CrackForceCalculator(IForceTupleCalculator forceTupleCalculator)
         {
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs
index bde2a20..8960e37 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculator.cs
@@ -25,7 +25,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         public CrackWidthCalculatorInputData InputData { get; set; }
         public IResult Result => result;
 
-        public ITraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         public void Run()
         {
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs
index 0903afd..4262d77 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthSimpleCalculator.cs
@@ -17,7 +17,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         public IResult Result => result;
 
         public Action<IResult> ActionToOutputResults { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public ITraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         public void Run()
         {