Add value diagram calculator saving

DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs

@@ -4,12 +4,8 @@ using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Calculators;
 using StructureHelperCommon.Models.Loggers;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Cracking;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace DataAccess.DTOs
 {
@@ -65,11 +61,26 @@ namespace DataAccess.DTOs
             {
                 TraceLogger?.AddMessage($"Current version of StructureHelper does not suppurt saving interaction diagram calculator, {limitCalculator.Name} was ignored");
             }
+            if (source is IValueDiagramCalculator valueDiagramCalculator)
+            {
+                return ProcessValueDiagramCalcualtor(valueDiagramCalculator);
+            }
             string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source);
             TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
             throw new StructureHelperException(errorString);
         }
 
+        private ValueDiagramCalculatorDTO ProcessValueDiagramCalcualtor(IValueDiagramCalculator valueDiagramCalculator)
+        {
+            var convertStrategy = new ValueDiagramCalculatorToDTOConvertStrategy()
+            {
+                ReferenceDictionary = ReferenceDictionary,
+                TraceLogger = TraceLogger
+            };
+            var dictionaryConvertStrategy = new DictionaryConvertStrategy<ValueDiagramCalculatorDTO, IValueDiagramCalculator>(this, convertStrategy);
+            return convertStrategy.Convert(valueDiagramCalculator);
+        }
+
         private CrackCalculatorDTO ProcessCrackCalculator(ICrackCalculator crackCalculator)
         {
             crackCalculatorStrategy.ReferenceDictionary = ReferenceDictionary;

DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs

@@ -3,6 +3,7 @@ using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Calculators;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Cracking;
 using System;
 using System.Collections.Generic;
@@ -39,11 +40,26 @@ namespace DataAccess.DTOs
                 ICrackCalculator calculator = GetCrackCalculator(crackCalculator);
                 return calculator;
             }
+            if (source is ValueDiagramCalculatorDTO valueDiagramCalculator)
+            {
+                TraceLogger?.AddMessage($"{CalculatorIs} value digram calculator");
+                return GetValueDiagramCalculator(valueDiagramCalculator);
+            }
             string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source);
             TraceLogger.AddMessage(errorString, TraceLogStatuses.Error);
             throw new StructureHelperException(errorString);
         }
 
+        private ValueDiagramCalculator GetValueDiagramCalculator(ValueDiagramCalculatorDTO valueDiagramCalculator)
+        {
+            var convertStrategy = new ValueDiagramCalcualtorFromDTOConvertStrategy()
+            {
+                ReferenceDictionary = ReferenceDictionary,
+                TraceLogger = TraceLogger,
+            };
+            return convertStrategy.Convert(valueDiagramCalculator);
+        }
+
         private ICrackCalculator GetCrackCalculator(ICrackCalculator crackCalculator)
         {
             crackConvertStrategy.ReferenceDictionary = ReferenceDictionary;

DataAccess/DTOs/Converters/Shapes/Point2DRangeFromDTOConvertStrategy.cs

@@ -0,0 +1,47 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperCommon.Services;
+
+namespace DataAccess.DTOs
+{
+    public class Point2DRangeFromDTOConvertStrategy : ConvertStrategy<Point2DRange, Point2DRangeDTO>
+    {
+        private IConvertStrategy<Point2D, Point2DDTO> pointConvertStrategy;
+
+        public Point2DRangeFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override Point2DRange GetNewItem(Point2DRangeDTO source)
+        {
+            ChildClass = this;
+            CheckSourceObject(source);
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            if (source.StartPoint is not Point2DDTO startPoint)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.StartPoint) + ": start point");
+            }
+            if (source.EndPoint is not Point2DDTO endPoint)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.StartPoint) + ": end point");
+            }
+            NewItem.StartPoint = pointConvertStrategy.Convert(startPoint);
+            NewItem.EndPoint = pointConvertStrategy.Convert(endPoint);
+            return NewItem;
+        }
+
+        private static void CheckSourceObject(Point2DRangeDTO source)
+        {
+            CheckObject.IsNull(source, ": point range source object");
+            CheckObject.IsNull(source.StartPoint + ": point range start point");
+            CheckObject.IsNull(source.EndPoint + ": point range end point");
+        }
+
+        private void InitializeStrategies()
+        {
+            pointConvertStrategy ??= new Point2DFromDTOConvertStrategy(this);
+        }
+    }
+}

DataAccess/DTOs/Converters/Shapes/Point2DRangeToDTOConvertStrategy.cs

@@ -0,0 +1,25 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+
+namespace DataAccess.DTOs
+{
+    public class Point2DRangeToDTOConvertStrategy : ConvertStrategy<Point2DRangeDTO, IPoint2DRange>
+    {
+        private IConvertStrategy<Point2DDTO, IPoint2D> pointConvertStrategy = new Point2DToDTOConvertStrategy();
+
+        public Point2DRangeToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override Point2DRangeDTO GetNewItem(IPoint2DRange source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id)
+            {
+                StartPoint = pointConvertStrategy.Convert(source.StartPoint),
+                EndPoint = pointConvertStrategy.Convert(source.EndPoint)
+            };
+            return NewItem;
+        }
+    }
+}

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalcualtorFromDTOConvertStrategy.cs

