Change value diagram calculator

2025-11-16 21:03:57 +05:00
parent f7e60e0bb3
commit 215f631bb0
170 changed files with 2108 additions and 387 deletions
--- a/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs
@@ -14,8 +14,8 @@ namespace StructureHelperLogics.Models.Analyses

        public void Update(IBeamShearAnalysis targetObject, IBeamShearAnalysis sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
            InitialzeStrategies();
            analysisUpdateStrategy.Update(targetObject, sourceObject);
--- a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs
@@ -32,8 +32,8 @@ namespace StructureHelperLogics.Models.Analyses

        public void Update(ICrossSectionNdmAnalysis targetObject, ICrossSectionNdmAnalysis sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
            analysisUpdateStrategy.Update(targetObject, sourceObject);
            targetObject.VersionProcessor.Versions.Clear();
--- a/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs
@@ -14,11 +14,11 @@ namespace StructureHelperLogics.Models.BeamShears
        IUpdateStrategy<IBeamShearRepository> repositoryUpdateStrategy;
        public void Update(IBeamShear targetObject, IBeamShear sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
-            CheckObject.IsNull(sourceObject.Repository);
-            CheckObject.IsNull(targetObject.Repository);
+            CheckObject.ThrowIfNull(sourceObject.Repository);
+            CheckObject.ThrowIfNull(targetObject.Repository);
            InitializeStrategies();
            clearStrategy.Process(targetObject.Repository);
            repositoryUpdateStrategy.Update(targetObject.Repository, sourceObject.Repository);
--- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs
@@ -10,13 +10,13 @@ namespace StructureHelperLogics.Models.BeamShears
    {
        public void Process(IBeamShearRepository entity)
        {
-            CheckObject.IsNull(entity.Calculators);
+            CheckObject.ThrowIfNull(entity.Calculators);
            entity.Calculators.Clear();
-            CheckObject.IsNull(entity.Actions);
+            CheckObject.ThrowIfNull(entity.Actions);
            entity.Actions.Clear();
-            CheckObject.IsNull(entity.Sections);
+            CheckObject.ThrowIfNull(entity.Sections);
            entity.Sections.Clear();
-            CheckObject.IsNull(entity.Stirrups);
+            CheckObject.ThrowIfNull(entity.Stirrups);
            entity.Stirrups.Clear();
        }
    }
--- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs
@@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears
    {
        public void Update(IBeamShearRepository targetObject, IBeamShearRepository sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
            targetObject.Actions.AddRange(sourceObject.Actions);
            targetObject.Sections.AddRange(sourceObject.Sections);
--- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionUpdateStrategy.cs
@@ -16,8 +16,8 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IBeamShearSection targetObject, IBeamShearSection sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            Check(targetObject, sourceObject);
            InitializeStrategies();
@@ -36,12 +36,12 @@ namespace StructureHelperLogics.Models.BeamShears

        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");
+            CheckObject.ThrowIfNull(sourceObject.Shape, "Source object shape");
+            CheckObject.ThrowIfNull(targetObject.Shape, "Target object shape");
+            CheckObject.ThrowIfNull(sourceObject.ConcreteMaterial, "Source concrete material");
+            CheckObject.ThrowIfNull(targetObject.ConcreteMaterial, "Target concrete material");
+            CheckObject.ThrowIfNull(sourceObject.ReinforcementMaterial, "Source reinforcement material");
+            CheckObject.ThrowIfNull(targetObject.ReinforcementMaterial, "Target reinforcement material");
        }

        private void InitializeStrategies()
--- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorCloneStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorCloneStrategy.cs
@@ -15,8 +15,8 @@ namespace StructureHelperLogics.Models.BeamShears

        public IBeamShearCalculator GetClone(IBeamShearCalculator sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
            InitializeStrategies();
            BeamShearCalculator calculator = new(Guid.NewGuid());
            updateStrategy.Update(calculator, sourceObject);
--- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorInputDataCloneStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorInputDataCloneStrategy.cs
@@ -21,8 +21,8 @@ namespace StructureHelperLogics.Models.BeamShears

        public IBeamShearCalculatorInputData GetClone(IBeamShearCalculatorInputData sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
            InitializeStrategies();
            BeamShearCalculatorInputData inputData = new(Guid.NewGuid());
            actionUpdateStrategy.Update(inputData, sourceObject);
--- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasActionsUpdateCloneStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasActionsUpdateCloneStrategy.cs
@@ -14,9 +14,9 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Actions.Clear();
            foreach (var item in sourceObject.Actions)
--- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasCalculatorsUpdateCloneStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasCalculatorsUpdateCloneStrategy.cs
@@ -17,9 +17,9 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Calculators.Clear();
            foreach (var calculator in sourceObject.Calculators)
--- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasSectionsUpdateCloneStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasSectionsUpdateCloneStrategy.cs
@@ -14,9 +14,9 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Sections.Clear();
            foreach (var item in sourceObject.Sections)
--- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasStirrupsUpdateCloneStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasStirrupsUpdateCloneStrategy.cs
@@ -15,9 +15,9 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IHasStirrups targetObject, IHasStirrups sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Stirrups.Clear();
            foreach (var item in sourceObject.Stirrups)
--- a/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs
@@ -74,8 +74,8 @@ namespace StructureHelperLogics.Models.BeamShears

        private void Check()
        {
-            CheckObject.IsNull(BeamShearSection);
-            CheckObject.IsNull(DesignRangeProperty);
+            CheckObject.ThrowIfNull(BeamShearSection);
+            CheckObject.ThrowIfNull(DesignRangeProperty);
        }

        private void GetShapeParameters()
--- a/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs
@@ -8,11 +8,11 @@ namespace StructureHelperLogics.Models.BeamShears
    {
        public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
-            CheckObject.IsNull(sourceObject.Actions);
-            CheckObject.IsNull(targetObject.Actions);
+            CheckObject.ThrowIfNull(sourceObject.Actions);
+            CheckObject.ThrowIfNull(targetObject.Actions);
            targetObject.Actions.Clear();
            targetObject.Actions.AddRange(sourceObject.Actions);
        }
--- a/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs
@@ -13,11 +13,11 @@ namespace StructureHelperLogics.Models.BeamShears
    {
        public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
-            CheckObject.IsNull(sourceObject.Sections);
-            CheckObject.IsNull(targetObject.Sections);
+            CheckObject.ThrowIfNull(sourceObject.Sections);
+            CheckObject.ThrowIfNull(targetObject.Sections);
            targetObject.Sections.Clear();
            targetObject.Sections.AddRange(sourceObject.Sections);
        }
--- a/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs
@@ -8,11 +8,11 @@ namespace StructureHelperLogics.Models.BeamShears
    {
        public void Update(IHasStirrups targetObject, IHasStirrups sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
-            CheckObject.IsNull(sourceObject.Stirrups);
-            CheckObject.IsNull(targetObject.Stirrups);
+            CheckObject.ThrowIfNull(sourceObject.Stirrups);
+            CheckObject.ThrowIfNull(targetObject.Stirrups);
            targetObject.Stirrups.Clear();
            targetObject.Stirrups.AddRange(sourceObject.Stirrups);
        }
--- a/StructureHelperLogics/Models/BeamShears/Logics/InclinedSectionUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/InclinedSectionUpdateStrategy.cs
@@ -8,8 +8,8 @@ namespace StructureHelperLogics.Models.BeamShears
    {
        public void Update(IInclinedSection targetObject, IInclinedSection sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
            targetObject.StartCoord = sourceObject.StartCoord;
            targetObject.EndCoord = sourceObject.EndCoord;
--- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupBaseUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupBaseUpdateStrategy.cs
@@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IStirrup targetObject, IStirrup sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Name = sourceObject.Name;
            targetObject.CompressedGap = sourceObject.CompressedGap;
@@ -24,8 +24,8 @@ namespace StructureHelperLogics.Models.BeamShears

        private void UpdateTargetChildren(IStirrup targetObject, IStirrup sourceObject)
        {
-            CheckObject.IsNull(sourceObject.VisualProperty);
-            CheckObject.IsNull(targetObject.VisualProperty);
+            CheckObject.ThrowIfNull(sourceObject.VisualProperty);
+            CheckObject.ThrowIfNull(targetObject.VisualProperty);
            visualUpdateStrategy ??= new PrimitiveVisualPropertyUpdateStrategy();
            visualUpdateStrategy.Update(targetObject.VisualProperty, sourceObject.VisualProperty);
        }
--- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityUpdateStrategy.cs
@@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears
        private IUpdateStrategy<IStirrup>? baseUpdateStrategy;
        public void Update(IStirrupByDensity targetObject, IStirrupByDensity sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            baseUpdateStrategy ??= new StirrupBaseUpdateStrategy();
            baseUpdateStrategy.Update(targetObject, sourceObject);
--- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs
@@ -14,12 +14,12 @@ namespace StructureHelperLogics.Models.BeamShears
        private IUpdateStrategy<IStirrup>? baseUpdateStrategy;
        public void Update(IStirrupByRebar targetObject, IStirrupByRebar sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            baseUpdateStrategy ??= new StirrupBaseUpdateStrategy();
            baseUpdateStrategy.Update(targetObject, sourceObject);
-            CheckObject.IsNull(sourceObject.Material);
+            CheckObject.ThrowIfNull(sourceObject.Material);
            targetObject.Material = sourceObject.Material.Clone() as IReinforcementLibMaterial;
            targetObject.Diameter = sourceObject.Diameter;
            targetObject.LegCount = sourceObject.LegCount;
--- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs
@@ -18,8 +18,8 @@ namespace StructureHelperLogics.Models.BeamShears.Logics

        public void Update(IStirrup targetObject, IStirrup sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            if (sourceObject is IStirrupGroup group)
            {
--- a/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs
@@ -72,8 +72,8 @@ namespace StructureHelperLogics.Models.BeamShears

        private void Check()
        {
-            CheckObject.IsNull(stirrupByDensity);
-            CheckObject.IsNull(inclinedSection);
+            CheckObject.ThrowIfNull(stirrupByDensity);
+            CheckObject.ThrowIfNull(inclinedSection);
        }
    }
 }
--- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorInputDataUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorInputDataUpdateStrategy.cs
@@ -15,8 +15,8 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IBeamShearCalculatorInputData targetObject, IBeamShearCalculatorInputData sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
            if (UpdateChildren)
            {
@@ -24,8 +24,8 @@ namespace StructureHelperLogics.Models.BeamShears
                hasActionUpdateStrategy?.Update(targetObject, sourceObject);
                hasSectionsUpdateStrategy?.Update(targetObject, sourceObject);
                hasStirrupsUpdateStrategy?.Update(targetObject, sourceObject);
-                CheckObject.IsNull(sourceObject.DesignRangeProperty);
-                CheckObject.IsNull(targetObject.DesignRangeProperty);
+                CheckObject.ThrowIfNull(sourceObject.DesignRangeProperty);
+                CheckObject.ThrowIfNull(targetObject.DesignRangeProperty);
                designRangeUpdateStrategy.Update(targetObject.DesignRangeProperty, sourceObject.DesignRangeProperty);
            }
            targetObject.CodeType = sourceObject.CodeType;
--- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorUpdateStrategy.cs
@@ -9,8 +9,8 @@ namespace StructureHelperLogics.Models.BeamShears
        private IUpdateStrategy<IBeamShearCalculatorInputData>? inputDataUpdateStrategy;
        public void Update(IBeamShearCalculator targetObject, IBeamShearCalculator sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; };
            targetObject.Name = sourceObject.Name;
            targetObject.ShowTraceData = sourceObject.ShowTraceData;
--- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs
@@ -8,8 +8,8 @@ namespace StructureHelperLogics.Models.BeamShears
    {
        public void Update(IBeamShearDesignRangeProperty targetObject, IBeamShearDesignRangeProperty sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.AbsoluteRangeValue = sourceObject.AbsoluteRangeValue;
            targetObject.RelativeEffectiveDepthRangeValue = sourceObject.RelativeEffectiveDepthRangeValue;
--- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs
@@ -8,8 +8,8 @@ namespace StructureHelperLogics.Models.BeamShears
    {
        public void Update(IBeamShearSectionLogicInputData targetObject, IBeamShearSectionLogicInputData sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.BeamShearAction = sourceObject.BeamShearAction;
            targetObject.InclinedSection = sourceObject.InclinedSection;
--- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs
@@ -14,8 +14,8 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IStirrupByInclinedRebar targetObject, IStirrupByInclinedRebar sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            baseUpdateStrategy ??= new StirrupBaseUpdateStrategy();
            baseUpdateStrategy.Update(targetObject, sourceObject);
@@ -25,7 +25,7 @@ namespace StructureHelperLogics.Models.BeamShears
            targetObject.LegCount = sourceObject.LegCount;
            if (UpdateChildren)
            {
-                CheckObject.IsNull(sourceObject.RebarSection, "Rebar section");
+                CheckObject.ThrowIfNull(sourceObject.RebarSection, "Rebar section");
                targetObject.RebarSection = sourceObject.RebarSection.Clone() as IRebarSection;
            }
        }
--- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs
@@ -13,8 +13,8 @@ namespace StructureHelperLogics.Models.BeamShears

        public void Update(IStirrupGroup targetObject, IStirrupGroup sourceObject)
        {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            baseUpdateStrategy ??= new StirrupBaseUpdateStrategy()
            {
@@ -29,8 +29,8 @@ namespace StructureHelperLogics.Models.BeamShears

        private static void UpdateTargetChildren(IStirrupGroup targetObject, IStirrupGroup sourceObject)
        {
-            CheckObject.IsNull(sourceObject.Stirrups);
-            CheckObject.IsNull(targetObject.Stirrups);
+            CheckObject.ThrowIfNull(sourceObject.Stirrups);
+            CheckObject.ThrowIfNull(targetObject.Stirrups);
            targetObject.Stirrups.Clear();
            foreach (var item in sourceObject.Stirrups)
            {
--- a/StructureHelperLogics/Models/CrossSections/CrossSectionCloneStrategy.cs
+++ b/StructureHelperLogics/Models/CrossSections/CrossSectionCloneStrategy.cs
@@ -27,8 +27,8 @@ namespace StructureHelperLogics.Models.CrossSections
            {
                SectionRepository = newRepository
            };
-            CheckObject.IsNull(targetObject.WorkPlaneProperty);
-            CheckObject.IsNull(sourceObject.WorkPlaneProperty);
+            CheckObject.ThrowIfNull(targetObject.WorkPlaneProperty);
+            CheckObject.ThrowIfNull(sourceObject.WorkPlaneProperty);
            workPlaneUpdateStrategy ??= new WorkPlanePropertyUpdateStrategy();
            workPlaneUpdateStrategy.Update(targetObject.WorkPlaneProperty, sourceObject.WorkPlaneProperty);
            return targetObject;
--- a/StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryUpdateStrategy.cs
@@ -16,8 +16,8 @@ namespace StructureHelperLogics.Models.CrossSections

        public void Update(ICrossSectionRepository targetObject, ICrossSectionRepository sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }          
        }
    }
--- a/StructureHelperLogics/Models/CrossSections/CrossSectionUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/CrossSections/CrossSectionUpdateStrategy.cs
@@ -27,8 +27,8 @@ namespace StructureHelperLogics.Models.CrossSections

        public void Update(ICrossSection targetObject, ICrossSection sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            UpdateRepository(targetObject, sourceObject);
            UpdateWorkPlane(targetObject, sourceObject);
@@ -48,8 +48,8 @@ namespace StructureHelperLogics.Models.CrossSections

        private void UpdateRepository(ICrossSection targetObject, ICrossSection sourceObject)
        {
-            CheckObject.IsNull(targetObject.SectionRepository);
-            CheckObject.IsNull(sourceObject.SectionRepository);
+            CheckObject.ThrowIfNull(targetObject.SectionRepository);
+            CheckObject.ThrowIfNull(sourceObject.SectionRepository);
            targetObject.SectionRepository.Calculators.Clear();
            targetObject.SectionRepository.Primitives.Clear();
            targetObject.SectionRepository.ForceActions.Clear();
--- a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs
@@ -17,8 +17,8 @@ namespace StructureHelperLogics.Models.Materials
        }
        public void Update(IConcreteLibMaterial targetObject, IConcreteLibMaterial sourceObject)
        {
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            libUpdateStrategy.Update(targetObject, sourceObject);
            targetObject.TensionForULS = sourceObject.TensionForULS;
--- a/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs
@@ -13,8 +13,8 @@ namespace StructureHelperLogics.Models.Materials
    {
        public void Update(IElasticMaterial targetObject, IElasticMaterial sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Modulus = sourceObject.Modulus;
            targetObject.CompressiveStrength = sourceObject.CompressiveStrength;
--- a/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs
@@ -15,8 +15,8 @@ namespace StructureHelperLogics.Models.Materials
        /// <inheritdoc/>
        public void Update(IFRMaterial targetObject, IFRMaterial sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Modulus = sourceObject.Modulus;
            targetObject.CompressiveStrength = sourceObject.CompressiveStrength;
--- a/StructureHelperLogics/Models/Materials/Logics/HasMaterialsUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/HasMaterialsUpdateCloningStrategy.cs
@@ -23,9 +23,9 @@ namespace StructureHelperLogics.Models.Materials.Logics
        /// <inheritdoc/>
        public void Update(IHasHeadMaterials targetObject, IHasHeadMaterials sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.HeadMaterials.Clear();
            foreach (var material in sourceObject.HeadMaterials)
--- a/StructureHelperLogics/Models/Materials/Logics/HeadMaterialBaseUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/HeadMaterialBaseUpdateStrategy.cs
@@ -8,8 +8,8 @@ namespace StructureHelperLogics.Models.Materials
    {
        public void Update(IHeadMaterial targetObject, IHeadMaterial sourceObject)
        {
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Name = sourceObject.Name;
            targetObject.Color = sourceObject.Color;
--- a/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs
@@ -26,8 +26,8 @@ namespace StructureHelperLogics.Models.Materials

        public void Update(IHeadMaterial targetObject, IHeadMaterial sourceObject)
        {
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            baseUpdateStrategy.Update(targetObject, sourceObject);
            targetObject.HelperMaterial = sourceObject.HelperMaterial.Clone() as IHelperMaterial;
--- a/StructureHelperLogics/Models/Materials/Logics/HelperMaterialSafetyFactorsUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/HelperMaterialSafetyFactorsUpdateStrategy.cs
@@ -14,8 +14,8 @@ namespace StructureHelperLogics.Models.Materials.Logics
    {
        public void Update(IHelperMaterial targetObject, IHelperMaterial sourceObject)
        {
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            if (sourceObject.SafetyFactors is not null)
            {
--- a/StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs
@@ -40,8 +40,8 @@ namespace StructureHelperLogics.Models.Materials

        public void Update(IHelperMaterial targetObject, IHelperMaterial sourceObject)
        {
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            safetyFactorUpdateStrategy.Update(targetObject, sourceObject);
            if (sourceObject is ILibMaterial)
--- a/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs
@@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.Materials
    {
        public void Update(ILibMaterial targetObject, ILibMaterial sourceObject)
        {
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.MaterialEntity = sourceObject.MaterialEntity;
            targetObject.MaterialLogic = sourceObject.MaterialLogic;
--- a/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs
@@ -9,10 +9,10 @@ namespace StructureHelperLogics.Models.Materials

        public void Update(IRebarSection targetObject, IRebarSection sourceObject)
        {
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Material);
+            CheckObject.ThrowIfNull(sourceObject.Material);
            targetObject.Diameter = sourceObject.Diameter;
            if (UpdateChildren)
            {
--- a/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs
+++ b/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs
@@ -20,8 +20,8 @@ namespace StructureHelperLogics.Models.Materials
        }
        public void Update(IReinforcementLibMaterial targetObject, IReinforcementLibMaterial sourceObject)
        {
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            libUpdateStrategy.Update(targetObject, sourceObject);
        }
--- a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs
+++ b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs
@@ -24,9 +24,9 @@ namespace StructureHelperLogics.Models.Templates.CrossSections
        {
            ValueDiagramCalculator diagramCalculator = new(Guid.NewGuid()) { Name = "New value diagram calcualtor"};
            ValueDiagramEntity diagramEntity = new(Guid.NewGuid()) { Name = "New diagram" };
-            diagramEntity.ValueDigram.Point2DRange.StartPoint.Y = 0.25;
-            diagramEntity.ValueDigram.Point2DRange.EndPoint.Y = - 0.25;
-            diagramCalculator.InputData.Digrams.Add(diagramEntity);
+            diagramEntity.ValueDiagram.Point2DRange.StartPoint.Y = 0.25;
+            diagramEntity.ValueDiagram.Point2DRange.EndPoint.Y = - 0.25;
+            diagramCalculator.InputData.Diagrams.Add(diagramEntity);
            return diagramCalculator;
        }

--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs
@@ -89,10 +89,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces

        private void CheckActions()
        {
-            var checkLogic = new CheckForceActionsLogic()
+            var checkLogic = new CheckForceActionsLogic(TraceLogger)
            {
-                Entity = InputData.ForceActions,
-                TraceLogger = TraceLogger
+                Entity = InputData.ForceActions
            };
            if (checkLogic.Check() == false)
            {
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs
@@ -41,7 +41,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
        }
        public void Update(IForceCalculatorInputData targetObject, IForceCalculatorInputData sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject, "Force calculator input data");
+            CheckObject.ThrowIfNull(targetObject, sourceObject, "Force calculator input data");
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Accuracy ??= new Accuracy();
            targetObject.CheckStrainLimit = sourceObject.CheckStrainLimit;
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorInputDataUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorInputDataUpdateStrategy.cs
@@ -15,7 +15,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve
    {
        public void Update(ILimitCurvesCalculatorInputData targetObject, ILimitCurvesCalculatorInputData sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject, "Limit curve calculator input data");
+            CheckObject.ThrowIfNull(targetObject, sourceObject, "Limit curve calculator input data");
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.LimitStates.Clear();
            targetObject.CalcTerms.Clear();
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorUpdateCloningStrategy.cs
@@ -30,9 +30,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve

        public void Update(ILimitCurvesCalculator targetObject, ILimitCurvesCalculator sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            var targetData = targetObject.InputData;
            limitCurvesInputDataUpdateStrategy.Update(targetData, sourceObject.InputData);
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CrackCalculatorUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CrackCalculatorUpdateCloningStrategy.cs
@@ -33,9 +33,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics

        public void Update(ICrackCalculator targetObject, ICrackCalculator sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            var sourceData = sourceObject.InputData;
            var targetData = targetObject.InputData;
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateCloningStrategy.cs
@@ -31,9 +31,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics

        public void Update(IForceCalculator targetObject, IForceCalculator sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            var sourceData = sourceObject.InputData;
            var targetData = targetObject.InputData;
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs
@@ -13,8 +13,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
        public ForceCalculatorUpdateStrategy() : this(new ForceCalculatorInputDataUpdateStrategy()) {        }
        public void Update(IForceCalculator targetObject, IForceCalculator sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Name = sourceObject.Name;
            targetObject.ShowTraceData = sourceObject.ShowTraceData;
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs
@@ -39,9 +39,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces

        public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Calculators.Clear();
            foreach (var calculator in sourceObject.Calculators)
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramCalculatorInputData.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramCalculatorInputData.cs
@@ -14,7 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
        /// <summary>
        /// Collection of diagram for calculation
        /// </summary>
-        List<IValueDiagramEntity> Digrams { get; }
+        List<IValueDiagramEntity> Diagrams { get; }
        bool CheckStrainLimit { get; set; }
    }
 }
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramEntity.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramEntity.cs
@@ -6,6 +6,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
    {
        string Name { get; set; }
        bool IsTaken { get; set; }
-        IValueDiagram ValueDigram { get; set; }
+        IValueDiagram ValueDiagram { get; set; }
    }
 }
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs
@@ -21,7 +21,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams

        public void Update(IValueDiagramCalculatorInputData targetObject, IValueDiagramCalculatorInputData sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.CheckStrainLimit = sourceObject.CheckStrainLimit;
            targetObject.StateTermPair.LimitState = sourceObject.StateTermPair.LimitState;
@@ -32,12 +32,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
                targetObject.Primitives.AddRange(sourceObject.Primitives);
                targetObject.ForceActions.Clear();
                targetObject.ForceActions.AddRange(sourceObject.ForceActions);
-                targetObject.Digrams.Clear();
+                targetObject.Diagrams.Clear();
                entityUpdateStrategy ??= new ValueDiagramEntityUpdateStrategy();
-                foreach (var entity in sourceObject.Digrams)
+                foreach (var entity in sourceObject.Diagrams)
                {
                    var newItem = entity.Clone() as IValueDiagramEntity;
-                    targetObject.Digrams.Add(newItem);
+                    targetObject.Diagrams.Add(newItem);
                }
            }
        }
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs
@@ -90,7 +90,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams

        private void GetEntitiesResults()
        {
-            var entities = InputData.Digrams
+            var entities = InputData.Diagrams
                .Where(x => x.IsTaken == true);
            foreach (var entity in entities)
            {
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs
@@ -31,9 +31,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams

        public void Update(IValueDiagramCalculator targetObject, IValueDiagramCalculator sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            var sourceData = sourceObject.InputData;
            var targetData = targetObject.InputData;
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateStrategy.cs
@@ -10,14 +10,14 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams

        public void Update(IValueDiagramCalculator targetObject, IValueDiagramCalculator sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Name = sourceObject.Name;
            targetObject.ShowTraceData = sourceObject.ShowTraceData;
            if (UpdateChildren == true)
            {
-                CheckObject.IsNull(targetObject.InputData, ": target value diagram calculator input data");
-                CheckObject.IsNull(sourceObject.InputData, ": source value diagram calculator input data");
+                CheckObject.ThrowIfNull(targetObject.InputData, ": target value diagram calculator input data");
+                CheckObject.ThrowIfNull(sourceObject.InputData, ": source value diagram calculator input data");
                inputDataUpdateStrategy ??= new ValueDiagramCalculatorInputDataUpdateStrategy();
                inputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData);
            }
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs
@@ -0,0 +1,30 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics
+{
+    public class ValueDiagramCheckLogic : CheckEntityLogic<IValueDiagram>
+    {
+        private const double minDistance = 1e-3;
+        private bool result;
+
+        public override bool Check()
+        {
+            result = true;
+            if (Entity is null)
+            {
+                string errorString = ErrorStrings.ParameterIsNull + ": value diagram";
+                TraceMessage(errorString);
+                throw new StructureHelperException(errorString);
+            }
+            double dx = Entity.Point2DRange.StartPoint.X - Entity.Point2DRange.EndPoint.X;
+            double dy = Entity.Point2DRange.StartPoint.Y - Entity.Point2DRange.EndPoint.Y;
+            if (Math.Abs(dx) < minDistance && Math.Abs(dy) < minDistance)
+            {
+                result = false;
+                TraceMessage($"Distance between point of diagram is too small");
+            }
+            return result;
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityCheckLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityCheckLogic.cs
@@ -0,0 +1,46 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
+{
+    public class ValueDiagramEntityCheckLogic : CheckEntityLogic<IValueDiagramEntity>
+    {       
+        private ICheckEntityLogic<IValueDiagram> valueDiagramCheckLogic;
+
+        public ValueDiagramEntityCheckLogic(IShiftTraceLogger? traceLogger)
+        {
+            valueDiagramCheckLogic = new ValueDiagramCheckLogic();
+            TraceLogger = traceLogger;
+        }
+
+        public ValueDiagramEntityCheckLogic(ICheckEntityLogic<IValueDiagram> valueDiagramCheckLogic, IShiftTraceLogger? traceLogger)
+        {
+            TraceLogger = traceLogger;
+            this.valueDiagramCheckLogic = valueDiagramCheckLogic;
+        }
+
+        public override bool Check()
+        {
+            bool result = true;
+            if (Entity is null)
+            {
+                string errorString = ErrorStrings.ParameterIsNull + ": value diagram entity";
+                TraceMessage(errorString);
+                throw new StructureHelperException(errorString);
+            }
+            valueDiagramCheckLogic.Entity = Entity.ValueDiagram;
+            bool IsValid = valueDiagramCheckLogic.Check();
+            if (IsValid == false)
+            {
+                result = false;
+                string name = string.IsNullOrWhiteSpace(Entity.Name)
+                    ? "<unnamed>"
+                    : Entity.Name;
+                TraceMessage($"Diagram: {name} has error: {valueDiagramCheckLogic.CheckResult}");
+            }
+            return result;
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityLogic.cs
@@ -25,12 +25,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
        private List<IPoint2D> GetPoints()
        {
            TraceLogger?.AddMessage($"Getting point for diagram {ValueDiagramEntity.Name} has been started");
-            var startPoint = ValueDiagramEntity.ValueDigram.Point2DRange.StartPoint;
-            var endPoint = ValueDiagramEntity.ValueDigram.Point2DRange.EndPoint;
-            double dx = (endPoint.X - startPoint.X) / ValueDiagramEntity.ValueDigram.StepNumber;
-            double dy = (endPoint.Y - startPoint.Y) / ValueDiagramEntity.ValueDigram.StepNumber;
+            var startPoint = ValueDiagramEntity.ValueDiagram.Point2DRange.StartPoint;
+            var endPoint = ValueDiagramEntity.ValueDiagram.Point2DRange.EndPoint;
+            double dx = (endPoint.X - startPoint.X) / ValueDiagramEntity.ValueDiagram.StepNumber;
+            double dy = (endPoint.Y - startPoint.Y) / ValueDiagramEntity.ValueDiagram.StepNumber;
            List<IPoint2D> point2Ds = [];
-            for (int i = 0; i < ValueDiagramEntity.ValueDigram.StepNumber + 1; i++)
+            for (int i = 0; i < ValueDiagramEntity.ValueDiagram.StepNumber + 1; i++)
            {
                double x = startPoint.X + dx * i;
                double y = startPoint.Y + dy * i;
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityUpdateStrategy.cs
@@ -21,14 +21,14 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams

        public void Update(IValueDiagramEntity targetObject, IValueDiagramEntity sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.IsTaken = sourceObject.IsTaken;
            targetObject.Name = sourceObject.Name;
            if (UpdateChildren == true)
            {
                valueDiagramUpdateStrategy ??= new ValueDiagramUpdateStrategy();
-                valueDiagramUpdateStrategy.Update(targetObject.ValueDigram, sourceObject.ValueDigram);
+                valueDiagramUpdateStrategy.Update(targetObject.ValueDiagram, sourceObject.ValueDiagram);
            }
        }
    }
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs
@@ -0,0 +1,100 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Forces.Logics;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using StructureHelperLogics.NdmCalculations.Primitives.Logics;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
+{
+    public class ValueDiagramInputDataCheckLogic : CheckEntityLogic<IValueDiagramCalculatorInputData>
+    {
+        private ICheckEntityLogic<IValueDiagramEntity> checkEntityLogic;
+        private ICheckEntityLogic<IHasPrimitives> primitivesCheckLogic;
+        private ICheckEntityLogic<IEnumerable<IForceAction>> actionsCheckLogic;
+
+        private bool result;
+
+        public ValueDiagramInputDataCheckLogic(
+            ICheckEntityLogic<IValueDiagramEntity> checkEntityLogic,
+            ICheckEntityLogic<IHasPrimitives> primitivesCheckLogic,
+            ICheckEntityLogic<IEnumerable<IForceAction>> actionsCheckLogic)
+        {
+            this.checkEntityLogic = checkEntityLogic;
+            this.primitivesCheckLogic = primitivesCheckLogic;
+            this.actionsCheckLogic = actionsCheckLogic;
+        }
+
+        public ValueDiagramInputDataCheckLogic()
+        {
+            checkEntityLogic = new ValueDiagramEntityCheckLogic(TraceLogger);
+            CheckRebarPrimitiveLogic checkRebarPrimitiveLogic = new()
+            {
+                CheckRebarHostMaterial = false,
+                CheckRebarPlacement = false
+            };
+            primitivesCheckLogic = new CheckPrimitiveCollectionLogic(TraceLogger, checkRebarPrimitiveLogic);
+            actionsCheckLogic = new CheckForceActionsLogic(TraceLogger);
+        }
+
+        public override bool Check()
+        {
+            result = true;
+            if (Entity is null)
+            {
+                string errorString = ErrorStrings.ParameterIsNull + ": input data";
+                TraceMessage(errorString);
+                throw new StructureHelperException(errorString);
+            }
+            if (Entity.Primitives is null || !Entity.Primitives.Any())
+            {
+                TraceMessage("Calculator does not contain any primitives");
+                result = false;
+            }
+            if (Entity.ForceActions is null || !Entity.ForceActions.Any())
+            {
+                TraceMessage("Calculator does not contain any forces");
+                result = false;
+            }
+            if (Entity.Diagrams is null || !Entity.Diagrams.Any() || !Entity.Diagrams.Where(x=> x.IsTaken == true).Any())
+            {
+                TraceMessage("Calculator does not contain any diagrams for calculation");
+                result = false;
+            }
+            foreach (var entity in Entity.Diagrams)
+            {
+                checkEntityLogic.Entity = entity;
+                bool isValid = checkEntityLogic.Check();
+                if (isValid == false)
+                {
+                    result = false;
+                    TraceMessage(checkEntityLogic.CheckResult);
+                }
+            }
+            CheckPrimitives();
+            CheckActions();
+            return result;
+        }
+
+        private void CheckPrimitives()
+        {
+            primitivesCheckLogic.Entity = Entity;
+            if (primitivesCheckLogic.Check() == false)
+            {
+                result = false;
+            }
+            TraceMessage(primitivesCheckLogic.CheckResult);
+
+        }
+
+        private void CheckActions()
+        {
+            actionsCheckLogic.Entity = Entity.ForceActions;
+            if (actionsCheckLogic.Check() == false)
+            {
+                result = false;
+            }
+            TraceMessage(actionsCheckLogic.CheckResult);
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramUpdateStrategy.cs
@@ -1,4 +1,5 @@
-using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models.Shapes;
 using StructureHelperCommon.Services;

@@ -6,19 +7,36 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
 {
    public class ValueDiagramUpdateStrategy : IParentUpdateStrategy<IValueDiagram>
    {
-        private IUpdateStrategy<IPoint2DRange> rangeUpdateStrategy;
+        private IUpdateStrategy<IPoint2DRange>? _rangeUpdateStrategy;
+
+        public ValueDiagramUpdateStrategy(IUpdateStrategy<IPoint2DRange> rangeUpdateStrategy)
+        {
+            _rangeUpdateStrategy = rangeUpdateStrategy ?? throw new StructureHelperException("rangeUpdateStrategy cannot be null");
+        }
+
+        public ValueDiagramUpdateStrategy() { }
+
        public bool UpdateChildren { get; set; } = true;

+        private IUpdateStrategy<IPoint2DRange> RangeUpdateStrategy
+            => _rangeUpdateStrategy ??= new Point2DRangeUpdateStrategy();
+
        public void Update(IValueDiagram targetObject, IValueDiagram sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject);
-            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            CheckObject.ThrowIfNull(targetObject, nameof(targetObject));
+            CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject));
+
+            if (ReferenceEquals(targetObject, sourceObject))
+                return;
+
            targetObject.StepNumber = sourceObject.StepNumber;
-            if (UpdateChildren == true)
+
+            if (UpdateChildren)
            {
-                rangeUpdateStrategy ??= new Point2DRangeUpdateStrategy();
-                rangeUpdateStrategy.Update(targetObject.Point2DRange, sourceObject.Point2DRange);
+                // Use property for lazy initialization
+                RangeUpdateStrategy.Update(targetObject.Point2DRange, sourceObject.Point2DRange);
            }
        }
    }
+
 }
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagram.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagram.cs
@@ -4,8 +4,17 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
 {
    public class ValueDiagram : IValueDiagram
    {
+        private int stepNumber = 50;
+
        public Guid Id { get; }
-        public int StepNumber { get; set; } = 50;
+        public int StepNumber
+        {
+            get => stepNumber;
+            set
+            {
+                stepNumber = Math.Max(value, 10);
+            }
+        }
        public IPoint2DRange Point2DRange { get; set; } = new Point2DRange(Guid.NewGuid());


--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculator.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculator.cs
@@ -1,13 +1,17 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Calculators;
+using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
+using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics;

 namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
 {
    public class ValueDiagramCalculator : IValueDiagramCalculator
    {
        private readonly IValueDiagramCalculatorLogic valueDiagramCalculatorLogic = new ValueDiagramCalculatorLogic();
-        private readonly ICheckInputDataLogic<IValueDiagramCalculatorInputData> checkInputDataLogic;
+        private readonly ICheckEntityLogic<IValueDiagramCalculatorInputData> checkInputDataLogic;
+
+
        private IValueDiagramCalculatorResult result;

        public Guid Id { get; }
@@ -20,9 +24,15 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams

        public IValueDiagramCalculatorInputData InputData { get; set; } = new ValueDiagramCalculatorInputData(Guid.NewGuid());

+        public ValueDiagramCalculator(ICheckEntityLogic<IValueDiagramCalculatorInputData> checkInputDataLogic)
+        {
+            this.checkInputDataLogic = checkInputDataLogic;
+        }
+
        public ValueDiagramCalculator(Guid id)
        {
            Id = id;
+            checkInputDataLogic = new ValueDiagramInputDataCheckLogic();
        }

        public object Clone()
@@ -35,6 +45,16 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams

        public void Run()
        {
+            checkInputDataLogic.Entity = InputData;
+            if (checkInputDataLogic.Check() != true)
+            {
+                result = new ValueDiagramCalculatorResult()
+                {
+                    IsValid = false,
+                    Description = checkInputDataLogic.CheckResult
+                };
+                return;
+            }
            valueDiagramCalculatorLogic.InputData = InputData;
            result = valueDiagramCalculatorLogic.GetResult();
        }
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculatorInputData.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculatorInputData.cs
@@ -17,7 +17,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
        public Guid Id { get; }

        /// <inheritdoc/>
-        public List<IValueDiagramEntity> Digrams { get; } = [];
+        public List<IValueDiagramEntity> Diagrams { get; } = [];
        /// <inheritdoc/>
        public List<IForceAction> ForceActions { get; } = [];
        /// <inheritdoc/>
--- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramEntity.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramEntity.cs
@@ -6,7 +6,7 @@
        public string Name { get; set; } = string.Empty;
        public bool IsTaken { get; set; } = true;

-        public IValueDiagram ValueDigram { get; set; } = new ValueDiagram(Guid.NewGuid());
+        public IValueDiagram ValueDiagram { get; set; } = new ValueDiagram(Guid.NewGuid());

        public ValueDiagramEntity(Guid id)
        {
--- a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs
@@ -69,10 +69,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
                TraceLogger?.AddMessage(message, TraceLogStatuses.Error);
                return;
            };
-            var checkLogic = new CheckForceActionsLogic()
+            var checkLogic = new CheckForceActionsLogic(TraceLogger)
            {
-                Entity = InputData.ForceActions,
-                TraceLogger = TraceLogger
+                Entity = InputData.ForceActions
            };
            if (checkLogic.Check() == false)
            {
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
@@ -14,8 +14,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
        public CrackCalculatorUpdateStrategy() : this(new CrackInputDataUpdateStrategy()) { }
        public void Update(ICrackCalculator targetObject, ICrackCalculator sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Name = sourceObject.Name;
            targetObject.ShowTraceData = sourceObject.ShowTraceData;
--- a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs
@@ -22,8 +22,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
        }
        public void Update(ICrackCalculatorInputData targetObject, ICrackCalculatorInputData sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.ForceActions.Clear();
            targetObject.ForceActions.AddRange(sourceObject.ForceActions);
--- a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs
@@ -12,8 +12,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
    {
        public void Update(IUserCrackInputData targetObject, IUserCrackInputData sourceObject)
        {
-            CheckObject.IsNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
+            CheckObject.ThrowIfNull(sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.SetSofteningFactor = sourceObject.SetSofteningFactor;
            targetObject.SofteningFactor = sourceObject.SofteningFactor;
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/DxfEntitiesToNdmPrimitivesConvertStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/DxfEntitiesToNdmPrimitivesConvertStrategy.cs
@@ -2,6 +2,7 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models.Shapes;
 using StructureHelperCommon.Services.Exports;
+using StructureHelperLogics.Models.Primitives;

 namespace StructureHelperLogics.NdmCalculations.Primitives
 {
@@ -31,6 +32,10 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
                {
                    primitives.Add(GetCirclePrimitive(circle));
                }
+                else if (dxfEntity is Point point)
+                {
+                    primitives.Add(GetPointPrimitive(point));
+                }
                else
                {
                    // just skip all types of primitives
@@ -39,6 +44,31 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
            }
        }

+        private INdmPrimitive GetPointPrimitive(Point point)
+        {
+            INdmPrimitive primitive = null;
+            double area = 0.000314;
+            if (point.Layer.Name == layerLogic.GetLayerName(LayerNames.StructuralRebars))
+            {
+                RebarNdmPrimitive rebar = new(Guid.NewGuid())
+                {
+                    Name = "Imported rebar",
+                    Area = area
+                };
+                primitive = rebar;
+            }
+            else
+            {
+                PointNdmPrimitive pointPrimitive = new(Guid.NewGuid())
+                {
+                    Name = "Imported point",
+                    Area = area
+                };
+                primitive = pointPrimitive;
+            }
+                return primitive;
+        }
+
        private INdmPrimitive GetCirclePrimitive(Circle circle)
        {
            INdmPrimitive primitive = null;
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs
@@ -27,8 +27,8 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
        }
        public void Update(IEllipseNdmPrimitive targetObject, IEllipseNdmPrimitive sourceObject)
        {
-            CheckObject.IsNull(sourceObject, "source object");
-            CheckObject.IsNull(targetObject, "target object");
+            CheckObject.ThrowIfNull(sourceObject, "source object");
+            CheckObject.ThrowIfNull(targetObject, "target object");
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            basePrimitiveUpdateStrategy.Update(targetObject, sourceObject);
            divisionPropsUpdateStrategy.Update(targetObject.DivisionSize, sourceObject.DivisionSize);
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs
@@ -18,9 +18,9 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics

        public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject)
        {
-            CheckObject.IsNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(cloningStrategy);
+            CheckObject.ThrowIfNull(sourceObject);
+            CheckObject.ThrowIfNull(targetObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Primitives.Clear();
            foreach (var primitive in sourceObject.Primitives)
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateStrategy.cs
@@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
    {
        public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Primitives.Clear();
            targetObject.Primitives.AddRange(sourceObject.Primitives);
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs
@@ -24,7 +24,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
        /// <inheritdoc/>
        public void Update(INdmElement targetObject, INdmElement sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            targetObject.Triangulate = sourceObject.Triangulate;
            tupleUpdateStrategy.Update(targetObject.UsersPrestrain, sourceObject.UsersPrestrain);
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveBaseUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveBaseUpdateStrategy.cs
@@ -16,7 +16,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives

        public void Update(INdmPrimitive targetObject, INdmPrimitive sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            InitializeStrategies();
            targetObject.Name = sourceObject.Name;
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs
@@ -28,8 +28,8 @@ namespace StructureHelperLogics.NdmCalculations.Primitives

        public void Update(IRectangleNdmPrimitive targetObject, IRectangleNdmPrimitive sourceObject)
        {
-            CheckObject.IsNull(sourceObject, "source object");
-            CheckObject.IsNull(targetObject, "target object");
+            CheckObject.ThrowIfNull(sourceObject, "source object");
+            CheckObject.ThrowIfNull(targetObject, "target object");
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            basePrimitiveUpdateStrategy.Update(targetObject, sourceObject);
            divisionPropsUpdateStrategy.Update(targetObject.DivisionSize, sourceObject.DivisionSize);
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ShapeNDMPrimitiveUpdateStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/ShapeNDMPrimitiveUpdateStrategy.cs
@@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives

        public void Update(IShapeNdmPrimitive targetObject, IShapeNdmPrimitive sourceObject)
        {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
            if (ReferenceEquals(targetObject, sourceObject)) { return; }
            InitializeStrategies();
            basePrimitiveUpdateStrategy.Update(targetObject, sourceObject);