From c1b9f80a96ea16028172235eb6fe4d12341679fb Mon Sep 17 00:00:00 2001
From: RedikultsevEvg <effect-project@yandex.ru>
Date: Tue, 20 Aug 2024 20:38:01 +0500
Subject: [PATCH] Analisys manager window was added

---
 .../UI/Resources/ButtonStyles.xaml            | 109 ++++++++++++++++++
 .../PublishProfiles/FolderProfile.pubxml.user |   2 +-
 StructureHelper/StructureHelper.csproj.user   |   8 +-
 .../CrackCalculatorInputDataViewModel.cs      |   2 +-
 .../Windows/MainWindow/AnalisesLogic.cs       |  13 +++
 .../MainWindow/AnalisesManagerView.xaml       | 103 +++++++++++++++++
 .../MainWindow/AnalisesManagerView.xaml.cs    |  27 +++++
 .../MainWindow/AnalisesManagerViewModel.cs    |  23 ++++
 .../Windows/MainWindow/DiagramLogic.cs        |  13 +++
 .../Windows/MainWindow/FileLogic.cs           |  19 +++
 .../AnalysisViewModelLogic.cs                 |   3 +-
 .../Logics/FactorCombinationUpdateStrategy.cs |  12 +-
 StructureHelperCommon/Services/CheckObject.cs |   7 +-
 .../Models/Materials/ConcreteLibMaterial.cs   |   2 +-
 .../Materials/FRMaterials/FRMaterial.cs       |   4 +-
 .../Models/Materials/ILibMaterial.cs          |   2 +-
 .../Models/Materials/LibMaterial.cs           |   2 +-
 .../Logics/ConcreteLibUpdateStrategy.cs       |  14 ++-
 .../Materials/Logics/ElasticMaterialLogic.cs  |   6 +-
 .../Materials/Logics/ElasticUpdateStrategy.cs |   2 +
 .../Materials/Logics/FRUpdateStrategy.cs      |   8 +-
 .../Logics/LibMaterialUpdateStrategy.cs       |  16 ++-
 .../Logics/MaterialUpdateStrategy.cs          |  33 ++++--
 .../Logics/ReinforcementLibUpdateStrategy.cs  |  14 ++-
 .../Materials/ReinforcementLibMaterial.cs     |   2 +-
 .../CrossSections/CalculatorLogic.cs          |   6 +-
 .../CheckCrackCalculatorInputDataLogic.cs     |   4 +-
 .../Cracking/CrackCalculator.cs               |  30 +++--
 .../Cracking/CrackCalculatorInputData.cs      |   6 +-
 .../Cracking/CrackCalculatorUpdateStrategy.cs |  12 +-
 .../Cracking/CrackInputDataUpdateStrategy.cs  |   6 +-
 .../Cracking/CrackWidthCalculationLogic.cs    |  31 ++---
 .../Cracking/CrackWidthRebarTupleResult.cs    |   2 +-
 .../Cracking/GetTupleInputDatasLogic.cs       |   4 +-
 .../Cracking/ICrackCalculator.cs              |   9 ++
 .../Cracking/ICrackCalculatorInputData.cs     |  14 +++
 .../Cracking/ICrackWidthCalculationLogic.cs   |   3 -
 .../Cracking/IGetTupleInputDatasLogic.cs      |   2 +-
 .../Cracking/IRebarStressResult.cs            |  25 ++++
 .../Cracking/IRebarStressResultLogic.cs       |  13 +++
 .../Cracking/RebarStressResult.cs             |  20 +---
 .../Cracking/RebarStressResultLogic.cs        |  53 +++++++++
 .../Cracking/TupleCrackInputData.cs           |   2 +-
 .../Cracks/CrackWidthCalculationLogicTests.cs |  93 +--------------
 .../CheckCrackWidthSP63InputDataLogicTests.cs |  88 +-------------
 .../Cracks/RebarStressResultLogicTests.cs     |  80 +++++++++++++
 .../ConcreteLibUpdateStrategyTests.cs         |  77 +++++++++++++
 .../CrackCalculatorUpdateStrategyTests.cs     | 104 +++++++++++++++++
 .../CrackInputDataUpdateStrategyTests.cs      |  89 ++++++++++++++
 .../LibMaterialUpdateStrategyTests.cs         |  98 ++++++++++++++++
 50 files changed, 1036 insertions(+), 281 deletions(-)
 create mode 100644 StructureHelper/Windows/MainWindow/AnalisesLogic.cs
 create mode 100644 StructureHelper/Windows/MainWindow/AnalisesManagerView.xaml
 create mode 100644 StructureHelper/Windows/MainWindow/AnalisesManagerView.xaml.cs
 create mode 100644 StructureHelper/Windows/MainWindow/AnalisesManagerViewModel.cs
 create mode 100644 StructureHelper/Windows/MainWindow/DiagramLogic.cs
 create mode 100644 StructureHelper/Windows/MainWindow/FileLogic.cs
 create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculator.cs
 create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs
 create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResult.cs
 create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs
 create mode 100644 StructureHelperLogics/NdmCalculations/Cracking/RebarStressResultLogic.cs
 create mode 100644 StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs
 create mode 100644 StructureHelperTests/UnitTests/UpdateStrategiesTests/ConcreteLibUpdateStrategyTests.cs
 create mode 100644 StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackCalculatorUpdateStrategyTests.cs
 create mode 100644 StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackInputDataUpdateStrategyTests.cs
 create mode 100644 StructureHelperTests/UnitTests/UpdateStrategiesTests/LibMaterialUpdateStrategyTests.cs

diff --git a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml b/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
index 7e48c6e..4887639 100644
--- a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
+++ b/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
@@ -85,6 +85,11 @@
         <Setter Property="BorderBrush" Value="Black"/>
     </Style>
 
+    <Style x:Key="ToolButton24" TargetType="Button" BasedOn="{StaticResource ToolButton}">
+        <Setter Property="Height" Value="24"/>
+        <Setter Property="Width" Value="24"/>
+    </Style>
+
     <Style x:Key="ButtonImage16" TargetType="Image">
         <Setter Property="Height" Value="16"/>
         <Setter Property="Width" Value="16"/>
@@ -218,4 +223,108 @@
         </Canvas>
     </DataTemplate>
 
+    <DataTemplate x:Key="FileOpen">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Path Margin="4" Data="M 2 6 l 8 0 l 3 3 l 6 0 l 0 12 l -17 0 z" Fill="DarkGray" Stroke="Black" StrokeThickness="1"/>
+                <Path Margin="4" Data="M 6 12 l 20 0 l -5 10 l -19 0 z" Fill="LightGray" Stroke="Black" StrokeThickness="1"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
+    <DataTemplate x:Key="FileSave">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Rectangle Height="26" Width="26" Canvas.Left="3" Canvas.Top="3"
+                            Fill="DarkGray" Stroke="Black" StrokeThickness="1"
+                            RadiusX="2" RadiusY="2"/>
+                <Rectangle Height="8" Width="12" Canvas.Left="10" Canvas.Top="4"
+                            Fill="LightGray" Stroke="Black" StrokeThickness="0.5"/>
+                <Rectangle Height="6" Width="4" Canvas.Left="16" Canvas.Top="5"
+                            Fill="DarkGray" Stroke="Black" StrokeThickness="0.5"/>
+                <Rectangle Height="14" Width="22" Canvas.Left="5" Canvas.Top="13"
+                            Fill="LightGray" Stroke="Black" StrokeThickness="0.5"
+                            RadiusX="2" RadiusY="2"/>
+                <Line X1="7" Y1="18" X2="24" Y2="18" Stroke="Black" StrokeThickness="0.5"/>
+                <Line X1="7" Y1="21" X2="24" Y2="21" Stroke="Black" StrokeThickness="0.5"/>
+                <Line X1="7" Y1="24" X2="24" Y2="24" Stroke="Black" StrokeThickness="0.5"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
+    <DataTemplate x:Key="Diagrams">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Line X1="2" Y1="16" X2="30" Y2="16" Stroke="Black" StrokeThickness="0.5"/>
+                <Line X1="16" Y1="2" X2="16" Y2="30" Stroke="Black" StrokeThickness="0.5"/>
+                <Path Margin="2" Data="M 0 21 l 6 0 l 9 -8 l 9 -8 l 4 0" Stroke="Black" StrokeThickness="1"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
+    <DataTemplate x:Key="NdmCrossSection">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Rectangle Height="16" Width="8" Canvas.Left="12" Canvas.Top="12"
+                            Fill="DarkGray" Stroke="Black" StrokeThickness="1"/> 
+                <Rectangle Height="6" Width="16" Canvas.Left="8" Canvas.Top="7"
+                            Fill="LightGray" Stroke="Black" StrokeThickness="1"/>
+                <Line X1="2" Y1="16" X2="30" Y2="16" Stroke="Black" StrokeThickness="0.5"/>
+                <Line X1="16" Y1="2" X2="16" Y2="30" Stroke="Black" StrokeThickness="0.5"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
+    <DataTemplate x:Key="SelectAll">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <CheckBox Canvas.Left="13" Canvas.Top="13" IsChecked="True"/>
+                <CheckBox Canvas.Left="2" Canvas.Top="2" IsChecked="True"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
+    <DataTemplate x:Key="DeSelectAll">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <CheckBox Canvas.Left="13" Canvas.Top="13" IsChecked="False"/>
+                <CheckBox Canvas.Left="2" Canvas.Top="2" IsChecked="False"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+    
+    <DataTemplate x:Key="InvertSelection">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <CheckBox Canvas.Left="13" Canvas.Top="13" IsChecked="True"/>
+                <CheckBox Canvas.Left="2" Canvas.Top="2" IsChecked="False"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
+    <DataTemplate x:Key="RunAnalisis">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Path Margin="4" Data="M 4 2 l 12 10 l -12 10 z" Fill="DarkGray" Stroke="Black" StrokeThickness="1"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
+    <DataTemplate x:Key="EditAnalisis">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Path Margin="4" Data="M 2 22 l 4 -6 l 15 -16 l 4 4 l -15 14 z" Fill="DarkGray" Stroke="Black" StrokeThickness="1"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
+    <DataTemplate x:Key="DeleteAnalisis">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Line X1="4" Y1="4" X2="26" Y2="26" Stroke="Black" StrokeThickness="2"/>
+                <Line X1="4" Y1="26" X2="26" Y2="4" Stroke="Black" StrokeThickness="2"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+
 </ResourceDictionary>
