diff --git a/DataAccess/DTOs/DTOEntities/FactoredCombinationPropertyDTO.cs b/DataAccess/DTOs/DTOEntities/FactoredCombinationPropertyDTO.cs
index 8bb4c3b..14dfa9f 100644
--- a/DataAccess/DTOs/DTOEntities/FactoredCombinationPropertyDTO.cs
+++ b/DataAccess/DTOs/DTOEntities/FactoredCombinationPropertyDTO.cs
@@ -20,5 +20,10 @@ namespace DataAccess.DTOs
         {
             Id = id;
         }
+
+        public object Clone()
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/DataAccess/DTOs/DTOEntities/Obsolete/ForceCombinationByFactorV1_0DTO.cs b/DataAccess/DTOs/DTOEntities/Obsolete/ForceCombinationByFactorV1_0DTO.cs
index c7c3ad6..ed9c753 100644
--- a/DataAccess/DTOs/DTOEntities/Obsolete/ForceCombinationByFactorV1_0DTO.cs
+++ b/DataAccess/DTOs/DTOEntities/Obsolete/ForceCombinationByFactorV1_0DTO.cs
@@ -35,7 +35,7 @@ namespace DataAccess.DTOs
         {
             get
             {
-                return new FactoredCombinationProperty()
+                return new FactoredCombinationProperty(Guid.NewGuid())
                 {
                     CalcTerm = CalcTerm,
                     LimitState = LimitState,
diff --git a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml b/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
index 0866ea8..c338420 100644
--- a/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
+++ b/StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml
@@ -615,6 +615,15 @@
             </Canvas.Children>
         </Canvas>
     </DataTemplate>
+    <DataTemplate x:Key="ShearCalculator">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <TextBlock Text="+-" FontSize="20" FontWeight="Bold" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Margin="4,-6,0,0"/>
+                <Path Data="M2,26 v-8 h10 v2 l-8,6 z" Fill="DarkGray" Stroke="Black" StrokeThickness="1"/>
+                <Path Data="M14,22 v-2 h16 v8 h-24 z" Fill="DarkGray" Stroke="Black" StrokeThickness="1"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
     <DataTemplate x:Key="ShearRectangleSection">
         <Canvas Style="{DynamicResource ButtonResultCanvas}">
             <Canvas.Children>
diff --git a/StructureHelper/StructureHelper.csproj.user b/StructureHelper/StructureHelper.csproj.user
index 39209a9..24ec385 100644
--- a/StructureHelper/StructureHelper.csproj.user
+++ b/StructureHelper/StructureHelper.csproj.user
@@ -12,9 +12,18 @@
     <Compile Update="Windows\Arrays\ArrayView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Update="Windows\BeamShears\BeamShearActionView.xaml.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Update="Windows\BeamShears\BeamShearView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Update="Windows\BeamShears\ConcentratedForceView.xaml.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Update="Windows\BeamShears\UniformDistributedLoadView.xaml.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Update="Windows\CalculationWindows\CalculatorsViews\Cracks\CrackCalculatorInputDataView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
@@ -140,9 +149,18 @@
     <Page Update="Windows\Arrays\ArrayView.xaml">
       <SubType>Designer</SubType>
     </Page>
+    <Page Update="Windows\BeamShears\BeamShearActionView.xaml">
+      <SubType>Designer</SubType>
+    </Page>
     <Page Update="Windows\BeamShears\BeamShearView.xaml">
       <SubType>Designer</SubType>
     </Page>
+    <Page Update="Windows\BeamShears\ConcentratedForceView.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Update="Windows\BeamShears\UniformDistributedLoadView.xaml">
+      <SubType>Designer</SubType>
+    </Page>
     <Page Update="Windows\CalculationWindows\CalculatorsViews\Cracks\CrackCalculatorInputDataView.xaml">
       <SubType>Designer</SubType>
     </Page>
diff --git a/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml b/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml
new file mode 100644
index 0000000..b183f1d
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml
@@ -0,0 +1,13 @@
+<Window x:Class="StructureHelper.Windows.BeamShears.BeamShearActionView"
+        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.BeamShears"
+        d:DataContext="{d:DesignInstance local:BeamShearActionViewModel}"
+        mc:Ignorable="d"
+        Title="BeamShearActionView" Height="450" Width="800" ResizeMode="NoResize" WindowStartupLocation="CenterScreen">
+    <Grid>
+        
+    </Grid>
+</Window>
diff --git a/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml.cs b/StructureHelper/Windows/BeamShears/BeamShearActionView.xaml.cs
new file mode 100644
index 0000000..802d29c
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/BeamShearActionView.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.BeamShears
+{
+    /// <summary>
+    /// Interaction logic for BeamShearActionView.xaml
+    /// </summary>
+    public partial class BeamShearActionView : Window
+    {
+        public BeamShearActionView()
+        {
+            InitializeComponent();
+        }
+    }
+}
diff --git a/StructureHelper/Windows/BeamShears/BeamShearActionViewModel.cs b/StructureHelper/Windows/BeamShears/BeamShearActionViewModel.cs
new file mode 100644
index 0000000..a162469
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/BeamShearActionViewModel.cs
@@ -0,0 +1,22 @@
+using StructureHelper.Windows.ViewModels;
+using StructureHelperCommon.Models.Forces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelper.Windows.BeamShears
+{
+    public class BeamShearActionViewModel : OkCancelViewModelBase
+    {
+        private readonly IBeamShearAction shearAction;
+        public BeamShearLoadsViewModel ShearLoads { get; private set; }
+
+        public BeamShearActionViewModel(IBeamShearAction shearAction)
+        {
+            this.shearAction = shearAction;
+            ShearLoads = new(this.shearAction.YAxisShearAction.ShearLoads);
+        }
+    }
+}
diff --git a/StructureHelper/Windows/BeamShears/BeamShearCalculatorsViewModel.cs b/StructureHelper/Windows/BeamShears/BeamShearCalculatorsViewModel.cs
index 53e5b48..c449294 100644
--- a/StructureHelper/Windows/BeamShears/BeamShearCalculatorsViewModel.cs
+++ b/StructureHelper/Windows/BeamShears/BeamShearCalculatorsViewModel.cs
@@ -1,5 +1,6 @@
 using StructureHelper.Infrastructure;
 using StructureHelper.Infrastructure.Enums;
+using StructureHelper.Windows.CalculationWindows.ProgressViews;
 using StructureHelper.Windows.ViewModels;
 using StructureHelper.Windows.ViewModels.Errors;
 using StructureHelperCommon.Infrastructures.Exceptions;
@@ -31,7 +32,7 @@ namespace StructureHelper.Windows.BeamShears
                     runCommand = new RelayCommand(param =>
                     {
                         RunMethod(param);
-                    }
+                    }, o => SelectedItem != null
                     ));
             }
         }