@@ -0,0 +1,30 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramCalcualtorFromDTOConvertStrategy : ConvertStrategy<ValueDiagramCalculator, ValueDiagramCalculatorDTO>
+    {
+        private IUpdateStrategy<IValueDiagramCalculator> updateStrategy;
+        private IConvertStrategy<ValueDiagramCalculatorInputData, ValueDiagramCalculatorInputDataDTO> inputDataConvertStrategy;
+
+        public override ValueDiagramCalculator GetNewItem(ValueDiagramCalculatorDTO source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            NewItem.InputData = inputDataConvertStrategy.Convert(source.InputData as ValueDiagramCalculatorInputDataDTO);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ValueDiagramCalculatorUpdateStrategy() { UpdateChildren = false };
+            inputDataConvertStrategy ??= new ValueDiagramCalculatorInputDataFromDTOConvertStrategy(this);
+        }
+    }
+}

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataFromDTOConvertStrategy.cs

@@ -0,0 +1,68 @@
+using DataAccess.DTOs.Converters;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramCalculatorInputDataFromDTOConvertStrategy : ConvertStrategy<ValueDiagramCalculatorInputData, ValueDiagramCalculatorInputDataDTO>
+    {
+        private IUpdateStrategy<IValueDiagramCalculatorInputData> updateStrategy;
+        private IConvertStrategy<ValueDiagramEntity, ValueDiagramEntityDTO> diagramConvertStrategy;
+        private IHasPrimitivesProcessLogic primitivesProcessLogic;
+        private IHasForceActionsProcessLogic actionsProcessLogic;
+        private IConvertStrategy<Accuracy, AccuracyDTO> accuracyConvertStrategy;
+
+        public ValueDiagramCalculatorInputDataFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override ValueDiagramCalculatorInputData GetNewItem(ValueDiagramCalculatorInputDataDTO source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            ProcessPrimitives(source);
+            ProcessActions(source);
+            NewItem.Digrams.Clear();
+            foreach (var diagram in source.Digrams)
+            {
+                if (diagram is not ValueDiagramEntityDTO diagramDTO)
+                {
+                    throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(diagram));
+                }
+                NewItem.Digrams.Add(diagramConvertStrategy.Convert(diagramDTO));
+            }
+            return NewItem;
+        }
+
+        private void ProcessPrimitives(IHasPrimitives source)
+        {
+            primitivesProcessLogic.Source = source;
+            primitivesProcessLogic.Target = NewItem;
+            primitivesProcessLogic.ReferenceDictionary = ReferenceDictionary;
+            primitivesProcessLogic.TraceLogger = TraceLogger;
+            primitivesProcessLogic.Process();
+        }
+        private void ProcessActions(IHasForceActions source)
+        {
+            actionsProcessLogic.Source = source;
+            actionsProcessLogic.Target = NewItem;
+            actionsProcessLogic.ReferenceDictionary = ReferenceDictionary;
+            actionsProcessLogic.TraceLogger = TraceLogger;
+            actionsProcessLogic.Process();
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ValueDiagramCalculatorInputDataUpdateStrategy() { UpdateChildren = false };
+            diagramConvertStrategy ??= new ValueDiagramEntityFromDTOConvertStrategy(this);
+            primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+            actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+            accuracyConvertStrategy ??= new AccuracyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+        }
+    }
+}

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataToDTOConvertStrategy.cs

@@ -0,0 +1,64 @@
+using DataAccess.DTOs.Converters;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramCalculatorInputDataToDTOConvertStrategy : ConvertStrategy<ValueDiagramCalculatorInputDataDTO, IValueDiagramCalculatorInputData>
+    {
+        private IUpdateStrategy<IValueDiagramCalculatorInputData> updateStrategy;
+        private IConvertStrategy<ValueDiagramEntityDTO, IValueDiagramEntity> diagramConvertStrategy;
+        private IHasPrimitivesProcessLogic primitivesProcessLogic;
+        private IHasForceActionsProcessLogic actionsProcessLogic;
+
+        public ValueDiagramCalculatorInputDataToDTOConvertStrategy() : base()
+        {
+        }
+
+        public ValueDiagramCalculatorInputDataToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override ValueDiagramCalculatorInputDataDTO GetNewItem(IValueDiagramCalculatorInputData source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            ProcessPrimitives(source);
+            ProcessActions(source);
+            NewItem.Digrams.Clear();
+            foreach (var diagram in source.Digrams)
+            {
+                NewItem.Digrams.Add(diagramConvertStrategy.Convert(diagram));
+            }
+            return NewItem;
+        }
+
+        private void ProcessPrimitives(IHasPrimitives source)
+        {
+            primitivesProcessLogic.Source = source;
+            primitivesProcessLogic.Target = NewItem;
+            primitivesProcessLogic.ReferenceDictionary = ReferenceDictionary;
+            primitivesProcessLogic.TraceLogger = TraceLogger;
+            primitivesProcessLogic.Process();
+        }
+        private void ProcessActions(IHasForceActions source)
+        {
+            actionsProcessLogic.Source = source;
+            actionsProcessLogic.Target = NewItem;
+            actionsProcessLogic.ReferenceDictionary = ReferenceDictionary;
+            actionsProcessLogic.TraceLogger = TraceLogger;
+            actionsProcessLogic.Process();
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ValueDiagramCalculatorInputDataUpdateStrategy() { UpdateChildren = false};
+            diagramConvertStrategy ??= new ValueDiagramEntityToDTOConvertStrategy(this);
+            primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+            actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+        }
+    }
+}

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorToDTOConvertStrategy.cs