\ No newline at end of file
diff --git a/StructureHelper/Properties/PublishProfiles/FolderProfile.pubxml.user b/StructureHelper/Properties/PublishProfiles/FolderProfile.pubxml.user
index 7b83bfc..e0e8fee 100644
--- a/StructureHelper/Properties/PublishProfiles/FolderProfile.pubxml.user
+++ b/StructureHelper/Properties/PublishProfiles/FolderProfile.pubxml.user
@@ -4,7 +4,7 @@ https://go.microsoft.com/fwlink/?LinkID=208121.
 -->
 <Project>
   <PropertyGroup>
-    <History>True|2024-03-11T15:33:14.1457807Z;True|2024-03-10T19:11:27.6834663+05:00;True|2024-02-02T12:22:50.1454015+05:00;True|2023-02-25T13:37:39.2738786+05:00;False|2023-02-25T13:37:24.0284261+05:00;True|2023-02-25T13:34:01.6858860+05:00;True|2023-02-25T13:31:18.8295711+05:00;False|2023-02-25T13:25:21.5807199+05:00;False|2023-02-25T13:24:41.7164398+05:00;</History>
+    <History>True|2024-08-13T09:00:35.8311260Z||;True|2024-08-12T12:59:16.1785759+05:00||;True|2024-03-11T20:33:14.1457807+05:00||;True|2024-03-10T19:11:27.6834663+05:00||;True|2024-02-02T12:22:50.1454015+05:00||;True|2023-02-25T13:37:39.2738786+05:00||;False|2023-02-25T13:37:24.0284261+05:00||;True|2023-02-25T13:34:01.6858860+05:00||;True|2023-02-25T13:31:18.8295711+05:00||;False|2023-02-25T13:25:21.5807199+05:00||;False|2023-02-25T13:24:41.7164398+05:00||;</History>
     <LastFailureDetails />
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/StructureHelper/StructureHelper.csproj.user b/StructureHelper/StructureHelper.csproj.user
index c2ddce4..3cd5c70 100644
--- a/StructureHelper/StructureHelper.csproj.user
+++ b/StructureHelper/StructureHelper.csproj.user
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <_LastSelectedProfileId>C:\Source\Repos\StructureHelper\StructureHelper\Properties\PublishProfiles\FolderProfile.pubxml</_LastSelectedProfileId>
+    <_LastSelectedProfileId>C:\Repos\StructureHelper\StructureHelper\Properties\PublishProfiles\FolderProfile.pubxml</_LastSelectedProfileId>
   </PropertyGroup>
   <ItemGroup>
     <ApplicationDefinition Update="App.xaml">
@@ -60,6 +60,9 @@
     <Compile Update="Windows\MainWindow\AboutView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Update="Windows\MainWindow\AnalisesManagerView.xaml.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Update="Windows\MainWindow\Materials\HeadMaterialView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
@@ -152,6 +155,9 @@
     <Page Update="Windows\MainWindow\AboutView.xaml">
       <SubType>Designer</SubType>
     </Page>
+    <Page Update="Windows\MainWindow\AnalisesManagerView.xaml">
+      <SubType>Designer</SubType>
+    </Page>
     <Page Update="Windows\MainWindow\Materials\HeadMaterialView.xaml">
       <SubType>Designer</SubType>
     </Page>
diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs
index 1d6b331..e8c9e6b 100644
--- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs
+++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs
@@ -15,7 +15,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
     public class CrackCalculatorInputDataViewModel : OkCancelViewModelBase
     {
         private CrackCalculator calculator;
-        CrackCalculatorInputData crackInputData;
+        ICrackCalculatorInputData crackInputData;
         private bool setUserValueSofteningFactor;
         private double softeningFactor;
         private string name;
diff --git a/StructureHelper/Windows/MainWindow/AnalisesLogic.cs b/StructureHelper/Windows/MainWindow/AnalisesLogic.cs
new file mode 100644
index 0000000..4e51153
--- /dev/null
+++ b/StructureHelper/Windows/MainWindow/AnalisesLogic.cs
@@ -0,0 +1,13 @@
+using StructureHelper.Infrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelper.Windows.MainWindow
+{
+    public class AnalisesLogic : ViewModelBase
+    {
+    }
+}
diff --git a/StructureHelper/Windows/MainWindow/AnalisesManagerView.xaml b/StructureHelper/Windows/MainWindow/AnalisesManagerView.xaml
new file mode 100644
index 0000000..6e9bd6b
--- /dev/null
+++ b/StructureHelper/Windows/MainWindow/AnalisesManagerView.xaml
@@ -0,0 +1,103 @@
+<Window x:Class="StructureHelper.Windows.MainWindow.AnalisesManagerView"
+        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.MainWindow"
+        mc:Ignorable="d"
+        d:DataContext="{d:DesignInstance local:AnalisesManagerViewModel}"
+        Title="Analises Manager" Height="450" Width="800" MinHeight="400" MinWidth="600">
+    <Grid>
+        <DockPanel>
+            <ToolBarTray DockPanel.Dock="Top">
+                <ToolBar DataContext="{Binding FileLogic}" ToolTip="File">
+                    <Button Style="{StaticResource ToolButton}" 
+                        Command="{Binding Add}" ToolTip="Open file">
+                        <Viewbox>
+                            <ContentControl ContentTemplate="{DynamicResource FileOpen}"/>
+                        </Viewbox>
+                    </Button>
+                    <Button Style="{StaticResource ToolButton}" 
+                        Command="{Binding Add}" ToolTip="Save file">
+                        <Viewbox>
+                            <ContentControl ContentTemplate="{DynamicResource FileSave}"/>
+                        </Viewbox>
+                    </Button>
+                </ToolBar>
+                <ToolBar ToolTip="Diagrams">
+                    <Button Style="{StaticResource ToolButton}" Command="{Binding Add}" ToolTip="Diagrams">
+                        <Viewbox>
+                            <ContentControl ContentTemplate="{DynamicResource Diagrams}"/>
+                        </Viewbox>
+                    </Button>
+                </ToolBar>
+                <ToolBar ToolTip="Cross-sections">
+                    <Button Style="{DynamicResource ToolButton}" Command="{Binding Add}" ToolTip="NDM Analisis">
+                        <Viewbox>
+                            <ContentControl ContentTemplate="{DynamicResource NdmCrossSection}"/>
+                        </Viewbox>
+                    </Button>
+                </ToolBar>
+            </ToolBarTray>
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="auto"/>
+                    <ColumnDefinition Width="*"/>
+                </Grid.ColumnDefinitions>
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="30"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+                    <ToolBar HorizontalAlignment="Right">
+                        <Button Style="{StaticResource ToolButton24}" Command="{Binding Add}" ToolTip="Select all">
+                            <Viewbox Width="24" Height="24">
+                                <ContentControl ContentTemplate="{DynamicResource SelectAll}"/>
+                            </Viewbox>
+                        </Button>
+                        <Button Style="{StaticResource ToolButton24}" Command="{Binding Add}" ToolTip="DeSelect all">
+                            <Viewbox Width="24" Height="24">
+                                <ContentControl ContentTemplate="{DynamicResource DeSelectAll}"/>
+                            </Viewbox>
+                        </Button>
+                        <Button Style="{StaticResource ToolButton24}" Command="{Binding Add}" ToolTip="Inver Selection">
+                            <Viewbox Width="24" Height="24">
+                                <ContentControl ContentTemplate="{DynamicResource InvertSelection}"/>
+                            </Viewbox>
+                        </Button>
+                    </ToolBar>
+                    <ListBox Grid.Row="1" MinWidth="200">
+
+                    </ListBox>
+                </Grid>
+                <Grid Grid.Column="1">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="30"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+                    <ToolBar HorizontalAlignment="Right">
+                        <Button Style="{StaticResource ToolButton24}" Command="{Binding Add}" ToolTip="Select all">
+                            <Viewbox Width="24" Height="24">
+                                <ContentControl ContentTemplate="{DynamicResource RunAnalisis}"/>
+                            </Viewbox>
+                        </Button>
+                        <Button Style="{StaticResource ToolButton24}" Command="{Binding Add}" ToolTip="Select all">
+                            <Viewbox Width="24" Height="24">
+                                <ContentControl ContentTemplate="{DynamicResource EditAnalisis}"/>
+                            </Viewbox>
+                        </Button>
+                        <Button Style="{StaticResource ToolButton24}" Command="{Binding Add}" ToolTip="Select all">
+                            <Viewbox Width="24" Height="24">
+                                <ContentControl ContentTemplate="{DynamicResource DeleteAnalisis}"/>
+                            </Viewbox>
+                        </Button>
+                    </ToolBar>
+                    <ListBox Grid.Row="1">
+
+                    </ListBox>
+                </Grid>
+
+            </Grid>
+        </DockPanel>
+    </Grid>
+</Window>
diff --git a/StructureHelper/Windows/MainWindow/AnalisesManagerView.xaml.cs b/StructureHelper/Windows/MainWindow/AnalisesManagerView.xaml.cs
new file mode 100644
index 0000000..81cfe06
--- /dev/null
+++ b/StructureHelper/Windows/MainWindow/AnalisesManagerView.xaml.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+
+namespace StructureHelper.Windows.MainWindow
+{
+    /// <summary>
+    /// Логика взаимодействия для AnalisesManagerView.xaml
+    /// </summary>
+    public partial class AnalisesManagerView : Window
+    {
+        public AnalisesManagerView()
+        {
+            InitializeComponent();
+        }
+    }
+}
diff --git a/StructureHelper/Windows/MainWindow/AnalisesManagerViewModel.cs b/StructureHelper/Windows/MainWindow/AnalisesManagerViewModel.cs
new file mode 100644
index 0000000..7fe72f8
--- /dev/null
+++ b/StructureHelper/Windows/MainWindow/AnalisesManagerViewModel.cs
@@ -0,0 +1,23 @@
+using StructureHelper.Infrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelper.Windows.MainWindow
+{
+    public class AnalisesManagerViewModel : ViewModelBase
+    {
+        public FileLogic FileLogic { get; }
+        public DiagramLogic DiagramLogic { get; }
+        public AnalisesLogic AnalisesLogic { get; }
+
+        public AnalisesManagerViewModel()
+        {
+            FileLogic = new();
+            DiagramLogic = new();
+            AnalisesLogic = new();
+        }
+    }
+}
diff --git a/StructureHelper/Windows/MainWindow/DiagramLogic.cs b/StructureHelper/Windows/MainWindow/DiagramLogic.cs
new file mode 100644
index 0000000..7c9e26d
--- /dev/null
+++ b/StructureHelper/Windows/MainWindow/DiagramLogic.cs
@@ -0,0 +1,13 @@
+using StructureHelper.Infrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelper.Windows.MainWindow
+{
+    public class DiagramLogic : ViewModelBase
+    {
+    }
+}
diff --git a/StructureHelper/Windows/MainWindow/FileLogic.cs b/StructureHelper/Windows/MainWindow/FileLogic.cs
new file mode 100644
index 0000000..3160a30
--- /dev/null
+++ b/StructureHelper/Windows/MainWindow/FileLogic.cs
@@ -0,0 +1,19 @@
+using StructureHelper.Infrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace StructureHelper.Windows.MainWindow
+{
+    public class FileLogic : ViewModelBase
+    {
+        private ICommand fileOpen;
+        private ICommand fileSave;
+
+        public ICommand FileOpen => fileOpen;
+        public ICommand FileSave => fileSave;
+    }
+}
diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs
index bce1479..ad52840 100644
--- a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs
+++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs
@@ -60,11 +60,12 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections
         private void AddCrackCalculator()
         {
             var inputData = new CrackCalculatorInputData();
-            var calculator = new CrackCalculator(inputData)
+            var calculator = new CrackCalculator()
             {
                 Name = "New crack calculator",
                 TraceLogger = new ShiftTraceLogger(),
             };
+            calculator.InputData = inputData;
             NewItem = calculator;
         }
 
diff --git a/StructureHelperCommon/Models/Forces/Logics/FactorCombinationUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/FactorCombinationUpdateStrategy.cs
index b09672c..6e17a50 100644
--- a/StructureHelperCommon/Models/Forces/Logics/FactorCombinationUpdateStrategy.cs
+++ b/StructureHelperCommon/Models/Forces/Logics/FactorCombinationUpdateStrategy.cs
@@ -10,11 +10,19 @@ namespace StructureHelperCommon.Models.Forces
 {
     public class FactorCombinationUpdateStrategy : IUpdateStrategy<IForceCombinationByFactor>
     {
-        readonly IUpdateStrategy<IForceTuple> tupleUpdateStrategy = new ForceTupleUpdateStrategy();
+        private IUpdateStrategy<IForceTuple> tupleUpdateStrategy;
+        public FactorCombinationUpdateStrategy(IUpdateStrategy<IForceTuple> tupleUpdateStrategy)
+        {
+            this.tupleUpdateStrategy = tupleUpdateStrategy;
+        }
+        public FactorCombinationUpdateStrategy() : this(new ForceTupleUpdateStrategy())
+        {
+            
+        }
         public void Update(IForceCombinationByFactor targetObject, IForceCombinationByFactor sourceObject)
         {
-            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             tupleUpdateStrategy.Update(targetObject.FullSLSForces, sourceObject.FullSLSForces);
             targetObject.ULSFactor = sourceObject.ULSFactor;
             targetObject.LongTermFactor = sourceObject.LongTermFactor;
diff --git a/StructureHelperCommon/Services/CheckObject.cs b/StructureHelperCommon/Services/CheckObject.cs
index c81a017..d012741 100644
--- a/StructureHelperCommon/Services/CheckObject.cs
+++ b/StructureHelperCommon/Services/CheckObject.cs
@@ -25,7 +25,7 @@ namespace StructureHelperCommon.Services
         public static void CompareTypes(object targetObject, object sourceObject)
         {
             IsNull(targetObject, "target object");
-            IsNull(targetObject, "source object");
+            IsNull(sourceObject, "source object");
             if (targetObject.GetType() != sourceObject.GetType())
             {
                 throw new StructureHelperException
@@ -34,7 +34,10 @@ namespace StructureHelperCommon.Services
         }
         public static void IsNull(object item, string message = "")
         {
-            if (item is null) { throw new StructureHelperException(ErrorStrings.ParameterIsNull + message); }
+            if (item is null)
+            {
+                throw new StructureHelperException(ErrorStrings.ParameterIsNull + ": "+ message);
+            }
         }
 
         public static void CheckType(object sourceObject, Type targetType)
diff --git a/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs b/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs
index c10926e..c15e1bd 100644
--- a/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs
+++ b/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs
@@ -21,7 +21,7 @@ namespace StructureHelperLogics.Models.Materials
         /// <inheritdoc/>
         public ILibMaterialEntity MaterialEntity { get; set; }
         /// <inheritdoc/>
-        public List<IMaterialSafetyFactor> SafetyFactors { get; }
+        public List<IMaterialSafetyFactor> SafetyFactors { get; set; }
         /// <inheritdoc/>
         public bool TensionForULS { get ; set; }
         /// <inheritdoc/>
diff --git a/StructureHelperLogics/Models/Materials/FRMaterials/FRMaterial.cs b/StructureHelperLogics/Models/Materials/FRMaterials/FRMaterial.cs
index 1a5d6b3..5ccbeb0 100644
--- a/StructureHelperLogics/Models/Materials/FRMaterials/FRMaterial.cs
+++ b/StructureHelperLogics/Models/Materials/FRMaterials/FRMaterial.cs
@@ -1,5 +1,6 @@
 using LoaderCalculator.Data.Materials;
 using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Infrastructures.Settings;
 using StructureHelperCommon.Models.Materials.Libraries;
 using System;
@@ -14,6 +15,7 @@ namespace StructureHelperLogics.Models.Materials
     {
         private IElasticMaterialLogic elasticMaterialLogic => new ElasticMaterialLogic();
         private MaterialTypes materialType;
+        IUpdateStrategy<IFRMaterial> fRUpdateStrategy = new FRUpdateStrategy();
         public double Modulus{ get; set; }
         public double CompressiveStrength { get; set; }
         public double TensileStrength { get; set; }
@@ -49,7 +51,7 @@ namespace StructureHelperLogics.Models.Materials
         public object Clone()
         {
             var newItem = new FRMaterial(this.materialType);
-            var updateStrategy = new FRUpdateStrategy();
+            var updateStrategy = fRUpdateStrategy;
             updateStrategy.Update(newItem, this);
             return newItem;
         }
diff --git a/StructureHelperLogics/Models/Materials/ILibMaterial.cs b/StructureHelperLogics/Models/Materials/ILibMaterial.cs
index 91ed43b..2674963 100644
--- a/StructureHelperLogics/Models/Materials/ILibMaterial.cs
+++ b/StructureHelperLogics/Models/Materials/ILibMaterial.cs
@@ -11,7 +11,7 @@ namespace StructureHelperLogics.Models.Materials
     public interface ILibMaterial : IHelperMaterial
     {
         ILibMaterialEntity MaterialEntity { get; set; }
-        List<IMaterialSafetyFactor> SafetyFactors { get; }
+        List<IMaterialSafetyFactor> SafetyFactors { get; set; }
         IMaterialLogic MaterialLogic { get; set; }
         List<IMaterialLogic> MaterialLogics { get; }
         (double Compressive, double Tensile) GetStrength(LimitStates limitState, CalcTerms calcTerm);
diff --git a/StructureHelperLogics/Models/Materials/LibMaterial.cs b/StructureHelperLogics/Models/Materials/LibMaterial.cs
index 656bcd8..8c42218 100644
--- a/StructureHelperLogics/Models/Materials/LibMaterial.cs
+++ b/StructureHelperLogics/Models/Materials/LibMaterial.cs
@@ -23,7 +23,7 @@ namespace StructureHelperLogics.Models.Materials
 
         public ILibMaterialEntity MaterialEntity { get; set; }
 
-        public List<IMaterialSafetyFactor> SafetyFactors { get; }
+        public List<IMaterialSafetyFactor> SafetyFactors { get; set; }
         public IMaterialLogic MaterialLogic { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
         public List<IMaterialLogic> MaterialLogics => throw new NotImplementedException();
diff --git a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs
index 343a940..d7baf4d 100644
--- a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs
@@ -1,4 +1,5 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -7,11 +8,20 @@ using System.Threading.Tasks;
 
 namespace StructureHelperLogics.Models.Materials
 {
-    internal class ConcreteLibUpdateStrategy : IUpdateStrategy<IConcreteLibMaterial>
+    public class ConcreteLibUpdateStrategy : IUpdateStrategy<IConcreteLibMaterial>
     {
-        LibMaterialUpdateStrategy libUpdateStrategy = new LibMaterialUpdateStrategy();
+        private IUpdateStrategy<ILibMaterial> libUpdateStrategy;
+        public ConcreteLibUpdateStrategy(IUpdateStrategy<ILibMaterial> libUpdateStrategy)
+        {
+            this.libUpdateStrategy = libUpdateStrategy;
+        }
+        public ConcreteLibUpdateStrategy() : this(new LibMaterialUpdateStrategy())
+        {
+            
+        }
         public void Update(IConcreteLibMaterial targetObject, IConcreteLibMaterial sourceObject)
         {
+            CheckObject.CompareTypes(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             libUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.TensionForULS = sourceObject.TensionForULS;
diff --git a/StructureHelperLogics/Models/Materials/Logics/ElasticMaterialLogic.cs b/StructureHelperLogics/Models/Materials/Logics/ElasticMaterialLogic.cs
index 77733d5..4fb2943 100644
--- a/StructureHelperLogics/Models/Materials/Logics/ElasticMaterialLogic.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/ElasticMaterialLogic.cs
@@ -12,13 +12,15 @@ namespace StructureHelperLogics.Models.Materials
 {
     internal class ElasticMaterialLogic : IElasticMaterialLogic
     {
+        private List<double> parameters;
+
         public IMaterial GetLoaderMaterial(IElasticMaterial elasticMaterial, LimitStates limitState, CalcTerms calcTerm, double factor = 1d)
         { 
             IMaterial material = new Material();
             material.InitModulus = elasticMaterial.Modulus;
             IFactorLogic factorLogic = new FactorLogic(elasticMaterial.SafetyFactors);
             var factors = factorLogic.GetTotalFactor(limitState, calcTerm);
-            IEnumerable<double> parameters = new List<double>()
+            parameters = new List<double>()
             {
                 elasticMaterial.Modulus,
                 elasticMaterial.CompressiveStrength * factors.Compressive * factor,
@@ -29,7 +31,7 @@ namespace StructureHelperLogics.Models.Materials
         return material;
         }
 
-    private double GetStressByStrain(IEnumerable<double> parameters, double strain)
+    private double GetStressByStrain(IEnumerable<double> parameters1, double strain)
     {
         double modulus = parameters.First();
         double stress = modulus * strain;
diff --git a/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs
index 2fd9148..8dfda6d 100644
--- a/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs
@@ -1,4 +1,5 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12,6 +13,7 @@ namespace StructureHelperLogics.Models.Materials
     {
         public void Update(IElasticMaterial targetObject, IElasticMaterial sourceObject)
         {
+            CheckObject.CompareTypes(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Modulus = sourceObject.Modulus;
             targetObject.CompressiveStrength = sourceObject.CompressiveStrength;
diff --git a/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs
index 8a7a9e0..df4bccf 100644
--- a/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs
@@ -1,4 +1,5 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12,12 +13,13 @@ namespace StructureHelperLogics.Models.Materials
     {
         public void Update(IFRMaterial targetObject, IFRMaterial sourceObject)
         {
+            CheckObject.ReferenceEquals(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Modulus = sourceObject.Modulus;
             targetObject.CompressiveStrength = sourceObject.CompressiveStrength;
-            targetObject.TensileStrength = targetObject.TensileStrength;
-            targetObject.ULSConcreteStrength = targetObject.ULSConcreteStrength;
-            targetObject.SumThickness = targetObject.SumThickness;
+            targetObject.TensileStrength = sourceObject.TensileStrength;
+            targetObject.ULSConcreteStrength = sourceObject.ULSConcreteStrength;
+            targetObject.SumThickness = sourceObject.SumThickness;
         }
     }
 }
diff --git a/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs
index 5fe96f9..b4281e1 100644
--- a/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs
@@ -1,5 +1,6 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models.Materials.Libraries;
+using StructureHelperCommon.Services;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -8,18 +9,23 @@ using System.Threading.Tasks;
 
 namespace StructureHelperLogics.Models.Materials
 {
-    internal class LibMaterialUpdateStrategy : IUpdateStrategy<ILibMaterial>
+    public class LibMaterialUpdateStrategy : IUpdateStrategy<ILibMaterial>
     {
         public void Update(ILibMaterial targetObject, ILibMaterial sourceObject)
         {
+            CheckObject.CompareTypes(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.MaterialEntity = sourceObject.MaterialEntity;
-            targetObject.SafetyFactors.Clear();
-            targetObject.MaterialLogic = sourceObject.MaterialLogic;
-            foreach (var item in sourceObject.SafetyFactors)
+            if (targetObject.SafetyFactors is not null & sourceObject.SafetyFactors is not null)
             {
-                targetObject.SafetyFactors.Add(item.Clone() as IMaterialSafetyFactor);
+                targetObject.SafetyFactors.Clear();
+                foreach (var item in sourceObject.SafetyFactors)
+                {
+                    targetObject.SafetyFactors.Add(item.Clone() as IMaterialSafetyFactor);
+                }
             }
+            targetObject.MaterialLogic = sourceObject.MaterialLogic;
+
         }
     }
 }
diff --git a/StructureHelperLogics/Models/Materials/Logics/MaterialUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/MaterialUpdateStrategy.cs
index 88a603f..360ef8e 100644
--- a/StructureHelperLogics/Models/Materials/Logics/MaterialUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/MaterialUpdateStrategy.cs
@@ -1,24 +1,37 @@
 using StructureHelper.Models.Materials;
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Infrastructures.Interfaces;
-using StructureHelperCommon.Models.Forces;
 using StructureHelperCommon.Services;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace StructureHelperLogics.Models.Materials
 {
     public class MaterialUpdateStrategy : IUpdateStrategy<IHeadMaterial>
     {
-        private readonly IUpdateStrategy<IElasticMaterial> elasticStrategy = new ElasticUpdateStrategy();
-        private readonly IUpdateStrategy<IFRMaterial> frStrategy = new FRUpdateStrategy();
-        private readonly IUpdateStrategy<IConcreteLibMaterial> concreteStrategy = new ConcreteLibUpdateStrategy();
-        private readonly IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy = new ReinforcementLibUpdateStrategy();
+        private IUpdateStrategy<IElasticMaterial> elasticStrategy;
+        private IUpdateStrategy<IFRMaterial> frStrategy;
+        private IUpdateStrategy<IConcreteLibMaterial> concreteStrategy;
+        private IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy;
+        public MaterialUpdateStrategy(IUpdateStrategy<IElasticMaterial> elasticStrategy,
+            IUpdateStrategy<IFRMaterial> frStrategy,
+            IUpdateStrategy<IConcreteLibMaterial> concreteStrategy,
+            IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy
+            )
+        {
+            this.elasticStrategy = elasticStrategy;
+            this.frStrategy = frStrategy;
+            this.concreteStrategy = concreteStrategy;
+            this.reinforcementStrategy= reinforcementStrategy;
+        }
+        public MaterialUpdateStrategy() : this(
+            new ElasticUpdateStrategy(),
+            new FRUpdateStrategy(),
+            new ConcreteLibUpdateStrategy(),
+            new ReinforcementLibUpdateStrategy()
+        )  {         }
+
         public void Update(IHeadMaterial targetObject, IHeadMaterial sourceObject)
         {
+            CheckObject.CompareTypes(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.Color = sourceObject.Color;
diff --git a/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs
index e8c1dc7..3b1934e 100644
--- a/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs
@@ -1,4 +1,5 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -7,11 +8,20 @@ using System.Threading.Tasks;
 
 namespace StructureHelperLogics.Models.Materials
 {
-    internal class ReinforcementLibUpdateStrategy : IUpdateStrategy<IReinforcementLibMaterial>
+    public class ReinforcementLibUpdateStrategy : IUpdateStrategy<IReinforcementLibMaterial>
     {
-        LibMaterialUpdateStrategy libUpdateStrategy = new LibMaterialUpdateStrategy();
+        private IUpdateStrategy<ILibMaterial> libUpdateStrategy;
+        public ReinforcementLibUpdateStrategy(IUpdateStrategy<ILibMaterial> libUpdateStrategy)
+        {
+            this.libUpdateStrategy = libUpdateStrategy;
+        }
+        public ReinforcementLibUpdateStrategy() : this(new LibMaterialUpdateStrategy())
+        {
+            
+        }
         public void Update(IReinforcementLibMaterial targetObject, IReinforcementLibMaterial sourceObject)
         {
+            CheckObject.CompareTypes(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             libUpdateStrategy.Update(targetObject, sourceObject);
         }
diff --git a/StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs b/StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs
index 08872ac..bc0dcc6 100644
--- a/StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs
+++ b/StructureHelperLogics/Models/Materials/ReinforcementLibMaterial.cs
@@ -23,7 +23,7 @@ namespace StructureHelperLogics.Models.Materials
         private readonly List<IMaterialLogic> materialLogics;
 
         public ILibMaterialEntity MaterialEntity { get; set; }
-        public List<IMaterialSafetyFactor> SafetyFactors { get; }
+        public List<IMaterialSafetyFactor> SafetyFactors { get; set; }
         public IMaterialLogic MaterialLogic { get; set; }
 
         public List<IMaterialLogic> MaterialLogics => materialLogics;
diff --git a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs
index 55828a3..88e2548 100644
--- a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs
+++ b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs
@@ -16,16 +16,18 @@ namespace StructureHelperLogics.Models.Templates.CrossSections
                 TraceLogger = new ShiftTraceLogger()
             };
             calculators.Add(forceCalculator);
-            CrackCalculatorInputData newInputData = new CrackCalculatorInputData();
+            var newInputData = new CrackCalculatorInputData();
             var checkLogic = new CheckCrackCalculatorInputDataLogic
             {
                 InputData = newInputData
             };
-            var crackCalculator = new CrackCalculator(newInputData, checkLogic)
+            checkLogic.InputData = newInputData;
+            var crackCalculator = new CrackCalculator(checkLogic, new CrackCalculatorUpdateStrategy(), null)
             {
                 Name = "New Crack Calculator",
                 TraceLogger = new ShiftTraceLogger()
             };
+            crackCalculator.InputData = newInputData;
             calculators.Add(crackCalculator);
             return calculators;
         }
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
index b032503..2515742 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
@@ -18,12 +18,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
     /// <summary>
     /// Logic of checking of input data for crack calcultor 
     /// </summary>
-    public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<CrackCalculatorInputData>
+    public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<ICrackCalculatorInputData>
     {
         private bool result;
         private ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic;
 
-        public CrackCalculatorInputData InputData {  get; set; }
+        public ICrackCalculatorInputData InputData {  get; set; }
 
 
         public string CheckResult { get; private set; }
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs
index ea7c63b..442c718 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs
@@ -14,7 +14,7 @@ using System.Threading.Tasks;
 
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
-    public class CrackCalculator : ICalculator
+    public class CrackCalculator : ICrackCalculator
     {
         const LimitStates limitState = LimitStates.SLS;
         const CalcTerms longTerm = CalcTerms.LongTerm;
@@ -22,26 +22,30 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         private const double maxSizeOfCrossSection = 1d;
         private CrackResult result;
         private IGetTupleInputDatasLogic datasLogic;
-        private CrackCalculatorUpdateStrategy updateStrategy = new();
-        private ICheckInputDataLogic<CrackCalculatorInputData> checkInputDataLogic;
+        private IUpdateStrategy<ICrackCalculator> updateStrategy;
+        private ICheckInputDataLogic<ICrackCalculatorInputData> checkInputDataLogic;
 
         public string Name { get; set; }
-        public CrackCalculatorInputData InputData { get; set; }
+        public ICrackCalculatorInputData InputData { get; set; }
         public IResult Result => result;
 
         public IShiftTraceLogger? TraceLogger { get; set; }
-        public CrackCalculator(CrackCalculatorInputData inputData, ICheckInputDataLogic<CrackCalculatorInputData> checkInputDataLogic)
+        public CrackCalculator(ICheckInputDataLogic<ICrackCalculatorInputData> checkInputDataLogic,
+            IUpdateStrategy<ICrackCalculator> updateStrategy,
+            IShiftTraceLogger traceLogger
+            )
         {
-            InputData = inputData;
             this.checkInputDataLogic = checkInputDataLogic;
+            this.updateStrategy = updateStrategy;
+            this.TraceLogger = traceLogger;
             Name = string.Empty;
         }
 
-        public CrackCalculator(CrackCalculatorInputData inputData)
-            : this(inputData,
-                  new CheckCrackCalculatorInputDataLogic()
-                  { InputData = inputData}
-                  ) { }
+        public CrackCalculator()
+            : this(new CheckCrackCalculatorInputDataLogic(),
+                  new CrackCalculatorUpdateStrategy(),
+                  new ShiftTraceLogger())
+        { }
 
         public object Clone()
         {
@@ -50,7 +54,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             {
                 InputData = InputData
             };
-            var newItem = new CrackCalculator(crackInputData, checkDataLogic);
+            var newItem = new CrackCalculator(checkDataLogic, new CrackCalculatorUpdateStrategy(), new ShiftTraceLogger());
+            newItem.InputData = crackInputData;
             updateStrategy.Update(newItem, this);
             return newItem;
         }
@@ -75,6 +80,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 
         private void CheckInputData()
         {
+            checkInputDataLogic.InputData = InputData;
             checkInputDataLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
             if (checkInputDataLogic.Check() == false)
             {
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs
index 00e5dad..7569192 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs
@@ -10,18 +10,18 @@ using System.Threading.Tasks;
 
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
-    public class CrackCalculatorInputData : IInputData, IHasPrimitives, IHasForceCombinations
+    public class CrackCalculatorInputData : ICrackCalculatorInputData
     {
         /// <inheritdoc/>
         public List<INdmPrimitive> Primitives { get; private set; }
         /// <inheritdoc/>
         public List<IForceAction> ForceActions { get; private set; }
-        public UserCrackInputData UserCrackInputData { get; set; }
+        public IUserCrackInputData UserCrackInputData { get; set; }
         public CrackCalculatorInputData()
         {
             Primitives = new();
             ForceActions = new();
-            UserCrackInputData = new()
+            UserCrackInputData = new UserCrackInputData()
             {
                 SetSofteningFactor = true,
                 SofteningFactor = 1d,
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
index c1735aa..27a39e9 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
@@ -8,22 +8,22 @@ using System.Threading.Tasks;
 
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
-    public class CrackCalculatorUpdateStrategy : IUpdateStrategy<CrackCalculator>
+    public class CrackCalculatorUpdateStrategy : IUpdateStrategy<ICrackCalculator>
     {
-        private IUpdateStrategy<CrackCalculatorInputData> inputDataUpdateStrategy;
+        private IUpdateStrategy<ICrackCalculatorInputData> inputDataUpdateStrategy;
 
-        public CrackCalculatorUpdateStrategy(IUpdateStrategy<CrackCalculatorInputData> inputDataUpdateStrategy)
+        public CrackCalculatorUpdateStrategy(IUpdateStrategy<ICrackCalculatorInputData> inputDataUpdateStrategy)
         {
             this.inputDataUpdateStrategy = inputDataUpdateStrategy;
         }
         public CrackCalculatorUpdateStrategy() : this(new CrackInputDataUpdateStrategy()) { }
-        public void Update(CrackCalculator targetObject, CrackCalculator sourceObject)
+        public void Update(ICrackCalculator targetObject, ICrackCalculator sourceObject)
         {
-            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
 
             targetObject.Name = sourceObject.Name;
-            targetObject.InputData ??= new();
+            targetObject.InputData ??= new CrackCalculatorInputData();
             inputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData);
         }
     }
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs
index 5e0acef..27d5571 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs
@@ -8,7 +8,7 @@ using System.Threading.Tasks;
 
 namespace StructureHelperLogics.NdmCalculations.Cracking
 {
-    public class CrackInputDataUpdateStrategy : IUpdateStrategy<CrackCalculatorInputData>
+    public class CrackInputDataUpdateStrategy : IUpdateStrategy<ICrackCalculatorInputData>
     {
         private IUpdateStrategy<IUserCrackInputData> userCrackInputDataUpdateStrategy;
         public CrackInputDataUpdateStrategy(IUpdateStrategy<IUserCrackInputData> userCrackInputDataUpdateStrategy)
@@ -20,10 +20,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         {
             
         }
-        public void Update(CrackCalculatorInputData targetObject, CrackCalculatorInputData sourceObject)
+        public void Update(ICrackCalculatorInputData targetObject, ICrackCalculatorInputData sourceObject)
         {
-            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.ForceActions.Clear();
             targetObject.ForceActions.AddRange(sourceObject.ForceActions);
             targetObject.Primitives.Clear();
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculationLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculationLogic.cs
index c87b4f0..89e66f2 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculationLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthCalculationLogic.cs
@@ -13,10 +13,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 {
     public class CrackWidthCalculationLogic : ICrackWidthCalculationLogic
     {
+        private IRebarStressResultLogic rebarStressResultLogic;
         private ICrackWidthLogic crackWidthLogic;
         private RebarCrackResult result;
         private ICrackSofteningLogic crackSofteningLogic;
-        private RebarStressResult rebarStressResult;
+        private IRebarStressResult rebarStressResult;
         private ICrackWidthLogicInputData acrc2InputData;
         private ICrackWidthLogicInputData acrc1InputData;
         private ICrackWidthLogicInputData acrc3InputData;
@@ -39,14 +40,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
 
         public IShiftTraceLogger? TraceLogger { get; set; }
 
-        public CrackWidthCalculationLogic(IRebarStressCalculator rebarStressCalculator, ICrackWidthLogic crackWidthLogic, IShiftTraceLogger? traceLogger)
+        public CrackWidthCalculationLogic(IRebarStressResultLogic rebarStressResultLogic, ICrackWidthLogic crackWidthLogic, IShiftTraceLogger? traceLogger)
         {
-            this.rebarStressCalculator = rebarStressCalculator;
+            this.rebarStressResultLogic = rebarStressResultLogic;
             this.crackWidthLogic = crackWidthLogic;
             this.TraceLogger = traceLogger;
         }
 
-        public CrackWidthCalculationLogic() : this (new RebarStressCalculator(), new CrackWidthLogicSP63(), null)
+        public CrackWidthCalculationLogic() : this (new RebarStressResultLogic(), new CrackWidthLogicSP63(), null)
         {
             
         }
@@ -74,7 +75,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             result.ShortTermResult = shortRebarResult;
         }
 
-        public CrackWidthRebarTupleResult ProcessShortTermCalculations()
+        private CrackWidthRebarTupleResult ProcessShortTermCalculations()
         {
             crackSofteningLogic = GetSofteningLogic(InputData.ShortRebarData);
             rebarStressResult = GetRebarStressResult(InputData.ShortRebarData);
@@ -98,7 +99,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             return shortRebarResult;
         }
 
-        public CrackWidthRebarTupleResult ProcessLongTermCalculations()
+        private CrackWidthRebarTupleResult ProcessLongTermCalculations()
         {
             crackSofteningLogic = GetSofteningLogic(InputData.LongRebarData);
             rebarStressResult = GetRebarStressResult(InputData.LongRebarData);
@@ -168,20 +169,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
             return crackWidthInputData;
         }
 
-        public RebarStressResult GetRebarStressResult(IRebarCrackInputData inputData)
+        private IRebarStressResult GetRebarStressResult(IRebarCrackInputData rebarCrackInputData)
         {
-            rebarStressCalculator.InputData.ForceTuple = inputData.ForceTuple;
-            rebarStressCalculator.InputData.NdmCollection = inputData.CrackedNdmCollection;
-            rebarStressCalculator.InputData.RebarPrimitive = InputData.RebarPrimitive;
-            rebarStressCalculator.Run();
-            var result = rebarStressCalculator.Result as RebarStressResult;
-            if (result.IsValid == false)
-            {
-                string errorString = LoggerStrings.CalculationError + result.Description;
-                TraceLogger?.AddMessage($"Rebar name: {InputData.RebarPrimitive.Name}\n" + errorString, TraceLogStatuses.Error);
-                throw new StructureHelperException(errorString);
-            }
-            return result;
+            rebarStressResultLogic.RebarCrackInputData = rebarCrackInputData;
+            rebarStressResultLogic.RebarPrimitive = InputData.RebarPrimitive;
+            rebarStressResultLogic.TraceLogger = TraceLogger?.GetSimilarTraceLogger(50);
+            return rebarStressResultLogic.GetRebarStressResult();
         }
 
     }
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthRebarTupleResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthRebarTupleResult.cs
index 409f295..0ce1929 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthRebarTupleResult.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackWidthRebarTupleResult.cs
@@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         public double CrackWidth { get; set; }
         public double UltimateCrackWidth { get; set; }
         public bool IsCrackLessThanUltimate => CrackWidth <= UltimateCrackWidth;
-        public RebarStressResult RebarStressResult { get; set; }
+        public IRebarStressResult RebarStressResult { get; set; }
         public double SofteningFactor { get; set; }
     }
 }
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs
index 82c15a2..730ca1a 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/GetTupleInputDatasLogic.cs
@@ -22,9 +22,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         public LimitStates LimitState { get; set; }
         public CalcTerms LongTerm { get; set; }
         public CalcTerms ShortTerm { get; set; }
-        public UserCrackInputData UserCrackInputData { get; set; }
+        public IUserCrackInputData UserCrackInputData { get; set; }
 
-        public GetTupleInputDatasLogic(List<INdmPrimitive> primitives, List<IForceAction> forceActions, UserCrackInputData userCrackInputData)
+        public GetTupleInputDatasLogic(List<INdmPrimitive> primitives, List<IForceAction> forceActions, IUserCrackInputData userCrackInputData)
         {
             Primitives = primitives;
             ForceActions = forceActions;
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculator.cs
new file mode 100644
index 0000000..786cb74
--- /dev/null
+++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculator.cs
@@ -0,0 +1,9 @@
+using StructureHelperCommon.Models.Calculators;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking
+{
+    public interface ICrackCalculator : ICalculator
+    {
+        ICrackCalculatorInputData InputData { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs
new file mode 100644
index 0000000..f1de0e1
--- /dev/null
+++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs
@@ -0,0 +1,14 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking
+{
+    public interface ICrackCalculatorInputData : IInputData, IHasPrimitives, IHasForceCombinations
+    {
+        List<IForceAction> ForceActions { get; }
+        List<INdmPrimitive> Primitives { get; }
+        IUserCrackInputData UserCrackInputData { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculationLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculationLogic.cs
index 35c3ddb..70bacfa 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculationLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthCalculationLogic.cs
@@ -8,8 +8,5 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         RebarCrackResult Result { get; }
 
         void Run();
-        CrackWidthRebarTupleResult ProcessLongTermCalculations();
-        CrackWidthRebarTupleResult ProcessShortTermCalculations();
-        RebarStressResult GetRebarStressResult(IRebarCrackInputData inputData);
     }
 }
\ No newline at end of file
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IGetTupleInputDatasLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IGetTupleInputDatasLogic.cs
index 26c8f93..683b780 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/IGetTupleInputDatasLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/IGetTupleInputDatasLogic.cs
@@ -11,6 +11,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         CalcTerms LongTerm { get; set; }
         CalcTerms ShortTerm { get; set; }
         List<TupleCrackInputData> GetTupleInputDatas();
-        UserCrackInputData UserCrackInputData { get; set; }
+        IUserCrackInputData UserCrackInputData { get; set; }
     }
 }
\ No newline at end of file
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResult.cs
new file mode 100644
index 0000000..0c920d4
--- /dev/null
+++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResult.cs
@@ -0,0 +1,25 @@
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Forces;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking
+{
+    public interface IRebarStressResult : IResult
+    {
+        /// <summary>
+        /// Strain tuple which stress and strain is obtained for
+        /// </summary>
+        StrainTuple StrainTuple { get; set; }
+        /// <summary>
+        /// Strain in fake concrete ndm-part which rounds rebas and locatade at axis of rebar (refrence strain in concrete)
+        /// </summary>
+        double ConcreteStrain { get; set; }
+        /// <summary>
+        /// Strain in rebar, dimensionless
+        /// </summary>
+        double RebarStrain { get; set; }
+        /// <summary>
+        /// Stress in rebar, Pa
+        /// </summary>
+        double RebarStress { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs
new file mode 100644
index 0000000..e293550
--- /dev/null
+++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs
@@ -0,0 +1,13 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking
+{
+    public interface IRebarStressResultLogic : ILogic
+    {
+        IRebarCrackInputData RebarCrackInputData { get; set; }
+        IRebarPrimitive RebarPrimitive { get; set; }
+
+        IRebarStressResult GetRebarStressResult();
+    }
+}
\ No newline at end of file
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs
index da257ca..63bcdf8 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResult.cs
@@ -11,27 +11,19 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
     /// <summary>
     /// Result of calculation of stress and strain in rebar
     /// </summary>
-    public class RebarStressResult : IResult
+    public class RebarStressResult : IRebarStressResult
     {
         /// <inheritdoc/>
         public bool IsValid { get; set; }
         /// <inheritdoc/>
         public string? Description { get; set; }
-        /// <summary>
-        /// Strain tuple which stress and strain is obtained for
-        /// </summary>
-        public StrainTuple StrainTuple { get; set; } 
-        /// <summary>
-        /// Stress in rebar, Pa
-        /// </summary>
+
+        public StrainTuple StrainTuple { get; set; }
+
         public double RebarStress { get; set; }
-        /// <summary>
-        /// Strain in rebar, dimensionless
-        /// </summary>
+
         public double RebarStrain { get; set; }
-        /// <summary>
-        /// Strain in fake concrete ndm-part which rounds rebas and locatade at axis of rebar (refrence strain in concrete)
-        /// </summary>
+
         public double ConcreteStrain { get; set; }
     }
 }
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResultLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResultLogic.cs
new file mode 100644
index 0000000..f433f4a
--- /dev/null
+++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResultLogic.cs
@@ -0,0 +1,53 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Loggers;
+using StructureHelperCommon.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using StructureHelperCommon.Infrastructures.Interfaces;
+
+namespace StructureHelperLogics.NdmCalculations.Cracking
+{
+    public class RebarStressResultLogic : IRebarStressResultLogic
+    {
+        private IRebarStressCalculator rebarStressCalculator;
+        public IRebarPrimitive RebarPrimitive { get; set; }
+        public IRebarCrackInputData RebarCrackInputData { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
+
+        public RebarStressResultLogic(IRebarStressCalculator rebarStressCalculator, IShiftTraceLogger? traceLogger)
+        {
+            this.rebarStressCalculator = rebarStressCalculator;
+            this.TraceLogger = traceLogger;
+        }
+
+        public RebarStressResultLogic() : this(new RebarStressCalculator(), null)
+        {
+
+        }
+
+        public IRebarStressResult GetRebarStressResult()
+        {
+            IRebarStressCalculatorInputData calculatorInputData = new RebarStressCalculatorInputData()
+            {
+                ForceTuple = RebarCrackInputData.ForceTuple,
+                NdmCollection = RebarCrackInputData.CrackedNdmCollection,
+                RebarPrimitive = RebarPrimitive,
+            };
+            rebarStressCalculator.InputData = calculatorInputData;
+            rebarStressCalculator.Run();
+            var result = rebarStressCalculator.Result as RebarStressResult;
+            if (result.IsValid == false)
+            {
+                string errorString = LoggerStrings.CalculationError + result.Description;
+                TraceLogger?.AddMessage($"Rebar name: {RebarPrimitive.Name}\n" + errorString, TraceLogStatuses.Error);
+                throw new StructureHelperException(errorString);
+            }
+            return result;
+        }
+    }
+}
diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs
index 69aa841..6e9d3c6 100644
--- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackInputData.cs
@@ -34,6 +34,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
         /// <summary>
         /// Settings ajusted by user
         /// </summary>
-        public UserCrackInputData UserCrackInputData { get; set; }
+        public IUserCrackInputData UserCrackInputData { get; set; }
     }
 }
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthCalculationLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthCalculationLogicTests.cs
index 8819164..ed46873 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthCalculationLogicTests.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/CrackWidthCalculationLogicTests.cs
@@ -10,98 +10,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
     [TestFixture]
     public class CrackWidthCalculationLogicTests
     {
-        private Mock<IRebarStressCalculator> _calculator;
-        private Mock<ICrackWidthLogic> _mockCrackWidthLogic;
-        private Mock<IShiftTraceLogger> _mockTraceLogger;
-        private CrackWidthCalculationLogic _logic;
-        private IRebarCrackCalculatorInputData _inputData;
-
-        [SetUp]
-        public void SetUp()
-        {
-            _calculator = new Mock<IRebarStressCalculator>();
-            _mockCrackWidthLogic = new Mock<ICrackWidthLogic>();
-            _mockTraceLogger = new Mock<IShiftTraceLogger>();
-            _inputData = new RebarCrackCalculatorInputData
-            {
-                
-            };
-
-            _inputData.UserCrackInputData = new UserCrackInputData();
-
-            _logic = new CrackWidthCalculationLogic(_calculator.Object, _mockCrackWidthLogic.Object, _mockTraceLogger.Object)
-            {
-                InputData = _inputData
-            };
-        }
-
-        [Test]
-        public void Run_ShouldPrepareNewResultAndProcessCalculations()
-        {
-            // Arrange
-            _mockCrackWidthLogic.Setup(m => m.GetCrackWidth())
-                .Returns(0.5); // Mock the GetCrackWidth method
-
-            // Act
-            _logic.Run();
-
-            // Assert
-            Assert.NotNull(_logic.Result);
-            Assert.IsTrue(_logic.Result.IsValid);
-            _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
-        }
-
-        [Test]
-        public void ProcessLongTermCalculation_ShouldReturnExpectedResult()
-        {
-            // Arrange
-            _mockCrackWidthLogic.SetupSequence(m => m.GetCrackWidth())
-                .Returns(0.5) // longTermLoadLongTermConcreteCrackWidth
-                .Returns(0.2); // longTermLoadShortConcreteWidth
-
-            // Act
-            var result = _logic.ProcessLongTermCalculations();
-
-            // Assert
-            Assert.NotNull(result);
-            Assert.AreEqual(0.5, result.CrackWidth);
-            _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
-        }
-
-        [Test]
-        public void ProcessShortTermCalculations_ShouldReturnExpectedResult()
-        {
-            // Arrange
-            _mockCrackWidthLogic.SetupSequence(m => m.GetCrackWidth())
-                .Returns(0.2) // longTermLoadShortConcreteWidth
-                .Returns(0.3); // fullLoadShortConcreteCrackWidth
-
-            // Act
-            var result = _logic.ProcessShortTermCalculations();
-
-            // Assert
-            Assert.NotNull(result);
-            Assert.AreEqual(0.0, result.CrackWidth); // Assuming acrcShort would be 0 in this scenario
-            _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
-        }
-
-        [Test]
-        public void GetRebarStressResult_ShouldReturnValidResult()
-        {
-            // Arrange
-            var mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
-            var expectedResult = new RebarStressResult { IsValid = true };
-            mockRebarStressCalculator.Setup(c => c.Run());
-            mockRebarStressCalculator.Setup(c => c.Result).Returns(expectedResult);
-
-            // Act
-            var result = _logic.GetRebarStressResult(_inputData.ShortRebarData);
-
-            // Assert
-            Assert.NotNull(result);
-            Assert.IsTrue(result.IsValid);
-            _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>(), TraceLogStatuses.Error), Times.Never);
-        }
+        
     }
 
 }
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckCrackWidthSP63InputDataLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckCrackWidthSP63InputDataLogicTests.cs
index 7026033..f337665 100644
--- a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckCrackWidthSP63InputDataLogicTests.cs
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckCrackWidthSP63InputDataLogicTests.cs
@@ -4,6 +4,10 @@ using StructureHelperCommon.Models;
 using StructureHelperLogics.NdmCalculations.Cracking;
 using StructureHelperLogics.NdmCalculations.Primitives;
 using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Calculators;
+using Autofac.Features.ResolveAnything;
+using StructureHelperLogics.NdmCalculations.Triangulations;
+using LoaderCalculator.Data.Ndms;
 
 namespace StructureHelperTests.UnitTests.Ndms.Cracks.InputDataTests
 {
@@ -11,89 +15,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks.InputDataTests
     [TestFixture]
     public class CrackWidthCalculationLogicTests
     {
-        private Mock<IRebarStressCalculator> _calculator;
-        private Mock<ICrackWidthLogic> mockCrackWidthLogic;
-        private Mock<IShiftTraceLogger> mockTraceLogger;
-        private Mock<IRebarCrackCalculatorInputData> mockInputData;
-        private Mock<IUserCrackInputData> mockUserCrackInputData;
-        private Mock<IRebarPrimitive> mockRebarPrimitive;
-        private Mock<IRebarStressCalculator> mockRebarStressCalculator;
-        private CrackWidthCalculationLogic crackWidthCalculationLogic;
-        private Mock<IRebarCrackInputData> mockRebarCrackInputData;
-
-        [SetUp]
-        public void SetUp()
-        {
-            _calculator = new Mock<IRebarStressCalculator>();
-            mockCrackWidthLogic = new Mock<ICrackWidthLogic>();
-            mockTraceLogger = new Mock<IShiftTraceLogger>();
-            mockInputData = new Mock<IRebarCrackCalculatorInputData>();
-            mockUserCrackInputData = new Mock<IUserCrackInputData>();
-            mockRebarPrimitive = new Mock<IRebarPrimitive>();
-            mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
-            mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
-
-            mockInputData.Setup(x => x.UserCrackInputData).Returns(mockUserCrackInputData.Object);
-            mockInputData.Setup(x => x.LongRebarData).Returns(mockRebarCrackInputData.Object);
-            mockInputData.Setup(x => x.ShortRebarData).Returns(mockRebarCrackInputData.Object);
-            mockInputData.Setup(x => x.RebarPrimitive).Returns(mockRebarPrimitive.Object);
-
-            mockRebarCrackInputData.Setup(x => x.ForceTuple).Returns(new ForceTuple());
-
-            crackWidthCalculationLogic = new CrackWidthCalculationLogic(_calculator.Object, mockCrackWidthLogic.Object, mockTraceLogger.Object)
-            {
-                InputData = mockInputData.Object
-            };
-        }
-
-        [Test]
-        public void Run_ShouldPrepareNewResultAndProcessCalculations()
-        {
-            // Arrange
-            mockCrackWidthLogic.Setup(x => x.GetCrackWidth()).Returns(0.5);
-
-            // Act
-            crackWidthCalculationLogic.Run();
-
-            // Assert
-            mockCrackWidthLogic.Verify(x => x.GetCrackWidth(), Times.AtLeastOnce);
-            Assert.IsNotNull(crackWidthCalculationLogic.Result);
-            Assert.IsTrue(crackWidthCalculationLogic.Result.IsValid);
-        }
-
-        [Test]
-        public void ProcessShortTermCalculations_ShouldCalculateCorrectShortTermCrackWidth()
-        {
-            // Arrange
-            mockUserCrackInputData.Setup(x => x.UltimateShortCrackWidth).Returns(1.0);
-            mockCrackWidthLogic.SetupSequence(x => x.GetCrackWidth())
-                .Returns(0.6) // longTermLoadShortConcreteWidth
-                .Returns(0.8); // fullLoadShortConcreteCrackWidth
-
-            crackWidthCalculationLogic.InputData = mockInputData.Object;
-
-            // Act
-            var shortTermResult = crackWidthCalculationLogic.ProcessShortTermCalculations();
-
-            // Assert
-            Assert.AreEqual(1.2, shortTermResult.CrackWidth);
-            Assert.AreEqual(1.0, shortTermResult.UltimateCrackWidth);
-        }
-
-        [Test]
-        public void ProcessLongTermCalculations_ShouldCalculateCorrectLongTermCrackWidth()
-        {
-            // Arrange
-            mockUserCrackInputData.Setup(x => x.UltimateLongCrackWidth).Returns(1.2);
-            mockCrackWidthLogic.Setup(x => x.GetCrackWidth()).Returns(0.9);
-
-            // Act
-            var longTermResult = crackWidthCalculationLogic.ProcessLongTermCalculations();
-
-            // Assert
-            Assert.AreEqual(0.9, longTermResult.CrackWidth);
-            Assert.AreEqual(1.2, longTermResult.UltimateCrackWidth);
-        }
+       
     }
 
 
diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs
new file mode 100644
index 0000000..882b681
--- /dev/null
+++ b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs
@@ -0,0 +1,80 @@
+using Moq;
+using NUnit.Framework;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Models.Loggers;
+using StructureHelperCommon.Models;
+using StructureHelperLogics.NdmCalculations.Cracking;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperTests.UnitTests.Ndms.Cracks
+{
+
+
+    [TestFixture]
+    public class RebarStressResultLogicTests
+    {
+        private Mock<IRebarStressCalculator> _mockRebarStressCalculator;
+        private Mock<IShiftTraceLogger> _mockTraceLogger;
+        private RebarStressResultLogic _rebarStressResultLogic;
+
+        [SetUp]
+        public void Setup()
+        {
+            _mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
+            _mockTraceLogger = new Mock<IShiftTraceLogger>();
+            _rebarStressResultLogic = new RebarStressResultLogic(_mockRebarStressCalculator.Object, _mockTraceLogger.Object);
+        }
+
+        [Test]
+        public void GetRebarStressResult_WhenCalculationIsValid_ReturnsRebarStressResult()
+        {
+            // Arrange
+            var mockRebarStressResult = new RebarStressResult
+            {
+                IsValid = true
+            };
+
+            _mockRebarStressCalculator.Setup(x => x.Run());
+            _mockRebarStressCalculator.Setup(x => x.Result).Returns(mockRebarStressResult);
+
+            var mockRebarPrimitive = new Mock<IRebarPrimitive>();
+            var mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
+
+            _rebarStressResultLogic.RebarPrimitive = mockRebarPrimitive.Object;
+            _rebarStressResultLogic.RebarCrackInputData = mockRebarCrackInputData.Object;
+
+            // Act
+            var result = _rebarStressResultLogic.GetRebarStressResult();
+
+            // Assert
+            Assert.AreEqual(mockRebarStressResult, result);
+            _mockRebarStressCalculator.Verify(x => x.Run(), Times.Once);
+        }
+
+        [Test]
+        public void GetRebarStressResult_WhenCalculationIsInvalid_ThrowsStructureHelperException()
+        {
+            // Arrange
+            var mockRebarStressResult = new RebarStressResult
+            {
+                IsValid = false,
+                Description = "Error in calculation"
+            };
+
+            _mockRebarStressCalculator.Setup(x => x.Run());
+            _mockRebarStressCalculator.Setup(x => x.Result).Returns(mockRebarStressResult);
+
+            var mockRebarPrimitive = new Mock<IRebarPrimitive>();
+            var mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
+
+            _rebarStressResultLogic.RebarPrimitive = mockRebarPrimitive.Object;
+            _rebarStressResultLogic.RebarCrackInputData = mockRebarCrackInputData.Object;
+
+            // Act & Assert
+            var ex = Assert.Throws<StructureHelperException>(() => _rebarStressResultLogic.GetRebarStressResult());
+            Assert.That(ex.Message, Is.EqualTo(LoggerStrings.CalculationError + mockRebarStressResult.Description));
+            _mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>(), TraceLogStatuses.Error), Times.Once);
+        }
+    }
+
+}
diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/ConcreteLibUpdateStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/ConcreteLibUpdateStrategyTests.cs
new file mode 100644
index 0000000..619aeca
--- /dev/null
+++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/ConcreteLibUpdateStrategyTests.cs
@@ -0,0 +1,77 @@
+using Moq;
+using NUnit.Framework;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.Models.Materials;
+using System;
+
+namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
+{
+
+
+    namespace YourNamespace.Tests
+    {
+        [TestFixture]
+        public class ConcreteLibUpdateStrategyTests
+        {
+            private Mock<IUpdateStrategy<ILibMaterial>> mockLibUpdateStrategy;
+            private ConcreteLibUpdateStrategy strategy;
+
+            [SetUp]
+            public void Setup()
+            {
+                mockLibUpdateStrategy = new Mock<IUpdateStrategy<ILibMaterial>>();
+                strategy = new ConcreteLibUpdateStrategy(mockLibUpdateStrategy.Object);
+            }
+
+            [Test]
+            public void Update_ShouldUpdateTargetObject_WhenSourceAndTargetAreNotTheSame()
+            {
+                // Arrange
+                var targetMock = new Mock<IConcreteLibMaterial>();
+                var sourceMock = new Mock<IConcreteLibMaterial>();
+
+                sourceMock.Setup(s => s.TensionForULS).Returns(false);
+                sourceMock.Setup(s => s.TensionForSLS).Returns(true);
+                sourceMock.Setup(s => s.RelativeHumidity).Returns(0.75);
+
+                // Act
+                strategy.Update(targetMock.Object, sourceMock.Object);
+
+                // Assert
+                mockLibUpdateStrategy.Verify(l => l.Update(targetMock.Object, sourceMock.Object), Times.Once);
+                targetMock.VerifySet(t => t.TensionForULS = false);
+                targetMock.VerifySet(t => t.TensionForSLS = true);
+                targetMock.VerifySet(t => t.RelativeHumidity = 0.75);
+            }
+
+            [Test]
+            public void Update_ShouldNotUpdate_WhenSourceAndTargetAreSame()
+            {
+                // Arrange
+                var targetMock = new Mock<IConcreteLibMaterial>();
+
+                // Act
+                strategy.Update(targetMock.Object, targetMock.Object);
+
+                // Assert
+                mockLibUpdateStrategy.Verify(l => l.Update(It.IsAny<IConcreteLibMaterial>(), It.IsAny<IConcreteLibMaterial>()), Times.Never);
+                targetMock.VerifySet(t => t.TensionForULS = It.IsAny<bool>(), Times.Never);
+                targetMock.VerifySet(t => t.TensionForSLS = It.IsAny<bool>(), Times.Never);
+                targetMock.VerifySet(t => t.RelativeHumidity = It.IsAny<double>(), Times.Never);
+            }
+
+            [Test]
+            public void Update_ShouldThrowStructureHelperException_WhenObjectsAreOfDifferentTypes()
+            {
+                // Arrange
+                var targetMock = new Mock<IConcreteLibMaterial>();
+                var sourceMock = new Mock<ConcreteLibMaterial>();
+
+                // Act & Assert
+                Assert.Throws<StructureHelperException>(() => strategy.Update(targetMock.Object, sourceMock.Object));
+            }
+        }
+    }
+
+}
diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackCalculatorUpdateStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackCalculatorUpdateStrategyTests.cs
new file mode 100644
index 0000000..fe4f899
--- /dev/null
+++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackCalculatorUpdateStrategyTests.cs
@@ -0,0 +1,104 @@
+using Moq;
+using NUnit.Framework;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Cracking;
+
+namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
+{
+
+
+    [TestFixture]
+    public class CrackCalculatorUpdateStrategyTests
+    {
+        private Mock<IUpdateStrategy<ICrackCalculatorInputData>> _inputDataUpdateStrategyMock;
+        private CrackCalculatorUpdateStrategy _crackCalculatorUpdateStrategy;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _inputDataUpdateStrategyMock = new Mock<IUpdateStrategy<ICrackCalculatorInputData>>();
+            _crackCalculatorUpdateStrategy = new CrackCalculatorUpdateStrategy(_inputDataUpdateStrategyMock.Object);
+        }
+
+        [Test]
+        public void Update_WhenTargetAndSourceAreSameObject_DoesNotCallInputDataUpdateStrategy()
+        {
+            // Arrange
+            var calculator = new Mock<ICrackCalculator>().Object;
+
+            // Act
+            _crackCalculatorUpdateStrategy.Update(calculator, calculator);
+
+            // Assert
+            _inputDataUpdateStrategyMock.Verify(s => s.Update(It.IsAny<ICrackCalculatorInputData>(), It.IsAny<ICrackCalculatorInputData>()), Times.Never);
+        }
+
+        [Test]
+        public void Update_WhenSourceObjectIsNull_ThrowsArgumentNullException()
+        {
+            // Arrange
+            var targetObject = new Mock<ICrackCalculator>().Object;
+
+            // Act & Assert
+            Assert.Throws<StructureHelperException>(() => _crackCalculatorUpdateStrategy.Update(targetObject, null));
+        }
+
+        [Test]
+        public void Update_WhenTargetObjectIsNull_ThrowsArgumentNullException()
+        {
+            // Arrange
+            var sourceObject = new Mock<ICrackCalculator>().Object;
+
+            // Act & Assert
+            Assert.Throws<StructureHelperException>(() => _crackCalculatorUpdateStrategy.Update(null, sourceObject));
+        }
+
+        [Test]
+        public void Update_UpdatesTargetObjectNameAndCallsInputDataUpdateStrategy()
+        {
+            // Arrange
+            var targetObject = new Mock<ICrackCalculator>();
+            var sourceObject = new Mock<ICrackCalculator>();
+
+            var targetInputData = new Mock<ICrackCalculatorInputData>().Object;
+            var sourceInputData = new Mock<ICrackCalculatorInputData>().Object;
+
+            targetObject.SetupAllProperties();
+            targetObject.Object.InputData = targetInputData;
+            sourceObject.SetupAllProperties();
+            sourceObject.Object.InputData = sourceInputData;
+            sourceObject.Setup(x => x.Name).Returns("Source Name");
+
+            // Act
+            _crackCalculatorUpdateStrategy.Update(targetObject.Object, sourceObject.Object);
+
+            // Assert
+            Assert.AreEqual("Source Name", targetObject.Object.Name);
+            _inputDataUpdateStrategyMock.Verify(s => s.Update(targetInputData, sourceInputData), Times.Once);
+        }
+
+        [Test]
+        public void Update_WhenTargetInputDataIsNull_CreatesNewInputDataAndUpdatesIt()
+        {
+            // Arrange
+            var targetObject = new Mock<ICrackCalculator>();
+            var sourceObject = new Mock<ICrackCalculator>();
+
+            var sourceInputData = new Mock<ICrackCalculatorInputData>().Object;
+
+            targetObject.SetupAllProperties();
+            targetObject.Object.InputData = null;
+            sourceObject.SetupAllProperties();
+            sourceObject.Object.InputData = sourceInputData;
+
+            // Act
+            _crackCalculatorUpdateStrategy.Update(targetObject.Object, sourceObject.Object);
+
+            // Assert
+            Assert.IsNotNull(targetObject.Object.InputData);
+            _inputDataUpdateStrategyMock.Verify(s => s.Update(targetObject.Object.InputData, sourceInputData), Times.Once);
+        }
+    }
+
+}
diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackInputDataUpdateStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackInputDataUpdateStrategyTests.cs
new file mode 100644
index 0000000..af45c91
--- /dev/null
+++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/CrackInputDataUpdateStrategyTests.cs
@@ -0,0 +1,89 @@
+using Moq;
+using NUnit.Framework;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperLogics.NdmCalculations.Cracking;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
+{
+
+    [TestFixture]
+    public class CrackInputDataUpdateStrategyTests
+    {
+        [Test]
+        public void Update_WithValidInput_UpdatesTargetObject()
+        {
+            // Arrange
+            var mockUserCrackInputDataUpdateStrategy = new Mock<IUpdateStrategy<IUserCrackInputData>>();
+            var targetObject = new Mock<ICrackCalculatorInputData>();
+            var sourceObject = new Mock<ICrackCalculatorInputData>();
+
+            var forceActions = new List<IForceAction> { new Mock<IForceAction>().Object };
+            var primitives = new List<INdmPrimitive> { new Mock<INdmPrimitive>().Object };
+            var userCrackInputData = new Mock<IUserCrackInputData>();
+
+            sourceObject.Setup(s => s.ForceActions).Returns(forceActions);
+            sourceObject.Setup(s => s.Primitives).Returns(primitives);
+            sourceObject.Setup(s => s.UserCrackInputData).Returns(userCrackInputData.Object);
+
+            targetObject.Setup(t => t.ForceActions).Returns(new List<IForceAction>());
+            targetObject.Setup(t => t.Primitives).Returns(new List<INdmPrimitive>());
+            targetObject.SetupProperty(t => t.UserCrackInputData, new Mock<IUserCrackInputData>().Object);
+
+            var strategy = new CrackInputDataUpdateStrategy(mockUserCrackInputDataUpdateStrategy.Object);
+
+            // Act
+            strategy.Update(targetObject.Object, sourceObject.Object);
+
+            // Assert
+            Assert.AreEqual(forceActions, targetObject.Object.ForceActions);
+            Assert.AreEqual(primitives, targetObject.Object.Primitives);
+            mockUserCrackInputDataUpdateStrategy.Verify(s => s.Update(It.IsAny<IUserCrackInputData>(), It.IsAny<IUserCrackInputData>()), Times.Once);
+        }
+
+        [Test]
+        public void Update_WhenTargetAndSourceAreSame_DoesNotUpdate()
+        {
+            // Arrange
+            var mockUserCrackInputDataUpdateStrategy = new Mock<IUpdateStrategy<IUserCrackInputData>>();
+            var targetObject = new Mock<ICrackCalculatorInputData>();
+
+            var strategy = new CrackInputDataUpdateStrategy(mockUserCrackInputDataUpdateStrategy.Object);
+
+            // Act
+            strategy.Update(targetObject.Object, targetObject.Object);
+
+            // Assert
+            mockUserCrackInputDataUpdateStrategy.Verify(s => s.Update(It.IsAny<IUserCrackInputData>(), It.IsAny<IUserCrackInputData>()), Times.Never);
+        }
+
+        [Test]
+        public void Update_WithNullTarget_ThrowsStructureHelperException()
+        {
+            // Arrange
+            var mockUserCrackInputDataUpdateStrategy = new Mock<IUpdateStrategy<IUserCrackInputData>>();
+            var sourceObject = new Mock<ICrackCalculatorInputData>();
+
+            var strategy = new CrackInputDataUpdateStrategy(mockUserCrackInputDataUpdateStrategy.Object);
+
+            // Act & Assert
+            Assert.Throws<StructureHelperException>(() => strategy.Update(null, sourceObject.Object));
+        }
+                
+        [Test]
+        public void Update_WithNullSource_ThrowsStructureHelperException()
+        {
+            // Arrange
+            var mockUserCrackInputDataUpdateStrategy = new Mock<IUpdateStrategy<IUserCrackInputData>>();
+            var targetObject = new Mock<ICrackCalculatorInputData>();
+
+            var strategy = new CrackInputDataUpdateStrategy(mockUserCrackInputDataUpdateStrategy.Object);
+
+            // Act & Assert
+            Assert.Throws<StructureHelperException>(() => strategy.Update(targetObject.Object, null));
+        }
+    }
+
+}
diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/LibMaterialUpdateStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/LibMaterialUpdateStrategyTests.cs
new file mode 100644
index 0000000..1019f67
--- /dev/null
+++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/LibMaterialUpdateStrategyTests.cs
@@ -0,0 +1,98 @@
+using NUnit.Framework;
+using Moq;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Models.Materials.Libraries;
+using StructureHelperCommon.Models.Materials;
+using StructureHelperLogics.Models.Materials;
+
+namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
+{
+
+
+    [TestFixture]
+    public class LibMaterialUpdateStrategyTests
+    {
+        private Mock<ILibMaterial> mockTargetMaterial;
+        private Mock<ILibMaterial> mockSourceMaterial;
+        private LibMaterialUpdateStrategy updateStrategy;
+
+        [SetUp]
+        public void Setup()
+        {
+            mockTargetMaterial = new Mock<ILibMaterial>();
+            mockSourceMaterial = new Mock<ILibMaterial>();
+            updateStrategy = new LibMaterialUpdateStrategy();
+
+            var targetSafetyFactors = new List<IMaterialSafetyFactor>();
+            mockTargetMaterial.Setup(t => t.SafetyFactors).Returns(targetSafetyFactors);
+        }
+
+        [Test]
+        public void Update_ShouldThrowException_WhenTargetAndSourceAreDifferentTypes()
+        {
+            // Arrange
+            var mockTarget1 = new ConcreteLibMaterial();
+            var mockTarget2 = new ReinforcementLibMaterial();
+
+            // Act & Assert
+            Assert.Throws<StructureHelperException>(() =>  updateStrategy.Update(mockTarget1, mockTarget2));
+        }
+
+        [Test]
+        public void Update_ShouldCopyMaterialEntityAndMaterialLogic()
+        {
+            // Arrange
+            var materialEntity = new Mock<ILibMaterialEntity>().Object;
+            var materialLogic = new Mock<IMaterialLogic>().Object;
+
+            mockSourceMaterial.Setup(s => s.MaterialEntity).Returns(materialEntity);
+            mockSourceMaterial.Setup(s => s.MaterialLogic).Returns(materialLogic);
+
+            // Act
+            updateStrategy.Update(mockTargetMaterial.Object, mockSourceMaterial.Object);
+
+            // Assert
+            mockTargetMaterial.VerifySet(t => t.MaterialEntity = materialEntity, Times.Once);
+            mockTargetMaterial.VerifySet(t => t.MaterialLogic = materialLogic, Times.Once);
+        }
+
+        //[Test]
+        public void Update_ShouldClearAndCopySafetyFactors()
+        {
+            // Arrange
+            var mockSafetyFactor1 = new Mock<IMaterialSafetyFactor>();
+            var mockSafetyFactor2 = new Mock<IMaterialSafetyFactor>();
+            var safetyFactors = new List<IMaterialSafetyFactor> { mockSafetyFactor1.Object, mockSafetyFactor2.Object };
+            var targetSafetyFactors = new List<IMaterialSafetyFactor>();
+
+            mockSourceMaterial.Setup(s => s.SafetyFactors).Returns(safetyFactors);
+            mockSafetyFactor1.Setup(f => f.Clone()).Returns(mockSafetyFactor1.Object);
+            mockSafetyFactor2.Setup(f => f.Clone()).Returns(mockSafetyFactor2.Object);
+
+            mockTargetMaterial.Setup(t => t.SafetyFactors).Returns(targetSafetyFactors);
+
+            // Act
+            updateStrategy.Update(mockTargetMaterial.Object, mockSourceMaterial.Object);
+
+            // Assert
+            //mockTargetMaterial.Verify(t => t.SafetyFactors.Clear(), Times.Once);
+            //mockTargetMaterial.Verify(t => t.SafetyFactors.Add(mockSafetyFactor1.Object), Times.Once);
+            //mockTargetMaterial.Verify(t => t.SafetyFactors.Add(mockSafetyFactor2.Object), Times.Once);
+        }
+
+        [Test]
+        public void Update_ShouldNotPerformUpdate_WhenObjectsAreReferenceEqual()
+        {
+            //Arrange
+
+            // Act
+            updateStrategy.Update(mockTargetMaterial.Object, mockTargetMaterial.Object);
+
+            // Assert
+            mockTargetMaterial.VerifySet(t => t.MaterialEntity = It.IsAny<ILibMaterialEntity>(), Times.Never);
+            //mockTargetMaterial.Verify(t => t.SafetyFactors.Clear(), Times.Never);
+            mockTargetMaterial.VerifySet(t => t.MaterialLogic = It.IsAny<IMaterialLogic>(), Times.Never);
+        }
+    }
+
+}