@@ -86,6 +87,14 @@ namespace StructureHelper.Windows.BeamShears
         }
         private void RunCalculator()
         {
+            if (SelectedItem.TraceLogger is not null)
+            {
+                SelectedItem.TraceLogger.TraceLoggerEntries.Clear();
+            }
+            else
+            {
+                SelectedItem.TraceLogger = new ShiftTraceLogger();
+            }
             if (SelectedItem is IBeamShearCalculator beamShearCalculator)
             {
                 beamShearCalculator.Run();
@@ -94,6 +103,7 @@ namespace StructureHelper.Windows.BeamShears
             {
                 throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(SelectedItem));
             }
+            TraceDocumentService.ShowDocument(SelectedItem.TraceLogger.TraceLoggerEntries);
         }
     }
 }
diff --git a/StructureHelper/Windows/BeamShears/BeamShearLoadsViewModel.cs b/StructureHelper/Windows/BeamShears/BeamShearLoadsViewModel.cs
new file mode 100644
index 0000000..a930bf4
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/BeamShearLoadsViewModel.cs
@@ -0,0 +1,31 @@
+using StructureHelper.Windows.ViewModels;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Models.Forces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelper.Windows.BeamShears
+{
+    public class BeamShearLoadsViewModel : SelectItemVM<IBeamShearLoad>
+    {
+        public BeamShearLoadsViewModel(List<IBeamShearLoad> collection) : base(collection)
+        {
+        }
+
+        public override void EditMethod(object parameter)
+        {
+            if (SelectedItem is IDistributedLoad distributedLoad)
+            {
+
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(SelectedItem));
+            }
+            base.EditMethod(parameter);
+        }
+    }
+}
diff --git a/StructureHelper/Windows/BeamShears/BeamShearView.xaml b/StructureHelper/Windows/BeamShears/BeamShearView.xaml
index b8274ea..acf97fe 100644
--- a/StructureHelper/Windows/BeamShears/BeamShearView.xaml
+++ b/StructureHelper/Windows/BeamShears/BeamShearView.xaml
@@ -17,7 +17,7 @@
                     <Button.ToolTip>
                         <uc:ButtonToolTipEh HeaderText="Shear action"
                                                 IconContent="{StaticResource DistributedLoad}"
-                                                DescriptionText="Add beam shear action"/>
+                                                DescriptionText="Adds beam shear action"/>
                     </Button.ToolTip>
                     <Viewbox>
                         <ContentControl ContentTemplate="{DynamicResource DistributedLoad}"/>
@@ -44,7 +44,7 @@
                     <Button.ToolTip>
                         <uc:ButtonToolTipEh HeaderText="Add stirrups by density"
                                                 IconContent="{StaticResource StirrupDensity}"
-                                                DescriptionText="Add uniformly distributed stirrups by value of density"/>
+                                                DescriptionText="Adds uniformly distributed stirrups by value of density"/>
                     </Button.ToolTip>
                     <Viewbox>
                         <ContentControl ContentTemplate="{DynamicResource StirrupDensity}"/>
@@ -54,25 +54,25 @@
                         Command="{Binding Add}"
                         CommandParameter="{x:Static enums:StirrupTypes.UniformRebar}">
                     <Button.ToolTip>
-                        <uc:ButtonToolTipEh HeaderText="Open file"
+                        <uc:ButtonToolTipEh HeaderText="Add stirrup by rebars"
                                                 IconContent="{StaticResource StirrupRebars}"
-                                                DescriptionText="Add uniformly distributed stirrups by rebars (step, diameter, strength)"/>
+                                                DescriptionText="Adds uniformly distributed stirrups by rebars (step, diameter, strength)"/>
                     </Button.ToolTip>
                     <Viewbox>
                         <ContentControl ContentTemplate="{DynamicResource StirrupRebars}"/>
                     </Viewbox>
                 </Button>
             </ToolBar>
-            <ToolBar ToolTip="Calculators">
+            <ToolBar ToolTip="Calculators" DataContext="{Binding Calculators}">
                 <Button Style="{StaticResource ToolButton}" 
-                        Command="{Binding FileOpen}">
+                        Command="{Binding Add}" CommandParameter="{x:Static enums:CalculatorTypes.BeamShearCalculator}">
                     <Button.ToolTip>
-                        <uc:ButtonToolTipEh HeaderText="Open file"
-                                                IconContent="{StaticResource FileOpen}"
-                                                DescriptionText="Open exsisting project from file"/>
+                        <uc:ButtonToolTipEh HeaderText="Add shear calculator"
+                                                IconContent="{StaticResource ShearCalculator}"
+                                                DescriptionText="Creates new shear beam calculator"/>
                     </Button.ToolTip>
                     <Viewbox>
-                        <ContentControl ContentTemplate="{DynamicResource FileOpen}"/>
+                        <ContentControl ContentTemplate="{DynamicResource ShearCalculator}"/>
                     </Viewbox>
                 </Button>
             </ToolBar>