@@ -0,0 +1,31 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+
+namespace DataAccess.DTOs
+{
+    internal class ValueDiagramCalculatorToDTOConvertStrategy : ConvertStrategy<ValueDiagramCalculatorDTO, IValueDiagramCalculator>
+    {
+        private IUpdateStrategy<IValueDiagramCalculator> updateStrategy;
+        private IConvertStrategy<ValueDiagramCalculatorInputDataDTO, IValueDiagramCalculatorInputData> inputDataConvertStrategy;
+        public override ValueDiagramCalculatorDTO GetNewItem(IValueDiagramCalculator source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            NewItem.InputData = inputDataConvertStrategy.Convert(source.InputData);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ValueDiagramCalculatorUpdateStrategy()
+            {
+                UpdateChildren = false
+            };
+            inputDataConvertStrategy ??= new DictionaryConvertStrategy<ValueDiagramCalculatorInputDataDTO, IValueDiagramCalculatorInputData>(
+                this, 
+                new ValueDiagramCalculatorInputDataToDTOConvertStrategy(this));
+        }
+    }
+}

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityFromDTOConvertStrategy.cs

@@ -0,0 +1,36 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramEntityFromDTOConvertStrategy : ConvertStrategy<ValueDiagramEntity, ValueDiagramEntityDTO>
+    {
+        private IUpdateStrategy<IValueDiagramEntity> updateStrategy;
+        private IConvertStrategy<ValueDiagram, ValueDiagramDTO> diagramConvertStrategy;
+
+        public ValueDiagramEntityFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override ValueDiagramEntity GetNewItem(ValueDiagramEntityDTO source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            if (source.ValueDigram is not ValueDiagramDTO diagramDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ValueDigram));
+            }
+            NewItem.ValueDigram = diagramConvertStrategy.Convert(diagramDTO);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ValueDiagramEntityUpdateStrategy() { UpdateChildren = false};
+            diagramConvertStrategy ??= new ValueDiagramFromDTOConvertStrategy(this);
+        }
+    }
+}

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityToDTOConvertStrategy.cs

@@ -0,0 +1,31 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramEntityToDTOConvertStrategy : ConvertStrategy<ValueDiagramEntityDTO, IValueDiagramEntity>
+    {
+        private IUpdateStrategy<IValueDiagramEntity> updateStrategy;
+        private IConvertStrategy<ValueDiagramDTO, IValueDiagram> diagramConvertStrategy;
+
+        public ValueDiagramEntityToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override ValueDiagramEntityDTO GetNewItem(IValueDiagramEntity source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            NewItem.ValueDigram = diagramConvertStrategy.Convert(source.ValueDigram);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ValueDiagramEntityUpdateStrategy() { UpdateChildren = false };
+            diagramConvertStrategy ??= new ValueDiagramToDTOConvertStrategy(this);
+        }
+    }
+}

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramFromDTOConvertStrategy.cs

@@ -0,0 +1,37 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramFromDTOConvertStrategy : ConvertStrategy<ValueDiagram, ValueDiagramDTO>
+    {
+        private IUpdateStrategy<IValueDiagram> updateStrategy;
+        private IConvertStrategy<Point2DRange, Point2DRangeDTO> pointConvertStrategy;
+
+        public ValueDiagramFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override ValueDiagram GetNewItem(ValueDiagramDTO source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            if (source.Point2DRange is not Point2DRangeDTO point2DRangeDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.Point2DRange));
+            }
+            NewItem.Point2DRange = pointConvertStrategy.Convert(point2DRangeDTO);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ValueDiagramUpdateStrategy() { UpdateChildren = false };
+            pointConvertStrategy ??= new Point2DRangeFromDTOConvertStrategy(this);
+        }
+    }
+}

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramToDTOConvertStrategy.cs

@@ -0,0 +1,32 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramToDTOConvertStrategy : ConvertStrategy<ValueDiagramDTO, IValueDiagram>
+    {
+        private IUpdateStrategy<IValueDiagram> updateStrategy;
+        private IConvertStrategy<Point2DRangeDTO, IPoint2DRange> pointConvertStrategy;
+
+        public ValueDiagramToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override ValueDiagramDTO GetNewItem(IValueDiagram source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            NewItem.Point2DRange = pointConvertStrategy.Convert(source.Point2DRange);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ValueDiagramUpdateStrategy() { UpdateChildren = false };
+            pointConvertStrategy ??= new Point2DRangeToDTOConvertStrategy(this);
+        }
+    }
+}

