Add circle shape calculation for shear

DataAccess/DTOs/Converters/BeamShears/BeamShearSectionFromDTOConvertStrategy.cs

@@ -43,7 +43,7 @@ namespace DataAccess.DTOs
 
         private void InitializeStrategies()
         {
-            updateStrategy ??= new BeamShearSectionUpdateStrategy();
+            updateStrategy ??= new BeamShearSectionUpdateStrategy() { UpdateChildren = false};
             shapeConvertStrategy = new DictionaryConvertStrategy<IShape, IShape>
                 (this, new ShapeFromDTOConvertStrategy(this));
             concreteConvertStrategy = new ConcreteLibMaterialFromDTOConvertStrategy()

DataAccess/DTOs/Converters/BeamShears/BeamShearSectionToDTOConvertStrategy.cs

@@ -50,7 +50,7 @@ namespace DataAccess.DTOs
 
         private void InitializeStrategies()
         {
-            updateStrategy ??= new BeamShearSectionUpdateStrategy();
+            updateStrategy ??= new BeamShearSectionUpdateStrategy() { UpdateChildren = false};
             shapeConvertStrategy = new DictionaryConvertStrategy<IShape, IShape>
                 (this, new ShapeToDTOConvertStrategy(this));
             concreteConvertStrategy = new ConcreteLibMaterialToDTOConvertStrategy()

DataAccess/DTOs/Converters/CircleShapeFromDTOConvertStrategy.cs

@@ -0,0 +1,29 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataAccess.DTOs
+{
+    public class CircleShapeFromDTOConvertStrategy : ConvertStrategy<CircleShape, CircleShapeDTO>
+    {
+        private IUpdateStrategy<ICircleShape> updateStrategy;
+
+        public CircleShapeFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override CircleShape GetNewItem(CircleShapeDTO source)
+        {
+            ChildClass = this;
+            ChildClass = this;
+            updateStrategy ??= new CircleShapeUpdateStrategy();
+            NewItem = new CircleShape(source.Id);
+            updateStrategy.Update(NewItem, source);
+            return NewItem;
+        }
+    }
+}

DataAccess/DTOs/Converters/CircleShapeToDTOConvertStrategy.cs

@@ -0,0 +1,23 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+
+namespace DataAccess.DTOs
+{
+    public class CircleShapeToDTOConvertStrategy : ConvertStrategy<CircleShapeDTO, ICircleShape>
+    {
+        private IUpdateStrategy<ICircleShape> updateStrategy;
+
+        public CircleShapeToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override CircleShapeDTO GetNewItem(ICircleShape source)
+        {
+            ChildClass = this;
+            updateStrategy ??= new CircleShapeUpdateStrategy();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            return NewItem;
+        }
+    }
+}

DataAccess/DTOs/Converters/ShapeFromDTOConvertStrategy.cs

@@ -7,6 +7,7 @@ namespace DataAccess.DTOs
     internal class ShapeFromDTOConvertStrategy : ConvertStrategy<IShape, IShape>
     {
         private IConvertStrategy<RectangleShape, RectangleShapeDTO> rectangleConvertStrategy;
+        private IConvertStrategy<CircleShape, CircleShapeDTO> circleConvertStrategy;
 
         public ShapeFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
         {
@@ -14,12 +15,19 @@ namespace DataAccess.DTOs
 
         public override IShape GetNewItem(IShape source)
         {
+            ChildClass = this;
             if (source is RectangleShapeDTO rectangleShapeDTO)
             {
                 rectangleConvertStrategy ??= new DictionaryConvertStrategy<RectangleShape, RectangleShapeDTO>
                     (this, new RectangleShapeFromDTOConvertStrategy(this));
                 NewItem = rectangleConvertStrategy.Convert(rectangleShapeDTO);
             }
+            if (source is CircleShapeDTO circleShapeDTO)
+            {
+                circleConvertStrategy ??= new DictionaryConvertStrategy<CircleShape, CircleShapeDTO>
+                    (this, new CircleShapeFromDTOConvertStrategy(this));
+                NewItem = circleConvertStrategy.Convert(circleShapeDTO);
+            }
             else
             {
                 throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source) + ": shape is unknown");

DataAccess/DTOs/Converters/ShapeToDTOConvertStrategy.cs

@@ -8,6 +8,7 @@ namespace DataAccess.DTOs
     public class ShapeToDTOConvertStrategy : ConvertStrategy<IShape, IShape>
     {
         private IConvertStrategy<RectangleShapeDTO, IRectangleShape> rectangleConvertStrategy;
+        private IConvertStrategy<CircleShapeDTO, ICircleShape> circleConvertStrategy;
 
         public ShapeToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
         {
@@ -15,16 +16,9 @@ namespace DataAccess.DTOs
 
         public override IShape GetNewItem(IShape source)
         {
-            try
+            ChildClass = this;
-            {
+            GetNewShape(source);
-                GetNewShape(source);
+            return NewItem;
-                return NewItem;
-            }
-            catch (Exception ex)
-            {
-                TraceErrorByEntity(this, ex.Message);
-                throw;
-            }
         }
 
         private void GetNewShape(IShape source)
@@ -34,6 +28,10 @@ namespace DataAccess.DTOs
             {
                 ProcessRectangle(rectangle);
             }
+            else if (source is ICircleShape circle)
+            {
+                ProcessCircle(circle);
+            }
             else
             {
                 string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source) + ": shape type";
@@ -42,6 +40,14 @@ namespace DataAccess.DTOs
             TraceLogger?.AddMessage($"Shape converting Id = {NewItem.Id} has been has been finished successfully", TraceLogStatuses.Debug);
         }
 
+        private void ProcessCircle(ICircleShape circle)
+        {
+            TraceLogger?.AddMessage($"Shape is circle", TraceLogStatuses.Debug);
+            circleConvertStrategy = new DictionaryConvertStrategy<CircleShapeDTO, ICircleShape>
+                (this, new CircleShapeToDTOConvertStrategy(this));
+            NewItem = circleConvertStrategy.Convert(circle);
+        }
+
         private void ProcessRectangle(IRectangleShape rectangle)
         {
             TraceLogger?.AddMessage($"Shape is rectangle", TraceLogStatuses.Debug);

DataAccess/DTOs/DTOEntities/BeamShears/BeamShearCalculatorInputDataDTO.cs

@@ -14,7 +14,7 @@ namespace DataAccess.DTOs
         public List<IBeamShearSection> Sections { get; } = new();
         [JsonProperty("Stirrups")]
         public List<IStirrup> Stirrups { get; } = new();
-        public IBeamShearDesignRangeProperty DesignRangeProperty { get; set; }
+        public IBeamShearDesignRangeProperty DesignRangeProperty { get; set; } = new BeamShearDesignRangePropertyDTO(Guid.NewGuid());
 
         public BeamShearCalculatorInputDataDTO(Guid id)
         {

DataAccess/DTOs/DTOEntities/BeamShears/BeamShearDesignRangePropertyDTO.cs

@@ -10,9 +10,9 @@ namespace DataAccess.DTOs
         [JsonProperty("AbsoluteRangeValue")]
         public double AbsoluteRangeValue { get; set; } = 0.0;
         [JsonProperty("RelativeEffectiveDepthRangeValue")]
-        public double RelativeEffectiveDepthRangeValue { get; set; } = 3.0;
+        public double RelativeEffectiveDepthRangeValue { get; set; } = 3.3;
         [JsonProperty("StepCount")]
-        public int StepCount { get; set; } = 50;
+        public int StepCount { get; set; } = 55;
 
         public BeamShearDesignRangePropertyDTO(Guid id)
         {

DataAccess/DTOs/DTOEntities/BeamShears/BeamShearSectionDTO.cs

@@ -17,13 +17,13 @@ namespace DataAccess.DTOs
         [JsonProperty("Shape")]
         public IShape Shape { get; set; } = new RectangleShapeDTO(Guid.Empty);
         [JsonProperty("ConcreteMaterial")]
-        public IConcreteLibMaterial ConcreteMaterial { get; set; }
+        public IConcreteLibMaterial ConcreteMaterial { get; set; } = new ConcreteLibMaterial(Guid.NewGuid());
         [JsonProperty("CenterCover")]
         public double CenterCover { get; set; }
         [JsonProperty("ReinforcementArea")]
         public double ReinforcementArea { get; set; }
         [JsonProperty("ReinforcementMaterial")]
-        public IReinforcementLibMaterial ReinforcementMaterial { get; set; }
+        public IReinforcementLibMaterial ReinforcementMaterial { get; set; } = new ReinforcementLibMaterial(Guid.NewGuid());
 
         public BeamShearSectionDTO(Guid id)
         {

DataAccess/DTOs/DTOEntities/CircleShapeDTO.cs

@@ -0,0 +1,23 @@
+using Newtonsoft.Json;
+using StructureHelperCommon.Models.Shapes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataAccess.DTOs
+{
+    public class CircleShapeDTO : ICircleShape
+    {
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("Diameter")]
+        public double Diameter { get; set; }
+
+        public CircleShapeDTO(Guid id)
+        {
+            Id = id;
+        }
+    }
+}

DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs

@@ -34,6 +34,7 @@ namespace DataAccess.DTOs
             List<(Type type, string name)> newList = new List<(Type type, string name)>
             {
                 { (typeof(AccuracyDTO), "Accuracy") },
+                { (typeof(CircleShapeDTO), "CircleShape") },
                 { (typeof(ConcreteLibMaterialDTO), "ConcreteLibMaterial") },
                 { (typeof(ColumnFilePropertyDTO), "ColumnFileProperty") },
                 { (typeof(ColumnedFilePropertyDTO), "ColumnedFileProperty") },
@@ -119,6 +120,7 @@ namespace DataAccess.DTOs
                 { (typeof(BeamShearAnalysisDTO), "BeamShearAnalysis") },
                 { (typeof(BeamShearCalculatorDTO), "BeamShearCalculator") },
                 { (typeof(BeamShearCalculatorInputDataDTO), "BeamShearCalculatorInputData") },
+                { (typeof(BeamShearDesignRangePropertyDTO), "BeamShearDesignRangeProperty") },
                 { (typeof(BeamShearRepositoryDTO), "BeamShearRepository") },
                 { (typeof(BeamShearSectionDTO), "BeamShearSection") },
                 { (typeof(List<IBeamShearAction>), "ListOfBeamShearActions") },

StructureHelper/Infrastructure/UI/Resources/ButtonStyles.xaml

@@ -637,6 +637,19 @@
             </Canvas.Children>
         </Canvas>
     </DataTemplate>
+    <DataTemplate x:Key="ShearCircleSection">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Ellipse Canvas.Left="3" Canvas.Top="3" Width="26" Height="26" Fill="LightGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="14" Canvas.Top="5" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="21" Canvas.Top="10" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="7" Canvas.Top="10" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="21" Canvas.Top="17" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="7" Canvas.Top="17" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="14" Canvas.Top="22" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
     <DataTemplate x:Key="ShearRectangleSection">
         <Canvas Style="{DynamicResource ButtonResultCanvas}">
             <Canvas.Children>
@@ -646,7 +659,21 @@
             </Canvas.Children>
         </Canvas>
     </DataTemplate>
-    <DataTemplate x:Key="ShearSectionTemplate">
+    <DataTemplate x:Key="ShearSectionCircleTemplate">
+        <Canvas Style="{DynamicResource ButtonResultCanvas}">
+            <Canvas.Children>
+                <Ellipse Canvas.Left="3" Canvas.Top="3" Width="26" Height="26" Fill="LightGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="5" Canvas.Top="5" Width="22" Height="22" Fill="LightGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="14" Canvas.Top="7" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="20" Canvas.Top="10.5" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="8" Canvas.Top="10.5" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="20" Canvas.Top="16.5" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="8" Canvas.Top="16.5" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+                <Ellipse Canvas.Left="14" Canvas.Top="20" Width="4" Height="4" Fill="DarkGray" Stroke ="Black"/>
+            </Canvas.Children>
+        </Canvas>
+    </DataTemplate>
+    <DataTemplate x:Key="ShearSectionRectangleTemplate">
         <Canvas Style="{DynamicResource ButtonResultCanvas}">
             <Canvas.Children>
                 <Rectangle Canvas.Left="5" Canvas.Top="3" Width="22" Height="26" Fill="LightGray" Stroke ="Black"/>

StructureHelper/Windows/BeamShears/BeamShearActionResultView.xaml

@@ -21,6 +21,16 @@
                         <ContentControl ContentTemplate="{StaticResource Report}"/>
                     </Viewbox>
                 </Button>
+                <Button Style="{DynamicResource ToolButton}" Command="{Binding ShowDiagramCommand}">
+                    <Button.ToolTip>
+                        <uc:ButtonToolTipEh HeaderText="Show digram"
+                                                IconContent="{StaticResource MomentCurvatureDiagram}"
+                                                DescriptionText="Shows diagram for result where inclined section is started from selected result start point"/>
+                    </Button.ToolTip>
+                    <Viewbox>
+                        <ContentControl ContentTemplate="{StaticResource MomentCurvatureDiagram}"/>
+                    </Viewbox>
+                </Button>
             </ToolBar>
         </ToolBarTray>
         <Grid>

StructureHelper/Windows/BeamShears/BeamShearActionResultViewModel.cs

@@ -2,11 +2,7 @@
 using StructureHelper.Windows.CalculationWindows.CalculatorsViews;
 using StructureHelper.Windows.CalculationWindows.ProgressViews;
 using StructureHelperLogics.Models.BeamShears;
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows.Input;
 
 namespace StructureHelper.Windows.BeamShears
@@ -15,6 +11,7 @@ namespace StructureHelper.Windows.BeamShears
     {
         private IBeamShearActionResult result;
         private RelayCommand showTraceCommand;
+        private RelayCommand showDiagramCommand;
 
         public IBeamShearSectionLogicResult SelectedResult { get; set; }
         public List<IBeamShearSectionLogicResult> SectionResults => result.SectionResults;
@@ -27,6 +24,7 @@ namespace StructureHelper.Windows.BeamShears
         }
 
         public ICommand ShowTraceCommand => showTraceCommand ??= new RelayCommand(ShowTrace, o => SelectedResult != null);
+        public ICommand ShowDiagramCommand => showDiagramCommand ??= new RelayCommand(Show2DDiagram, o => SelectedResult != null);
 
         private void ShowTrace(object obj)
         {
@@ -34,5 +32,12 @@ namespace StructureHelper.Windows.BeamShears
             var traceWindows = new TraceDocumentView(SelectedResult.TraceLogger);
             traceWindows.ShowDialog();
         }
+
+        private void Show2DDiagram(object obj)
+        {
+            if (SelectedResult is null) { return; }
+            var logic = new ShearDiagramLogic(result);
+            logic.ShowWindow(SelectedResult.InputData.InclinedSection.StartCoord);
+        }
     }
 }

StructureHelper/Windows/BeamShears/BeamShearResultViewModel.cs

@@ -48,7 +48,7 @@ namespace StructureHelper.Windows.BeamShears
         {
             if (SelectedResult is null) { return; }
             var logic = new ShearDiagramLogic(SelectedResult);
-            logic.ShowWindow();
+            logic.ShowWindow(0.0);
         }
 
         private void ShowSectionResults(object commandParameter)

StructureHelper/Windows/BeamShears/BeamShearSectionsViewModel.cs

@@ -3,6 +3,7 @@ using StructureHelper.Windows.ViewModels;
 using StructureHelper.Windows.ViewModels.Errors;
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
 using StructureHelperLogics.Models.BeamShears;
 using System;
 using System.Windows;
@@ -50,6 +51,18 @@ namespace StructureHelper.Windows.BeamShears
                     Name = "New rectangle section"
                 };
             }
+            else if (sectionType is PrimitiveType.Circle)
+            {
+                NewItem = new BeamShearSection(Guid.NewGuid())
+                {
+                    Name = "New circle section",
+                    Shape = new CircleShape(Guid.NewGuid()) { Diameter = 0.6 }
+                };
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(sectionType));
+            }
         }
 
         private void EditSection()

StructureHelper/Windows/BeamShears/BeamShearView.xaml

@@ -37,6 +37,18 @@
                         <ContentControl ContentTemplate="{DynamicResource ShearRectangleSection}"/>
                     </Viewbox>
                 </Button>
+                <Button Style="{StaticResource ToolButton}" 
+                        Command="{Binding Add}"
+                        CommandParameter="{x:Static enums:PrimitiveType.Circle}">
+                    <Button.ToolTip>
+                        <uc:ButtonToolTipEh HeaderText="Circle section"
+                                                IconContent="{StaticResource ShearCircleSection}"
+                                                DescriptionText="Add circle shear section (diameter, strength)"/>
+                    </Button.ToolTip>
+                    <Viewbox>
+                        <ContentControl ContentTemplate="{DynamicResource ShearCircleSection}"/>
+                    </Viewbox>
+                </Button>
             </ToolBar>
             <ToolBar ToolTip="Stirrups" DataContext="{Binding Stirrups}">
                 <Button Style="{StaticResource ToolButton}" 
@@ -103,14 +115,27 @@ CommandParameter="{x:Static enums:StirrupTypes.GroupOfStirrups}">
             </ToolBar>
             <ToolBar ToolTip="Templates">
                 <Button Style="{StaticResource ToolButton}" 
-                        Command="{Binding AddTemplate}">
+                        Command="{Binding AddTemplate}"
+                        CommandParameter="{x:Static enums:PrimitiveType.Rectangle}">
                     <Button.ToolTip>
                         <uc:ButtonToolTipEh HeaderText="Create rectangle template"
-                                                IconContent="{StaticResource ShearSectionTemplate}"
+                                                IconContent="{StaticResource ShearSectionRectangleTemplate}"
                                                 DescriptionText="Create rectangle section by template"/>
                     </Button.ToolTip>
                     <Viewbox>
-                        <ContentControl ContentTemplate="{DynamicResource ShearSectionTemplate}"/>
+                        <ContentControl ContentTemplate="{DynamicResource ShearSectionRectangleTemplate}"/>
+                    </Viewbox>
+                </Button>
+                <Button Style="{StaticResource ToolButton}" 
+                        Command="{Binding AddTemplate}"
+                        CommandParameter="{x:Static enums:PrimitiveType.Circle}">
+                    <Button.ToolTip>
+                        <uc:ButtonToolTipEh HeaderText="Create circle template"
+                                                IconContent="{StaticResource ShearSectionCircleTemplate}"
+                                                DescriptionText="Create circle section by template"/>
+                    </Button.ToolTip>
+                    <Viewbox>
+                        <ContentControl ContentTemplate="{DynamicResource ShearSectionCircleTemplate}"/>
                     </Viewbox>
                 </Button>
             </ToolBar>

StructureHelper/Windows/BeamShears/BeamShearViewModel.cs

@@ -1,4 +1,6 @@
 using StructureHelper.Infrastructure;
+using StructureHelper.Infrastructure.Enums;
+using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperLogics.Models.Analyses;
 using StructureHelperLogics.Models.BeamShears;
 using System;
@@ -38,10 +40,24 @@ namespace StructureHelper.Windows.BeamShears
 
         private void AddTemplateMethod(object param)
         {
-            var templateRepository = BeamShearTemplatesFactory.GetTemplateRepository(ShearSectionTemplateTypes.Rectangle);
+            if (param is PrimitiveType.Rectangle)
-            var updateStrategy = new BeamShearRepositoryAddUpdateStrategy();
+            {
-            updateStrategy.Update(repository, templateRepository);
+                var templateRepository = BeamShearTemplatesFactory.GetTemplateRepository(ShearSectionTemplateTypes.Rectangle);
-            Refresh();
+                var updateStrategy = new BeamShearRepositoryAddUpdateStrategy();
+                updateStrategy.Update(repository, templateRepository);
+                Refresh();
+            }
+            else if (param is PrimitiveType.Circle)
+            {
+                var templateRepository = BeamShearTemplatesFactory.GetTemplateRepository(ShearSectionTemplateTypes.Circle);
+                var updateStrategy = new BeamShearRepositoryAddUpdateStrategy();
+                updateStrategy.Update(repository, templateRepository);
+                Refresh();
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(param));
+            }
         }
 
         private void Refresh()

StructureHelper/Windows/BeamShears/SectionView.xaml

@@ -17,7 +17,7 @@
         </Grid.RowDefinitions>
         <TabControl>
             <TabItem Header="Main">
-                <StackPanel>
+                <StackPanel x:Name="ShapeStackPanel">
                     <Grid>
                         <Grid.ColumnDefinitions>
                             <ColumnDefinition/>
@@ -31,7 +31,6 @@
                         <TextBox Grid.Column="1" Text="{Binding Name}"/>
                     </Grid>
                     <!--ShapeEditTemplates.xaml-->
-                    <ContentControl ContentTemplate="{StaticResource RectangleShapeEdit}" Content="{Binding Shape}"/>
                 </StackPanel>
             </TabItem>
             <TabItem Header="Concrete" DataContext="{Binding ConcreteMaterial}">

StructureHelper/Windows/BeamShears/SectionView.xaml.cs

@@ -1,5 +1,13 @@
-using StructureHelperLogics.Models.BeamShears;
+using StructureHelper.Infrastructure.Enums;
+using StructureHelper.Infrastructure.UI.DataContexts;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperLogics.Models.BeamShears;
+using StructureHelperLogics.Models.Primitives;
+using System.Collections.Generic;
 using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
 
 namespace StructureHelper.Windows.BeamShears
 {
@@ -18,7 +26,26 @@ namespace StructureHelper.Windows.BeamShears
         }
         public SectionView(IBeamShearSection section) : this(new SectionViewModel(section))
         {
-            
+            AddPrimitiveProperties(section.Shape, ShapeStackPanel);
+        }
+
+        private void AddPrimitiveProperties(IShape shape, StackPanel stackPanel)
+        {
+            List<string> templateNames = new List<string>();
+            if (shape is IRectangleShape) { templateNames.Add("RectangleShapeEdit"); }
+            else if (shape is ICircleShape) { templateNames.Add("CircleShapeEdit"); }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(shape));
+            }
+                foreach (var name in templateNames)
+                {
+                    ContentControl contentControl = new ContentControl();
+                    contentControl.SetResourceReference(ContentTemplateProperty, name);
+                    Binding binding = new Binding { Source = viewModel.Shape };
+                    contentControl.SetBinding(ContentProperty, binding);
+                    stackPanel.Children.Add(contentControl);
+                }
         }
     }
 }