@@ -80,7 +80,7 @@
                 <Button Style="{StaticResource ToolButton}" 
                         Command="{Binding AddTemplate}">
                     <Button.ToolTip>
-                        <uc:ButtonToolTipEh HeaderText="Open file"
+                        <uc:ButtonToolTipEh HeaderText="Create rectangle template"
                                                 IconContent="{StaticResource ShearSectionTemplate}"
                                                 DescriptionText="Create rectangle section by template"/>
                     </Button.ToolTip>
diff --git a/StructureHelper/Windows/BeamShears/ConcentratedForceView.xaml b/StructureHelper/Windows/BeamShears/ConcentratedForceView.xaml
new file mode 100644
index 0000000..639e836
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/ConcentratedForceView.xaml
@@ -0,0 +1,38 @@
+<Window x:Class="StructureHelper.Windows.BeamShears.ConcentratedForceView"
+        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.BeamShears"
+        d:DataContext="{d:DesignInstance local:ConcentratedForceViewModel}"
+        mc:Ignorable="d"
+        Title="ConcentratedForceView" Height="200" Width="300" ResizeMode="NoResize" WindowStartupLocation="CenterOwner">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition/>
+            <RowDefinition Height="40"/>
+        </Grid.RowDefinitions>
+        <Grid>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="150"/>
+                <ColumnDefinition/>
+            </Grid.ColumnDefinitions>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="25"/>
+                <RowDefinition Height="25"/>
+                <RowDefinition Height="25"/>
+                <RowDefinition Height="25"/>
+                <RowDefinition/>
+            </Grid.RowDefinitions>
+            <TextBlock Text="Load value"/>
+            <TextBox Grid.Column="1" Text="{Binding ForceValue}"/>
+            <TextBlock Grid.Row="1" Text="Substract ratio"/>
+            <TextBox Grid.Row="1" Grid.Column="1" Text="{Binding LoadRatio, Converter={StaticResource PlainDouble}}"/>
+            <TextBlock Grid.Row="2" Text="Relative applying level"/>
+            <TextBox Grid.Row="2" Grid.Column="1" Text="{Binding RelativeLevel, Converter={StaticResource LengthConverter}}"/>
+            <TextBlock Grid.Row="3" Text="Force point"/>
+            <TextBox Grid.Row="3" Grid.Column="1" Text="{Binding ForceCoordinate, Converter={StaticResource LengthConverter}}"/>
+        </Grid>
+        <ContentControl Grid.Row="1" ContentTemplate="{StaticResource OkCancelButtons}" Content="{Binding}"/>
+    </Grid>
+</Window>
diff --git a/StructureHelper/Windows/BeamShears/ConcentratedForceView.xaml.cs b/StructureHelper/Windows/BeamShears/ConcentratedForceView.xaml.cs
new file mode 100644
index 0000000..98cd997
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/ConcentratedForceView.xaml.cs
@@ -0,0 +1,24 @@
+using StructureHelperCommon.Models.Forces;
+using System.Windows;
+
+namespace StructureHelper.Windows.BeamShears
+{
+    /// <summary>
+    /// Interaction logic for ConcentratedForceView.xaml
+    /// </summary>
+    public partial class ConcentratedForceView : Window
+    {
+        private readonly ConcentratedForceViewModel viewModel;
+        public ConcentratedForceView(ConcentratedForceViewModel viewModel)
+        {
+            InitializeComponent();
+            this.viewModel = viewModel;
+            DataContext = this.viewModel;
+            this.viewModel.ParentWindow = this;
+        }
+        public ConcentratedForceView(IConcentratedForce concenratedForce) : this(new ConcentratedForceViewModel(concenratedForce))
+        {
+            
+        }
+    }
+}
diff --git a/StructureHelper/Windows/BeamShears/ConcentratedForceViewModel.cs b/StructureHelper/Windows/BeamShears/ConcentratedForceViewModel.cs
new file mode 100644
index 0000000..3a8c53c
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/ConcentratedForceViewModel.cs
@@ -0,0 +1,58 @@
+using StructureHelper.Windows.ViewModels;
+using StructureHelperCommon.Models.Forces;
+
+namespace StructureHelper.Windows.BeamShears
+{
+    public class ConcentratedForceViewModel : OkCancelViewModelBase
+    {
+        private readonly IConcentratedForce concenratedForce;
+
+        public double ForceCoordinate
+        {
+            get => concenratedForce.ForceCoordinate;
+            set
+            {
+                concenratedForce.ForceCoordinate = value;
+            }
+        }
+        public double ForceValue
+        {
+            get => concenratedForce.ForceValue;
+            set
+            {
+                concenratedForce.ForceValue = value;
+            }
+        }
+        public double LoadRatio
+        {
+            get => concenratedForce.LoadRatio;
+            set
+            {
+                concenratedForce.LoadRatio = value;
+            }
+        }
+        public double RelativeLevel
+        {
+            get => concenratedForce.RelativeLoadLevel;
+            set
+            {
+                if (value > 0.5d)
+                {
+                    concenratedForce.RelativeLoadLevel = 0.5;
+                    return;
+                }
+                if (value < -0.5d)
+                {
+                    concenratedForce.RelativeLoadLevel = -0.5;
+                    return;
+                }
+                concenratedForce.RelativeLoadLevel = value;
+            }
+        }
+
+        public ConcentratedForceViewModel(IConcentratedForce concenratedForce)
+        {
+            this.concenratedForce = concenratedForce;
+        }
+    }
+}
diff --git a/StructureHelper/Windows/BeamShears/UniformDistributedLoadView.xaml b/StructureHelper/Windows/BeamShears/UniformDistributedLoadView.xaml
new file mode 100644
index 0000000..3bcbcbb
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/UniformDistributedLoadView.xaml
@@ -0,0 +1,41 @@
+<Window x:Class="StructureHelper.Windows.BeamShears.UniformDistributedLoadView"
+        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.BeamShears"
+        d:DataContext="{d:DesignInstance local:UniformDistributedLoadViewModel}"
+        mc:Ignorable="d"
+        Title="Uniformly Distributed Load" Height="200" Width="300" ResizeMode="NoResize" WindowStartupLocation="CenterOwner">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition/>
+            <RowDefinition Height="40"/>
+        </Grid.RowDefinitions>
+        <Grid>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="150"/>
+                <ColumnDefinition/>
+            </Grid.ColumnDefinitions>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="25"/>
+                <RowDefinition Height="25"/>
+                <RowDefinition Height="25"/>
+                <RowDefinition Height="25"/>
+                <RowDefinition Height="25"/>
+                <RowDefinition/>
+            </Grid.RowDefinitions>
+            <TextBlock Text="Load value"/>
+            <TextBox Grid.Column="1" Text="{Binding LoadValue}"/>
+            <TextBlock Grid.Row="1" Text="Substract ratio"/>
+            <TextBox Grid.Row="1" Grid.Column="1" Text="{Binding LoadRatio, Converter={StaticResource PlainDouble}}"/>
+            <TextBlock Grid.Row="2" Text="Relative applying level"/>
+            <TextBox Grid.Row="2" Grid.Column="1" Text="{Binding RelativeLevel, Converter={StaticResource LengthConverter}}"/>
+            <TextBlock Grid.Row="3" Text="Start point"/>
+            <TextBox Grid.Row="3" Grid.Column="1" Text="{Binding StartCoordinate, Converter={StaticResource LengthConverter}}"/>
+            <TextBlock Grid.Row="4" Text="End point"/>
+            <TextBox Grid.Row="4" Grid.Column="1" Text="{Binding EndCoordinate, Converter={StaticResource LengthConverter}}"/>
+        </Grid>
+        <ContentControl Grid.Row="1" ContentTemplate="{StaticResource OkCancelButtons}" Content="{Binding}"/>
+    </Grid>
+</Window>
diff --git a/StructureHelper/Windows/BeamShears/UniformDistributedLoadView.xaml.cs b/StructureHelper/Windows/BeamShears/UniformDistributedLoadView.xaml.cs
new file mode 100644
index 0000000..cf4d120
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/UniformDistributedLoadView.xaml.cs
@@ -0,0 +1,37 @@
+using StructureHelperCommon.Models.Forces;
+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.BeamShears
+{
+    /// <summary>
+    /// Interaction logic for UniformDistributedLoadView.xaml
+    /// </summary>
+    public partial class UniformDistributedLoadView : Window
+    {
+        private readonly UniformDistributedLoadViewModel viewModel;
+        public UniformDistributedLoadView(UniformDistributedLoadViewModel viewModel)
+        {
+            InitializeComponent();
+            this.viewModel = viewModel;
+            this.DataContext = this.viewModel;
+            this.viewModel.ParentWindow = this;
+        }
+
+        public UniformDistributedLoadView(IDistributedLoad distributedLoad) : this(new UniformDistributedLoadViewModel(distributedLoad))
+        {
+            
+        }
+    }
+}
diff --git a/StructureHelper/Windows/BeamShears/UniformDistributedLoadViewModel.cs b/StructureHelper/Windows/BeamShears/UniformDistributedLoadViewModel.cs
new file mode 100644
index 0000000..7761255
--- /dev/null
+++ b/StructureHelper/Windows/BeamShears/UniformDistributedLoadViewModel.cs
@@ -0,0 +1,71 @@
+using StructureHelper.Windows.ViewModels;
+using StructureHelperCommon.Models.Forces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelper.Windows.BeamShears
+{
+    public class UniformDistributedLoadViewModel : OkCancelViewModelBase
+    {
+        private readonly IDistributedLoad distributedLoad;
+
+        public double LoadRatio
+        {
+            get => distributedLoad.LoadRatio;
+            set
+            {
+                distributedLoad.LoadRatio = value;
+            }
+        }
+        public double LoadValue
+        {
+            get => distributedLoad.LoadValue * -1;
+            set
+            {
+                distributedLoad.LoadValue = value * -1;
+            }
+        }
+        public double RelativeLevel
+        {
+            get => distributedLoad.RelativeLoadLevel;
+            set
+            {
+                if (value > 0.5d)
+                {
+                    distributedLoad.RelativeLoadLevel = 0.5;
+                    return;
+                }
+                if (value < -0.5d)
+                {
+                    distributedLoad.RelativeLoadLevel = -0.5;
+                    return;
+                }
+                distributedLoad.RelativeLoadLevel = value;
+            }
+        }
+        public double StartCoordinate
+        {
+            get => distributedLoad.StartCoordinate;
+            set
+            {
+                distributedLoad.StartCoordinate = value;
+            }
+        }
+        public double EndCoordinate
+        {
+            get => distributedLoad.EndCoordinate;
+            set
+            {
+                distributedLoad.EndCoordinate = value;
+            }
+        }
+
+        public UniformDistributedLoadViewModel(IDistributedLoad distributedLoad)
+        {
+            this.distributedLoad = distributedLoad;
+        }
+    }
+}
diff --git a/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentService.cs b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentService.cs
new file mode 100644
index 0000000..5c3875b
--- /dev/null
+++ b/StructureHelper/Windows/CalculationWindows/ProgressViews/TraceDocumentService.cs
@@ -0,0 +1,23 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelper.Windows.CalculationWindows.ProgressViews
+{
+    public static class TraceDocumentService
+    {
+        public static void ShowDocument(IEnumerable<ITraceLoggerEntry> traceLoggerEntries)
+        {
+            if (traceLoggerEntries is null)
+            {
+                throw new StructureHelperException(ErrorStrings.ParameterIsNull + ": Document entries");
+            }
+            var wnd = new TraceDocumentView(traceLoggerEntries);
+            wnd.ShowDialog();
+        }
+    }
+}
diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs
index db3b76e..ba5a6d6 100644
--- a/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs
+++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs
@@ -210,12 +210,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections
                     ProcessResult();
                 }
             }