DataAccess/DTOs/DTOEntities/Shapes/Point2DRangeDTO.cs

@@ -0,0 +1,26 @@
+using Newtonsoft.Json;
+using StructureHelperCommon.Models.Shapes;
+
+namespace DataAccess.DTOs
+{
+    public class Point2DRangeDTO : IPoint2DRange
+    {
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("StartPoint")]
+        public IPoint2D StartPoint { get; set; }
+        [JsonProperty("EndPoint")]
+        public IPoint2D EndPoint { get; set; }
+
+
+        public Point2DRangeDTO(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            return this;
+        }
+    }
+}

DataAccess/DTOs/DTOEntities/StateCalcTermPairDTO.cs

@@ -0,0 +1,11 @@
+using StructureHelperCommon.Infrastructures.Enums;
+using StructureHelperCommon.Models.States;
+
+namespace DataAccess.DTOs
+{
+    public class StateCalcTermPairDTO : IStateCalcTermPair
+    {
+        public LimitStates LimitState { get; set; }
+        public CalcTerms CalcTerm { get; set; }
+    }
+}

DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs

@@ -7,6 +7,7 @@ using StructureHelperCommon.Models.Forces;
 using StructureHelperCommon.Models.Materials.Libraries;
 using StructureHelperCommon.Models.Shapes;
 using StructureHelperLogics.Models.BeamShears;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Primitives;
 
 namespace DataAccess.DTOs
@@ -45,6 +46,7 @@ namespace DataAccess.DTOs
                 { (typeof(List<LimitStates>), "ListOfLimitState") },
                 { (typeof(List<IPartialFactor>), "ListOfPartialFactor") },
                 { (typeof(RebarSectionDTO), "RebarSection") },
+                { (typeof(StateCalcTermPairDTO), "StateCalcTermPair") },
                 { (typeof(VisualPropertyDTO), "VisualProperty") },
                 { (typeof(WorkPlanePropertyDTO), "WorkPlanePropertyDTO") },
             };
@@ -55,6 +57,20 @@ namespace DataAccess.DTOs
             newList.AddRange(GetCalculatorList());
             newList.AddRange(GetNdmPrimitiveList());
             newList.AddRange(GetBeamShearList());
+            newList.AddRange(GetValueDiagramList());
+            return newList;
+        }
+
+        private static IEnumerable<(Type type, string name)> GetValueDiagramList()
+        {
+            List<(Type type, string name)> newList = new()
+            {
+                { (typeof(List<IValueDiagramEntity>), "ListOfValueDiagramEntity") },
+                { (typeof(ValueDiagramCalculatorDTO), "ValueDiagramCalculator") },
+                { (typeof(ValueDiagramCalculatorInputDataDTO), "ValueDiagramCalculatorInputData") },
+                { (typeof(ValueDiagramEntityDTO), "ValueDiagramEntity") },
+                { (typeof(ValueDiagramDTO), "ValueDiagram") },
+            };
             return newList;
         }
 
@@ -131,6 +147,7 @@ namespace DataAccess.DTOs
             {
                 { (typeof(List<IVertex>), "ListOfVertex2D") },
                 { (typeof(Point2DDTO), "Point2D") },
+                { (typeof(Point2DRangeDTO), "Point2DRange") },
                 { (typeof(VertexDTO), "Vertex2D") },
                 { (typeof(RectangleShapeDTO), "RectangleShape") },
                 { (typeof(CircleShapeDTO), "CircleShape") },

DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorDTO.cs

@@ -0,0 +1,39 @@
+using Newtonsoft.Json;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramCalculatorDTO : IValueDiagramCalculator
+    {
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("Name")]
+        public string Name { get; set; }
+        [JsonProperty("InputData")]
+        public IValueDiagramCalculatorInputData InputData { get; set; }
+        [JsonProperty("ShowTraceData")]
+        public bool ShowTraceData { get; set; }
+        [JsonIgnore]
+        public IResult Result => throw new NotImplementedException();
+        [JsonIgnore]
+        public IShiftTraceLogger? TraceLogger { get; set; }
+
+
+        public ValueDiagramCalculatorDTO(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            return this;
+        }
+
+        public void Run()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorInputDataDTO.cs

@@ -0,0 +1,32 @@
+using Newtonsoft.Json;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.States;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramCalculatorInputDataDTO : IValueDiagramCalculatorInputData
+    {
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("StateTermPair")]
+        public IStateCalcTermPair StateTermPair { get; set; } = new StateCalcTermPairDTO();
+        [JsonProperty("Diagrams")]
+        public List<IValueDiagramEntity> Digrams { get; } = [];
+        [JsonProperty("CheckStrainLimits")]
+        public bool CheckStrainLimit { get; set; } = true;
+        [JsonProperty("ForceActions")]
+        public List<IForceAction> ForceActions { get; } = [];
+        [JsonProperty("Primitives")]
+        public List<INdmPrimitive> Primitives { get; } = [];
+
+
+        public ValueDiagramCalculatorInputDataDTO(Guid id)
+        {
+            Id = id;
+        }
+
+
+    }
+}

DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramDTO.cs

@@ -0,0 +1,26 @@
+using Newtonsoft.Json;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramDTO : IValueDiagram
+    {
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("Point2DRange")]
+        public IPoint2DRange Point2DRange { get; set; }
+        [JsonProperty("StepNumber")]
+        public int StepNumber { get; set; }
+
+        public ValueDiagramDTO(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            return this;
+        }
+    }
+}

DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramEntityDTO.cs

@@ -0,0 +1,28 @@
+using Newtonsoft.Json;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+
+namespace DataAccess.DTOs
+{
+    public class ValueDiagramEntityDTO : IValueDiagramEntity
+    {
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("Name")]
+        public string Name { get; set; }
+        [JsonProperty("IsTaken")]
+        public bool IsTaken { get; set; }
+        [JsonProperty("ValueDiagram")]
+        public IValueDiagram ValueDigram { get; set; }
+
+
+        public ValueDiagramEntityDTO(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            return this;
+        }
+    }
+}

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

@@ -21,6 +21,7 @@
                     <ColumnDefinition Width="*"/>
                 </Grid.ColumnDefinitions>
                 <Grid.RowDefinitions>
+                    <RowDefinition Height="22"/>
                     <RowDefinition Height="22"/>
                     <RowDefinition Height="22"/>
                     <RowDefinition Height="15"/>
@@ -29,6 +30,8 @@
                 <CheckBox Grid.Column="1" Margin="0,3" IsChecked="{Binding IsTaken}"/>
                 <TextBlock Grid.Row="1" Text="Name"/>
                 <TextBox Grid.Column="1" Grid.Row="1" Text="{Binding Name}"/>
+                <TextBlock Grid.Row="2" Text="Step number"/>
+                <TextBox Grid.Column="1" Grid.Row="2" Text="{Binding ValueDiagram.StepNumber}"/>
             </Grid>
             <Grid>
                 <Grid.ColumnDefinitions>

StructureHelper/Windows/Graphs/GraphView.xaml

@@ -61,61 +61,69 @@
                 <ColumnDefinition Width="Auto"/>
                 <ColumnDefinition Width="5*"/>
             </Grid.ColumnDefinitions>
-            <Grid>
+            <TabControl>
-                <Grid.RowDefinitions>
+                <TabItem Header="Series">
-                    <RowDefinition/>
+                    <ScrollViewer>
-                    <RowDefinition Height="170"/>
+                        <ListBox ItemsSource="{Binding Series}" ScrollViewer.VerticalScrollBarVisibility="Hidden">
-                </Grid.RowDefinitions>
+                            <ListBox.ItemTemplate>
-                <ListBox ItemsSource="{Binding Series}">
+                                <DataTemplate>
-                    <ListBox.ItemTemplate>
+                                    <Expander Header="{Binding Name}" IsExpanded="True" Background="{Binding Color}">
-                        <DataTemplate>
+                                        <Grid HorizontalAlignment="Stretch">
-                            <Expander Header="{Binding Name}" IsExpanded="True" Background="{Binding Color}">
-                                <Grid HorizontalAlignment="Stretch">
-                                    <Grid.RowDefinitions>
-                                        <RowDefinition Height="70"/>
-                                        <RowDefinition/>
-                                    </Grid.RowDefinitions>
-                                    <GroupBox Grid.Row="0" Margin="10,0,10,0" Header="X-axis values">
-                                        <StackPanel>
-                                            <ComboBox ItemsSource="{Binding XItems.Collection}" SelectedItem="{Binding XItems.SelectedItem}">
-                                                <ComboBox.ItemTemplate>
-                                                    <DataTemplate>
-                                                        <Grid>
-                                                            <Grid.ColumnDefinitions>
-                                                                <ColumnDefinition Width="20"/>
-                                                                <ColumnDefinition/>
-                                                            </Grid.ColumnDefinitions>
-                                                            <Rectangle Grid.Column="0" Margin="3">
-                                                                <Rectangle.Fill>
-                                                                    <SolidColorBrush Color="{Binding Color}"/>
-                                                                </Rectangle.Fill>
-                                                            </Rectangle>
-                                                            <TextBlock Grid.Column="1" Text="{Binding Name}"/>
-                                                        </Grid>
-                                                    </DataTemplate>
-                                                </ComboBox.ItemTemplate>
-                                            </ComboBox>
-                                            <CheckBox Margin="5" Content="Invert Values" IsChecked="{Binding InvertXValues}"/>
-                                        </StackPanel>
-
-                                    </GroupBox>
-                                    <GroupBox Grid.Row="1" Margin="10,0,10,0" Header="Y-axis values">
-                                        <Grid>
                                             <Grid.RowDefinitions>
+                                                <RowDefinition Height="70"/>
                                                 <RowDefinition/>
-                                                <RowDefinition Height="30"/>
                                             </Grid.RowDefinitions>
