Add curvature calculator

2025-11-22 21:17:39 +05:00
parent 215f631bb0
commit 7ab4909c67
42 changed files with 705 additions and 108 deletions
--- a/StructureHelper/Infrastructure/Enums/CalculatorTypes.cs
+++ b/StructureHelper/Infrastructure/Enums/CalculatorTypes.cs
@@ -7,6 +7,7 @@
        CrackCalculator,
        FireCalculator,
        BeamShearCalculator,
-        ValueDiagram
+        ValueDiagramCalculator,
+        CurvatureCalcualtor
    }
 }
--- a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
+++ b/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>
--- a/StructureHelper/StructureHelper.csproj.user
+++ b/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>
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CalculatorViewModel.cs
+++ b/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;
+        }
+    }
+}
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs
+++ b/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,
-                NdmPrimitives,
-                unitLogic.GetUnit(UnitTypes.Force),
-                unitLogic.GetUnit(UnitTypes.Moment),
-                unitLogic.GetUnit(UnitTypes.Curvature));
+            CalculateWithCrack(ValidTupleList, NdmPrimitives);
        }

        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()
-                {
-                    Primitives = ndmPrimitives,
-                    LimitState = limitState,
-                    CalcTerm = calcTerm,
-                    TraceLogger = TraceLogger
-                };
+                GetTriangulationLogic(ndmPrimitives, limitState, calcTerm);
                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];
-                }
-
-                SetProgress?.Invoke(i);
-            }
+            triangulateLogic = new TriangulatePrimitiveLogic()
+            {
+                Primitives = ndmPrimitives,
+                LimitState = limitState,
+                CalcTerm = calcTerm,
+                TraceLogger = TraceLogger
+            };
        }

        private static List<string> GetCrackLabels()
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorInputDataViewModel.cs
+++ b/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());
+            }
+        }
+    }
+}
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml
+++ b/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>
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml.cs
+++ b/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;
+        }
+    }
+}
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorViewModel.cs
+++ b/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();
+        }
+    }
+}
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorInputDataViewModel.cs
+++ b/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;
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorView.xaml
+++ b/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"/>
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorViewModel.cs
+++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorViewModel.cs
@@ -8,30 +8,14 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr
    {
        private IValueDiagramCalculator valueDiagramCalculator;
        
-        public bool ShowTraceData
-        {
-            get => valueDiagramCalculator.ShowTraceData;
-            set
-            {
-                valueDiagramCalculator.ShowTraceData = value;
-                OnPropertyChanged(nameof(ShowTraceData));
-            }
-        }
-        public string Name
-        {
-            get => valueDiagramCalculator.Name;
-            set
-            {
-                valueDiagramCalculator.Name = value;
-                OnPropertyChanged(nameof(Name));
-            }
-        }
+        public CalculatorViewModel CalculatorViewModel { get; private set; }
        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()
--- a/StructureHelper/Windows/MainWindow/CrossSections/AnalysisViewModelLogic.cs
+++ b/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)
-            {
-                EditValueDiagramCalculator(valueDiagramCalculator);
+            else if (SelectedItem is ValueDiagramCalculator valueDiagramCalculator) {EditValueDiagramCalculator(valueDiagramCalculator);}
+            else if (SelectedItem is CurvatureCalculator curvatureCalculator) {EditCurvatureCalculator(curvatureCalculator);}
+            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)
--- a/StructureHelper/Windows/MainWindow/CrossSections/CrossSectionView.xaml
+++ b/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>
--- a/StructureHelperCommon/Infrastructures/Exceptions/StructureHelperNullReferenceException.cs
+++ b/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)
+        {
+        }
+    }
+}
--- a/StructureHelperCommon/Services/Forces/TupleConverter.cs
+++ b/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 };
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs
+++ b/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()
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs
+++ b/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();
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorInputData.cs
+++ b/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;
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalcualtor.cs
+++ b/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();
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalcualtorLogic.cs
+++ b/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();
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculator.cs
+++ b/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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorInputData.cs
+++ b/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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorResult.cs
+++ b/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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalcualtor.cs
+++ b/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
+    {
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorInputData.cs
+++ b/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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs
+++ b/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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtor.cs
+++ b/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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorInputData.cs
+++ b/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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorResult.cs
+++ b/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; }
+
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs
+++ b/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);
+            }
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorUpdateStrategy.cs
+++ b/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);
+            }
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/Logics/CalculatorUpdateStrategy.cs
+++ b/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());
            }
        }
    }
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs
+++ b/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;
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs
+++ b/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;
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceResult.cs
+++ b/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>
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackStrainLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackStrainLogic.cs
@@ -10,11 +10,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
    internal class CrackStrainLogic : ICrackStrainLogic
    {
-        public StrainTuple BeforeCrackingTuple { get; set; }
-        public StrainTuple AfterCrackingTuple { get; set; }
+        public IForceTuple BeforeCrackingTuple { 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;
--- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculatorInputData.cs
+++ b/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; }
    }
 }
--- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackForceResult.cs
+++ b/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; }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackStrainLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackStrainLogic.cs
@@ -9,9 +9,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
    internal interface ICrackStrainLogic
    {
-        StrainTuple BeforeCrackingTuple { get; set; }
-        StrainTuple AfterCrackingTuple { get; set; }
+        IForceTuple BeforeCrackingTuple { get; set; }
+        IForceTuple AfterCrackingTuple { get; set; }
        double SofteningFactor { get; set; }
-        StrainTuple GetCrackedStrainTuple();
+        IForceTuple GetCrackedStrainTuple();
    }
 }
--- a/StructureHelperLogics/Services/NdmPrimitives/ITriangulatePrimitiveLogic.cs
+++ b/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();
    }
 }
--- a/StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs
+++ b/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;