StructureHelper/Windows/BeamShears/SectionViewModel.cs

@@ -41,7 +41,7 @@ namespace StructureHelper.Windows.BeamShears
                 beamShearSection.CenterCover = value;
             }
         }
-        public IRectangleShape Shape { get; }
+        public IShape Shape { get; }
         public ConcreteViewModel ConcreteMaterial { get; }
         public ReinforcementViewModel ReinforcementMaterial { get; }
 
@@ -55,7 +55,7 @@ namespace StructureHelper.Windows.BeamShears
                 TensionForSLSVisibility = false,
                 HumidityVisibility = false
             };
-            Shape = beamShearSection.Shape as IRectangleShape;
+            Shape = beamShearSection.Shape;
             ReinforcementMaterial = new(beamShearSection.ReinforcementMaterial) { MaterialLogicVisibility = false };
         }
     }

StructureHelper/Windows/BeamShears/ShearDiagramLogic.cs

@@ -11,8 +11,7 @@ namespace StructureHelper.Windows.BeamShears
 {
     public class ShearDiagramLogic
     {
-        const string ForceUnitString = "kN";
+        private const string ForceUnitString = "kN";
-
         private IBeamShearActionResult result;
         private IUnit unitForce;
 
@@ -23,23 +22,23 @@ namespace StructureHelper.Windows.BeamShears
             unitForce = unitLogic.GetUnit(UnitTypes.Force, ForceUnitString);
         }
 
-        public void ShowWindow()
+        public void ShowWindow(double sectionsStartCoordinate)
         {
             SafetyProcessor.RunSafeProcess(() =>
             {
                 var seriesList = new List<Series>();
-                var series = new Series(GetParametersByCurveResult()) { Name = "" };
+                var series = new Series(GetParametersByCurveResult(sectionsStartCoordinate)) { Name = "" };
                 seriesList.Add(series);
                 var vm = new GraphViewModel(seriesList);
                 var wnd = new GraphView(vm);
                 wnd.ShowDialog();
             },
-            "Errors appeared during showing a graph, see detailed information");
+            "Errors appeared during showing a chart, see detailed information");
         }