-
-            if (SelectedItem.TraceLogger is not null)
-            {
-                var wnd = new TraceDocumentView(SelectedItem.TraceLogger.TraceLoggerEntries);
-                wnd.ShowDialog();
-            }
+            TraceDocumentService.ShowDocument(SelectedItem.TraceLogger.TraceLoggerEntries);
         }
 
         private void ShowInteractionDiagramByInputData(LimitCurvesCalculator calculator)
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAction.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAction.cs
new file mode 100644
index 0000000..7306e41
--- /dev/null
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAction.cs
@@ -0,0 +1,32 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Forces.BeamShearActions
+{
+    public class BeamShearAction : IBeamShearAction
+    {
+        private IUpdateStrategy<IBeamShearAction> updateStrategy;
+        public Guid Id { get; }
+        public string Name { get; set; }
+        public IBeamShearAxisAction XAxisShearAction { get; } = new BeamShearAxisAction(Guid.NewGuid());
+
+        public IBeamShearAxisAction YAxisShearAction { get; } = new BeamShearAxisAction(Guid.NewGuid());
+
+        public BeamShearAction(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            BeamShearAction beamShearAction = new(Guid.NewGuid());
+            updateStrategy ??= new BeamShearActionUpdateStrategy();
+            updateStrategy.Update(beamShearAction, this);
+            return beamShearAction;
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearActionUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearActionUpdateStrategy.cs
new file mode 100644
index 0000000..39755dc
--- /dev/null
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearActionUpdateStrategy.cs
@@ -0,0 +1,28 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+
+namespace StructureHelperCommon.Models.Forces.BeamShearActions
+{
+    public class BeamShearActionUpdateStrategy : IUpdateStrategy<IBeamShearAction>
+    {
+        private IUpdateStrategy<IBeamShearAxisAction> axisActionUpdateStrategy;
+        public void Update(IBeamShearAction targetObject, IBeamShearAction sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            InitializeStrategies();
+            CheckObject.IsNull(targetObject.XAxisShearAction);
+            CheckObject.IsNull(sourceObject.XAxisShearAction);
+            axisActionUpdateStrategy.Update(targetObject.XAxisShearAction, sourceObject.XAxisShearAction);
+            CheckObject.IsNull(sourceObject.YAxisShearAction);
+            CheckObject.IsNull(targetObject.YAxisShearAction);
+            axisActionUpdateStrategy.Update(targetObject.YAxisShearAction, sourceObject.YAxisShearAction);
+        }
+
+        private void InitializeStrategies()
+        {
+            axisActionUpdateStrategy ??= new BeamShearAxisActionUpdateStrategy();
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisAction.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisAction.cs
new file mode 100644
index 0000000..7ad9b37
--- /dev/null
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisAction.cs
@@ -0,0 +1,37 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Forces.BeamShearActions
+{
+    /// <inheritdoc/>
+    public class BeamShearAxisAction : IBeamShearAxisAction
+    {
+        private IUpdateStrategy<IBeamShearAxisAction> updateStrategy;
+        ///<inheritdoc/>
+        public Guid Id { get; }
+        ///<inheritdoc/>
+        public string Name { get; set; } = string.Empty;
+        ///<inheritdoc/>
+        public double SupportShearForce { get; set; }
+        ///<inheritdoc/>
+        public IFactoredCombinationProperty FactoredCombinationProperty { get; } = new FactoredCombinationProperty(Guid.NewGuid());
+        ///<inheritdoc/>
+        public List<IBeamShearLoad> ShearLoads { get; }
+
+
+        public BeamShearAxisAction(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            BeamShearAxisAction beamShearAxisAction = new(Guid.NewGuid());
+            return beamShearAxisAction;
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisActionUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisActionUpdateStrategy.cs
new file mode 100644
index 0000000..5ef0235
--- /dev/null
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisActionUpdateStrategy.cs
@@ -0,0 +1,41 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces.Logics;
+using StructureHelperCommon.Services;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Forces.BeamShearActions
+{
+    public class BeamShearAxisActionUpdateStrategy : IUpdateStrategy<IBeamShearAxisAction>
+    {
+        private IUpdateStrategy<IFactoredCombinationProperty> combinationUpdateStrategy;
+        public void Update(IBeamShearAxisAction targetObject, IBeamShearAxisAction sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            InitializeStrategies();
+            targetObject.Name = sourceObject.Name;
+            targetObject.SupportShearForce = sourceObject.SupportShearForce;
+            CheckObject.IsNull(targetObject.FactoredCombinationProperty);
+            CheckObject.IsNull(sourceObject.FactoredCombinationProperty);
+            combinationUpdateStrategy.Update(targetObject.FactoredCombinationProperty, sourceObject.FactoredCombinationProperty);
+            CheckObject.IsNull(targetObject.ShearLoads);
+            targetObject.ShearLoads.Clear();
+            CheckObject.IsNull(sourceObject.ShearLoads);
+            foreach (var item in sourceObject.ShearLoads)
+            {
+                IBeamShearLoad beamShearLoad = item.Clone() as IBeamShearLoad;
+                targetObject.ShearLoads.Add(beamShearLoad);
+            }
+        }
+
+        private void InitializeStrategies()
+        {
+            combinationUpdateStrategy ??= new FactoredCombinationPropertyUpdateStrategy(); 
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs
new file mode 100644
index 0000000..078595b
--- /dev/null
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs
@@ -0,0 +1,23 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Forces.BeamShearActions
+{
+    public class BeamShearLoadBaseUpdateStrategy : IUpdateStrategy<IBeamShearLoad>
+    {
+        public void Update(IBeamShearLoad targetObject, IBeamShearLoad sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            targetObject.Name = sourceObject.Name;
+            targetObject.LoadRatio = sourceObject.LoadRatio;
+            targetObject.RelativeLoadLevel = sourceObject.RelativeLoadLevel;
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadUpdateStrategy.cs
new file mode 100644
index 0000000..a463071
--- /dev/null
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadUpdateStrategy.cs
@@ -0,0 +1,54 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Forces.BeamShearActions
+{
+    public class BeamShearLoadUpdateStrategy : IUpdateStrategy<IBeamShearLoad>
+    {
+        private IUpdateStrategy<IConcentratedForce> concentratedForceUpdateStrategy;
+        private IUpdateStrategy<IDistributedLoad> distributedLoadUpdateStrategy;
+        public void Update(IBeamShearLoad targetObject, IBeamShearLoad sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            InitializeStrategies();
+            UpdateObjects(targetObject, sourceObject);
+        }
+
+        private void UpdateObjects(IBeamShearLoad targetObject, IBeamShearLoad sourceObject)
+        {
+            if (sourceObject is IDistributedLoad distributedSource)
+            {
+                if (targetObject is IDistributedLoad distributedTarget)
+                {
+                    distributedLoadUpdateStrategy.Update(distributedTarget, distributedSource);
+                    return;
+                }
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject) + ": target object is not distributed load");
+            }
+            if (sourceObject is IConcentratedForce concentratedSource)
+            {
+                if (targetObject is IConcentratedForce concentratedTarget)
+                {
+                    concentratedForceUpdateStrategy.Update(concentratedTarget, concentratedSource);
+                    return;
+                }
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(targetObject) + ": target object is not concentrated force");
+            }
+            throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(sourceObject));
+        }
+
+        private void InitializeStrategies()
+        {
+            concentratedForceUpdateStrategy ??= new ConcentratedForceUpdateStrategy();
+            distributedLoadUpdateStrategy ??= new DistributedLoadUpdateStrategy();
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForce.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForce.cs
index a861227..eb9f057 100644
--- a/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForce.cs
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForce.cs
@@ -1,4 +1,6 @@
 using NLog;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces.BeamShearActions;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -8,12 +10,15 @@ using System.Threading.Tasks;
 namespace StructureHelperCommon.Models.Forces
 {
     /// <inheritdoc/>
-    public class ConcentratedForce : IConcenratedForce
+    public class ConcentratedForce : IConcentratedForce
     {
         private double relativeLoadLevel;
+        private IUpdateStrategy<IConcentratedForce>? updateStrategy;
 
         /// <inheritdoc/>
-        public Guid Id { get; set; }
+        public Guid Id { get;}
+
+
         /// <inheritdoc/>
         public string Name { get; set; }
         /// <inheritdoc/>
@@ -33,10 +38,18 @@ namespace StructureHelperCommon.Models.Forces
         }
         /// <inheritdoc/>
         public double LoadRatio { get; set; } = 1;
+        public ConcentratedForce(Guid id)
+        {
+            Id = id;
+        }
 
+        /// <inheritdoc/>
         public object Clone()
         {
-            throw new NotImplementedException();
+            ConcentratedForce concentratedForce = new(Guid.NewGuid());
+            updateStrategy ??= new ConcentratedForceUpdateStrategy();
+            updateStrategy.Update(concentratedForce, this);
+            return concentratedForce;
         }
     }
 }
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForceUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForceUpdateStrategy.cs
new file mode 100644
index 0000000..5877888
--- /dev/null
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForceUpdateStrategy.cs
@@ -0,0 +1,25 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+
+namespace StructureHelperCommon.Models.Forces.BeamShearActions
+{
+    public class ConcentratedForceUpdateStrategy : IUpdateStrategy<IConcentratedForce>
+    {
+        private IUpdateStrategy<IBeamShearLoad> baseUpdateStrategy;
+        public void Update(IConcentratedForce targetObject, IConcentratedForce sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            InitializeStrategies();
+            baseUpdateStrategy.Update(targetObject, sourceObject);
+            targetObject.ForceValue = sourceObject.ForceValue;
+            targetObject.ForceCoordinate = sourceObject.ForceCoordinate;
+        }
+
+        private void InitializeStrategies()
+        {
+            baseUpdateStrategy ??= new BeamShearLoadBaseUpdateStrategy();
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/UniformlyDistributedLoad.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoad.cs
similarity index 65%
rename from StructureHelperCommon/Models/Forces/BeamShearActions/UniformlyDistributedLoad.cs
rename to StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoad.cs
index 4a3a130..081b2a1 100644
--- a/StructureHelperCommon/Models/Forces/BeamShearActions/UniformlyDistributedLoad.cs
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoad.cs
@@ -1,4 +1,6 @@
-using System;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces.BeamShearActions;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -6,9 +8,10 @@ using System.Threading.Tasks;
 
 namespace StructureHelperCommon.Models.Forces
 {
-    public class UniformlyDistributedLoad : IUniformlyDistributedLoad
+    public class DistributedLoad : IDistributedLoad
     {
         private double relativeLoadLevel;
+        private IUpdateStrategy<IDistributedLoad> updateStrategy;
 
         public Guid Id { get; }
 
@@ -30,14 +33,17 @@ namespace StructureHelperCommon.Models.Forces
         /// <inheritdoc/>
         public double LoadRatio { get; set; } = 1;
 
-        public UniformlyDistributedLoad(Guid id)
+        public DistributedLoad(Guid id)
         {
             Id = id;
         }
 
         public object Clone()
         {
-            throw new NotImplementedException();
+            DistributedLoad distributedLoad = new(Guid.NewGuid());
+            updateStrategy ??= new DistributedLoadUpdateStrategy();
+            updateStrategy.Update(distributedLoad, this);
+            return distributedLoad;
         }
     }
 }
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoadUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoadUpdateStrategy.cs
new file mode 100644
index 0000000..108f1fa
--- /dev/null
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoadUpdateStrategy.cs
@@ -0,0 +1,25 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+
+namespace StructureHelperCommon.Models.Forces.BeamShearActions
+{
+    public class DistributedLoadUpdateStrategy : IUpdateStrategy<IDistributedLoad>
+    {
+        private IUpdateStrategy<IBeamShearLoad> baseUpdateStrategy;
+        public void Update(IDistributedLoad targetObject, IDistributedLoad sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            InitializeStrategies();
+            baseUpdateStrategy.Update(targetObject, sourceObject);
+            targetObject.LoadValue = sourceObject.LoadValue;
+            targetObject.StartCoordinate = sourceObject.StartCoordinate;
+            targetObject.EndCoordinate = sourceObject.EndCoordinate;
+        }
+        private void InitializeStrategies()
+        {
+            baseUpdateStrategy ??= new BeamShearLoadBaseUpdateStrategy();
+        }
+    }
+}
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearAction.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearAction.cs
index d878070..fa7c031 100644
--- a/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearAction.cs
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearAction.cs
@@ -8,7 +8,7 @@ namespace StructureHelperCommon.Models.Forces
 {
     public interface IBeamShearAction : IAction
     {
-        IBeamShearAxisAction XAxisSheaAction { get; }
-        IBeamShearAxisAction YAxisSheaAction { get; }
+        IBeamShearAxisAction XAxisShearAction { get; }
+        IBeamShearAxisAction YAxisShearAction { get; }
     }
 }
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearAxisAction.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearAxisAction.cs
index cf0f653..d63e9d8 100644
--- a/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearAxisAction.cs
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearAxisAction.cs
@@ -11,7 +11,17 @@ namespace StructureHelperCommon.Models.Forces
     /// </summary>
     public interface IBeamShearAxisAction : IAction
     {
+        /// <summary>
+        /// Shear force at support point, N
+        /// </summary>
         double SupportShearForce { get; set; }
+        /// <summary>
+        /// Properties of combination of forces
+        /// </summary>
+        IFactoredCombinationProperty FactoredCombinationProperty { get; }
+        /// <summary>
+        /// Collection of loads which are applyed on beam at its span
+        /// </summary>
         List<IBeamShearLoad> ShearLoads {get;}
     }
 }
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearLoad.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearLoad.cs
index 459e404..5eb58d3 100644
--- a/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearLoad.cs
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/IBeamShearLoad.cs
@@ -12,7 +12,7 @@ namespace StructureHelperCommon.Models.Forces
     public interface IBeamShearLoad : IAction
     {
         /// <summary>
-        /// Value of level where action is applyied at, 0.5 is top surface, -0.5 is bottom surface
+        /// Value of level where action is applyied at, 0.5 is top surface of beam, -0.5 is bottom surface of beam
         /// </summary>
         double RelativeLoadLevel { get; set; }
         /// <summary>
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/IConcenratedForce.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/IConcentratedForce.cs
similarity index 90%
rename from StructureHelperCommon/Models/Forces/BeamShearActions/IConcenratedForce.cs
rename to StructureHelperCommon/Models/Forces/BeamShearActions/IConcentratedForce.cs
index f2dfca6..280a7a3 100644
--- a/StructureHelperCommon/Models/Forces/BeamShearActions/IConcenratedForce.cs
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/IConcentratedForce.cs
@@ -9,7 +9,7 @@ namespace StructureHelperCommon.Models.Forces
     /// <summary>
     /// Implement properties for concentrated load in beam
     /// </summary>
-    public interface IConcenratedForce : IBeamShearLoad
+    public interface IConcentratedForce : IBeamShearLoad
     {
         /// <summary>
         /// Coordinate of location of force along beam, m
diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/IUniformlyDistributedLoad.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/IDistributedLoad.cs
similarity index 89%
rename from StructureHelperCommon/Models/Forces/BeamShearActions/IUniformlyDistributedLoad.cs
rename to StructureHelperCommon/Models/Forces/BeamShearActions/IDistributedLoad.cs
index 8c1abfb..9876068 100644
--- a/StructureHelperCommon/Models/Forces/BeamShearActions/IUniformlyDistributedLoad.cs
+++ b/StructureHelperCommon/Models/Forces/BeamShearActions/IDistributedLoad.cs
@@ -3,7 +3,7 @@
     /// <summary>
     /// Implement properties of 
     /// </summary>
-    public interface IUniformlyDistributedLoad : IBeamShearLoad
+    public interface IDistributedLoad : IBeamShearLoad
     {
         /// <summary>
         /// Value of uniformly distributed load, N/m
diff --git a/StructureHelperCommon/Models/Forces/FactoredCombinationProperty.cs b/StructureHelperCommon/Models/Forces/FactoredCombinationProperty.cs
index a1df9f4..796b024 100644
--- a/StructureHelperCommon/Models/Forces/FactoredCombinationProperty.cs
+++ b/StructureHelperCommon/Models/Forces/FactoredCombinationProperty.cs
@@ -1,4 +1,6 @@
 using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces.Logics;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -10,6 +12,7 @@ namespace StructureHelperCommon.Models.Forces
     /// <inheritdoc/>
     public class FactoredCombinationProperty : IFactoredCombinationProperty
     {
+        private IUpdateStrategy<IFactoredCombinationProperty> updateStrategy;
         /// <inheritdoc/>
         public Guid Id { get; }
         /// <inheritdoc/>
@@ -25,9 +28,13 @@ namespace StructureHelperCommon.Models.Forces
         {
             Id = id;
         }
-        public FactoredCombinationProperty() : this(Guid.NewGuid())
+
+        public object Clone()
         {
-            
+            FactoredCombinationProperty factoredCombinationProperty = new(Guid.NewGuid());
+            updateStrategy ??= new FactoredCombinationPropertyUpdateStrategy();
+            updateStrategy.Update(factoredCombinationProperty, this);
+            return factoredCombinationProperty;
         }
     }
 }
diff --git a/StructureHelperCommon/Models/Forces/ForceCombinationFromFile.cs b/StructureHelperCommon/Models/Forces/ForceCombinationFromFile.cs
index aa915b7..3beac30 100644
--- a/StructureHelperCommon/Models/Forces/ForceCombinationFromFile.cs
+++ b/StructureHelperCommon/Models/Forces/ForceCombinationFromFile.cs
@@ -34,7 +34,7 @@ namespace StructureHelperCommon.Models.Forces
         public bool SetInGravityCenter { get; set; } = true;
         public IPoint2D ForcePoint { get; set; } = new Point2D();
 
-        public IFactoredCombinationProperty CombinationProperty { get; set; } = new FactoredCombinationProperty();
+        public IFactoredCombinationProperty CombinationProperty { get; set; } = new FactoredCombinationProperty(Guid.NewGuid());
 
         public object Clone()
         {
diff --git a/StructureHelperCommon/Models/Forces/ForceFactoredList.cs b/StructureHelperCommon/Models/Forces/ForceFactoredList.cs
index e5891e0..45cdcad 100644
--- a/StructureHelperCommon/Models/Forces/ForceFactoredList.cs
+++ b/StructureHelperCommon/Models/Forces/ForceFactoredList.cs
@@ -23,7 +23,7 @@ namespace StructureHelperCommon.Models.Forces
         /// <inheritdoc/>
         public List<IForceTuple> ForceTuples { get; } = new() { new ForceTuple()};
         /// <inheritdoc/>
-        public IFactoredCombinationProperty CombinationProperty { get; set; }= new FactoredCombinationProperty();
+        public IFactoredCombinationProperty CombinationProperty { get; set; }= new FactoredCombinationProperty(Guid.NewGuid());
 
 
         public ForceFactoredList(Guid id)
diff --git a/StructureHelperCommon/Models/Forces/IFactoredCombinationProperty.cs b/StructureHelperCommon/Models/Forces/IFactoredCombinationProperty.cs
index 9cc437a..91b79c6 100644
--- a/StructureHelperCommon/Models/Forces/IFactoredCombinationProperty.cs
+++ b/StructureHelperCommon/Models/Forces/IFactoredCombinationProperty.cs
@@ -11,7 +11,7 @@ namespace StructureHelperCommon.Models.Forces
     /// <summary>
     /// Properties of factored combination of forces
     /// </summary>
-    public interface IFactoredCombinationProperty : ISaveable
+    public interface IFactoredCombinationProperty : ISaveable, ICloneable
     {
         /// <summary>
         /// Term of calculation for assigned combination
diff --git a/StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs
index 8aeef73..4ee7f45 100644
--- a/StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs
+++ b/StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs
@@ -8,9 +8,9 @@ using System.Threading.Tasks;
 
 namespace StructureHelperCommon.Models.Forces
 {
-    public class UniformlyDisributedLoadUpdateStrategy : IUpdateStrategy<IUniformlyDistributedLoad>
+    public class UniformlyDisributedLoadUpdateStrategy : IUpdateStrategy<IDistributedLoad>
     {
-        public void Update(IUniformlyDistributedLoad targetObject, IUniformlyDistributedLoad sourceObject)
+        public void Update(IDistributedLoad targetObject, IDistributedLoad sourceObject)
         {
             CheckObject.IsNull(targetObject);
             CheckObject.IsNull(sourceObject);
diff --git a/StructureHelperLogics/Models/BeamShears/Logics/GetSumForceByShearActionLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/GetSumForceByShearActionLogic.cs
index 74223f2..7ccb246 100644
--- a/StructureHelperLogics/Models/BeamShears/Logics/GetSumForceByShearActionLogic.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/GetSumForceByShearActionLogic.cs
@@ -20,11 +20,11 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public double GetSumShearForce(IBeamShearLoad beamShearAction, double startCoord, double endCoord)
         {
-            if (beamShearAction is IUniformlyDistributedLoad distributedLoad)
+            if (beamShearAction is IDistributedLoad distributedLoad)
             {
                 return GetDistributedLoadSum(distributedLoad, startCoord, endCoord);
             }
-            else if (beamShearAction is IConcenratedForce concenratedForce)
+            else if (beamShearAction is IConcentratedForce concenratedForce)
             {
                 return GetConcentratedForceSum(concenratedForce, startCoord, endCoord);
             }
@@ -34,7 +34,7 @@ namespace StructureHelperLogics.Models.BeamShears
             }
         }
 
-        private double GetConcentratedForceSum(IConcenratedForce concentratedForce, double startCoord, double endCoord)
+        private double GetConcentratedForceSum(IConcentratedForce concentratedForce, double startCoord, double endCoord)
         {
             TraceLogger?.AddMessage($"Concentrated force Name = {concentratedForce.Name}, Value = {concentratedForce.ForceValue}(N/m) ");
             if (concentratedForce.ForceCoordinate > endCoord)
@@ -61,7 +61,7 @@ namespace StructureHelperLogics.Models.BeamShears
             return totalLoad;
         }
 
-        private double GetDistributedLoadSum(IUniformlyDistributedLoad distributedLoad, double startCoord, double endCoord)
+        private double GetDistributedLoadSum(IDistributedLoad distributedLoad, double startCoord, double endCoord)
         {
             TraceLogger?.AddMessage($"Uniformly distributed load Name = {distributedLoad.Name}, Value = {distributedLoad.LoadValue}(N/m) ");
             double loadStartCoord = Math.Max(distributedLoad.StartCoordinate, 0d);