Add curvature calculator

StructureHelper/Infrastructure/Enums/CalculatorTypes.cs

@@ -7,6 +7,7 @@
         CrackCalculator,
         FireCalculator,
         BeamShearCalculator,
-        ValueDiagram
+        ValueDiagramCalculator,
+        CurvatureCalcualtor
     }
 }

StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml

@@ -267,7 +267,19 @@
             </Canvas.Children>
         </Canvas>
     </DataTemplate>
-    
+    <DataTemplate x:Key="CurvatureCalculator">
+        <Canvas Style="{DynamicResource ButtonCalculatorCanvas}">
+            <Canvas.Children>
+                <ContentControl ContentTemplate="{DynamicResource ButtonCalculatorRectangle}"/>
+                <Path Data="M 6 16 a 10 15 90 0 0 20 0  l 2 5 a 7 15 90 0 1 -24 0 z" Fill="{DynamicResource CalculatorFrame}"/>
+                <Path Data="M 4 18 a 8 15 90 0 0 24 0" Stroke="Black"  StrokeThickness="0.5"/>
+                <Line X1="16" Y1="5" X2="12" Y2="21" Stroke="Black"/>
+                <Line X1="11" Y1="15" X2="12" Y2="21" Stroke="Black"/>
+                <Line X1="16" Y1="16" X2="12" Y2="21" Stroke="Black"/>
+                <TextBlock FontSize="8" Text="R" FontWeight="Bold" Margin="17,3,0,0"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
     <DataTemplate x:Key="DeSelectAll">
         <Canvas Style="{DynamicResource ButtonResultCanvas}">
             <Canvas.Children>

StructureHelper/StructureHelper.csproj.user

@@ -63,6 +63,9 @@
     <Compile Update="Windows\CalculationWindows\CalculatorsViews\Cracks\TupleCrackResultView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Update="Windows\CalculationWindows\CalculatorsViews\Curvatures\CurvatureCalculatorView.xaml.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Update="Windows\CalculationWindows\CalculatorsViews\ForceCalculatorViews\ForceResultLogic\LimitCurveDataView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>

StructureHelper/Windows/CalculationWindows/CalculatorsViews/CalculatorViewModel.cs

@@ -0,0 +1,38 @@
+using StructureHelper.Infrastructure;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
+{
+    public class CalculatorViewModel : ViewModelBase
+    {
+        private ICalculator calcualtor;
+
+        public bool ShowTraceData
+        {
+            get => calcualtor.ShowTraceData;
+            set
+            {
+                calcualtor.ShowTraceData = value;
+                OnPropertyChanged(nameof(ShowTraceData));
+            }
+        }
+        public string Name
+        {
+            get => calcualtor.Name;
+            set
+            {
+                calcualtor.Name = value;
+                OnPropertyChanged(nameof(Name));
+            }
+        }
+
+        public CalculatorViewModel(ICalculator calcualtor)
+        {
+            this.calcualtor = calcualtor;
+        }
+    }
+}

StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs

@@ -25,6 +25,9 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
         static IGetUnitLogic unitLogic = new GetUnitLogic();
         static readonly CrackForceBynarySearchCalculator calculator = new();
         private ITriangulatePrimitiveLogic triangulateLogic;
+        private IUnit unitForce = unitLogic.GetUnit(UnitTypes.Force);
+        private IUnit unitMoment = unitLogic.GetUnit(UnitTypes.Moment);
+        private IUnit unitCurvature = unitLogic.GetUnit(UnitTypes.Curvature);
 
         private List<IExtendedForceTupleCalculatorResult> ValidTupleList { get; set; }
         ArrayParameter<double> arrayParameter;
@@ -67,11 +70,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
         {
             List<string> labels = GetCrackLabels();
             arrayParameter = new ArrayParameter<double>(ValidTupleList.Count(), labels);
-            CalculateWithCrack(ValidTupleList,
+            CalculateWithCrack(ValidTupleList, NdmPrimitives);
-                NdmPrimitives,
-                unitLogic.GetUnit(UnitTypes.Force),
-                unitLogic.GetUnit(UnitTypes.Moment),
-                unitLogic.GetUnit(UnitTypes.Curvature));
         }
 
         public void ShowWindow()
@@ -92,31 +91,19 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
             "Errors appeared during showing a graph, see detailed information");
         }
 