-                                            <ContentControl ContentTemplate="{StaticResource ResourceKey=SelectItems}" Content="{Binding YItems}"/>
+                                            <GroupBox Grid.Row="0" Margin="10,0,10,0" Header="X-axis values">
-                                            <CheckBox Grid.Row="1" Margin="5" Content="Invert Values" IsChecked="{Binding InvertYValues}"/>
+                                                <StackPanel>
+                                                    <ComboBox ItemsSource="{Binding XItems.Collection}" SelectedItem="{Binding XItems.SelectedItem}">
+                                                        <ComboBox.ItemTemplate>
+                                                            <DataTemplate>
+                                                                <Grid>
+                                                                    <Grid.ColumnDefinitions>
+                                                                        <ColumnDefinition Width="20"/>
+                                                                        <ColumnDefinition/>
+                                                                    </Grid.ColumnDefinitions>
+                                                                    <Rectangle Grid.Column="0" Margin="3">
+                                                                        <Rectangle.Fill>
+                                                                            <SolidColorBrush Color="{Binding Color}"/>
+                                                                        </Rectangle.Fill>
+                                                                    </Rectangle>
+                                                                    <TextBlock Grid.Column="1" Text="{Binding Name}"/>
+                                                                </Grid>
+                                                            </DataTemplate>
+                                                        </ComboBox.ItemTemplate>
+                                                    </ComboBox>
+                                                    <CheckBox Margin="5" Content="Invert Values" IsChecked="{Binding InvertXValues}"/>
+                                                </StackPanel>
+
+                                            </GroupBox>
+                                            <GroupBox Grid.Row="1" Margin="10,0,10,0" Header="Y-axis values">
+                                                <Grid>
+                                                    <Grid.RowDefinitions>
+                                                        <RowDefinition/>
+                                                        <RowDefinition Height="30"/>
+                                                    </Grid.RowDefinitions>
+                                                    <ContentControl ContentTemplate="{StaticResource ResourceKey=SelectItems}" Content="{Binding YItems}"/>
+                                                    <CheckBox Grid.Row="1" Margin="5" Content="Invert Values" IsChecked="{Binding InvertYValues}"/>
+                                                </Grid>
+                                            </GroupBox>
                                         </Grid>
-                                    </GroupBox>
+                                    </Expander>
-                                </Grid>
+                                </DataTemplate>
-                            </Expander>
+                            </ListBox.ItemTemplate>
-                        </DataTemplate>
+                        </ListBox>
-                    </ListBox.ItemTemplate>
+                    </ScrollViewer>
-                </ListBox>
+                </TabItem>
-                <ContentControl Grid.Row="1" ContentTemplate="{StaticResource ResourceKey=LineVisualProperties}" Content="{Binding VisualProps}"/>
+                <TabItem Header="Settings">
-            </Grid>
+                    <Grid>
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="170"/>
+                            <RowDefinition/>
+                        </Grid.RowDefinitions>
+                        <ContentControl ContentTemplate="{StaticResource ResourceKey=LineVisualProperties}" Content="{Binding VisualProps}"/>
+                    </Grid>
+                </TabItem>
+            </TabControl>
             <GridSplitter Grid.Column="1" Width="3" VerticalAlignment="Stretch" HorizontalAlignment="Center" ShowsPreview="False"/>
             <Grid Grid.Column="2">
                 <lvc:CartesianChart Name="MainChart" Series="{Binding SeriesCollection}" LegendLocation="Bottom" Zoom="Xy" Background="White">

StructureHelper/Windows/MainWindow/CrossSections/ValueDiagramLogic.cs

@@ -1,6 +1,4 @@
 using LoaderCalculator.Data.Matrix;
-using LoaderCalculator.Data.Ndms;
-using LoaderCalculator.Logics;
 using StructureHelper.Services.ResultViewers;
 using StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalculatorViews;
 using StructureHelper.Windows.Graphs;
@@ -18,7 +16,6 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
 {
     internal class ValueDiagramLogic
     {
-        private IStressLogic stressLogic = new StressLogic();
         private IValueDiagramCalculatorResult valueDiagramResult;
         private List<ForceResultFunc> resultFuncs = [];
         private List<string> labels;
@@ -49,6 +46,10 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
                     var primitives = valueDiagramResult.InputData.Primitives
                     .Where(x => x is IHasDivisionSize);
                     Series series = GetSeries(forceTupleResult, valueDiagramResult.InputData.Primitives, entityResult.PointList);
+                    if (valueDiagramResult.EntityResults.Count > 1)
+                    {
+                        series.Name = $"${entityResult.ValueDiagramEntity.Name} ({series.Name})";
+                    }
                     seriesList.Add(series);
                 }                
             }
