TableCell class was added

StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentVM.cs

@@ -4,6 +4,7 @@ using StructureHelper.Windows.ViewModels.Errors;
 using StructureHelper.Windows.ViewModels.Materials;
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Models.Loggers;
+using StructureHelperCommon.Models.Tables;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -136,9 +137,20 @@ namespace StructureHelper.Windows.CalculationWindows.ProgressViews
                     }
                     else
                     {
-                        if (cell is StringLoggerEntry stringEntry)
+                        if (cell.Value is StringLoggerEntry stringEntry)
                         {
                             tableCell = new TableCell(GetParagraphByStringEntry(stringEntry));
+                            tableCell.ColumnSpan = cell.ColumnSpan;
+                            if (cell.Role == CellRole.Regular)
+                            {
+                                tableCell.TextAlignment = TextAlignment.Left;
+                                tableCell.Background = Brushes.LightYellow;
+                            }
+                            else if (cell.Role == CellRole.Header)
+                            {
+                                tableCell.TextAlignment = TextAlignment.Center;
+                                tableCell.Background = Brushes.AliceBlue;
+                            }
                         }
                         else
                         {

StructureHelperCommon/Models/Loggers/Factories/TraceTablesFactory.cs

@@ -8,18 +8,25 @@ using System.Threading.Tasks;
 
 namespace StructureHelperCommon.Models.Loggers
 {
-    public static class TraceLoggerTableByPointsFactory
+    public class TraceTablesFactory
     {
-        public static TableLoggerEntry GetTableByPoint2D(IPoint2D point2D)
+        public int Priority { get; set; }
+        public TraceTablesFactory(TraceLoggerStatuses status = TraceLoggerStatuses.Info, int priorityShift = 0)
+        {
+            Priority = LoggerService.GetPriorityByStatus(status) + priorityShift;
+        }
+        public TableLoggerEntry GetTableByPoint2D(IPoint2D point2D)
         {
             var table = new TableLoggerEntry(2);
+            table.Priority = Priority;
             table.Table.AddRow(GetHeaderRow());
             table.Table.AddRow(GetPointRow(point2D));
             return table;
         }
-        public static TableLoggerEntry GetTableByPoint2D(IEnumerable<IPoint2D> points)
+        public TableLoggerEntry GetTableByPoint2D(IEnumerable<IPoint2D> points)
         {
             var table = new TableLoggerEntry(2);
+            table.Priority = Priority;
             table.Table.AddRow(GetHeaderRow());
             foreach (var item in points)
             {
@@ -28,30 +35,44 @@ namespace StructureHelperCommon.Models.Loggers
             return table;
         }
 
-        private static ShTableRow<ITraceLoggerEntry> GetHeaderRow()
+        private ShTableRow<ITraceLoggerEntry> GetHeaderRow()
         {
             var headerRow = new ShTableRow<ITraceLoggerEntry>(2);
-            headerRow.Elements[0] = new StringLoggerEntry()
+            IShTableCell<ITraceLoggerEntry> tableCell;
+            ITraceLoggerEntry loggerEntry;
+            loggerEntry = new StringLoggerEntry()
             {
                 Message = "X",
                 Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info)
             };
-            headerRow.Elements[1] = new StringLoggerEntry()
+            tableCell = new ShTableCell<ITraceLoggerEntry>()
+            {
+                Value = loggerEntry,
+                Role = CellRole.Header,
+            };
+            headerRow.Elements[0] = tableCell;
+            loggerEntry = new StringLoggerEntry()
             {
                 Message = "Y",
                 Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info)
             };
+            tableCell = new ShTableCell<ITraceLoggerEntry>()
+            {
+                Value = loggerEntry,
+                Role = CellRole.Header,
+            };
+            headerRow.Elements[1] = tableCell;
             return headerRow;
         }
-        private static ShTableRow<ITraceLoggerEntry> GetPointRow(IPoint2D point2D)
+        private ShTableRow<ITraceLoggerEntry> GetPointRow(IPoint2D point2D)
         {
             var pointRow = new ShTableRow<ITraceLoggerEntry>(2);
-            pointRow.Elements[0] = new StringLoggerEntry()
+            pointRow.Elements[0].Value = new StringLoggerEntry()
             {
                 Message = Convert.ToString(point2D.X),
                 Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info)
             };
-            pointRow.Elements[1] = new StringLoggerEntry()
+            pointRow.Elements[1].Value = new StringLoggerEntry()
             {
                 Message = Convert.ToString(point2D.Y),
                 Priority = LoggerService.GetPriorityByStatus(TraceLoggerStatuses.Info)

StructureHelperCommon/Models/Loggers/TableLoggerEntry.cs

@@ -9,8 +9,8 @@ namespace StructureHelperCommon.Models.Loggers
 {
     public class TableLoggerEntry : ITraceLoggerEntry
     {
-        private ListTable<ITraceLoggerEntry> table;
+        private ShTable<ITraceLoggerEntry> table;
-        public ListTable<ITraceLoggerEntry> Table {get => table;}
+        public ShTable<ITraceLoggerEntry> Table {get => table;}
         public DateTime TimeStamp { get; }
 
         public int Priority { get; set; }

StructureHelperCommon/Models/Tables/IShTableCell.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Tables
+{
+    public enum CellRole
+    {
+        Title,
+        Header,
+        Regular
+    }
+
+    /// <summary>
+    /// Generic interface for cell of table
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface IShTableCell<T>
+    {
+        /// <summary>
+        /// Value of cell
+        /// </summary>
+        T Value { get; set; }
+        /// <summary>
+        /// Number of cell, joined with this one
+        /// </summary>
+        int ColumnSpan { get; set; }
+        /// <summary>
+        /// Role of the cell in table
+        /// </summary>
+        CellRole Role { get; set; }
+    }
+}

StructureHelperCommon/Models/Tables/IShTableRow.cs

@@ -4,7 +4,7 @@ namespace StructureHelperCommon.Models.Tables
 {
     public interface IShTableRow<T>
     {
-        List<T> Elements { get; }
+        List<IShTableCell<T>> Elements { get; }
         int RowSize { get; }
     }
 }

StructureHelperCommon/Models/Tables/ShTable.cs

@@ -6,13 +6,13 @@ using System.Threading.Tasks;
 
 namespace StructureHelperCommon.Models.Tables
 {
-    public class ListTable<T>
+    public class ShTable<T>
     {
         private List<IShTableRow<T>> table;
 
         public int RowSize { get; }
 
-        public ListTable(int rowSize)
+        public ShTable(int rowSize)
         {
             if (rowSize <= 0)
             {
@@ -42,7 +42,7 @@ namespace StructureHelperCommon.Models.Tables
             return table;
         }
 
-        public List<T> GetElementsFromRow(int rowIndex)
+        public List<IShTableCell<T>> GetElementsFromRow(int rowIndex)
         {
             if (rowIndex >= 0 && rowIndex < table.Count)
             {
@@ -66,7 +66,7 @@ namespace StructureHelperCommon.Models.Tables
             if (columnIndex >= 0 && columnIndex < RowSize &&
                 rowIndex >= 0 && rowIndex < table.Count)
             {
-                table[rowIndex].Elements[columnIndex] = value;
+                table[rowIndex].Elements[columnIndex].Value = value;
             }
             else
             {

StructureHelperCommon/Models/Tables/ShTableCell.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Tables
+{
+    /// <inheritdoc/>
+    public class ShTableCell<T> : IShTableCell<T>
+    {
+        /// <inheritdoc/>
+        public T Value { get; set; }
+        /// <inheritdoc/>
+        public int ColumnSpan { get; set; }
+        /// <inheritdoc/>
+        public CellRole Role { get; set; }
+        public ShTableCell()
+        {
+            Role = CellRole.Regular;
+            ColumnSpan = 1;
+        }
+    }
+}

StructureHelperCommon/Models/Tables/ShTableRow.cs

@@ -8,7 +8,7 @@ namespace StructureHelperCommon.Models.Tables
 {
     public class ShTableRow<T> : IShTableRow<T>
     {
-        private List<T> elements;
+        private List<IShTableCell<T>> elements;
 
         public int RowSize { get; }
 
@@ -20,15 +20,16 @@ namespace StructureHelperCommon.Models.Tables
             }
 
             RowSize = rowSize;
-            elements = new List<T>(rowSize);
+            elements = new List<IShTableCell<T>>(rowSize);
             for (int i = 0; i < rowSize; i++)
             {
-                elements.Add(default);
+                var newCell = new ShTableCell<T>();
+                elements.Add(newCell);
             }
         }
 
         // Property to access elements in the row
-        public List<T> Elements => elements;
+        public List<IShTableCell<T>> Elements => elements;
 
         internal void Add(object value)
         {

StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs

@@ -58,19 +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)
+            TraceLogger?.AddEntry(
-            {
+                new TraceTablesFactory(
-                AddTAbleToTraceLoggerByPoints(surroundList);
+                    TraceLoggerStatuses.Info, TraceLogger.ShiftPriority)
-            }
+                    .GetTableByPoint2D(surroundList));
             try
             {
                 limitCurveLogic.ActionToOutputResults = GetCurrentStepNumber;
                 factoredList = limitCurveLogic.GetPoints(surroundList);
                 TraceLogger?.AddMessage($"Solution was successfully obtained for {factoredList.Count()} point");
-                if (TraceLogger is not null)
+                TraceLogger?.AddEntry(
-                {
+                    new TraceTablesFactory(
-                    AddTAbleToTraceLoggerByPoints(factoredList);
+                        TraceLoggerStatuses.Info, TraceLogger.ShiftPriority)
-                }
+                        .GetTableByPoint2D(factoredList));
                 result.Points = factoredList;
             }
             catch (Exception ex)
@@ -81,13 +81,6 @@ 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)

StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveLogic.cs

@@ -2,6 +2,7 @@
 using StructureHelperCommon.Models.Loggers;
 using StructureHelperCommon.Models.Shapes;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve.Factories;
+using System.Windows.Media.Media3D;
 
 //Copyright (c) 2023 Redikultsev Evgeny, Ekaterinburg, Russia
 //All rights reserved.
@@ -38,9 +39,15 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
             TraceLogger?.AddMessage($"Predicate name is {GetPredicateLogic.Name}");
             Predicate<IPoint2D> limitPredicate = GetPredicateLogic.GetPredicate();
             //if predicate is true for point (0,0), then check other point is pointless
-            if (limitPredicate(new Point2D()) == true)
+            var zeroPoint = new Point2D();
+            if (limitPredicate(zeroPoint) == true)
             {
-                TraceLogger?.AddMessage($"Predicate is true for point  (0d, 0d). All point will be skiped", TraceLoggerStatuses.Warning);
+                TraceLogger?.AddMessage($"Predicate is true for point. All point will be skiped", TraceLoggerStatuses.Warning);
+                TraceLogger?.AddEntry(
+                    new TraceTablesFactory(
+                        TraceLoggerStatuses.Warning, 0)
+                    .GetTableByPoint2D(zeroPoint));
+                TraceLogger?.AddMessage($"All point will be skiped", TraceLoggerStatuses.Warning);
                 var range = points.Select(point => new Point2D { X = 0d, Y = 0d }).ToList();
                 resultList.AddRange(range);
                 return resultList;
@@ -113,10 +120,18 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
             };
             lock (lockObject)
             {
-                TraceLogger?.AddMessage($"Source point (X = {localCurrentPoint.X}, Y = {localCurrentPoint.Y})");
+                TraceLogger?.AddMessage($"Source point");
+                TraceLogger?.AddEntry(
+                new TraceTablesFactory(
+                    TraceLoggerStatuses.Info, TraceLogger.ShiftPriority)
+                    .GetTableByPoint2D(localCurrentPoint));
                 TraceLogger?.TraceLoggerEntries.AddRange(logic.TraceLogger.TraceLoggerEntries);
                 TraceLogger?.AddMessage($"Parameter value {parameter} was obtained");
-                TraceLogger?.AddMessage($"Calculated point (X={localCurrentPoint.X} * {parameter} = {resultPoint.X}, Y={localCurrentPoint.Y} * {parameter} = {resultPoint.Y})");
+                TraceLogger?.AddMessage($"Calculated point\n(X={localCurrentPoint.X} * {parameter} = {resultPoint.X},\nY={localCurrentPoint.Y} * {parameter} = {resultPoint.Y})");
+                TraceLogger?.AddEntry(
+                new TraceTablesFactory(
+                    TraceLoggerStatuses.Info, TraceLogger.ShiftPriority)
+                    .GetTableByPoint2D(resultPoint));
             }
             return resultPoint;
         }

StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs

@@ -45,7 +45,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
             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);
+                TraceLogger?.AddMessage($"Since current parameter value {parameter} has a low accuracy (value less than {limitparamValue}) new parameter calculating is started", TraceLoggerStatuses.Warning);
                 parameterCalculator.Accuracy.IterationAccuracy = 0.0001d;
                 parameterCalculator.Run();
                 result = parameterCalculator.Result as FindParameterResult;

StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculator.cs

@@ -86,6 +86,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
                     foreach (var calcTerm in InputData.CalcTerms)
                     {
                         var ndms = NdmPrimitivesService.GetNdms(primitiveSeries.Collection, limitState, calcTerm);
+                        TraceLogger?.AddMessage($"Number of elementary parts N={ndms.Count()} were obtainded succesfully");
+                        TraceLogger?.AddMessage($"Summary area of elementary parts Asum={ndms.Sum(x=>x.Area)}", TraceLoggerStatuses.Debug);
                         foreach (var predicateEntry in InputData.PredicateEntries)
                         {
                             string calcName = $"{primitiveSeries.Name}_{predicateEntry.Name}_{limitState}_{calcTerm}";

StructureHelperLogics/Services/NdmPrimitives/NdmPrimitivesService.cs

@@ -2,18 +2,8 @@
 using StructureHelperCommon.Infrastructures.Enums;
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Models.Shapes;
-using StructureHelperCommon.Services.Forces;
-using StructureHelperLogics.Models.Calculations.CalculationProperties;
-using StructureHelperLogics.Models.Primitives;
 using StructureHelperLogics.NdmCalculations.Primitives;
 using StructureHelperLogics.NdmCalculations.Triangulations;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Cryptography.X509Certificates;
-using System.Text;
-using System.Threading.Tasks;
-using static System.Collections.Specialized.BitVector32;
 
 namespace StructureHelperLogics.Services.NdmPrimitives
 {