-        private void CalculateWithCrack(List<IExtendedForceTupleCalculatorResult> validTupleList, IEnumerable<INdmPrimitive> ndmPrimitives, IUnit unitForce, IUnit unitMoment, IUnit unitCurvature)
+        private void CalculateWithCrack(List<IExtendedForceTupleCalculatorResult> validTupleList, IEnumerable<INdmPrimitive> ndmPrimitives)
         {
             var data = arrayParameter.Data;
             for (int i = 0; i < validTupleList.Count(); i++)
             {
-                var valueList = new List<double>
-                {
-                    validTupleList[i].ForcesTupleResult.ForceTuple.Mx * unitMoment.Multiplyer,
-                    validTupleList[i].ForcesTupleResult.ForceTuple.My * unitMoment.Multiplyer,
-                    validTupleList[i].ForcesTupleResult.ForceTuple.Nz * unitForce.Multiplyer
-                };
                 calculator.InputData.EndTuple = validTupleList[i].ForcesTupleResult.ForceTuple;
                 var limitState = validTupleList[i].StateCalcTermPair.LimitState;
                 var calcTerm = validTupleList[i].StateCalcTermPair.CalcTerm;
-                triangulateLogic = new TriangulatePrimitiveLogic()
+                GetTriangulationLogic(ndmPrimitives, limitState, calcTerm);
-                {
-                    Primitives = ndmPrimitives,
-                    LimitState = limitState,
-                    CalcTerm = calcTerm,
-                    TraceLogger = TraceLogger
-                };
                 var ndms = triangulateLogic.GetNdms();
                 calculator.InputData.CheckedNdmCollection = calculator.InputData.SectionNdmCollection = ndms;
                 calculator.Run();
-                var result = (CrackForceResult)calculator.Result;
+                var result = (ICrackForceResult)calculator.Result;
                 if (result.IsValid == false)
                 {
                     MessageBox.Show(
@@ -126,6 +113,24 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
                         MessageBoxIcon.Information);
                     return;
                 }
+                IExtendedForceTupleCalculatorResult extendedForceTupleCalculatorResult = validTupleList[i];
+                List<double> valueList = GetValueList(result, extendedForceTupleCalculatorResult);
+                for (int j = 0; j < valueList.Count; j++)
+                {
+                    data[i, j] = valueList[j];
+                }
+                SetProgress?.Invoke(i);
+            }
+        }
+
+        private List<double> GetValueList(ICrackForceResult result, IExtendedForceTupleCalculatorResult extendedForceTupleCalculatorResult)
+        {
+            var valueList = new List<double>
+                {
+                    extendedForceTupleCalculatorResult.ForcesTupleResult.ForceTuple.Mx * unitMoment.Multiplyer,
+                    extendedForceTupleCalculatorResult.ForcesTupleResult.ForceTuple.My * unitMoment.Multiplyer,
+                    extendedForceTupleCalculatorResult.ForcesTupleResult.ForceTuple.Nz * unitForce.Multiplyer
+                };
             valueList.Add(result.CrackedStrainTuple.Mx);
             valueList.Add(result.CrackedStrainTuple.My);
             valueList.Add(result.CrackedStrainTuple.Nz);
@@ -139,14 +144,18 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
             valueList.Add(result.SofteningFactors.Nz);
 
             valueList.Add(result.PsiS);
+            return valueList;
+        }
 
-                for (int j = 0; j < valueList.Count; j++)
+        private void GetTriangulationLogic(IEnumerable<INdmPrimitive> ndmPrimitives, LimitStates limitState, CalcTerms calcTerm)
         {
-                    data[i, j] = valueList[j];
+            triangulateLogic = new TriangulatePrimitiveLogic()
-                }
+            {
-
+                Primitives = ndmPrimitives,
-                SetProgress?.Invoke(i);
+                LimitState = limitState,
-            }
+                CalcTerm = calcTerm,
+                TraceLogger = TraceLogger
+            };
         }
 
         private static List<string> GetCrackLabels()

StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorInputDataViewModel.cs

@@ -0,0 +1,64 @@
+using StructureHelper.Infrastructure;
+using StructureHelper.Infrastructure.UI.DataContexts;
+using StructureHelper.Windows.ViewModels;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.Models.CrossSections;
+using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures
+{
+    public class CurvatureCalculatorInputDataViewModel : ViewModelBase
+    {
+        private ICurvatureCalculatorInputData inputData;
+        private double deflectionFactor;
+        private double spanLength;
+
+        public double DeflectionFactor
+        {
+            get => inputData.DeflectionFactor;
+            set
+            {
+                inputData.DeflectionFactor = Math.Max(value, 0.0);
+                OnPropertyChanged(nameof(DeflectionFactor));
+            }
+        }
+
+        public double SpanLength
+        {
+            get => inputData.SpanLength;
+            set
+            {
+                inputData.SpanLength = Math.Max(value, 0.0);
+                OnPropertyChanged(nameof(SpanLength));
+            }
+        }
+
+        public SourceTargetVM<IForceAction> CombinationViewModel { get; }
+        public SourceTargetVM<PrimitiveBase> PrimitivesViewModel { get; }
+
+        public CurvatureCalculatorInputDataViewModel(ICurvatureCalculatorInputData inputData, ICrossSectionRepository repository)
+        {
+            this.inputData = inputData;
+            CombinationViewModel = SourceTargetFactory.GetSourceTargetVM(repository.ForceActions, inputData.ForceActions);
+            PrimitivesViewModel = SourceTargetFactory.GetSourceTargetVM(repository.Primitives, inputData.Primitives);
+        }
+        public void Refresh()
+        {
+            var combinations = CombinationViewModel.GetTargetItems();
+            inputData.ForceActions.Clear();
+            foreach (var item in combinations)
+            {
+                inputData.ForceActions.Add(item);
+            }
+            inputData.Primitives.Clear();
+            foreach (var item in PrimitivesViewModel.GetTargetItems())
+            {
+                inputData.Primitives.Add(item.GetNdmPrimitive());
+            }
+        }
+    }
+}

StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml

@@ -0,0 +1,49 @@
+<Window x:Class="StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures.CurvatureCalculatorView"
+        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.CalculatorsViews.Curvatures"
+        xmlns:uc="clr-namespace:StructureHelper.Windows.UserControls"
+        d:DataContext="{d:DesignInstance local:CurvatureCalculatorViewModel}"
+        mc:Ignorable="d"
+        Title="Curvature Calculator" Height="250" Width="400" WindowStartupLocation="CenterScreen" ResizeMode="NoResize">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition/>
+            <RowDefinition Height="40"/>
+        </Grid.RowDefinitions>
+        <TabControl>
+            <TabItem Header="Main">
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="120"/>
+                        <ColumnDefinition Width="*"/>
+                    </Grid.ColumnDefinitions>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="22"/>
+                        <RowDefinition Height="22"/>
+                        <RowDefinition Height="22"/>
+                        <RowDefinition Height="22"/>
+                        <RowDefinition/>
+                    </Grid.RowDefinitions>
+                    <TextBlock Grid.Row="0" Text="Name"/>
+                    <TextBox Grid.Column="1" Grid.Row="0" Text="{Binding CalculatorViewModel.Name}"/>
+                    <TextBlock Grid.Row="1" Text="Show trace data"/>
+                    <CheckBox Grid.Column="1" Grid.Row="1" Margin="0,3" IsChecked="{Binding CalculatorViewModel.ShowTraceData}"/>
+                    <TextBlock Grid.Row="2" Text="Deflection factor"/>
+                    <TextBox Grid.Column="1" Grid.Row="2" Text="{Binding InputDataViewModel.DeflectionFactor, Converter={StaticResource PlainDouble}}"/>
+                    <TextBlock Grid.Row="3" Text="Span length"/>
+                    <TextBox Grid.Column="1" Grid.Row="3" Text="{Binding InputDataViewModel.SpanLength, Converter={StaticResource LengthConverter}}"/>
+                </Grid>
+            </TabItem>
+            <TabItem Header="Forces">
+                <ContentControl ContentTemplate="{StaticResource SourceToTarget}" Content="{Binding InputDataViewModel.CombinationViewModel}"/>
+            </TabItem>
+            <TabItem Header="Primitives">
+                <ContentControl ContentTemplate="{StaticResource SourceToTarget}" Content="{Binding InputDataViewModel.PrimitivesViewModel}"/>
+            </TabItem>
+        </TabControl>
+        <ContentControl Grid.Row="1" ContentTemplate="{StaticResource OkCancelButtons}" Content="{Binding}"/>
+    </Grid>
+</Window>

StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml.cs

@@ -0,0 +1,19 @@
+using System.Windows;
+
+namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures
+{
+    /// <summary>
+    /// Логика взаимодействия для CurvatureCalculatorView.xaml
+    /// </summary>
+    public partial class CurvatureCalculatorView : Window
+    {
+        private CurvatureCalculatorViewModel viewModel;
+        public CurvatureCalculatorView(CurvatureCalculatorViewModel viewModel)
+        {
+            InitializeComponent();
+            viewModel.ParentWindow = this;
+            this.viewModel = viewModel;
+            this.DataContext = viewModel;
+        }
+    }
+}

StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorViewModel.cs

@@ -0,0 +1,25 @@
+using StructureHelper.Windows.ViewModels;
+using StructureHelperLogics.Models.CrossSections;
+using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
+
+namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures
+{
+    public class CurvatureCalculatorViewModel : OkCancelViewModelBase
+    {
+        private ICurvatureCalculator curvatureCalculator;
+        public CalculatorViewModel CalculatorViewModel { get; private set; }
+        public CurvatureCalculatorInputDataViewModel InputDataViewModel { get; private set; }
+
+        public CurvatureCalculatorViewModel(ICurvatureCalculator calculator, ICrossSectionRepository repository)
+        {
+            this.curvatureCalculator = calculator;
+            CalculatorViewModel = new CalculatorViewModel(calculator);
+            InputDataViewModel = new(calculator.InputData, repository);
+        }
+
+        public void Refresh()
+        {
+            InputDataViewModel.Refresh();
+        }
+    }
+}

StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorInputDataViewModel.cs

@@ -27,7 +27,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr
         public StateCalcTermPairViewModel StateCalcTermPairViewModel { get; }
         public ValueDiagramsViewModel ValueDiagramsViewModel { get; }
 