-        private ArrayParameter<double> GetParametersByCurveResult()
+        private ArrayParameter<double> GetParametersByCurveResult(double sectionsStartCoordinate)
         {
             List<IBeamShearSectionLogicResult> results = result.SectionResults
-                .Where(x => x.InputData.InclinedSection.StartCoord == 0)
+                .Where(x => x.InputData.InclinedSection.StartCoord == sectionsStartCoordinate)
                 .ToList();
             var labels = GetLabels();
             var arrayParameter = new ArrayParameter<double>(results.Count(), labels.Count(), labels);

StructureHelperCommon/Models/Shapes/Logics/CircleShapeCloneStrategy.cs

@@ -0,0 +1,17 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using System;
+
+namespace StructureHelperCommon.Models.Shapes
+{
+    internal class CircleShapeCloneStrategy : ICloneStrategy<ICircleShape>
+    {
+        IUpdateStrategy<ICircleShape> updateStrategy;
+        public ICircleShape GetClone(ICircleShape sourceObject)
+        {
+            updateStrategy ??= new CircleShapeUpdateStrategy();
+            CircleShape clone = new CircleShape(Guid.NewGuid());
+            updateStrategy.Update(clone, sourceObject);
+            return clone;
+        }
+    }
+}

StructureHelperCommon/Models/Shapes/Logics/CircleShapeUpdateStrategy.cs

@@ -1,4 +1,5 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -11,6 +12,8 @@ namespace StructureHelperCommon.Models.Shapes
     {
         public void Update(ICircleShape targetObject, ICircleShape sourceObject)
         {
+            CheckObject.IsNull(sourceObject);
+            CheckObject.IsNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Diameter = sourceObject.Diameter;
         }

StructureHelperCommon/Models/Shapes/Logics/RectangleShapeCloneStrategy.cs

@@ -0,0 +1,21 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Shapes
+{
+    public class RectangleShapeCloneStrategy : ICloneStrategy<IRectangleShape>
+    {
+        IUpdateStrategy<IRectangleShape> updateStrategy;
+        public IRectangleShape GetClone(IRectangleShape sourceObject)
+        {
+            RectangleShape clone = new RectangleShape(Guid.NewGuid());
+            updateStrategy ??= new RectangleShapeUpdateStrategy();
+            updateStrategy.Update(clone, sourceObject);
+            return clone;
+        }
+    }
+}

StructureHelperCommon/Models/Shapes/Logics/ShapeCloneStrategy.cs

@@ -0,0 +1,33 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperCommon.Models.Shapes
+{
+    public class ShapeCloneStrategy : ICloneStrategy<IShape>
+    {
+        private ICloneStrategy<IRectangleShape> rectangleCloneStrategy;
+        private ICloneStrategy<ICircleShape> circleCloneStrategy;
+        public IShape GetClone(IShape sourceObject)
+        {
+            if (sourceObject is IRectangleShape rectangleShape)
+            {
+                rectangleCloneStrategy ??= new RectangleShapeCloneStrategy();
+                return rectangleCloneStrategy.GetClone(rectangleShape);
+            }
+            else if (sourceObject is ICircleShape circleShape)
+            {
+                circleCloneStrategy ??= new CircleShapeCloneStrategy();
+                return circleCloneStrategy.GetClone(circleShape);
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(sourceObject));
+            }
+        }
+    }
+}

StructureHelperLogics/Models/BeamShears/BeamShearDesignRangeProperty.cs

@@ -5,11 +5,11 @@ namespace StructureHelperLogics.Models.BeamShears
     /// <inheritdoc>
     public class BeamShearDesignRangeProperty : IBeamShearDesignRangeProperty
     {
-        private const int minStepCount = 0;
+        private const int minStepCount = 10;
         private const int maxStepCount = 1000;
         private double absoluteRangeValue = 0.0;
-        private double relativeEffectiveDepthRangeValue = 3.0;
+        private double relativeEffectiveDepthRangeValue = 3.3;
-        private int stepCount = 50;
+        private int stepCount = 55;
 
         /// <inheritdoc>
         public Guid Id { get; }

StructureHelperLogics/Models/BeamShears/BeamShearSection.cs

@@ -28,7 +28,9 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public object Clone()
         {
-            BeamShearSection newItem = new(Guid.NewGuid());
+            var cloneStrategy = new ShapeCloneStrategy();
+            IShape shapeClone = cloneStrategy.GetClone(Shape);
+            BeamShearSection newItem = new(Guid.NewGuid()) { Shape = shapeClone};
             updateStrategy ??= new BeamShearSectionUpdateStrategy();
             updateStrategy.Update(newItem, this);
             return newItem;

StructureHelperLogics/Models/BeamShears/Factories/BeamShearTemplatesFactory.cs

@@ -1,8 +1,10 @@
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Models.Forces;
 using StructureHelperCommon.Models.Forces.BeamShearActions;
+using StructureHelperCommon.Models.Shapes;
 using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -12,6 +14,7 @@ namespace StructureHelperLogics.Models.BeamShears
     public enum ShearSectionTemplateTypes
     {
         Rectangle,
+        Circle
     }
     public static class BeamShearTemplatesFactory
     {
@@ -21,23 +24,46 @@ namespace StructureHelperLogics.Models.BeamShears
             {
                 return GetRectangleSection();
             }
+            if (templateType is ShearSectionTemplateTypes.Circle)
+            {
+                return GetCircleSection();
+            }
             else
             {
                 throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(templateType));
             }
         }
 
+        private static IBeamShearRepository GetCircleSection()
+        {
+            BeamShearSection section = new(Guid.NewGuid())
+            {
+                Name = "New circle section",
+                Shape = new CircleShape(Guid.NewGuid()) { Diameter = 0.6},
+            };
+            return BuildRepository(section);
+        }
+
         private static IBeamShearRepository GetRectangleSection()
+        {
+            BeamShearSection section = new(Guid.NewGuid())
+            {
+                Name = "New rectangle section",
+                Shape = new RectangleShape(Guid.NewGuid()) { Height = 0.6, Width = 0.4 },
+            };
+            return BuildRepository(section);
+        }
+
+        private static IBeamShearRepository BuildRepository(BeamShearSection section)
         {
             BeamShearRepository shearRepository = new(Guid.Empty);
             IBeamShearAction shearAction = BeamShearActionFactory.GetBeamShearAction(ShearActionTypes.DistributedLoad);
             shearAction.Name = "New shear action";
             shearRepository.Actions.Add(shearAction);
-            BeamShearSection section = new(Guid.NewGuid()) { Name = "New shear section"};
             shearRepository.Sections.Add(section);
-            StirrupByRebar stirrupByUniformRebar = new(Guid.NewGuid()) { Name = "New uniform stirrup"};
+            StirrupByRebar stirrupByUniformRebar = new(Guid.NewGuid()) { Name = "New uniform stirrup" };
             shearRepository.Stirrups.Add(stirrupByUniformRebar);
-            BeamShearCalculator beamShearCalculator = new(Guid.NewGuid()) { Name = "New shear calculator"};
+            BeamShearCalculator beamShearCalculator = new(Guid.NewGuid()) { Name = "New shear calculator" };
             beamShearCalculator.InputData.Sections.Add(section);
             beamShearCalculator.InputData.Stirrups.Add(stirrupByUniformRebar);
             beamShearCalculator.InputData.Actions.Add(shearAction);

StructureHelperLogics/Models/BeamShears/Factories/SectionEffectivenessFactory.cs

@@ -9,7 +9,7 @@ namespace StructureHelperLogics.Models.BeamShears
 {
     public static class SectionEffectivenessFactory
     {
-        public static ISectionEffectiveness GetSheaEffectiveness(BeamShearSectionType sectionType)
+        public static ISectionEffectiveness GetShearEffectiveness(BeamShearSectionType sectionType)
         {
             if (sectionType == BeamShearSectionType.Rectangle)
             {

StructureHelperLogics/Models/BeamShears/Factories/StirrupEffectivenessFactory.cs

@@ -36,7 +36,8 @@ namespace StructureHelperLogics.Models.BeamShears
             {
                 MaxCrackLengthRatio = 1.5,
                 StirrupPlacementFactor = 0.75,
-                StirrupShapeFactor = 0.5
+                StirrupShapeFactor = 0.5,
+                MinimumStirrupRatio = 0.1
             };
             return stirrupEffectiveness;
         }
@@ -47,7 +48,8 @@ namespace StructureHelperLogics.Models.BeamShears
             {
                 MaxCrackLengthRatio = 2,
                 StirrupPlacementFactor = 0.75,
-                StirrupShapeFactor = 1
+                StirrupShapeFactor = 1,
+                MinimumStirrupRatio = 0.25
             };
             return stirrupEffectiveness;
         }

StructureHelperLogics/Models/BeamShears/IStirrupEffectiveness.cs

@@ -23,5 +23,9 @@ namespace StructureHelperLogics.Models.BeamShears
         /// Factor of difference between real and uniform distribution
         /// </summary>
         double StirrupPlacementFactor { get; set; }
+        /// <summary>
+        /// Minimum ratio of density of stirrup to density of concrete
+        /// </summary>
+        double MinimumStirrupRatio { get; set; }
     }
 }

StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionLogic.cs

@@ -1,7 +1,9 @@
-using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Calculators;
 using StructureHelperCommon.Models.Loggers;
+using StructureHelperCommon.Models.Shapes;
 using StructureHelperLogics.Models.BeamShears.Logics;
 
 namespace StructureHelperLogics.Models.BeamShears
@@ -72,7 +74,8 @@ namespace StructureHelperLogics.Models.BeamShears
             double concreteStrength = concreteLogic.GetShearStrength();
             double stirrupStrength = stirrupLogic.GetShearStrength();
             if (stirrupStrength > concreteStrength)
-            {
+            {      
+                localTraceLogger?.AddMessage($"Shear reinforcement strength Qsw = {stirrupStrength} is greater than concrete strength for shear Qb = {concreteStrength}, shear reinforcement strength has to be restricted.");
                 stirrupStrength = GetStirrupStrengthBySearch();
             }
             concreteStrength *= factorOfLongitudinalForce;
@@ -103,7 +106,7 @@ namespace StructureHelperLogics.Models.BeamShears
 
         private double GetStirrupStrengthBySearch()
         {
-            var logic = new StirrupBySearchLogic(TraceLogger)
+            var logic = new StirrupBySearchLogic(localTraceLogger.GetSimilarTraceLogger(100))
             {
                 InputData = InputData,
                 SectionEffectiveness = sectionEffectiveness
@@ -115,7 +118,18 @@ namespace StructureHelperLogics.Models.BeamShears
 
         private void InitializeStrategies()
         {
-            sectionEffectiveness = SectionEffectivenessFactory.GetSheaEffectiveness(BeamShearSectionType.Rectangle);
+            if (InputData.InclinedSection.BeamShearSection.Shape is IRectangleShape)
+            {
+                sectionEffectiveness = SectionEffectivenessFactory.GetShearEffectiveness(BeamShearSectionType.Rectangle);
+            }
+            else if (InputData.InclinedSection.BeamShearSection.Shape is ICircleShape)
+            {
+                sectionEffectiveness = SectionEffectivenessFactory.GetShearEffectiveness(BeamShearSectionType.Circle);
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(InputData.InclinedSection.BeamShearSection.Shape));
+            }
             concreteLogic = new(sectionEffectiveness, InputData.InclinedSection, localTraceLogger);
             stirrupLogic = new(InputData, localTraceLogger);
             getLongitudinalForceFactorLogic = new GetLongitudinalForceFactorLogic(localTraceLogger?.GetSimilarTraceLogger(100));

StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionUpdateStrategy.cs

@@ -3,33 +3,45 @@ using StructureHelperCommon.Models.Shapes;
 using StructureHelperCommon.Models.Shapes.Logics;
 using StructureHelperCommon.Services;
 using StructureHelperLogics.Models.Materials;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace StructureHelperLogics.Models.BeamShears
 {
-    public class BeamShearSectionUpdateStrategy : IUpdateStrategy<IBeamShearSection>
+    public class BeamShearSectionUpdateStrategy : IParentUpdateStrategy<IBeamShearSection>
     {
         private IUpdateStrategy<IShape> shapeUpdateStrategy;
         private IUpdateStrategy<IConcreteLibMaterial> concreteUpdateStrategy;
         private IUpdateStrategy<IReinforcementLibMaterial> reinforcementUpdateStrategy;
+
+        public bool UpdateChildren { get; set; } = true;
+
         public void Update(IBeamShearSection targetObject, IBeamShearSection sourceObject)
         {
             CheckObject.IsNull(targetObject);
             CheckObject.IsNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            Check(targetObject, sourceObject);
             InitializeStrategies();
             targetObject.Name = sourceObject.Name;
             targetObject.ReinforcementArea = sourceObject.ReinforcementArea;
-            shapeUpdateStrategy.Update(targetObject.Shape, sourceObject.Shape);
-            targetObject.ConcreteMaterial ??= new ConcreteLibMaterial();
-            concreteUpdateStrategy.Update(targetObject.ConcreteMaterial, sourceObject.ConcreteMaterial);
-            targetObject.ReinforcementMaterial ??= new ReinforcementLibMaterial(Guid.NewGuid());
-            reinforcementUpdateStrategy.Update(targetObject.ReinforcementMaterial, sourceObject.ReinforcementMaterial);
             targetObject.CenterCover = sourceObject.CenterCover;
+            if (UpdateChildren)
+            {
+                shapeUpdateStrategy.Update(targetObject.Shape, sourceObject.Shape);
+                targetObject.ConcreteMaterial ??= new ConcreteLibMaterial(Guid.NewGuid());
+                concreteUpdateStrategy.Update(targetObject.ConcreteMaterial, sourceObject.ConcreteMaterial);
+                targetObject.ReinforcementMaterial ??= new ReinforcementLibMaterial(Guid.NewGuid());
+                reinforcementUpdateStrategy.Update(targetObject.ReinforcementMaterial, sourceObject.ReinforcementMaterial);
+            }
+        }
+
+        private static void Check(IBeamShearSection targetObject, IBeamShearSection sourceObject)
+        {
+            CheckObject.IsNull(sourceObject.Shape, "Source object shape");
+            CheckObject.IsNull(targetObject.Shape, "Target object shape");
+            CheckObject.IsNull(sourceObject.ConcreteMaterial, "Source concrete material");
+            CheckObject.IsNull(targetObject.ConcreteMaterial, "Target concrete material");
+            CheckObject.IsNull(sourceObject.ReinforcementMaterial, "Source reinforcement material");
+            CheckObject.IsNull(targetObject.ReinforcementMaterial, "Target reinforcement material");
         }
 
         private void InitializeStrategies()

StructureHelperLogics/Models/BeamShears/Logics/CheckStrategies/CheckBeamShearSectionLogic.cs

@@ -9,6 +9,7 @@ namespace StructureHelperLogics.Models.BeamShears.Logics
         private const double minValueOfCenterCover = 0.01;
         private const double minValueOfCrossSectionWidth = 0.05;
         private const double minValueOfCrossSectionHeight = 0.05;
+        private const double minCircleDiameter = 0.05;
         private bool result;
         private string checkResult;
 
@@ -63,6 +64,10 @@ namespace StructureHelperLogics.Models.BeamShears.Logics
                 {
                     CheckRectangleShape(rectangle);
                 }
+                else if (Entity.Shape is ICircleShape circle)
+                {
+                    CheckCircleShape(circle);
+                }
                 else
                 {
                     result = false;
@@ -71,6 +76,15 @@ namespace StructureHelperLogics.Models.BeamShears.Logics
             }
         }
 
+        private void CheckCircleShape(ICircleShape circle)
+        {
+            if (circle.Diameter < minCircleDiameter)
+            {
+                result = false;
+                TraceMessage($"\nValue of cross-section diameter D = {circle.Diameter}(m) must not be less than bmin = {minCircleDiameter}(m)");
+            }
+        }
+
         private void CheckRectangleShape(IRectangleShape rectangle)
         {
             if (rectangle.Width < minValueOfCrossSectionWidth)

StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityStrengthLogic.cs

@@ -11,7 +11,7 @@ namespace StructureHelperLogics.Models.BeamShears
     /// <inheritdoc/>
     public class StirrupByDensityStrengthLogic : IBeamShearStrenghLogic
     {
-        private const double minStirrupRatio = 0.25;
+        //private const double minStirrupRatio = 0.25;
         private readonly IStirrupEffectiveness stirrupEffectiveness;
         private readonly IStirrupByDensity stirrupByDensity;
         private readonly IInclinedSection inclinedSection;
@@ -45,9 +45,10 @@ namespace StructureHelperLogics.Models.BeamShears
             double finalDensity = stirrupEffectiveness.StirrupShapeFactor * stirrupEffectiveness.StirrupPlacementFactor * stirrupByDensity.StirrupDensity;
             TraceLogger?.AddMessage($"Stirrups design density qsw = {stirrupEffectiveness.StirrupShapeFactor} * {stirrupEffectiveness.StirrupPlacementFactor} * {stirrupByDensity.StirrupDensity} = {finalDensity}(N/m)");
             double concreteDensity = inclinedSection.WebWidth * inclinedSection.ConcreteTensionStrength;
-            if (finalDensity < minStirrupRatio * concreteDensity)
+            double minFinalDensity = stirrupEffectiveness.MinimumStirrupRatio * concreteDensity;
+            if (finalDensity < minFinalDensity)
             {
-                TraceLogger?.AddMessage($"Since stirrups design density qsw = {finalDensity}(N/m) less than {minStirrupRatio} * {concreteDensity}, final density is equal to zero", TraceLogStatuses.Warning);
+                TraceLogger?.AddMessage($"Since stirrups design density qsw = {finalDensity}(N/m) less than qsw,min = {stirrupEffectiveness.MinimumStirrupRatio} * {concreteDensity} = {minFinalDensity}(N/m), final density is equal to zero", TraceLogStatuses.Warning);
                 finalDensity = 0;
             }
             double strength = finalDensity * finalCrackLength;

StructureHelperLogics/Models/BeamShears/Logics/StirrupByInclinedRebarStrengthLogic.cs

@@ -35,12 +35,12 @@ namespace StructureHelperLogics.Models.BeamShears
             GetGeometry();
             if (inclinedSection.StartCoord > rebarEndPoint)
             {
-                TraceLogger?.AddMessage($"Inclined section start point coordinate X = {inclinedSection.StartCoord} is greater than inclined rebar end point x = {rebarEndPoint}, inclined rebar has been ignored");
+                TraceLogger?.AddMessage($"Inclined section start point coordinate X = {inclinedSection.StartCoord} is greater than inclined rebar end point X = {rebarEndPoint}, inclined rebar has been ignored");
                 return 0.0;
             }
             if (inclinedSection.EndCoord < rebarStartPoint)
             {
-                TraceLogger?.AddMessage($"Inclined section end point coordinate X = {inclinedSection.EndCoord} is less than inclined rebar start point x = {rebarStartPoint}, inclined rebar has been ignored");
+                TraceLogger?.AddMessage($"Inclined section end point coordinate X = {inclinedSection.EndCoord} is less than inclined rebar start point X = {rebarStartPoint}, inclined rebar has been ignored");
                 return 0.0;
             }
             if (inclinedSection.StartCoord > rebarTrueEndPoint & inclinedSection.StartCoord < rebarEndPoint)

StructureHelperLogics/Models/BeamShears/Logics/StirrupBySearchLogic.cs

@@ -8,29 +8,32 @@ namespace StructureHelperLogics.Models.BeamShears
     {
         private ConcreteStrengthLogic concreteLogic;
         private StirrupStrengthLogic stirrupLogic;
-        private ShiftTraceLogger? localTraceLogger { get; set; }
+        public IShiftTraceLogger? TraceLogger { get; set; }
-
+        public IBeamShearSectionLogicInputData InputData { get; internal set; }
+        public ISectionEffectiveness SectionEffectiveness { get; internal set; }
         public StirrupBySearchLogic(IShiftTraceLogger? traceLogger)
         {
             TraceLogger = traceLogger;
         }
 
-        public IShiftTraceLogger? TraceLogger { get; set; }
-        public IBeamShearSectionLogicInputData InputData { get; internal set; }
-        public ISectionEffectiveness SectionEffectiveness { get; internal set; }
-
         public double GetShearStrength()
         {
-            double parameter = GetParameter();
+            double parameter = GetInclinedCrackRatio();
-            BeamShearSectionLogicInputData newInputData = GetNewInputData(parameter);
+            BeamShearSectionLogicInputData newInputData = GetNewInputDataByCrackLengthRatio(parameter);
-            stirrupLogic = new(newInputData, localTraceLogger);
+            TraceLogger?.AddMessage($"New value of dangerous inclinated crack has been obtained: start point Xstart = {newInputData.InclinedSection.StartCoord}(m), end point Xend = {newInputData.InclinedSection.EndCoord}(m)");
+            stirrupLogic = new(newInputData, TraceLogger);
             double stirrupStrength = stirrupLogic.GetShearStrength();
             return stirrupStrength;
         }
 
-        public double GetParameter()
+        /// <summary>
+        /// Calculates ratio of inclined crack length to inclined section length
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="StructureHelperException"></exception>
+        private double GetInclinedCrackRatio()
         {
-            var parameterCalculator = new FindParameterCalculator(TraceLogger);
+            var parameterCalculator = new FindParameterCalculator();
             parameterCalculator.InputData.Predicate = GetPredicate;
             parameterCalculator.Accuracy.IterationAccuracy = 0.0001d;
             parameterCalculator.Accuracy.MaxIterationCount = 1000;
@@ -40,24 +43,32 @@ namespace StructureHelperLogics.Models.BeamShears
                 throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $": predicate error");
             }
             var result = parameterCalculator.Result as FindParameterResult;
-            var parameter = result.Parameter;
+            var crackLengthRatio = result.Parameter;
-            return parameter;
+            while (GetPredicate(crackLengthRatio) == false)
+            {
+                crackLengthRatio += 0.0001;
+            }
+            return crackLengthRatio;
         }
-
+        /// <summary>
-        private bool GetPredicate(double factor)
+        /// Predicate of comparing of stirrup strength and concrete strength
+        /// </summary>
+        /// <param name="crackLengthRatio">Ratio of inclined crack length and inclined section length</param>
+        /// <returns>Is true when stirrup strength is greate than concrete strength</returns>
+        private bool GetPredicate(double crackLengthRatio)
         {
-            BeamShearSectionLogicInputData newInputData = GetNewInputData(factor);
+            BeamShearSectionLogicInputData newInputData = GetNewInputDataByCrackLengthRatio(crackLengthRatio);
-            concreteLogic = new(SectionEffectiveness, newInputData.InclinedSection, localTraceLogger);
+            concreteLogic = new(SectionEffectiveness, newInputData.InclinedSection, null);
-            stirrupLogic = new(newInputData, localTraceLogger);
+            stirrupLogic = new(newInputData, null);
             double concreteStrength = concreteLogic.GetShearStrength();
             double stirrupStrength = stirrupLogic.GetShearStrength();
             return stirrupStrength > concreteStrength;
         }
 
-        private BeamShearSectionLogicInputData GetNewInputData(double factor)
+        private BeamShearSectionLogicInputData GetNewInputDataByCrackLengthRatio(double crackLengthRatio)
         {
             double sourceCrackLength = InputData.InclinedSection.EndCoord - InputData.InclinedSection.StartCoord;
-            double newCrackLength = sourceCrackLength * factor;
+            double newCrackLength = sourceCrackLength * crackLengthRatio;
             double newStartCoord = InputData.InclinedSection.EndCoord - newCrackLength;
             InclinedSection newSection = new();
             var updateStrategy = new InclinedSectionUpdateStrategy();

StructureHelperLogics/Models/BeamShears/Logics/StirrupStrengthLogic.cs

@@ -1,5 +1,6 @@
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Shapes;
 
 namespace StructureHelperLogics.Models.BeamShears
 {
@@ -11,6 +12,7 @@ namespace StructureHelperLogics.Models.BeamShears
         private IBeamShearStrenghLogic stirrupByDensityStrengthLogic;
         private IBeamShearStrenghLogic stirrupGroupStrengthLogic;
         private IBeamShearStrenghLogic stirrupByInclinedRebarStrengthLogic;
+        private IStirrupEffectiveness stirrupEffectiveness;
 
         public StirrupStrengthLogic(IBeamShearSectionLogicInputData inputData, IShiftTraceLogger? traceLogger)
         {
@@ -22,28 +24,28 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public double GetShearStrength()
         {
-            var stirrupEffectiveness = StirrupEffectivenessFactory.GetEffectiveness(BeamShearSectionType.Rectangle);
+            GetStirrupEffectiveness();
             if (stirrup is IStirrupByRebar stirrupByRebar)
             {
-                TraceLogger?.AddMessage($"Stirrups type is stirrup by rebar {stirrupByRebar.Name}");
+                TraceLogger?.AddMessage($"Stirrups type is stirrup by rebar Name = {stirrupByRebar.Name}");
                 stirrupByDensityStrengthLogic = new StirrupByRebarStrengthLogic(stirrupEffectiveness, stirrupByRebar, inclinedSection, inputData.ForceTuple, TraceLogger);
                 return stirrupByDensityStrengthLogic.GetShearStrength();
             }
             else if (stirrup is IStirrupGroup stirrupGroup)
             {
-                TraceLogger?.AddMessage($"Stirrups type is stirrupGroup {stirrupGroup.Name}");
+                TraceLogger?.AddMessage($"Stirrups type is stirrup group Name = {stirrupGroup.Name}");
                 stirrupGroupStrengthLogic ??= new StirrupGroupStrengthLogic(inputData, stirrupGroup, TraceLogger);
                 return stirrupGroupStrengthLogic.GetShearStrength();
             }
             else if (stirrup is IStirrupByDensity stirrupByDensity)
             {
-                TraceLogger?.AddMessage($"Stirrups type is stirrup by density {stirrupByDensity.Name}");
+                TraceLogger?.AddMessage($"Stirrups type is stirrup by density Name = {stirrupByDensity.Name}");
-                stirrupByDensityStrengthLogic = new StirrupByDensityStrengthLogic(stirrupEffectiveness, stirrupByDensity, inclinedSection,TraceLogger);
+                stirrupByDensityStrengthLogic = new StirrupByDensityStrengthLogic(stirrupEffectiveness, stirrupByDensity, inclinedSection, TraceLogger);
                 return stirrupByDensityStrengthLogic.GetShearStrength();
             }
             else if (stirrup is IStirrupByInclinedRebar inclinedRebar)
             {
-                TraceLogger?.AddMessage($"Stirrups type is inclined rebar {inclinedRebar.Name}");
+                TraceLogger?.AddMessage($"Stirrups type is inclined rebar Name = {inclinedRebar.Name}");
                 stirrupByInclinedRebarStrengthLogic ??= new StirrupByInclinedRebarStrengthLogic(inclinedSection, inclinedRebar, TraceLogger);
                 return stirrupByInclinedRebarStrengthLogic.GetShearStrength();
             }
@@ -53,5 +55,18 @@ namespace StructureHelperLogics.Models.BeamShears
             }
 
         }
+
+        private void GetStirrupEffectiveness()
+        {
+            if (inclinedSection.BeamShearSection.Shape is IRectangleShape)
+            {
+                stirrupEffectiveness = StirrupEffectivenessFactory.GetEffectiveness(BeamShearSectionType.Rectangle);
+            }
+            else if (inclinedSection.BeamShearSection.Shape is ICircleShape)
+            {
+                stirrupEffectiveness = StirrupEffectivenessFactory.GetEffectiveness(BeamShearSectionType.Circle);
+
+            }
+        }
     }
 }

StructureHelperLogics/Models/BeamShears/StirrupEffectiveness.cs

@@ -15,5 +15,7 @@ namespace StructureHelperLogics.Models.BeamShears
         public double StirrupShapeFactor { get; set; }
         /// <inheritdoc/>
         public double StirrupPlacementFactor { get; set; }
+        /// <inheritdoc/>
+        public double MinimumStirrupRatio { get; set; }
     }
 }