@@ -60,10 +61,15 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
         private Series GetSeries(IForceTupleCalculatorResult tupleResult, List<INdmPrimitive> ndmPrimitives, List<IPoint2D> points)
         {
             List<(INdmPrimitive ndmPrimitive, IPoint2D point)> pointPrimitives = GetPrimitivePoints(ndmPrimitives, points);
+            if (pointPrimitives.Count == 0)
+            {
+                throw new StructureHelperException("There are not points for drawings");
+            }
             ArrayParameter<double> arrayParameter = new(pointPrimitives.Count + 3, labels);
             var data = arrayParameter.Data;
             IPoint2D startPoint = pointPrimitives[0].point;
             IPoint2D endPoint = pointPrimitives[^1].point;
+            IStrainMatrix strainMatrix = tupleResult.LoaderResults.StrainMatrix;
             for (int i = 0; i < pointPrimitives.Count; i++)
             {
                 IPoint2D currentPoint = pointPrimitives[i].point;
@@ -73,7 +79,7 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
                 data[i, 2] = currentPoint.Y;
                 for (int j = 0; j < resultFuncs.Count; j++)
                 {
-                    data[i, j + 3] = GetValueByPoint(tupleResult.LoaderResults.StrainMatrix, pointPrimitives[i].ndmPrimitive, pointPrimitives[i].point, resultFuncs[j]);
+                    data[i, j + 3] = GetValueByPoint(strainMatrix, pointPrimitives[i].ndmPrimitive, pointPrimitives[i].point, resultFuncs[j]);
                 }
 
             }
@@ -92,7 +98,7 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
             {
                 data[pointPrimitives.Count, j+3] = 0.0;
                 data[pointPrimitives.Count + 1, j+3] = 0.0;
-                data[pointPrimitives.Count + 2, j + 3] = GetValueByPoint(tupleResult.LoaderResults.StrainMatrix, pointPrimitives[0].ndmPrimitive, pointPrimitives[0].point, resultFuncs[j]);
+                data[pointPrimitives.Count + 2, j + 3] = GetValueByPoint(strainMatrix, pointPrimitives[0].ndmPrimitive, pointPrimitives[0].point, resultFuncs[j]);
             }
 
             StructureHelperCommon.Models.Forces.IForceTuple inputForceTuple = tupleResult.InputData.ForceTuple;

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

@@ -0,0 +1,28 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+using StructureHelperLogics.NdmCalculations.Cracking;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
+{
+    public class CalculatorCloningStrategyContainer : ICalculatorCloningStrategyContainer
+    {
+        private ICloningStrategy cloningStrategy;
+
+
+        public IUpdateStrategy<IForceCalculator> ForceCalculatorStrategy => new ForceCalculatorUpdateCloningStrategy(cloningStrategy);
+
+        public IUpdateStrategy<ICrackCalculator> CrackCalculatorStrategy => new CrackCalculatorUpdateCloningStrategy(cloningStrategy);
+
+        public IUpdateStrategy<ILimitCurvesCalculator> LimitCurvesCalculatorStrategy => new LimitCurvesCalculatorUpdateCloningStrategy(cloningStrategy);
+
+        public IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy => new ValueDiagramCalculatorUpdateCloningStrategy(cloningStrategy);
+        public CalculatorCloningStrategyContainer(ICloningStrategy cloningStrategy)
+        {
+            this.cloningStrategy = cloningStrategy;
+        }
+    }
+}

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

@@ -1,5 +1,4 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
-using StructureHelperCommon.Infrastructures.Settings;
 using StructureHelperCommon.Services;
 using StructureHelperLogics.NdmCalculations.Primitives;
 using StructureHelperLogics.NdmCalculations.Primitives.Logics;

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

@@ -6,6 +6,7 @@ using StructureHelperCommon.Models.Parameters;
 using StructureHelperCommon.Services;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
 using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
 using StructureHelperLogics.NdmCalculations.Cracking;
 using StructureHelperLogics.NdmCalculations.Primitives;
 using StructureHelperLogics.NdmCalculations.Primitives.Logics;
@@ -18,28 +19,20 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
     public class HasCalculatorsUpdateCloningStrategy : IUpdateStrategy<IHasCalculators>
     {
         private ICloningStrategy cloningStrategy;
-        private IUpdateStrategy<IForceCalculator> forceCalculatorUpdateStrategy;
+        private ICalculatorCloningStrategyContainer cloningStrategyContainer;
-        private IUpdateStrategy<ICrackCalculator> crackCalculatorUpdateStrategy;
-        private IUpdateStrategy<ILimitCurvesCalculator> limitCurvesCalculatorUpdateStrategy;
 
 
         public HasCalculatorsUpdateCloningStrategy(
             ICloningStrategy cloningStrategy,
-            IUpdateStrategy<IForceCalculator> forceCalculatorUpdateStrategy,
+            ICalculatorCloningStrategyContainer cloningStrategyContainer)
-            IUpdateStrategy<ICrackCalculator> crackCalculatorUpdateStrategy,
-            IUpdateStrategy<ILimitCurvesCalculator> limitCurvesCalculatorUpdateStrategy)
         {
             this.cloningStrategy = cloningStrategy;
-            this.forceCalculatorUpdateStrategy = forceCalculatorUpdateStrategy;
+            this.cloningStrategyContainer = cloningStrategyContainer;
-            this.crackCalculatorUpdateStrategy = crackCalculatorUpdateStrategy;
-            this.limitCurvesCalculatorUpdateStrategy = limitCurvesCalculatorUpdateStrategy;
         }
 
         public HasCalculatorsUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
             cloningStrategy,
-            new ForceCalculatorUpdateCloningStrategy(cloningStrategy),
+            new CalculatorCloningStrategyContainer(cloningStrategy)
-            new CrackCalculatorUpdateCloningStrategy(cloningStrategy),
-            new LimitCurvesCalculatorUpdateCloningStrategy(cloningStrategy)
             )
         {
         }