-        public ValueDiagramCalculatorInputDataViewModel(ICrossSectionRepository repository, IValueDiagramCalculatorInputData inputData)
+        public ValueDiagramCalculatorInputDataViewModel(IValueDiagramCalculatorInputData inputData, ICrossSectionRepository repository)
         {
             this.inputData = inputData;
             this.repository = repository;

StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorView.xaml

@@ -29,9 +29,9 @@
                         <RowDefinition/>
                     </Grid.RowDefinitions>
                     <TextBlock Grid.Row="0" Text="Name"/>
-                    <TextBox Grid.Column="1" Grid.Row="0" Text="{Binding Name}"/>
+                    <TextBox Grid.Column="1" Grid.Row="0" Text="{Binding CalculatorViewModel.Name}"/>
                     <TextBlock Grid.Row="1" Text="Show trace data"/>
-                    <CheckBox Grid.Column="1" Grid.Row="1" Margin="0,3" IsChecked="{Binding ShowTraceData}"/>
+                    <CheckBox Grid.Column="1" Grid.Row="1" Margin="0,3" IsChecked="{Binding CalculatorViewModel.ShowTraceData}"/>
                     <TextBlock Grid.Row="2" Text="Limit state"/>
                     <ComboBox Grid.Column="1" Grid.Row="2" ItemsSource="{Binding InputDataViewModel.StateCalcTermPairViewModel.LimitStatesCollection}" SelectedItem="{Binding InputDataViewModel.StateCalcTermPairViewModel.LimitState}"/>
                     <TextBlock Grid.Row="3" Text="Calc term"/>

StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorViewModel.cs

@@ -8,30 +8,14 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr
     {
         private IValueDiagramCalculator valueDiagramCalculator;
         
-        public bool ShowTraceData
+        public CalculatorViewModel CalculatorViewModel { get; private set; }
-        {
-            get => valueDiagramCalculator.ShowTraceData;
-            set
-            {
-                valueDiagramCalculator.ShowTraceData = value;
-                OnPropertyChanged(nameof(ShowTraceData));
-            }
-        }
-        public string Name
-        {
-            get => valueDiagramCalculator.Name;
-            set
-            {
-                valueDiagramCalculator.Name = value;
-                OnPropertyChanged(nameof(Name));
-            }
-        }
         public ValueDiagramCalculatorInputDataViewModel InputDataViewModel { get; set; }
 
         public ValueDiagramCalculatorViewModel(ICrossSectionRepository repository, IValueDiagramCalculator valueDiagramCalculator)
         {
             this.valueDiagramCalculator = valueDiagramCalculator;
-            InputDataViewModel = new(repository, valueDiagramCalculator.InputData);
+            CalculatorViewModel = new(valueDiagramCalculator);
+            InputDataViewModel = new(valueDiagramCalculator.InputData, repository);
         }
 
         public void Refresh()

StructureHelper/Windows/MainWindow/CrossSections/AnalysisViewModelLogic.cs

@@ -2,6 +2,7 @@
 using StructureHelper.Infrastructure;
 using StructureHelper.Infrastructure.Enums;
 using StructureHelper.Windows.CalculationWindows.CalculatorsViews;
+using StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures;
 using StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalculatorViews;
 using StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagrams;
 using StructureHelper.Windows.CalculationWindows.ProgressViews;
@@ -14,6 +15,7 @@ using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Calculators;
 using StructureHelperLogics.Models.CrossSections;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
+using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
 using StructureHelperLogics.NdmCalculations.Analyses.Logics;
 using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Cracking;
@@ -54,16 +56,30 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections
             {
                 AddCrackCalculator();
             }
-            else if (parameterType == CalculatorTypes.ValueDiagram)
+            else if (parameterType == CalculatorTypes.ValueDiagramCalculator)
             {
                 AddValueDiagramCalculator();
             }
+            else if (parameterType == CalculatorTypes.CurvatureCalcualtor)
+            {
+                AddCurvatureCalculator();
+            }
             else
             {
                 throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(parameterType));
             }
         }
 
+        private void AddCurvatureCalculator()
+        {
+            var calculator = new CurvatureCalculator(Guid.NewGuid())
+            {
+                Name = "New Curvature calculator",
+                ShowTraceData = false,
+            };
+            NewItem = calculator;
+        }
+
         private void AddValueDiagramCalculator()
         {
             var calculator = new ValueDiagramCalculator(Guid.NewGuid())
@@ -130,13 +146,19 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections
         private void EditCalculator()
         {
             if (SelectedItem is ForceCalculator forceCalculator) { EditForceCalculator(forceCalculator);}
-            else if (SelectedItem is LimitCurvesCalculator limitCurvesCalculator) { EditLimitCurveCalculator(limitCurvesCalculator);            }
+            else if (SelectedItem is LimitCurvesCalculator limitCurvesCalculator) { EditLimitCurveCalculator(limitCurvesCalculator);}
             else if (SelectedItem is CrackCalculator crackCalculator) { EditCrackCalculator(crackCalculator);}
-            else if (SelectedItem is IValueDiagramCalculator valueDiagramCalculator)
+            else if (SelectedItem is ValueDiagramCalculator valueDiagramCalculator) {EditValueDiagramCalculator(valueDiagramCalculator);}
-            {
+            else if (SelectedItem is CurvatureCalculator curvatureCalculator) {EditCurvatureCalculator(curvatureCalculator);}
-                EditValueDiagramCalculator(valueDiagramCalculator);
+            else { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(SelectedItem)); }
         }
-            else { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(SelectedItem));}
+
+        private void EditCurvatureCalculator(CurvatureCalculator sourceCalculator)
+        {
+            var clone = sourceCalculator.Clone() as ICurvatureCalculator;
+            var vm = new CurvatureCalculatorViewModel(sourceCalculator, repository);
+            var wnd = new CurvatureCalculatorView(vm);
+            ShowWindow(sourceCalculator, clone, wnd);
         }
 
         private void EditValueDiagramCalculator(IValueDiagramCalculator sourceCalculator)

StructureHelper/Windows/MainWindow/CrossSections/CrossSectionView.xaml

@@ -101,9 +101,9 @@
                         <ContentControl ContentTemplate="{DynamicResource CrackCalculator}"/>
                     </Viewbox>
                 </Button>