@@ -58,15 +51,19 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
                 //var newCalculator = calculator.Clone() as ICalculator;
                 if (calculator is IForceCalculator forceCalculator)
                 {
-                    forceCalculatorUpdateStrategy.Update(newCalculator as IForceCalculator, forceCalculator);
+                    cloningStrategyContainer.ForceCalculatorStrategy.Update(newCalculator as IForceCalculator, forceCalculator);
                 }
                 else if (calculator is ICrackCalculator crackCalculator)
                 {
-                    crackCalculatorUpdateStrategy.Update(newCalculator as ICrackCalculator, crackCalculator);
+                    cloningStrategyContainer.CrackCalculatorStrategy.Update(newCalculator as ICrackCalculator, crackCalculator);
                 }
                 else if (calculator is ILimitCurvesCalculator limitCalculator)
                 {
-                    limitCurvesCalculatorUpdateStrategy.Update(newCalculator as ILimitCurvesCalculator, limitCalculator);
+                    cloningStrategyContainer.LimitCurvesCalculatorStrategy.Update(newCalculator as ILimitCurvesCalculator, limitCalculator);
+                }
+                else if (calculator is IValueDiagramCalculator valueDiagramCalculator)
+                {
+                    cloningStrategyContainer.ValueDiagramCalculatorStrategy.Update(newCalculator as IValueDiagramCalculator, valueDiagramCalculator);
                 }
                 else
                 {

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

@@ -0,0 +1,14 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
+using StructureHelperLogics.NdmCalculations.Cracking;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
+{
+    public interface ICalculatorCloningStrategyContainer
+    {
+        IUpdateStrategy<IForceCalculator> ForceCalculatorStrategy { get; }
+        IUpdateStrategy<ICrackCalculator> CrackCalculatorStrategy { get; }
+        IUpdateStrategy<ILimitCurvesCalculator> LimitCurvesCalculatorStrategy { get; }
+        IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy { get; }
+    }
+}

StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagram.cs

@@ -5,7 +5,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
 {
     public interface IValueDiagram : ISaveable, ICloneable
     {
-        IPoint2DRange Point2DRange { get; }
+        IPoint2DRange Point2DRange { get; set; }
         public int StepNumber { get; set; }
     }
 }

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

@@ -0,0 +1,44 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using StructureHelperLogics.NdmCalculations.Primitives.Logics;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
+{
+    public class ValueDiagramCalculatorUpdateCloningStrategy : IUpdateStrategy<IValueDiagramCalculator>
+    {
+        private readonly ICloningStrategy cloningStrategy;
+        private readonly IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
+        private readonly IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
+
+        public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
+            cloningStrategy,
+            new HasForceActionUpdateCloningStrategy(cloningStrategy),
+            new HasPrimitivesUpdateCloningStrategy(cloningStrategy))
+        {
+            this.cloningStrategy = cloningStrategy;
+        }
+
+
+        public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy,
+            IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
+            IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy)
+        {
+            this.cloningStrategy = cloningStrategy;
+            this.forcesUpdateStrategy = forcesUpdateStrategy;
+            this.primitivesUpdateStrategy = primitivesUpdateStrategy;
+        }
+
+        public void Update(IValueDiagramCalculator targetObject, IValueDiagramCalculator sourceObject)
+        {
+            CheckObject.IsNull(cloningStrategy);
+            CheckObject.IsNull(sourceObject);
+            CheckObject.IsNull(targetObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            var sourceData = sourceObject.InputData;
+            var targetData = targetObject.InputData;
+            primitivesUpdateStrategy.Update(targetData, sourceData);
+            forcesUpdateStrategy.Update(targetData, sourceData);
+        }
+    }
+}

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

@@ -4,7 +4,7 @@ using StructureHelperCommon.Services;
 
 namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
 {
-    internal class ValueDiagramUpdateStrategy : IParentUpdateStrategy<IValueDiagram>
+    public class ValueDiagramUpdateStrategy : IParentUpdateStrategy<IValueDiagram>
     {
         private IUpdateStrategy<IPoint2DRange> rangeUpdateStrategy;
         public bool UpdateChildren { get; set; } = true;

StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagram.cs

@@ -6,7 +6,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
     {
         public Guid Id { get; }
         public int StepNumber { get; set; } = 50;
-        public IPoint2DRange Point2DRange { get; } = new Point2DRange(Guid.NewGuid());
+        public IPoint2DRange Point2DRange { get; set; } = new Point2DRange(Guid.NewGuid());
 
 
         public ValueDiagram(Guid id)