-                <Button Style="{DynamicResource ToolButton}" Command="{Binding Add}"  CommandParameter="{x:Static enums:CalculatorTypes.ValueDiagram}" >
+                <Button Style="{DynamicResource ToolButton}" Command="{Binding Add}"  CommandParameter="{x:Static enums:CalculatorTypes.ValueDiagramCalculator}" >
                     <Button.ToolTip>
-                        <uc:ButtonToolTipEh HeaderText="Add Value Diagram Calctulator"
+                        <uc:ButtonToolTipEh HeaderText="Add Value Diagram Calculator"
                                                 IconContent="{StaticResource ValueDiagramCalculator}"
                                                 DescriptionText="Adds new calculator for creating diagram of results on line of cross-section"/>
                     </Button.ToolTip>
@@ -111,6 +111,16 @@
                         <ContentControl ContentTemplate="{StaticResource ValueDiagramCalculator}"/>
                     </Viewbox>
                 </Button>
+                <Button Style="{DynamicResource ToolButton}" Command="{Binding Add}"  CommandParameter="{x:Static enums:CalculatorTypes.CurvatureCalcualtor}" >
+                    <Button.ToolTip>
+                        <uc:ButtonToolTipEh HeaderText="Add Curvature Calculator"
+                                                IconContent="{StaticResource CurvatureCalculator}"
+                                                DescriptionText="Adds new calculator for calculating of curvature of cross-section"/>
+                    </Button.ToolTip>
+                    <Viewbox>
+                        <ContentControl ContentTemplate="{StaticResource CurvatureCalculator}"/>
+                    </Viewbox>
+                </Button>
                 <Button Style="{DynamicResource ToolButton}" Command="{Binding Run}" ToolTip="Run Calculations">
                     <Viewbox>
                         <ContentControl ContentTemplate="{DynamicResource CalculatorRun}"/>
@@ -381,13 +391,20 @@
                                                 </Viewbox>
                                             </MenuItem.Icon>
                                         </MenuItem>
-                                        <MenuItem Header="Add Value Diagram Calculator" Command="{Binding Add}" CommandParameter="{x:Static enums:CalculatorTypes.ValueDiagram}">
+                                        <MenuItem Header="Add Value Diagram Calculator" Command="{Binding Add}" CommandParameter="{x:Static enums:CalculatorTypes.ValueDiagramCalculator}">
                                             <MenuItem.Icon>
                                                 <Viewbox Width="16" Height="16">
                                                     <ContentControl ContentTemplate="{DynamicResource ValueDiagramCalculator}"/>
                                                 </Viewbox>
                                             </MenuItem.Icon>
                                         </MenuItem>
+                                        <MenuItem Header="Add Curvature Calculator" Command="{Binding Add}" CommandParameter="{x:Static enums:CalculatorTypes.CurvatureCalcualtor}">
+                                            <MenuItem.Icon>
+                                                <Viewbox Width="16" Height="16">
+                                                    <ContentControl ContentTemplate="{DynamicResource CurvatureCalculator}"/>
+                                                </Viewbox>
+                                            </MenuItem.Icon>
+                                        </MenuItem>
                                     </MenuItem>
                                 </ContextMenu>
                             </Expander.ContextMenu>

StructureHelperCommon/Infrastructures/Exceptions/StructureHelperNullReferenceException.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperCommon.Infrastructures.Exceptions
+{
+    public class StructureHelperNullReferenceException : StructureHelperException
+    {
+        public StructureHelperNullReferenceException(string errorString) : base(errorString)
+        {
+        }
+
+        public StructureHelperNullReferenceException(Exception ex) : base(ex)
+        {
+        }
+    }
+}

StructureHelperCommon/Services/Forces/TupleConverter.cs

@@ -17,6 +17,12 @@ namespace StructureHelperCommon.Services.Forces
             return strainMatrix;
         }
 
+        public static StrainMatrix ConvertToLoaderStrainMatrix(IForceTuple strainTuple)
+        {
+            var strainMatrix = new StrainMatrix() { Kx = strainTuple.Mx, Ky = strainTuple.My, EpsZ = strainTuple.Nz };
+            return strainMatrix;
+        }
+
         public static StrainTuple ConvertToStrainTuple(IStrainMatrix strainMatrix)
         {
             StrainTuple strainTuple = new StrainTuple() { Mx = strainMatrix.Kx, My = strainMatrix.Ky, Nz = strainMatrix.EpsZ };

StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs

@@ -18,7 +18,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
     {
         public static IStressLogic stressLogic = new StressLogic();
         public IEnumerable<INdm> NdmCollection { get; set; }
-        public StrainTuple StrainTuple { get; set; }
+        public IForceTuple StrainTuple { get; set; }
         public IShiftTraceLogger? TraceLogger { get; set; }
 
         public StrainTuple GetSofteningFactors()

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs

@@ -0,0 +1,40 @@
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureCalculator : ICurvatureCalculator
+    {
+        private ICurvatureCalculatorResult result;
+        public Guid Id { get; }
+        public string Name { get; set; } = string.Empty;
+        public ICurvatureCalculatorInputData InputData { get; set; } = new CurvatureCalculatorInputData(Guid.NewGuid());
+        public bool ShowTraceData { get; set; } = false;
+
+        public IResult Result => result;
+
+        public IShiftTraceLogger? TraceLogger { get; set; }
+
+
+        public CurvatureCalculator(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            var updateStrategy = new CurvatureCalculatorUpdateStrategy();
+            CurvatureCalculator newItem = new(Guid.NewGuid());
+            updateStrategy.Update(newItem, this);
+            return newItem;
+        }
+
+        public void Run()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorInputData.cs

@@ -0,0 +1,20 @@
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureCalculatorInputData : ICurvatureCalculatorInputData
+    {
+        public Guid Id { get; }
+        public List<IForceAction> ForceActions { get; } = [];
+
+        public List<INdmPrimitive> Primitives { get; } = [];
+        public double DeflectionFactor { get; set; } = 0.1042;
+        public double SpanLength { get; set; } = 6.0;
+
+        public CurvatureCalculatorInputData(Guid id)
+        {
+            Id = id;
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalcualtor.cs

@@ -0,0 +1,35 @@
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureTermCalcualtor : ICurvatureTermCalcualtor
+    {
+        private ICurvatureTermCalcualtorResult result;
+        public ICurvatureTermCalcualtorInputData InputData { get; set; }
+
+        public IResult Result => result;
+
+        public IShiftTraceLogger? TraceLogger { get; set; }
+
+        public Guid Id { get; }
+
+        public CurvatureTermCalcualtor(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Run()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalcualtorLogic.cs

@@ -0,0 +1,14 @@
+using StructureHelperCommon.Models.Calculators;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    internal interface ICurvatureCalcualtorLogic
+    {
+        ICurvatureCalculatorInputData InputData {get;set;}
+        IResult Result { get; }
+        void Run();
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculator.cs

@@ -0,0 +1,12 @@
+using StructureHelperCommon.Models.Calculators;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureCalculator : ICalculator
+    {
+        ICurvatureCalculatorInputData InputData { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorInputData.cs

@@ -0,0 +1,15 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureCalculatorInputData : IInputData, ISaveable, IHasForceActions, IHasPrimitives
+    {
+        double DeflectionFactor { get; set; }
+        double SpanLength { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorResult.cs

@@ -0,0 +1,13 @@
+using StructureHelperCommon.Models.Calculators;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureCalculatorResult : IResult
+    {
+        ICurvatureCalculatorInputData InputData { get; set; }
+        List<ICurvatureForceCalculatorResult> ForceCalculatorResults { get; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalcualtor.cs

@@ -0,0 +1,11 @@
+using StructureHelperCommon.Models.Calculators;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureForceCalcualtor : ILogicCalculator
+    {
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorInputData.cs

@@ -0,0 +1,14 @@
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureForceCalculatorInputData : IInputData, IHasPrimitives
+    {
+        IDesignForceTuple DesignForceTuple { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs

@@ -0,0 +1,11 @@
+using StructureHelperCommon.Models.Calculators;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureForceCalculatorResult : IResult
+    {
+        ICurvatureForceCalculatorInputData InputData { get; set; }
+        ICurvatureTermCalcualtorResult LongTermResult { get; set; }
+        ICurvatureTermCalcualtorResult ShortTermResult { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtor.cs

@@ -0,0 +1,12 @@
+using StructureHelperCommon.Models.Calculators;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureTermCalcualtor : ILogicCalculator
+    {
+        ICurvatureTermCalcualtorInputData InputData { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorInputData.cs

@@ -0,0 +1,14 @@
+using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureTermCalcualtorInputData : IInputData, IHasPrimitives
+    {
+        IForceTuple DesignForceTuple { get; set; }
+        CalcTerms LoadTerm { get; set; }
+        CalcTerms CalculationTerm { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorResult.cs

@@ -0,0 +1,13 @@
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public interface ICurvatureTermCalcualtorResult : IResult
+    {
+        ICurvatureTermCalcualtorInputData InputData { get; set; }
+        IForceTuple CurvatureValue { get; set; }
+        IForceTuple Deflection { get; set; }
+
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs

@@ -0,0 +1,31 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureCalculatorInputDataUpdateStrategy : IParentUpdateStrategy<ICurvatureCalculatorInputData>
+    {
+        public bool UpdateChildren { get; set; } = true;
+
+        public void Update(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject)
+        {
+            CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject));
+            CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
+            if (ReferenceEquals(targetObject, sourceObject))
+                return;
+            targetObject.DeflectionFactor = sourceObject.DeflectionFactor;
+            targetObject.SpanLength = sourceObject.SpanLength;
+            if (UpdateChildren == true)
+            {
+                CheckObject.ThrowIfNull(sourceObject.Primitives);
+                CheckObject.ThrowIfNull(targetObject.Primitives);
+                targetObject.Primitives.Clear();
+                targetObject.Primitives.AddRange(sourceObject.Primitives);
+                CheckObject.ThrowIfNull(sourceObject.ForceActions);
+                CheckObject.ThrowIfNull(targetObject.ForceActions);
+                targetObject.ForceActions.Clear();
+                targetObject.ForceActions.AddRange(sourceObject.ForceActions);
+            }
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorUpdateStrategy.cs

@@ -0,0 +1,40 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures
+{
+    public class CurvatureCalculatorUpdateStrategy : IParentUpdateStrategy<ICurvatureCalculator>
+    {
+        private IUpdateStrategy<ICurvatureCalculatorInputData> inputDataUpdateStrategy;
+        private IUpdateStrategy<ICurvatureCalculatorInputData> InputDataUpdateStrategy => inputDataUpdateStrategy ??= new CurvatureCalculatorInputDataUpdateStrategy();
+
+        public CurvatureCalculatorUpdateStrategy(IUpdateStrategy<ICurvatureCalculatorInputData> inputDataUpdateStrategy)
+        {
+            this.inputDataUpdateStrategy = inputDataUpdateStrategy ?? throw new StructureHelperNullReferenceException(ErrorStrings.NullReference + ": input data of curvature calculator can not be null");
+        }
+
+        public CurvatureCalculatorUpdateStrategy()
+        {
+            
+        }
+
+        public bool UpdateChildren { get; set; } = true;
+
+        public void Update(ICurvatureCalculator targetObject, ICurvatureCalculator sourceObject)
+        {
+            CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject));
+            CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
+            if (ReferenceEquals(targetObject, sourceObject))
+                return;
+            targetObject.Name = sourceObject.Name;
+            targetObject.ShowTraceData = sourceObject.ShowTraceData;
+            if (UpdateChildren == true)
+            {
+                CheckObject.ThrowIfNull(sourceObject.InputData);
+                CheckObject.ThrowIfNull(targetObject.InputData);
+                InputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData);
+            }
+        }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/Logics/CalculatorUpdateStrategy.cs

@@ -5,6 +5,7 @@ using StructureHelperCommon.Services;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
+using StructureHelperLogics.NdmCalculations.Analyses.Curvatures;
 using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Cracking;
 using StructureHelperLogics.NdmCalculations.Primitives;
@@ -38,9 +39,13 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Logics
             {
                 new ValueDiagramCalculatorUpdateStrategy().Update(diagramCalculator, (IValueDiagramCalculator)sourceObject);
             }
+            else if (targetObject is ICurvatureCalculator curvatureCalculator)
+            {
+                new CurvatureCalculatorUpdateStrategy().Update(curvatureCalculator, (ICurvatureCalculator)sourceObject);
+            }
             else
             {
-                ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(INdmPrimitive), sourceObject.GetType());
+                ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(ICalculator), sourceObject.GetType());
             }
         }
     }

StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs

@@ -5,18 +5,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
 {
     public class ValueDiagramCalculatorInputDataUpdateStrategy : IParentUpdateStrategy<IValueDiagramCalculatorInputData>
     {
-        private IUpdateStrategy<IValueDiagramEntity> entityUpdateStrategy;
-
-        public ValueDiagramCalculatorInputDataUpdateStrategy(IUpdateStrategy<IValueDiagramEntity> entityUpdateStrategy)
-        {
-            this.entityUpdateStrategy = entityUpdateStrategy;
-        }
-
-        public ValueDiagramCalculatorInputDataUpdateStrategy()
-        {
-            
-        }
-
         public bool UpdateChildren { get; set; } = true;
 
         public void Update(IValueDiagramCalculatorInputData targetObject, IValueDiagramCalculatorInputData sourceObject)
@@ -33,7 +21,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
                 targetObject.ForceActions.Clear();
                 targetObject.ForceActions.AddRange(sourceObject.ForceActions);
                 targetObject.Diagrams.Clear();
-                entityUpdateStrategy ??= new ValueDiagramEntityUpdateStrategy();
                 foreach (var entity in sourceObject.Diagrams)
                 {
                     var newItem = entity.Clone() as IValueDiagramEntity;

StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs

@@ -148,14 +148,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             TraceLogger?.AddMessage($"Valid result was obtained", TraceLogStatuses.Debug);
         }
 
-        private StrainTuple GetSofteningFactors(StrainTuple reducedStrainTuple)
+        private StrainTuple GetSofteningFactors(IForceTuple reducedStrainTuple)
         {
             softeningFactorLogic.NdmCollection = InputData.SectionNdmCollection;
             softeningFactorLogic.StrainTuple = reducedStrainTuple;
             return softeningFactorLogic.GetSofteningFactors();
         }
 
-        private StrainTuple GetReducedStrainTuple(double factorOfCrackAppearance, double softeningFactor)
+        private IForceTuple GetReducedStrainTuple(double factorOfCrackAppearance, double softeningFactor)
         {
             const double notCrackedForceFactor = 0.99d;
             var notCrackedForceTuple = ForceTupleService.InterpolateTuples(InputData.StartTuple, InputData.EndTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple;

StructureHelperLogics/NdmCalculations/Cracking/CrackForceResult.cs

@@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
     /// <summary>
     /// Result of crack calculation
     /// </summary>
-    public class CrackForceResult : IResult
+    public class CrackForceResult : ICrackForceResult
     {
         /// <inheritdoc/>
         public bool IsValid { get; set; }
@@ -41,15 +41,15 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         /// <summary>
         /// General curvature in cracked section
         /// </summary>
-        public StrainTuple CrackedStrainTuple { get; set; }
+        public IForceTuple CrackedStrainTuple { get; set; }
         /// <summary>
         /// Average general curvature with considering of cracking
         /// </summary>
-        public StrainTuple ReducedStrainTuple { get; set; }
+        public IForceTuple ReducedStrainTuple { get; set; }
         /// <summary>
         /// Factor of softening of stifness with considering of cracks
         /// </summary>
-        public StrainTuple SofteningFactors { get; set; }
+        public IForceTuple SofteningFactors { get; set; }
         /// <summary>
         /// Collection of ndms which crack properties looking for
         /// </summary>

StructureHelperLogics/NdmCalculations/Cracking/CrackStrainLogic.cs

@@ -10,11 +10,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
     internal class CrackStrainLogic : ICrackStrainLogic
     {
-        public StrainTuple BeforeCrackingTuple { get; set; }
+        public IForceTuple BeforeCrackingTuple { get; set; }
-        public StrainTuple AfterCrackingTuple { get; set; }
+        public IForceTuple AfterCrackingTuple { get; set; }
         public double SofteningFactor { get; set; }
 
-        public StrainTuple GetCrackedStrainTuple()
+        public IForceTuple GetCrackedStrainTuple()
         {
             var strainTuple = ForceTupleService.InterpolateTuples(BeforeCrackingTuple, AfterCrackingTuple, SofteningFactor) as StrainTuple;
             return strainTuple;

StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculatorInputData.cs

@@ -1,20 +1,29 @@
 using LoaderCalculator.Data.Ndms;
 using StructureHelperCommon.Models.Calculators;
 using StructureHelperCommon.Models.Forces;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
+    /// <summary>
+    /// Implements input data for search of forces of crack appearance in some range of load
+    /// </summary>
     public interface ICrackForceCalculatorInputData: IInputData
     {
-        
+        /// <summary>
+        /// Start tuple of range for search of forces of crack appearance
+        /// </summary>
         IForceTuple StartTuple { get; set; }
+        /// <summary>
+        /// End tuple of range for search of forces of crack appearance
+        /// </summary>
         IForceTuple EndTuple { get; set; }
+        /// <summary>
+        /// Collection of NdmElements for checking of crack appearance
+        /// </summary>
         IEnumerable<INdm> CheckedNdmCollection { get; set; }
+        /// <summary>
+        /// Collection of initial NdmElements of cross-section 
+        /// </summary>
         IEnumerable<INdm> SectionNdmCollection { get; set; }
     }
 }

StructureHelperLogics/NdmCalculations/Cracking/ICrackForceResult.cs

@@ -0,0 +1,20 @@
+using LoaderCalculator.Data.Ndms;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking
+{
+    public interface ICrackForceResult : IResult
+    {
+        IForceTuple CrackedStrainTuple { get; set; }
+        IForceTuple EndTuple { get; set; }
+        double FactorOfCrackAppearance { get; set; }
+        bool IsSectionCracked { get; set; }
+        IEnumerable<INdm> NdmCollection { get; set; }
+        double PsiS { get; set; }
+        IForceTuple ReducedStrainTuple { get; set; }
+        IForceTuple SofteningFactors { get; set; }
+        IForceTuple StartTuple { get; set; }
+        IForceTuple TupleOfCrackAppearance { get; set; }
+    }
+}

StructureHelperLogics/NdmCalculations/Cracking/ICrackStrainLogic.cs

@@ -9,9 +9,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
     internal interface ICrackStrainLogic
     {
-        StrainTuple BeforeCrackingTuple { get; set; }
+        IForceTuple BeforeCrackingTuple { get; set; }
-        StrainTuple AfterCrackingTuple { get; set; }
+        IForceTuple AfterCrackingTuple { get; set; }
         double SofteningFactor { get; set; }
-        StrainTuple GetCrackedStrainTuple();
+        IForceTuple GetCrackedStrainTuple();
     }
 }

StructureHelperLogics/Services/NdmPrimitives/ITriangulatePrimitiveLogic.cs

@@ -5,11 +5,27 @@ using StructureHelperLogics.NdmCalculations.Primitives;
 
 namespace StructureHelperLogics.Services.NdmPrimitives
 {
+    /// <summary>
+    /// Implements logic of meshing of StructureHelper NdmPrimitives to collection of Loader Indem parts
+    /// </summary>
     public interface ITriangulatePrimitiveLogic : ILogic
     {
+        /// <summary>
+        /// Collection of primitives which have to be meshed
+        /// </summary>
         IEnumerable<INdmPrimitive> Primitives { get; set; }
+        /// <summary>
+        /// Limit state for meshing
+        /// </summary>
         LimitStates LimitState { get; set; }
+        /// <summary>
+        /// Term (duration) of calculating for meshing
+        /// </summary>
         CalcTerms CalcTerm { get; set; }
+        /// <summary>
+        /// Meshes collection of primitives
+        /// </summary>
+        /// <returns>List of Loader Ndm parts</returns>
         List<INdm> GetNdms();
     }
 }

StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs

@@ -1,16 +1,15 @@
 using LoaderCalculator.Data.Ndms;
 using StructureHelperCommon.Infrastructures.Enums;
-using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Loggers;
-using StructureHelperCommon.Models.Materials;
-using StructureHelperCommon.Models.Shapes;
-using StructureHelperLogics.Models.Materials;
 using StructureHelperLogics.NdmCalculations.Primitives;
 using StructureHelperLogics.NdmCalculations.Triangulations;
 
 namespace StructureHelperLogics.Services.NdmPrimitives
 {
+    /// <summary>
+    /// Direct meshing logic
+    /// </summary>
     public class TriangulatePrimitiveLogic : ITriangulatePrimitiveLogic
     {
         private IMeshHasDivisionLogic divisionLogic;